函数调用


　　只有函数被调用时，才会执行。调用运算符是跟在任何产生一个函数值的表达式之后的一对圆括号，圆括号内可包含零个或多个用逗号隔开的表达式。每个表达式产生一个参数值，每个参数值被赋予函数声明时定义的形参名
　　javascript一共有4种调用模式：函数调用模式、方法调用模式、构造器调用模式和间接调用模式
【1】函数调用模式
　　当一个函数并非一个对象的属性时，那么它就是被当做一个函数来调用的。对于普通的函数调用来说，函数的返回值就是调用表达式的值

  1. function add(x,y){
  2.     return x+y;
  3. }
  4. var sum = add(3,4);
  5. console.log(sum)//7

　　使用函数调用模式调用函数时，非严格模式下，this被绑定到全局对象；在严格模式下，this是undefined

  1. function add(x,y){
  2.     console.log(this);//window
  3. }    
  4. add();
  5. function add(x,y){
  6.     'use strict';
  7.     console.log(this);//undefined
  8. }    
  9. add();//window

　　因此，’this’可以用来判断当前是否是严格模式

  1. var strict = (function(){return !this;}());

重写
　　因为函数调用模式的函数中的this绑定到全局对象，所以会发生全局属性被重写的现象

  1. var a = 0;
  2. function fn(){
  3.     this.a = 1;
  4. }
  5. fn();
  6. console.log(this,this.a,a);//window 1 1

【2】方法调用模式
　　当一个函数被保存为对象的一个属性时，我们称它为一个方法。当一个方法被调用时，this被绑定到该对象。如果调用表达式包含一个提取属性的动作，那么它就是被当做一个方法来调用

  1. var o = {
  2.     m: function(){
  3.         console.log(1);
  4.     }
  5. };
  6. o.m();//1

　　方法可以使用this访问自己所属的对象，所以它能从对象中取值或对对象进行修改。this到对象的绑定发生在调用的时候。通过this可取得它们所属对象的上下文的方法称为公共方法
有点类似于python里的方法调用 func(self, a, b)

  1. var o = {
  2.     a: 1,
  3.     m: function(){
  4.         return this;
  5.     },
  6.     n: function(){
  7.         this.a = 2;
  8.     }
  9. };
  10. console.log(o.m().a);//1
  11. o.n();
  12. console.log(o.m().a);//2

　　任何函数只要作为方法调用实际上都会传入一个隐式的实参——这个实参是一个对象，方法调用的母体就是这个对象。通常来讲，基于那个对象的方法可以执行多种操作，方法调用的语法已经很清晰地表明了函数将基于一个对象进行操作

  1. rect.setSize(width,height);
  2. setRectSize(rect,width,height);

　　假设上面两行代码的功能完全一样，它们都作用于一个假定的对象rect。可以看出，第一行的方法调用语法非常清晰地表明这个函数执行的载体是rect对象，函数中的所有操作都将基于这个对象
　　和变量不同，关键字this没有作用域的限制，嵌套的函数不会从调用它的函数中继承this。如果嵌套函数作为方法调用，其this的值指向调用它的对象。如果嵌套函数作为函数调用，其this值不是全局对象(非严格模式下)就是undefined(严格模式下)

  1. var o = {
  2.     m: function(){
  3.          function n(){
  4.              return this;
  5.          }
  6.          return n();
  7.     }
  8. }
  9. console.log(o.m());//window
  10. var o = {
  11.     m: function(){
  12.          function n(){
  13.              'use strict';
  14.              return this;
  15.          }
  16.          return n();
  17.     }
  18. }
  19. console.log(o.m());//undefined

　　如果想访问这个外部函数的this值，需要将this的值保存在一个变量里，这个变量和内部函数都同在一个作用域内。通常使用变量self或that来保存this
比如：考虑一些dragFunc它们的调用来自于其自身的类，所以this指向原类，这时如果需要window中的变量值，就需要用self将之保存。在angular中，应该将这样的变量定义写到init中，而不能在初始变量声明中直接定义。

  1. var o = {
  2.     m: function(){
  3.         var self = this;
  4.         console.log(this === o);//true
  5.          function n(){
  6.              console.log(this === o);//false
  7.              console.log(self === o);//true
  8.              return self;
  9.          }
  10.          return n();
  11.     }
  12. }
  13. console.log(o.m() === o);//true

【3】构造函数调用模式
　　如果函数或者方法调用之前带有关键字new，它就构成构造函数调用

  1. function fn(){
  2.     this.a = 1;
  3. };
  4. var obj = new fn();
  5. console.log(obj.a);//1

　　如果构造函数调用在圆括号内包含一组实参列表，先计算这些实参表达式，然后传入函数内

  1. function fn(x){
  2.     this.a = x;
  3. };
  4. var obj = new fn(2);
  5. console.log(obj.a);//2

　　如果构造函数没有形参，javascript构造函数调用的语法是允许省略实参列表和圆括号的。凡是没有形参的构造函数调用都可以省略圆括号

  1. var o = new Object();
  2. //等价于
  3. var o = new Object;

　　[注意]尽管构造函数看起来像一个方法调用，它依然会使用这个新对象作为调用上下文。也就是说，在表达式new o.m()中，调用上下文并不是o

  1. var o = {
  2.     m: function(){
  3.         return this;
  4.     }
  5. }
  6. var obj = new o.m();
  7. console.log(obj,obj === o);//{} false
  8. console.log(obj.constructor === o.m);//true

　　构造函数通常不使用return关键字，它们通常初始化新对象，当构造函数的函数体执行完毕时，它会显式返回。在这种情况下，构造函数调用表达式的计算结果就是这个新对象的值

  1. function fn(){
  2.     this.a = 2;
  3. }
  4. var test = new fn();
  5. console.log(test);//{a:2}

　　如果构造函数使用return语句但没有指定返回值，或者返回一个原始值（如：返回1），那么这时将忽略返回值，同时使用这个新对象作为调用结果

  1. function fn(){
  2.     this.a = 2;
  3.     return;
  4. }
  5. var test = new fn();
  6. console.log(test);//{a:2}

　　如果构造函数显式地使用return语句返回一个对象，那么调用表达式的值就是这个对象

  1. var obj = {a:1};
  2. function fn(){
  3.     this.a = 2;
  4.     return obj;
  5. }
  6. var test = new fn();
  7. console.log(test);//{a:1}

【4】间接调用模式
　　javascript中函数也是对象，函数对象也可以包含方法。call()和apply()方法可以用来间接地调用函数
　　这两个方法都允许显式指定调用所需的this值，也就是说，任何函数可以作为任何对象的方法来调用，哪怕这个函数不是那个对象的方法。两个方法都可以指定调用的实参。call()方法使用它自有的实参列表作为函数的实参，apply()方法则要求以数组的形式传入参数

  1. var obj = {};
  2. function sum(x,y){
  3.     return x+y;
  4. }
  5. console.log(sum.call(obj,1,2));//3
  6. console.log(sum.apply(obj,[1,2]));//3