从use strict看JS（二）：函数传参模式与arguments

摘要：系列系列列表从看一与箭头函数从看二函数传参模式与的上一篇说到，对做了以下限定。是另外一个变量，指向不同的值，而这两个值有相同的类型。函数中，和指向同一个值，更改的就等于更改了的。可以用改进问题是这个在严格模式下不能运行。

系列列表：
从use strict看JS（一）：this与箭头函数
从use strict看JS（二）：函数传参模式与arguments

上一篇说到，use strict对arguments做了以下限定

arguments。不允许对arguments赋值。禁止使用arguments.callee。arguments不再追踪参数的变化

这是为什么呢？如果你明白下面两个例子就不用看这篇文章了~

    function notChangeName(obj){
        obj="change";
    }
    function changeName(obj){
        obj.name="change";
    }
    var dog={
        name:"dog"
    };
    notChangeName(dog);
    //输出Object {name: "dog"}，没改变
    console.log(dog);
    changeName(dog);
    //输出Object {name: "change"}，改了
    console.log(dog);

    //经典例子,JavaScript高级程序设计的例子
    function setName(obj){
        obj.name="doge";
        obj=new Object();
        obj.name="cat";
    }
    var person={};
    setName(person);
    //doge
    console.log(person.name);

function notChangeName(name){
    "use strict";
    name="cat";
    // 严格模式输出dog，非严格输出cat
    console.log(arguments[0]);
}
function changeName(obj){
    "use strict";
    obj.name="cat";
    // 输出cat
    console.log(arguments[0].name);
}
notChangeName("dog");
changeName({name:"dog"});

function dog(){
    // "use strict";
    //严格模式SyntaxError，非严格输出"a"
    arguments="a";
    console.log(arguments);
}
dog();

js一个变量对应一个值，一个值对应一种类型；而一种类型对应多个值，一个值对应多个变量。
字符串的值不能改变，但能让变量指向不同的值

举两个栗子：

no1.

var dog={
}
var cat=dog;
dog.name="doge";
var third={
    name:"the third man"
}
// 输出doge
console.log(cat.name);

上述例子中，dog和cat是不同的变量，但指向同一个值，所以dog改变会反应到cat上。third是另外一个变量，指向不同的值，而这两个值有相同的类型。如下图

no2.

var str="doge";
// 输出o
console.log(str[1]);
str[1]="c";
// 输出o，字符串的值不能改变
console.log(str[1]);
str="cat";
// 输出c，变量指向了不同的值
console.log(str[0]);

所以，在前面的例子中，notChangeName函数内部将变量obj指向不同的值，外部的dog指向同一个值且值未发生变化。因而不能改变dog的name。
changeName函数中，obj和dog指向同一个值，更改obj的name就等于更改了dog的name。
JavaScript高级程序设计的例子同理。如下：

    function notChangeName(obj){
        obj="change";
    }
    function changeName(obj){
        obj.name="change";
    }
    var dog={
        name:"dog"
    };
    notChangeName(dog);
    //输出Object {name: "dog"}，没改变
    console.log(dog);
    changeName(dog);
    //输出Object {name: "change"}，改了
    console.log(dog);

    //经典例子,JavaScript高级程序设计的例子
    function setName(obj){
        obj.name="doge";
        obj=new Object();
        obj.name="cat";
    }
    var person={};
    setName(person);
    //doge
    console.log(person.name);

use strict下的arguments会保持对“值”的引用，因而arguments变量是不能被重新赋值的，如果强制赋值呢？比如arguments="a"，那就强制报错，没得商量。
也是因为保持对“值”的引用，arguments不再追踪参数的变化，但如果参数是obj且改变的是“值”，而不是重新赋值，那就不一样了。如下：

function notChangeName(name){
    "use strict";
    name="cat";
    // 严格模式输出dog，非严格输出cat
    console.log(arguments[0]);
}
function changeName(obj){
    "use strict";
    obj.name="cat";
    // 输出cat
    console.log(arguments[0].name);
}
notChangeName("dog");
changeName({name:"dog"});

function dog(){
    // "use strict";
    //严格模式SyntaxError，非严格输出"a"
    arguments="a";
    console.log(arguments);
}
dog();

这就是一个点而已，arguments不是数组，是个类数组对象，没有数组的push、pop、map那些方法，那如何把它变为数组呢？循环遍历一遍也是可以的，arguments有长度，但有更简单的方法，如下：

function argToArr(index){
    var newArg=Array.prototype.slice.apply(arguments);
    newArg.push(2);
}
argToArr(1);

为何不直接

arguments=Array.prototype.slice.apply(arguments);

因为现在很多都用use strict了，这个会报错，还不知道为何会报错的再看一遍文章哈，自觉点

这个用来干啥呢，它能在函数内部调用自己，常用来解耦和。比如写个斐波那契数列函数

function fib(n){
    if(n===1||n===2){
        return 1;
    }
    return fib(n-1)+fib(n-2);
}

这个问题在哪呢，耦合性太强，改了外层的fib，内部函数名称也得改。可以用arguments.callee改进

function fibArg(n){
    if(n===1||n===2){
        return 1;
    }
    return arguments.callee(n-1)+arguments.callee(n-2);
}

问题是这个在严格模式下不能运行。不绕了，来个终极方法

var fib=(function f(n){
    "use strict";
    if(n===1||n===2){
        return 1;
    }
    return f(n-1)+f(n-2);
})

这种模式之后还会涉及，跟立即执行函数类似，jQuery这些也用了，以后再聊~

好像没谈为何要这样限定arguments！

夜已深，就不继续悟道了。