摘要：方法真是一個有意思的東西，它可以改變函數(shù)調(diào)用時的值。所以前面的說法其實(shí)不對，所有的對象都可以被視為類數(shù)組，有的視為長度為的數(shù)組，沒有的，視為長度為的數(shù)組。

call方法真是一個有意思的東西，它可以改變函數(shù)調(diào)用時this的值。而我們知道，在函數(shù)里，this指向了調(diào)用這個函數(shù)的環(huán)境對象，比如一道經(jīng)典面試題：

var num = 2;
var obj = {
  num: 1,
  show: function () {
    console.log(this.num)
  }
};
var foo = obj.show;
obj.show();/* 顯示1；show是被obj調(diào)用的，所以this指向obj */
foo();/* 顯示2；相當(dāng)于global.foo(),所以this指向global，如果在瀏覽器里global就是window */

換句話說，如果一個對象obj上有方法foo，你可以通過obj.foo()調(diào)用；如果沒有obj上沒有方法foo，obj.foo()是會報錯的，但是，使用foo.call(obj)，可以強(qiáng)行達(dá)到obj.foo()的效果，比如：

function foo(){
    console.log(this.num);
}
var obj = {
    num: 1
}
foo.call(obj);// 1

Array.prototype.slice.call的用處就是這樣，可以在array-like（類數(shù)組，就是長得像數(shù)組，但不是數(shù)組）的對象上強(qiáng)行使用slice方法，比如：Array.prototype.slice.call(arguments)就是把arguments對象轉(zhuǎn)化為數(shù)組。當(dāng)然，除了arguments，我們還能在HTMLCollection或NodeList身上使用。那么到底什么算是類數(shù)組呢？

有l(wèi)ength屬性的對象。

比如：

var obj1 = {
  0: "Tom",
  1: "Jack",
  2: "Jason",
  length: 3
}
var arr = [].slice.call(obj1);
console.log("arr: ", arr);/* [ "Tom", "Jack", "Jason" ] */

那如果沒有l(wèi)ength呢？

var obj1 = {
  0: "Tom",
  1: "Jack",
  2: "Jason"
}
var arr = [].slice.call(obj1);//* [] */

原來沒有l(wèi)ength屬性的對象也會被轉(zhuǎn)為數(shù)組，只不過認(rèn)為它length=0而已。

那如果對象的屬性沒有按照0-n順序乖乖排好呢？

var obj1 = {
  1: "Tom",
  3: "Jack",
  5: "Jason",
  7: "Dave",
  foo: "bar",
  length: 6
}
var arr = [].slice.call(obj1);/* [ , "Tom", , "Jack", , "Jason" ] */

原來轉(zhuǎn)化的時候，會以length為基礎(chǔ)，生成一個長度為length的數(shù)組，obj的屬性是數(shù)組的有效index的話，就會把對應(yīng)值填入到對應(yīng)位置，其他的位置找不到值，就會填入undefined。

所以前面的說法其實(shí)不對，所有的對象都可以被視為類數(shù)組，有length的視為長度為length的數(shù)組，沒有的，視為長度為0的數(shù)組。

以length屬性為基礎(chǔ)

這句話很重要。

另外，call方法的參數(shù)如果是原始值類型，會傳入它的自動包裝對象：

var arr = [].slice.call("hello");

等價于：

var arr = [].slice.call(new String("hello"));/* [ "h", "e", "l", "l", "o" ] */

因?yàn)閚ew String("hello")就是
{
    0: "h",
    1: "e",
    2: "l",
    3: "l",
    4: "o",
    length: 5
}    

以上就是Array.prototype.slice.call的一些細(xì)節(jié)，那么除了slice之外，Array對象還有很多其他的方法，這些方法是不是也能用到對象身上呢？

join方法是把數(shù)組轉(zhuǎn)化為字符串的方法，具體表現(xiàn)不再贅述，看兩個例子：

var obj1 = {
  0: "Tom",
  1: "Jack",
  2: "Jason",
  length: 6
}
var arr = [].join.call(obj1, "-");// Tom-Jack-Jason---

var obj1 = {
  0: "Tom",
  1: "Jack",
  2: "Jason",
}
var arr = [].join.call(obj1, "-"); // ""

還是那句話，以length為基礎(chǔ),沒有length屬性的，視為長度為0的數(shù)組。

這個方法比較好玩：

var obj1 = {
  0: "Tom",
  1: "Jack",
  2: "Jason",
  length: 6
}
var arr = [].push.call(obj1, "Dave");
console.log("arr: ", arr);// 7，因?yàn)閜ush方法返回的是push之后array的操作數(shù)
console.log("obj: ", obj1);// { "0": "Tom", "1": "Jack", "2": "Jason", "6": "Dave", length: 7 }

可以看到obj1里新增屬性6，值為"Dave"，并且length也更新為7，這說明調(diào)用push時會對原有對象進(jìn)行修改。
我們可以利用這個特性，比如當(dāng)我們需要一個obj1的類數(shù)組副本時：

var obj = {
  foo: "foo",
  bar: "bar",
  cei: "cei"
};
var copy = {};
for (var i in obj) {
  [].push.call(copy, obj[i])
}
console.log(copy);// { "0": "foo", "1": "bar", "2": "cei", length: 3 }

如果，沒有傳入length呢？

var obj1 = {
  0: "Tom",
  1: "Jack",
  2: "Jason"
}
var arr = [].push.call(obj1, "Dave");
console.log("arr: ", arr);// 1
console.log("obj: ", obj1);// { "0": "Dave", "1": "Jack", "2": "Jason", length: 1 }

這里的行為有些詭異，不過也更好地解釋了以length為基礎(chǔ)這句話：
沒有length的時候，認(rèn)為數(shù)組長度為0，并且會對obj進(jìn)行修改，把屬性0的值改為Dave.

那么，會舉一反三的話，對于pop, shift和unshift這三個方法的行為應(yīng)該能想象得出來，就不再贅述了。

var obj1 = {
  0: "Tom",
  1: "Jack",
  2: "Jason",
  length: 6
}
var arr = [].reverse.call(obj1);
console.log("arr: ", arr);// { "3": "Jason", "4": "Jack", "5": "Tom", length: 6 }
console.log("obj: ", obj1);// { "3": "Jason", "4": "Jack", "5": "Tom", length: 6 }

reverse的話，arr === obj1

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].sort.call(obj1);
console.log("arr: ", arr);// { "0": "a", "1": "b", "2": "c", length: 6 }
console.log("obj: ", obj1);// { "0": "a", "1": "b", "2": "c", length: 6 }

sort也一樣，arr === obj1

concat的表現(xiàn)就不是我們意料之中的了：

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}

var add = {
  foo: "foo",
  bar: "bar"
}
var arr = [].concat.call(obj1, add);
console.log("arr: ", arr);// [ { "0": "c", "1": "b", "2": "a", length: 6 }, "foo", "bar" ]
console.log("obj: ", obj1);// { "0": "c", "1": "b", "2": "a", length: 6 }

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].concat.call(obj1, "foo", "bar");
console.log("arr: ", arr);// [ { "0": "c", "1": "b", "2": "a", length: 6 }, "foo", "bar" ]
console.log("obj: ", obj1);// { "0": "c", "1": "b", "2": "a", length: 6 }

可以看到obj1并不會改變，不會像push一樣會接著形成一個類數(shù)組的對象.

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].splice.call(obj1, 0, 1);
console.log("arr: ", arr);// [ "c" ]
console.log("obj: ", obj1);// { "0": "b", "1": "a", length: 5 }

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].splice.call(obj1, 1, 0, "foo","bar");
console.log("arr: ", arr);// []
console.log("obj: ", obj1);// { "0": "c", "1": "foo", "2": "bar", "3": "b", "4": "a", length: 8 }

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].splice.call(obj1, 1, 1, "foo","bar");
console.log("arr: ", arr);// [ "b" ]
console.log("obj: ", obj1);// { "0": "c", "1": "foo", "2": "bar", "3": "a", length: 7 }

splice的行為回歸了，它現(xiàn)在對obj1產(chǎn)生影響，并且是我們預(yù)計的樣子

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].every.call(obj1, function (val) {
  return val === "a" || val === "c"
});
console.log("arr: ", arr);// false
console.log("obj: ", obj1);// { "0": "c", "1": "b", "2": "a", length: 6 }

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].filter.call(obj1, function (val) {
  return val === "a" || val === "c"
});
console.log("arr: ", arr);// [ "c", "a" ]
console.log("obj: ", obj1);// { "0": "c", "1": "b", "2": "a", length: 6 }

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].forEach.call(obj1, function (val) {
  return val + " add";
});
console.log("arr: ", arr);// undefined
console.log("obj: ", obj1);// { "0": "c", "1": "b", "2": "a", length: 6 }

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].map.call(obj1, function (val) {
  return val + " add";
});
console.log("arr: ", arr);// [ "c add", "b add", "a add", , ,  ]
console.log("obj: ", obj1);// { "0": "c", "1": "b", "2": "a", length: 6 }

var obj1 = {
  0: "c",
  1: "b",
  2: "a",
  length: 6
}
var arr = [].reduce.call(obj1, function (pre, cur) {
  return pre + " " + cur
});
console.log("arr: ", arr);// "c b a"
console.log("obj: ", obj1);// { "0": "c", "1": "b", "2": "a", length: 6 }