§ Array.from

Array.from(arrayLike[, mapFn[, thisArg]])

  • arrayLike
    • 想要转换成数组的伪数组对象或可迭代对象。
  • mapFn (可选参数)
    • 如果指定了该参数,新数组中的每个元素会执行该回调函数。
  • thisArg (可选参数)
    • 可选参数,执行回调函数 mapFn 时 this 对象。

从一个类似数组或可迭代对象中创建一个新的数组实例。
返回一个新的数组实例

1
2
3
4
5
6
7
var bar = ["a", "b", "c"];
Array.from(bar); // ["a", "b", "c"]

Array.from('foo'); // ["f", "o", "o"]

let s = new Set(['foo', window]);
Array.from(s); // ["foo", window]

§ Array.isArray

Array.isArray(obj)
确定传递的值是否是一个Array。
返回一个boolean值

1
2
3
4
5
6
7
8
9
10
11
12
Array.isArray([]);              // true
Array.isArray([1]); // true
rray.isArray(new Array()); // true
Array.isArray(Array.prototype); // true,Array.prototype 也是一个数组
Array.isArray(); // false
Array.isArray({}); // false
Array.isArray(null); // false
Array.isArray(undefined); // false
Array.isArray(17); // false
Array.isArray('Array'); // false
Array.isArray(true); // false
Array.isArray(false); // false

§ Array.prototype.concat

arrayObject.concat(arrayX,arrayX,......,arrayX)
用于连接两个或多个数组。
不会改变原数组,会返回被连接数组的一个副本。

1
arr1.contact(arr2)

§ Array.prototype.join

arrayObject.join(separator)
separator是指定要使用的分隔符。如果省略该参数,则使用逗号作为分隔符。
将一个数组(或一个类数组对象)的所有元素连接成一个字符串并返回这个字符串。
不会改变原数组,会返回拼接的字符串。

1
["hello", "world", "!"].join("-");    // hello-world-!

§ Array.prototype.map

创建一个新数组,其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
不会改变原数组,返回一个新数组,每个元素都是回调函数的结果。

1
2
3
4
5
6
7
8
9
10
11
var new_array = arr.map(function callback(currentValue, index, array) {
// Return element for new_array
}[, thisArg])

var numbers = [1, 4, 9];
var doubles = numbers.map(function(num) {
return num * 2;
});

// doubles数组的值为: [2, 8, 18]
// numbers数组未被修改: [1, 4, 9]

§ Array.prototype.forEach

对数组的每个元素执行一次提供的函数。
不会改变原数组,没有返回值

1
2
3
4
5
array.forEach(callback(currentValue, index, array){
//do something
}, this)

array.forEach(callback[, thisArg])

§ Array.prototype.pop

从数组中删除最后一个元素,此方法更改数组的长度。
改变原数组,并返回该删除元素的值

1
[12, 32, 43, 89].pop()      // 89

§ Array.prototype.push

将一个或多个元素添加到数组的末尾。
改变原数组,返回新数组的长度

1
2
3
arr.push(element1, ..., elementN)

["ss", "nnn"].push("opio", "yuuy");

§ Array.prototype.shift

从数组中删除第一个元素,并返回该元素的值。
改变原数组,返回改删除的值

1
[22, 323, 434].shift();    // 22

§ Array.prototype.unshift

将一个或多个元素添加到数组的开头。
改变原数组,返回新数组的长度。

1
2
3
arr.unshift(element1, ..., elementN)

[11, 22, 33].unshift(44, 55); // 5

§ Array.prototype.reverse

将数组中元素的位置颠倒。第一个数组元素成为最后一个数组元素,最后一个数组元素成为第一个。
改变原数组。返回该数组的引用

1
2
3
arr.reverse()

['one', 'two', 'three'].reverse(); // ['three', 'two', 'one']

§ Array.prototype.slice

返回一个从开始到结束(不包括结束)选择的数组的一部分浅拷贝到一个新数组对象。
原始数组不会被修改。

1
2
3
4
5
6
7
8
arr.slice();
// [0, end]

arr.slice(begin);
// [begin, end]

arr.slice(begin, end);
// [begin, end)

§ Array.prototype.splice

通过删除现有元素和/或添加新元素来更改一个数组的内容。
改变原数组,返回被删除的元素组成的数组

1
2
3
4
5
array.splice(start)

array.splice(start, deleteCount)

array.splice(start, deleteCount, item1, item2, ...)

§ Array.prototype.indexof

返回在数组中可以找到一个给定元素的第一个索引,如果不存在,则返回-1。

1
2
3
4
5
6
7
8
9
arr.indexOf(searchElement)
arr.indexOf(searchElement[, fromIndex = 0])

var array = [2, 5, 9];
array.indexOf(2); // 0
array.indexOf(7); // -1
array.indexOf(9, 2); // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0

§ Array.prototype.lastIndexOf

回指定元素(也即有效的 JavaScript 值或变量)在数组中的最后一个的索引。
如果不存在则返回 -1。从数组的后面向前查找,从 fromIndex 处开始。

1
arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])