JavaScript函数参数与调用

函数调用：

/*    1.    函数调用        */
      var temp = distance(0,1,2,3);
        
/*    2.    方法调用        */
      this.CName = "全局";
      var o = {
            CName:"o类",
            m:function(){
                  var self = this;
                  console.log(this == o);            //true
                  console.log(this.CName);         //o类
                  f();
                  function f(){
                          console.log(this == o);        
                         //false,此this绑定到全局对象
                          console.log(this.CName);    
                         //全局
                          console.log(self == o);        
                          //true
                          console.log(self.CName);    
                          //o类
                }
           }

      };
      o.m();
       

关于this：

一丶当它为一个对象上的方法的时候，this是当前这个对象。

二丶函数调用模式当函数并非一个对象的属性时，那么它被当做一个函数来调用。此模式下this绑定到全局对象。通过在对象内将this赋值给that，可以使函数模式下调用that来访问指定对象。

函数的实参和形参：

/*    1.    可选形参        */
      function getPropertyNames(o,a){
            a = a||[];
            for(var property in o){
                a.push(property);
            }
            return a;    
      }
    
      var a = getPropertyNames(o);
      var b;
      getPropertyNames(p,b);             //    两种调用
        
    /*    2.    可变长实参        */
      function max(){
            var max = 0;
            for(var i=0; i<arguments.length; i++){
                if(arguments[i]>max){
                    max=arguments[i];
                }
            return max;
            }
      }
        
      // 关于arguments
      function test_1(a,b,c,d){
            console.log(a,b,c,d);            //1,2,3,4
            for(var i=0; i<arguments.length; i++){
                arguments[i] = 0;
            }
            console.log(a,b,c,d);            //0,0,0,0
      }
      test_1(1,2,3,4);
      //改变arguments[i]时，对应传进去的参数也会改变

caller&callee：

      //    caller:    正在执行函数的函数
      //    callee:    正在执行的函数
      function test_2(){
            console.log("test_2");
            
            function test_3(){
                  console.log("test_3");
                  function test_4(){
                        console.log("test_4");
                        //arguments.callee();  //这里会循环调用test_4
                        //test_4.caller();//这里回调到test_4调用者test_3
                }
                return test_4();
            }
            return test_3();
        }
        test_2();
        
        // 还可以用来做递归
        var plus = function(x){
            if(x<=1) return 1;
            return x*arguments.callee(x-1);
        }
        console.log(plus(5));

参数类型检测：

isfinite();        //    是否有限数
isArrayLike();  //    是否是数组

函数的自定义属性：

uniqueInterger.count = 0
//    给uniqueInterger函数定义了一个count属性
function uniqueInterger(){
      //var a="myfunc";
     return uniqueInterger.count++;
}
    console.log(uniqueInterger());    //    0
    console.log(uniqueInterger());    //    1
    console.log(uniqueInterger());    //    2

作为命名空间的函数：

function myModule(){
     //    模块代码
     //    这个模块使用的变量都是局部变量
     //    不会污染全局命名空间
}
myModule()  //别忘记调用这个函数
        
//或者更简单的
(function(){
     // 模块代码
}());