输出结果题

const obj = { 1: "a", 2: "b", 3: "c" };
const set = new Set([1, 2, 3, 4, 5]);

obj.hasOwnProperty("1");
obj.hasOwnProperty(1);
set.has("1");
set.has(1);

A: false true false true
B: false true true true
C: true true false true
D: true true true true

答案: C

所有对象键（不包括Symbols）都会被存储为字符串，即使你没有给定字符串类型的键。 这就是为什么obj.hasOwnProperty（‘1’）也返回true。

上面的说法不适用于Set。 在我们的Set中没有“1”：set.has（‘1’）返回false。 它有数字类型1，set.has（1）返回true。

const a = {};
const b = { key: "b" };
const c = { key: "c" };

a[b] = 123;
a[c] = 456;

console.log(a[b]);

A: 123
B: 456
C: undefined
D: ReferenceError

答案: B

对象键自动转换为字符串。我们试图将一个对象设置为对象a的键，其值为123。

但是，当对象自动转换为字符串化时，它变成了**[Object object]**。 所以我们在这里说的是a[“Object object”] = 123。 然后，我们可以尝试再次做同样的事情。 c对象同样会发生隐式类型转换。那么，a[“Object object”] = 456。

然后，我们打印a[b]，它实际上是a[“Object object”]。 我们将其设置为456，因此返回456。

3. var的变量提升

       var a = 10;                       //
        (function() {
            console.log(a);              //  undefined
            a = 5;                       //
            console.log(window.a);       // 10
            var a = 20;                  //  相当于一开始声明var a = undefinded
            console.log(a);              //20
        })()

4. 箭头函数的this指向定义的地方

const shape = {
  radius: 10,
  diameter() {
    return this.radius * 2;
  },
  perimeter: () => 2 * Math.PI * this.radius
};

shape.diameter();
shape.perimeter();

A: 20 and 62.83185307179586
B: 20 and NaN
C: 20 and 63
D: NaN and 63

答案: B
请注意，diameter是普通函数，而perimeter是箭头函数。

对于箭头函数，this关键字指向是它所在上下文（定义时的位置）的环境，与普通函数不同！ 这意味着当我们调用perimeter时，它不是指向shape对象，而是指其定义时的环境（window）。没有值radius属性，返回undefined。

5. 隐式转换

+true;
!"Lydia";

A: 1 and false
B: false and NaN
C: false and false

答案: A

一元加号会尝试将boolean类型转换为数字类型。 true被转换为1，false被转换为0。
字符串’Lydia’是一个真值。 我们实际上要问的是“这个真值是假的吗？”。 这会返回false。

	var a = 1;
    function Fn1(){
        var a = 2;
        console.log(this.a + a);
    }
    function Fn2(){
        var a = 10;
        Fn1();
    }
    Fn2();               

    var Fn3 = function(){
        this.a = 3;
    }
    Fn3.prototype = {
        a:4
    }
    var fn3 = new Fn3();
    Fn1.call(fn3);

3
5
调用Fn2()时，再调用Fn1,此时，this指向window，this.a = 1, a=2。
fn3.Fn1()。 this指向fn3，this.a=3, a=2

	var obj = {"key":"1","value":"2"};
    var newObj = obj;
    newObj.value += obj.key;
    console.log(obj.value);

21
对象共享地址，一改全改。
字符串的+是拼接

	var m = 1, j=k=0;
    function add(n){
        return n = n+1;
    }
    y = add(m);
    function add(n){
        return n = n + 3;
    }
    z=add(m);
    console.log(y + ',' + z);

4，4
同名函数以最后的为准。

	function create(){
        let b = 100;
        return function(){
            console.log(b);
        } 
    }
    let fn = create();
    let b = 200;
    fn();

100
闭包，一层一层向上找

	function print(fn1){
        let d = 200;
        fn1();
    }
    let d = 100;
    function fn1(){
        console.log(d);
    }
    print(fn1);

100
闭包查找变量时从函数定义的地方开始向上找！

let i
for(i = 0; i <=3; i++){
	setTimeout(function(){
		console.log(i)
	}, 0)
}

4444

for(let i = 0; i <=3; i++){
	setTimeout(function(){
		console.log(i)
	}, 0)
}

0123

注意le声明的位置！要在for里面。

let a = 100
function test(){
	alert(a)
	a = 10
	alert(a)
}
test()
alert(a)

100
10
10
alert的是window的方法。