call和apply的区别

昨天和js大神谈js，他说要是他出题的话，就问apply和call的区别。。。

现在整理一下，首先说apply和call的不同之处其实就是 方法传递的参数不同，(还有一个是性能方面的差别，apply的性能要差很多。)

call( fun, arg1 , arg2 ,arg3...... ), 而apply只接受 两个参数 apply( fun , [ arg1 , arg2 ,arg3....])(以数组形式存储)

两者的作用呢，都是变化上下文，所谓的上下文是指 对象的空间:

var a = {
    o : 100,
    m : function (){
     console.log(this.o);
     var o = 200;
       }
    }    

　　则变量o和函数m的上下文就是对象 a。

注 ：在JavaScript中，代码将总是有着某种形式的上下文(代码在其内部工作的 对象)

上下文是通过变量this（号称魔法变量）工作。变量this总是引用代 码当前所在的那个对象。记住全局对象实际上是window对象的属性。这意味着即使是在全局上下文里，this 变量仍然引用一个对象。

下面来举一些有点磨人的例子：

(1)全局变量k

var k = 200;
var obj = {
    f : function() {
        console.log( k );
        k = 100;
    }
        
}

obj.f();    // 200 ,k为一个全局的变量，k的上下文是window

(2 ) this.k,此处的this指代的对象是 obj，而在执行console.log(this.k)的时候，下一句k还没有定义，但是由于声明提前，所以k已经声明，所以不会报错，

而是undefined（相当于在内存开了一个0字节的内存，也就是只是声明了一个变量，而没有给它赋值，则默认值）

var k = 200;
var obj = {
    f : function() {
        console.log( this.k );
        k = 100;
    }
        
}

obj.f();   // undefined

(3) 自执行的函数，是一个自我封闭的区域，其中的this没有上下文，没有上下文默认为全局的window是其上下文。

var k = 200;
var o = {
    k : 100,
    m : (function()  {
     console.log(k);        //200
     console.log(this.k);   // 200
    } )()
}

o.m;

其他一些问题：（好难）

1.考的是函数中参数arguments的类型，arguments是参数的集合，是一个对象不是数组

(function(){
    return typeof arguments;
})()
结果是: object

2.命名函数表达式的函数名只对函数体内可见

var f = function g(){ return 23; };
  typeof g();
//根据标准，命名函数表达式的函数名只对函数体内可见 
//因此报错

//Uncaught ReferenceError: g is not defined
//at <anonymous>:3:3
//at Object.InjectedScript._evaluateOn (<anonymous>:905:140)
//at Object.InjectedScript._evaluateAndWrap (<anonymous>:838:34)
//at Object.InjectedScript.evaluate (<anonymous>:694:21)

3.参数是不可删除的

(function(x){
    delete x;
    return x;
    })(1);
结果是：1

4.未赋值的变量默认为undefined

var y = 1, x = y = typeof x;
    x;
结果是:undefined
//声明两个变量x与y，y最初赋为1,x没有赋值，默认赋给window的一个属性undefined，
//因此typeof undefined为"undefined",最后x= y= "undefined"

5.函数名被优先级更高的参数名覆盖了,内存覆盖了

 (function f(f){
    return typeof f();
    })(function(){ return 1; });
//结果就是： typeof 1; 最终结果是: number
//函数名被优先级更高的参数名覆盖了

6.自执行函数的上下文，这个解释了自执行函数的上写文是window了

 var foo = { 
      bar: function() { return this.baz; }, 
      baz: 1
    };
    (function(){ 
      return typeof arguments[0]();
    })(foo.bar);
结果是: undefined
//我们把下面那个自动执行函数分解一下
//var a = function(){
//  return typeof arguments[0]();
//};
//a(foo.bar)
//执行完arguments[0]()，即得到this.baz
//由于this变量在此绑定失效，它指向window，window有bax变量吗？
//没有，返回"undefined"

7.还是this指代的当前对象的变化

var foo = {
      bar: function(){ return this.baz; },
      baz: 1
    }
    typeof (f = foo.bar)();
结果是: undefined
解释是：这个函数可以等价于:
// window.f;
// f = foo.bar;
// f();
//此时this指向的对象是window了，所以最后结果是undefined;

8.内存中后赋值的会覆盖掉先赋值的（包括变量赋值和函数赋值哟）

 var f = (function f(){ return "1"; }, function g(){ return 2; })();
    typeof f;
结果是 typeof 2 => number
解释是： var a = ( 1,2,3 )
a ;  => 3
函数赋值亦是这样，f先是赋值为f(),然后赋值为g().
所以最后执行的是g函数

9.这题好难。。。。理解

var x = 1;
 if (function f(){}) {
   x += typeof f;
 }
x ;
结果是： 1undefined
//函数声明只能裸露于全局作用域下或位于函数体中
//从句法上讲，它们不能出现在快中，例如不能出现在if,while,或for语句中，因为块只能包含语句。
因此if()中的f函数不能当做函数声明，当成表达式使用
//可能是预编译阶段做了如下处理：
//if ( xxx = function(){} )
//根据第2条，命名函数表达式的函数名只对函数体内可见，所以是找不到f的。

10.typeof undefined = "undefined" //string型的

  var x = [typeof x, typeof y][1];
     typeof typeof x;
结果是： string
x数组其实是： [ "undefined" , "undefined" ]

11.这题其实简单，就是要看清楚{有几层

 (function(foo){
      return typeof foo.bar;
    })({ foo: { bar: 1 } });
结果是: undefined
看到这样复杂的可以这样解释：
var a = {foo:{bar:1}}
(function( foo ) {
return typeof foo.bar
})(a);
a中的属性只有foo

12.声明提升

(function f(){
      function f(){ return 1; }
      return f();
      function f(){ return 2; }
    })();
结果: 2

13.这题就不是很明白，应该是instanceof对象是否是特定类的一个实例

function f(){ return f; }
 new f() instanceof f;
结果是:false
解释是: 由于函数f会返回自身，这个new就形同虚设
如果f的形式为function f(){ return this;}或function f(){}就不一样

14.函数的length就是指它形参的长度，with就是一个读写器，题意就是取出函数的length属性

with (function(x, undefined){}) length;
结果是:2