js提升

1、加不加 var 可是有区别的哟！！

 

 

Js代码  

1. a = 10;  
2. alert(window.a); // 10  
3.    
4. alert(delete a); // true  
5.    
6. alert(window.a); // undefined  
7.    
8. var b = 20;  
9. alert(window.b); // 20  
10.    
11. alert(delete b); // false  
12.    
13. alert(window.b); // still 20  

  

2、关于 this（最后三个表达式添加了特定的操作之后，调用括号左侧就不再是引用类型的值了。）

Js代码  

1. var foo = {  
2.   bar: function () {  
3.     alert(this);  
4.   }  
5. };  
6.    
7. foo.bar(); // Reference, OK => foo  
8. (foo.bar)(); // Reference, OK => foo  
9.    
10. (foo.bar = foo.bar)(); // global?  
11. (false || foo.bar)(); // global?  
12. (foo.bar, foo.bar)(); // global?  

  

3、继续关于 this （有这么一种情况下，当调用表达式左侧是引用类型的值，但是this的值却是null，最终变为全局对象。 发生这种情况的条件是当引用类型值的base对象恰好为活跃对象。）

Js代码  

1. function foo() {  
2.   function bar() {  
3.     alert(this); // global  
4.   }  
5.   bar(); // 和AO.bar()是一样的  
6. }  

 

4、上面的情况在 With 时例外

Js代码  

1. var x = 10;  
2.    
3. with ({  
4.    
5.   foo: function () {  
6.     alert(this.x);  
7.   },  
8.   x: 20  
9.    
10. }) {  
11.    
12.   foo(); // 20  
13.    
14. }  

 

5、通过Function构造器创建的函数的[[Scope]]属性

Js代码  

1. var x = 10;  
2.    
3. function foo() {  
4.    
5.   var y = 20;  
6.    
7.   function barFD() { // FunctionDeclaration  
8.     alert(x);  
9.     alert(y);  
10.   }  
11.    
12.   var barFE = function () { // FunctionExpression  
13.     alert(x);  
14.     alert(y);  
15.   };  
16.    
17.   var barFn = Function('alert(x); alert(y);');  
18.    
19.   barFD(); // 10, 20  
20.   barFE(); // 10, 20  
21.   barFn(); // 10, "y" is not defined  
22.    
23. }  
24.    
25. foo();  

 问题就在于当函数通过Function构造器来创建的时候，其[[Scope]]属性永远都只包含全局对象。 哪怕在上层上下文中（非全局上下文）创建一个闭包都是无济于事的。

6、发生了什么？怎么最外层的“y”变成了30？

Js代码  

1. var x = 10, y = 10;  
2.    
3. with ({x: 20}) {  
4.    
5.   var x = 30, y = 30;  
6.    
7.   alert(x); // 30  
8.   alert(y); // 30  
9. }  
10.    
11. alert(x); // 10  
12. alert(y); // 30  

• x=10, y=10
• 对象{x: 20}添加到了作用域链的最前面
• 在with中遇到了var语句，当然了，这个时候什么也不会发生。因为早在进入上下文阶段所有的变量都已经解析过了并且添加到了对应的变量对象上了。
• 这里修改了“x”的值，原本“x”是在第二步的时候添加的对象{x: 20}（该对象被添加到了作用域链的最前面）中的“x”，现在变成了30。
• 同样的，“y”的值也修改了，由原本的10变成了30
• 之后，在with语句结束之后，其特殊对象从作用域链中移除（修改过的“x”——30，也随之移除），作用域链又恢复到了with语句前的状态。
• 正如在最后两个alert中看到的，“x”的值恢复到了原先的10，而“y”的值因为在with语句的时候被修改过了，因此变为了30。

7、 [] == ![] 为何等于true？ 一道简单的题目让我顿悟了！

自己发展一下：

Js代码  

1. alert("000000" == false) //true  
2. alert(["00000"] == ![]) //true  
3. alert([""] == ![]) //true  
4. alert("000000" == ![]) 和 alert("000000" == []) 为啥不一样呢？？   
5. alert("" == ![]) 和 alert("" == []) 为啥又一样呢？？  
6. alert(0 == ![]) 和 alert(0 == []) 为啥也一样呢？？