arguments属性

在函数对象中有一个属性叫做arguments,通过这个属性可以获取相应的参数值，这个属性是一个数组，其实就是传递进来的参数

function say(num) {
        /*
         * 在函数对象中有一个属性叫做arguments,通过这个属性可以获取相应的参数值，这个属性
         * 是一个数组，其实就是传递进来的参数
         */
        alert(arguments.length);//3
        for(var i=0;i<arguments.length;i++) {
            alert(arguments[i]);//1,2,3
        }
        alert(num);//1
    }
    say(1,2,3);

arguments的callee方法

function factorial(num) {
        if(num<=1) return 1; 
        //此时和函数名耦合在一起
        else return num*factorial(num-1);
    }
    /**
     * 以上是一个求阶乘的函数,以上递归调用的函数名称和原有函数名耦合在一起了，如果将来这个函数名称更改之后，
     * 递归调用就会失效
     */
    var cf = factorial;
    //此时不会报错
    alert(cf(5));
    factorial = null;
    //此时由于cf这个函数依然使用factorial这个名称来调用，但是factorial已经指向null了，所以就会报错

在arguments这个对象中有一个callee的方法，arguments.callee(arg)可以反向的调用

function factorial(num) {
        if(num<=1) return 1; 
        //此时和函数名耦合在一起
        else return num*factorial(num-1);
        //以下就实现了函数名的解耦合，在js中通常都是使用这种方式做递归
        else return num*arguments.callee(num-1);

    }
    /**
     * 以上是一个求阶乘的函数,以上递归调用的函数名称和原有函数名耦合在一起了，如果将来这个函数名称更改之后，
     * 递归调用就会失效
     */
    var cf = factorial;
    //如上情况就需要使用arguments.callee方法来调用
    alert(cf(5));

this属性

当需要创建一个类的时候，设置类的属性和方法需要通过this关键字来引用。但是特别注意:this关键字在调用时会根据不同的调用对象变得不同。 

var color = "red";
    function showColor() {
        alert(this.color);
    }
    /**
     * 创建了一个类，有一个color的属性和一个show的方法
     */
    function Circle(color) {
        this.color = color;
        this.showColor = showColor;
    }

    var c = new Circle("yellow");
    //使用c来调用showColor方法，等于调用了showColor()方法
    //此时的this是c，所以color就是yellow
    c.showColor();//yellow
    //此时调用的对象等于是window,showColor的this就是window,所以就会找window中color
    showColor();//red

函数的length

函数的length就表示该函数所期望的参数值

function fn1() {

    }

    function fn2(num1,num2) {

    }

    function fn3(num1){

    }
    alert(fn1.length);//0
    alert(fn2.length);//2
    alert(fn3.length);//1

call和apply属性

call是通过参数列表来完成传递，apply是通过数组来完成传递。

function sum(num1,num2) {
        return num1+num2;
    }

    function callSum1(num1,num2) {
        //使用sum这个函数来完成一次调用，调用的参数就是callSum1这个函数的参数
        //apply的第二个参数表示一组参数数组
        return sum.apply(this,arguments);
    }

    function callSum2(num1,num2) {
        //关键就是第二个参数是数组
        return sum.apply(this,[num1,num2]);
    }
    alert(callSum1(12,22));//34
    alert(callSum2(22,32));//54

    function callSum3(num1,num2) {
        //call是通过参数列表来完成传递，其他和apply没有任何区别
        return sum.call(this,num1,num2);
    }
    alert(callSum3(22,33));//55

使用call和apply之后，对象中可以不需要定义方法了

var color = "red";
    function showColor() {
        alert(this.color);
    }
    /**
     * 创建了一个类，有一个color的属性和一个show的方法
     */
    function Circle(color) {
        this.color = color;
    }

    var c = new Circle("yellow");

    showColor.call(this);//使用上下文来调用showColor,结果是red
    showColor.call(c);//上下文对象是c,结果就是yellow