JavaScript-Array

影响原数组的方法	不影响原数组的方法
pop,push,shift,unshift,splice,fill等	concat、reverse、join、slice

伪数组对象	可迭代对象
（拥有一个 length 属性和若干索引属性的任意对象）,如String，因为`var s = '123';s.length为3，s[0]为1`	可以获取对象中的元素,如 Map和 Set 等

Array
- [element0, element1, …, elementN]
- new Array(element0, element1[, …[, elementN]])
- new Array(arrayLength)//注意这里，当参数个数只有一个且为数字时的差别就在这里
Array.length
- length 属性的值是一个 0 到 2^32-1 的整数。
- 可以设置 length 属性的值来截断任何数组。当通过改变length属性值来扩展数组时，实际元素的数目将会增加。例如：将一个拥有 2 个元素的数组的 length 属性值设为 3 时，那么这个数组将会包含3个元素，并且，第三个元素的值将会是 undefined 。
- length 属性不一定表示数组中定义值的个数
Array.prototype
- Array.prototype 本身也是一个 Array。
- 因为 Array.prototype 也是个数组，所以它也有 length 属性，这个值为 0，因为它是个空数组。
Array.from
- 从一个类似数组或者可迭代对象中创建新的数组
- Array.from(arrayLike[, mapFn[, thisArg]])
- 等价于Array.from(arrayLike).map(mapFn,thisArg);
- IE不支持，需要pollfily
Array.of
- 创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
- 参考pollfily，可以理解Array.of的作用

if (!Array.of) {
  Array.of = function() {
    return Array.prototype.slice.call(arguments);
  };
}

Array.prototype.concat()
- 用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。
- 注意concat的拷贝是浅拷贝，即只拷贝数组中存储对象的内存地址。
Array.prototype.copyWithin()
- 浅复制数组的一部分到同一数组中的另一个位置，并返回它，而不修改其大小。
- arr.copyWithin(target[, start[, end]])
- target：0 为基底的索引，复制序列到该位置。如果是负数，target 将从末尾开始计算。如果 target 大于等于 arr.length，将会不发生拷贝。如果 target 在 start 之后，复制的序列将被修改以符合 arr.length。
- start：0 为基底的索引，开始复制元素的起始位置。如果是负数，start 将从末尾开始计算。如果 start 被忽略，copyWithin 将会从0开始复制。
- end：0 为基底的索引，开始复制元素的结束位置。copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。如果是负数， end 将从末尾开始计算。
  如果 end 被忽略，copyWithin 将会复制到 arr.length。

var array1 = [1, 2, 3, 4, 5];

// place at position 0 the element between position 3 and 4
console.log(array1.copyWithin(0, 3, 4));
// expected output: Array [4, 2, 3, 4, 5]

// place at position 1 the elements after position 3
console.log(array1.copyWithin(1, 3));
// expected output: Array [4, 4, 5, 4, 5]

Array.prototype.entries
- 返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。
- arr.entries()
  - 1、 Array Iterator
    - var iterator = arr.entries();
  - 2、iterator.next()
    - console.log(iterator.next());
  - 3、iterator.next方法运行

var arr = ["a", "b", "c"];
var iter = arr.entries();
var a = [];

// for(var i=0; i< arr.length; i++){   // 实际使用的是这个 
for(var i=0; i< arr.length+1; i++){    // 注意，是length+1，比数组的长度大
    var tem = iter.next();             // 每次迭代时更新next
    console.log(tem.done);             // 这里可以看到更新后的done都是false
    if(tem.done !== true){             // 遍历迭代器结束done才是true
        console.log(tem.value);
        a[i]=tem.value;
    }
}
    
console.log(a);

var arr = ["a", "b", "c"];
var iterator = arr.entries();
// undefined

for (let e of iterator) {
    console.log(e);
}

// [0, "a"] 
// [1, "b"] 
// [2, "c"]

Array.prototype.every
- 测试数组的所有元素是否都通过了指定函数的测试。
- arr.every(callback[, thisArg])
- every 方法为数组中的每个元素执行一次 callback 函数，直到它找到一个使 callback 返回 false（表示可转换为布尔值 false 的值）的元素。如果发现了一个这样的元素，every 方法将会立即返回 false。否则，callback 为每一个元素返回 true，every 就会返回 true。callback 只会为那些已经被赋值的索引调用。不会为那些被删除或从来没被赋值的索引调用。
- callback 被调用时传入三个参数：元素值，元素的索引，原数组。
Array.prototype.fill
- 用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。
- arr.fill(value[, start[, end]])
- fill 方法接受三个参数 value, start 以及 end. start 和 end 参数是可选的, 其默认值分别为 0 和 this 对象的 length 属性值。
  如果 start 是个负数, 则开始索引会被自动计算成为 length+start, 其中 length 是 this 对象的 length 属性值。如果 end 是个负数, 则结束索引会被自动计算成为 length+end。

[1, 2, 3].fill(4);               // [4, 4, 4]
[1, 2, 3].fill(4, 1);            // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
[1, 2, 3].fill(4, 3, 3);         // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
[1, 2, 3].fill(4, 3, 5);         // [1, 2, 3]
Array(3).fill(4);                // [4, 4, 4]
[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}

// Objects by reference.
var arr = Array(3).fill({}) // [{}, {}, {}];
arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]

Array.prototype.filter
- 创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。
- var new_array = arr.filter(callback(element[, index[, array]])[, thisArg])
- filter 为数组中的每个元素调用一次 callback 函数，并利用所有使得 callback 返回 true 或等价于 true 的值的元素创建一个新数组。callback 只会在已经赋值的索引上被调用，对于那些已经被删除或者从未被赋值的索引不会被调用。那些没有通过 callback 测试的元素会被跳过，不会被包含在新数组中。
- callback 被调用时传入三个参数：
  - 元素的值
  - 元素的索引
  - 被遍历的数组

function isBigEnough(element) {
  return element >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

Array.prototype.find
- 返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
- arr.find(callback[, thisArg])
- find 方法对数组中的每一项元素执行一次 callback 函数，直至有一个 callback 返回 true。当找到了这样一个元素后，该方法会立即返回这个元素的值，否则返回 undefined。注意 callback 函数会为数组中的每个索引调用即从 0 到 length - 1，而不仅仅是那些被赋值的索引，这意味着对于稀疏数组来说，该方法的效率要低于那些只遍历有值的索引的方法

var inventory = [
    {name: 'apples', quantity: 2},
    {name: 'bananas', quantity: 0},
    {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
    return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries)); // { name: 'cherries', quantity: 5 }

Array.prototype.findIndex()
- 返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。
- findIndex方法对数组中的每个数组索引0…length-1（包括）执行一次callback函数，直到找到一个callback函数返回真实值（强制为true）的值。如果找到这样的元素，findIndex会立即返回该元素的索引。如果回调从不返回真值，或者数组的length为0，则findIndex返回-1。与某些其他数组方法（如Array#some）不同，在稀疏数组中，即使对于数组中不存在的条目的索引也会调用回调函数。
Array.prototype.forEach()
- 对数组的每个元素执行一次提供的函数。
- 没有办法中止或者跳出 forEach 循环，除了抛出一个异常。如果你需要这样，使用forEach()方法是错误的，你可以用一个简单的循环作为替代。如果您正在测试一个数组里的元素是否符合某条件，且需要返回一个布尔值，那么可使用 Array.every 或 Array.some。如果可用，新方法 find() 或者findIndex() 也可被用于真值测试的提早终止。
- 如果数组在迭代时被修改了，则其他元素会被跳过。

array.forEach(callback(currentValue, index, array){
    //do something
}, this)

array.forEach(callback[, thisArg])

Array.prototype.includes()
- 用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。
- arr.includes(searchElement)
- arr.includes(searchElement, fromIndex)
- includes() 作为一个通用方法，这意味着在string、arguments中也可以使用
Array.prototype.indexOf()
- 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
- arr.indexOf(searchElement[, fromIndex = 0])
- fromIndex ：开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找，以此类推。注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0.

-Array.prototype.join()
- 将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。

Array.prototype.keys()
- 返回一个包含数组中每个索引键的Array Iterator对象。
- 索引迭代器会包含那些没有对应元素的索引

var arr = ["a", , "c"];
var sparseKeys = Object.keys(arr);
var denseKeys = [...arr.keys()];//...:扩展运算符。将一个数组转为用逗号分隔的参数序列。
console.log(sparseKeys); // ['0', '2']
console.log(denseKeys);  // [0, 1, 2]

Array.prototype.lastIndexOf()
- 返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。
- arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])
- fromIndex：从此位置开始逆向查找。默认为数组的长度减 1，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。
Array.prototype.map()
- 创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
- map 方法会给原数组中的每个元素都按顺序调用一次 callback 函数。callback 每次执行后的返回值（包括 undefined）组合起来形成一个新数组。 callback 函数只会在有值的索引上被调用；那些从来没被赋过值或者使用 delete 删除的索引则不会被调用
Array.prototype.pop()
- 从数组中删除最后一个元素，并返回该元素的值，当数组为空时返回undefined。此方法更改数组的长度。
Array.prototype.push()
- 将一个或多个元素添加到数组的末尾，并返回新数组的长度。
- arr.push(element1, …, elementN)
Array.prototype.reduce()
- 对累加器和数组中的每个元素（从左到右）应用一个函数，将其减少为单个值。
- arr.reduce(callback[, initialValue])
- reduce为数组中的每一个元素依次执行callback函数，不包括数组中被删除或从未被赋值的元素
Array.prototype.reduceRight()
- 接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。
Array.prototype.reverse()
- 将数组中元素的位置颠倒。
Array.prototype.shift()
- 从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
- 如果数组为空则返回undefined 。
Array.prototype.slice()
- 返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象。且原始数组不会被修改。

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

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

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

Array.prototype.some()
- 对于放在空数组上的任何条件，此方法返回false。
- 测试数组中的某些元素是否通过由提供的函数实现的测试。
- arr.some(callback[, thisArg])
- some 为数组中的每一个元素执行一次 callback 函数，直到找到一个使得 callback 返回一个“真值”（即可转换为布尔值 true 的值）。如果找到了这样一个值，some 将会立即返回 true。否则，some 返回 false。callback 只会在那些”有值“的索引上被调用，不会在那些被删除或从来未被赋值的索引上调用。
Array.prototype.sort()
- 用原地算法对数组的元素进行排序，并返回数组。排序不一定是稳定的。默认排序顺序是根据字符串Unicode码点。
- 由于它取决于具体实现，因此无法保证排序的时间和空间复杂性。
- arr.sort([compareFunction])
- compareFunction 可选：用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。

var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
  return a - b;
});
console.log(numbers);

也可以写成：
var numbers = [4, 2, 5, 1, 3]; 
numbers.sort((a, b) => a - b); 
console.log(numbers);

// [1, 2, 3, 4, 5]

Array.prototype.splice()
- 通过删除现有元素和/或添加新元素来更改一个数组的内容。
- array.splice(start[, deleteCount[, item1[, item2[, …]]]])
- 由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。
Array.prototype.unshift()
- 将一个或多个元素添加到数组的开头，并返回新数组的长度。
Array.prototype.values()
- 返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值

猜你喜欢