数组的属性和方法总结

总结数组的属性和方法

数组有三大属性及31种方法，用活了，出神入化。

属性

constructor属性（数组）

1. 语法：array.constructor
2. 备注：
   • array 是一个数组的名称
   • constructor属性是每个具有原型的对象的原型成员。 这包括除 Global 和 Math 对象之外的所有内部 JavaScript 对象。 constructor 属性包含了对某种函数的引用，此种函数构造了特定对象的实例。
3. 示例：

var x = new Array();

if (x.constructor == Array)
    document.write("Object is an Array.");
else
    document.write("Object is not an Array.");

// Output:
// Object is an Array

prototype属性（数组）

为数组的类返回原型的引用。

1. 语法： array.prototype
2. 备注：
   • array 参数是数组的名称。
   • 用 prototype 属性为对象的类提供一组基本功能。 对象的新的实例“继承”了赋予该对象的原型的行为。
     例如，若要将方法添加到返回数组的最大元素的值的 Array 对象，请声明函数、将它添加到 Array.prototype 并使用它。
3. 示例：（取数组中最大值）

   function array_max( ){
       var i, max = this[0];
       for (i = 1; i < this.length; i++)
       {
       if (max < this[i])
       max = this[i];
       }
       return max;
   }
   Array.prototype.max = array_max;
   var myArray = new Array(7, 1, 3, 11, 25, 9
   );
   document.write(myArray.max());
   
   // Output: 25

所有内部 JavaScript 对象都有一个只读的 prototype 属性。 可将属性和方法添加到原型中，但不能为对象分配其他原型。 但是，可以向用户定义的对象分配新的原型。

length属性（数组、类数组）

获取或设置数组的长度。此数值比数组中所定义的最高位元素大1。

1. 语法： arrayObj.length
2. 备注：这点比较简单，会js的都会，不多说。但是这里有一点容易被人忽视，就是稀松数组！

3. 示例：

   var arr = new Array();
   arr[3] = 0;
   console.log(arr.length)
   // Output: 4
   console.log(arr[2]);
   //Output: undefined

4. 类数组和字符串也有length属性，不能根据是否有length属性判断是否为数组。

函数

Array.from 函数（数组）

从类似数组的对象或可迭代的对象返回一个数组。

1. 语法： Array.from(arrayLike [ , mapfn [ , thisArg ] ] );
2. 参数：
   • arrayLike
     必需。类似数组的对象或可迭代的对象。
   • mapfn
     可选。要对 arrayLike 中的每个元素调用的映射函数。
   • thisArg
     可选。指定映射函数中的 this 对象。
3. 备注：
   • arrayLike 参数必须是具有编制索引的元素和 length 属性的对象或可迭代对象，如 Set 对象。
   • 对数组中每个元素调用了可选映射函数。

4. 示例：

   • 下面的示例返回集合中包含的对象数组。

     var setObj = new Set("a", "b", "c");
     var objArr = Array.from(setObj);
     // objArr[1] == "b";

   • 使用箭头语法和映射函数更改元素的值。

         var arr = Array.from([1, 2, 3], x => x * 10);
     // arr[0] == 10;
     // arr[1] == 20;
     // arr[2] == 30;

Array.isArray函数

判断对象是否为数组

1. 语法： Array.isArray(object)
2. 参数： object 必需。要检测的对象。
3. 返回值： 返回布尔值。如果object参数不是对象，也返回false。
4. 示例：

   var ar = [];
   var result = Array.isArray(ar);
   // Output: true
   
   var ar = new Array();
   var result = Array.isArray(ar);
   // Output: true
   
   var ar = [1, 2, 3];
   var result = Array.isArray(ar);
   // Output: true
   
   var result = Array.isArray("an array");
   document.write(result);
   // Output: false

Array.of函数

从传入的参数返回一个数组。

1. 语法： Array.of(element0 [ , element1][, …][,elementN]);
2. 参数： element0,…elementN 可选。要置于数组中的元素。这将创建一个具有n+1个元素、长度的数组。
3. 备注：此函数类似于调用new Array（args），但当传入一个参数时，Array.of不包括特殊行为。
4. 示例：

   var arr = Array.of(1, 2, 3);
   // arr[0] == 1 
   
   var arr1 = Array.of(3);
   // arr1[0] == 3
   
   // With new Array, a single argument specifies
   // the length of the new array.
   var arr2 = new Array(3);
   // arr2[0] is undefined
   // arr2.length == 3
   
   var arr3 = new Array(3,4);
   // arr3[0] = 3;
   // arr3.length == 2;

keys方法、values方法、entries方法（数组）

返回一个迭代器，他能返回数组的索引值、元素值、键值对。

1. 语法：arrayObj.keys()[values()][,entries()];
2. 参数：arrayObj 必需。数组对象
3. 备注：ES6提供三个新的方法——entries()，keys()和values()——用于遍历数组。它们都返回一个遍历器对象，可以用for…of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。
4. 示例：

   for (let index of ['a', 'b'].keys()) {
     console.log(index);
   }
   // 0
   // 1
   
   for (let elem of ['a', 'b'].values()) {
     console.log(elem);
   }
   // 'a'
   // 'b'
   
   for (let [index, elem] of ['a', 'b'].entries()) {
     console.log(index, elem);
   }
   // 0 "a"
   // 1 "b"

如果不使用for… of 循环，可以手动调用遍历器对象next方法。

var k = ["a", "b", "c"].keys();
// k.next().value == 0
// k.next().value == 1
// k.next().value == 2 

let letter = ['a', 'b', 'c'];
let entries = letter.entries();
console.log(entries.next().value); // [0, 'a']
console.log(entries.next().value); // [1, 'b']
console.log(entries.next().value); // [2, 'c']

5. 在开发中，遇到过把一个类数组对象转化成数组，那数组能不能转化成对象呢？借助上面的就可以实现了。

   let arr = [1,2,3,4,'a'];
   let obj = {};
   for(let [index,elem] of arr.entries()){
        obj[index] = elem;
   }
   console.log(obj);
   //Object {0: 1, 1: 2, 2: 3, 3: 4, 4: "a"}
   //转化成一个类数组对象。

every方法（Array）

　确定数组的所有成员是否满足指定的测试。

1. 语法： array1.every(callbackfn [ , thisArg ] );

2. 参数：

   • array1 必需，一个数组对象。
   • callbackfn 必需，一个接受最多三个参数的函数。 every 方法会为 array1 中的每个元素调用 callbackfn 函数，直到 callbackfn 返回 false，或直到到达数组的结尾。
   • thisArg 可选。可在 callbackfn 函数中为其引用 this 关键字的对象。如果省略 thisArg，则 undefined 将用作 this 值。

3. 返回值：如果 callbackfn 函数为所有数组元素返回 true，则为 true；否则为 false。如果数组没有元素，则 every 方法将返回 true。

4. 异常：如果 callbackfn 参数不是函数对象，则将引发 TypeError 异常。

5. 备注：

   • every 方法会按升序顺序对每个数组元素调用一次 callbackfn 函数，直到 callbackfn 函数返回 false。如果找到导致 callbackfn 返回 false 的元素，则 every 方法会立即返回 false。否则，every 方法返回 true。
   • 不为数组中缺少的元素调用该回调函数。
   • 除了数组对象之外，every 方法可由具有 length 属性且具有 已按数字编制索引的属性名的任何对象使用。
   • 可以使用 some 方法 (Array) (JavaScript)检查回调函数是否对数组的任何元素均返回 true。

6. 回调函数语法。function callbackfn(value,index,array1);

   • value：数组元素的值。
   • index：数组元素的数字索引。
   • array1：包含该元素的数组对象。

7. 修改数组对象：
   | every方法启动后的条件 | 元素是否传递给回调函数 |
   | :——– | :——–|
   | 在数组的原始长度之外添加元素。 | 否 |
   | 添加元素以填充数组中缺少的元素。|是，如果该索引尚未传递给回调函数。 |
   | 元素被更改。 | 是，如果该元素尚未传递给回调函数。 |
   | 从数组中删除元素。 | 否，除非该元素已传递给回调函数 |

8. 示例：

   function CheckIfEven(value, index, ar) {
       document.write(value + " ");
   
       if (value % 2 == 0)
           return true;
       else
           return false;
   }
   
   // Create an array.
   var numbers = [2, 4, 5, 6, 8];
   
   // Check whether the callback function returns true for all of the
   // array values.
   if (numbers.every(CheckIfEven))
       document.write("All are even.");
   else
       document.write("Some are not even.");
   
   // Output:
   // 2 4 5 Some are not even.

下面的示例阐释 thisArg 参数的用法，该参数指定对其引用 this 关键字的对象。

// Create a function that returns true if the value is
// numeric and within range.
var checkNumericRange = function(value) {
    if (typeof value !== 'number')
        return false;
    else 
        return value >= this.minimum && value <= this.maximum;
}

// Create an array of numbers.
var numbers = [10, 15, 19];

// Check whether the callback function returns true for
// all of the array values.
// The obj argument enables use of the this value
// within the callback function.

var obj = { minimum: 10, maximum: 20 }

if (numbers.every(checkNumericRange, obj))
    document.write ("All are within range.");
else
    document.write ("Some are not within range.");

// Output:
//   All are within range.

fill方法（数组）

使用指定值填充数组。

1. 语法：arrayObj.fill(value [ , start [ , end ] ] );

2. 参数：

   • arrayObj
     必需。数组对象。
   • value
     必需。用于填充数组的值。
   • start
     可选。用于填充数组值的起始索引。默认值为 0。
   • end
     可选。用于填充数组值的结束索引。默认值是 this 对象的 length 属性

3. 备注：如果 start 为负，则 start 被视为 length+start，其中，length 是数组的长度。如果 end 为负，则 end 被视为 length+end。

4. 示例：

   [0, 0, 0].fill(7, 1);
   // Array contains [0,7,7]
   
   [0, 0, 0].fill(7);
   // Array contains [7,7,7]

5. 由fill方法我们是否可以联想到splice方法，这两种方法有一定的异同点。

filter方法

返回数组中的满足回调函数中指定的条件的元素。

1. 语法： array1.filter(callbackfn [ , thisArg ] );
2. 参数：
   | 参数 | 定义 |
   | :——– | :——– |
   | array1 | 必需。一个数组对象 |
   | callbackfn | 必需。一个接受最多三个参数的函数。对于数组中的每个元素，filter 方法都会调用 callbackfn 函数一次。 |
   | thisArg | 可选。可在 callbackfn 函数中为其引用 this 关键字的对象。如果省略 thisArg，则 undefined 将用作 this 值。|
3. 返回值：一个包含回调函数为其返回 true 的所有值的新数组。如果回调函数为 array1 的所有元素返回 false，则新数组的长度为 0。
4. 异常：如果 callbackfn 参数不是函数对象，则将引发 TypeError 异常。
5. 备注：
   • 对于数组中的每个元素，filter 方法都会调用 callbackfn 函数一次（采用升序索引顺序）。不为数组中缺少的元素调用该回调函数。
   • 除了数组对象之外，filter 方法可由具有 length 属性且具有已按数字编制索引的属性名的任何对象使用。
6. 回调函数语法: function callbackfn( value ,index,array1);
   | 回调参数 | 定义 |
   | :——– | :——– |
   | value | 数组元素的值。 |
   | index | 数组元素的数字索引。 |
   | array1 | 包含该元素的数组对象。 |
7. 修改数组对象： filter方法不直接修改原始数组，但回调函数可能会修改他。
   | filter 方法启动后的条件 | 元素是否传递给回调函数 |
   | :——– | :——– |
   | 在数组的原始长度之外添加元素。 | 否 |
   | 添加元素以填充数组中缺少的元素。|是，如果该索引尚未传递给回调函数。 |
   | 元素被更改。 | 是，如果该元素尚未传递给回调函数。 |
   | 从数组中删除元素。 | 否，除非该元素已传递给回调函数 |
8. 示例：

   // Define a callback function.
   function CheckIfPrime(value, index, ar) {
       high = Math.floor(Math.sqrt(value)) + 1;
   
       for (var div = 2; div <= high; div++) {
           if (value % div == 0) {
               return false;
           }
       } 
       return true;
   }
   
   // Create the original array.
   var numbers = [31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53];
   
   // Get the prime numbers that are in the original array. 
   var primes = numbers.filter(CheckIfPrime);
   
   document.write(primes);
   // Output: 31,37,41,43,47,53

在下面的示例中，callbackfn 参数包含回调函数的代码。

// Create the original array.
var arr = [5, "element", 10, "the", true];
// Create an array that contains the string
// values that are in the original array.
var result = arr.filter(
    function (value) {
        return (typeof value === 'string');
    }
);

document.write(result);
// Output: element, the

thisArg 参数的用法，该参数指定对其引用 this 关键字的对象。

var checkNumericRange = function(value) {
    if (typeof value !== 'number')
        return false;
    else 
        return value >= this.minimum && value <= this.maximum;
}

var numbers = [6, 12, "15", 16, "the", -12];

// The obj argument enables use of the this value
// within the callback function.
var obj = { minimum: 10, maximum: 20 }

var result = numbers.filter(checkNumericRange, obj);

document.write(result);
// Output: 12,16

9. 值得一提的是，filter方法不仅仅适用于数组，字符串也可以适用。

findIndex方法（数组）

返回满足回调函数中指定的测试条件的第一个数组元素的索引值。

1. 语法：arrayObj.findIndex( callbackfn [ , thisArg ] );
2. 参数：
   • arrayObj
     必需。数组对象。
   • callbackfn
     必需。用于测试数组中的每个元素的回调函数。
   • thisArg
     可选。指定回调函数中的 this 对象。如果未指定，则未定义 this 对象。
3. 备注：
   • 对于数组中的每个元素，findIndex 方法都会调用一次回调函数（采用升序索引顺序），直到有元素返回 true。只要有一个元素返回 true，findIndex 立即返回该返回 true 的元素的索引值。如果数组中没有任何元素返回 true，则 findIndex 返回 -1。
   • findIndex 不会改变数组对象。

4. 回调函数语法：function callbackfn( value , index , thisArg );
   | 回调参数 | 定义 |
   | :——– | :——– |
   | value | 数组元素的值。 |
   | index | 数组元素的数字索引。 |
   | array1 | 要遍历的数组对象。 |

5. 示例：

   [1,2,3].findIndex(function(x) { x == 2; });
   // Returns an index value of 1.
   
   [1,2,3].findIndex(x => x == 4);
   // Returns an index value of -1.

6. indexOf方法和此方法有点像，但不如findIndex方法全面。indexOf是指定元素去数组中寻找，有就返回其索引（只识别第一个符合条件的元素），没有就返回-1.findIndex可以编辑一个函数去匹配。

map方法

对数组的每个元素调用定义的回调函数并返回包含结果的数组。

1. 语法：array1.map( callbackfn [ , thisArg ] );

2. 参数：
   | 参数 | 定义 |
   | :——– | :——– |
   | array1 | 必选。 一个数组对象。 |
   | callbackfn | 必选。 最多可以接受三个参数的函数。 对于数组中的每个元素，map 方法都会调用 callbackfn 函数一次。 |
   | thisArg | 可选。 callbackfn 函数中的 this 关键字可引用的对象。 如果省略 thisArg，则 undefined 将用作 this 值。 |

3. 返回值：一个新数组，其中的每个元素均为关联的原始数组元素的回调函数返回值。

4. 异常：如果 callbackfn 参数不是函数对象，则将引发 TypeError 异常。
5. 备注：
   • 对于数组中的每个元素，map 方法都会调用 callbackfn 函数一次（采用升序索引顺序）。 将不会为数组中缺少的元素调用回调函数。
   • 除了数组对象之外，map 方法可由具有 length 属性且具有已按数字编制索引的属性名的任何对象使用。
6. 回调函数语法：function callbackfn( value , index, array1);
   | 回调参数 | 定义 |
   | :——– | :——– |
   | value | 数组元素的值。 |
   | index | 数组元素的数字索引。 |
   | array1 | 包含该元素的数组对象。 |

7. 修改数组对象： 数组对象可由回调函数修改。
   | map 方法启动后的条件 | 元素是否传递给回调函数 |
   | :——– | :——– |
   | 在数组的原始长度之外添加元素。 | 否 |
   | 添加元素以填充数组中缺少的元素。|是，如果该索引尚未传递给回调函数。 |
   | 元素被更改。 | 是，如果该元素尚未传递给回调函数。 |
   | 从数组中删除元素。 | 否，除非该元素已传递给回调函数 |

8. 示例：

   // Define the callback function.
   function AreaOfCircle(radius) {
       var area = Math.PI * (radius * radius);
       return area.toFixed(0);
   }
   
   // Create an array.
   var radii = [10, 20, 30];
   
   // Get the areas from the radii.
   var areas = radii.map(AreaOfCircle);
   
   document.write(areas);
   
   // Output:
   // 314,1257,2827

下面的示例阐释 thisArg 参数的用法，该参数指定 this 关键字可引用的对象。

// Define an object that contains a divisor property and
// a remainder function.
var obj = {
    divisor: 10,
    remainder: function (value) {
        return value % this.divisor;
    }
}

// Create an array.
var numbers = [6, 12, 25, 30];

// Get the remainders.
// The obj argument specifies the this value in the callback function.
var result = numbers.map(obj.remainder, obj);
document.write(result);

// Output:
// 6,2,5,0

9. 该方法同样适用于字符串。和forEach方法有一定的相同点，但本质不一样，注意区分。

reduce方法

对数组中的所有元素调用指定的回调函数。该回调函数的返回值为累积结果，并且此返回值在下一次调用该回调函数时作为参数提供。

1. 语法：array1.reduce(callbackfn[, initialValue])；

2. 参数：
   | 参数 | 定义 |
   | :——– | :——– |
   | array1 | 必选。 一个数组对象。 |
   | callbackfn | 必需。一个接受最多四个参数的函数。对于数组中的每个元素，reduce 方法都会调用 callbackfn 函数一次。 |
   | initialValue | 可选。如果指定 initialValue，则它将用作初始值来启动累积。第一次调用 callbackfn 函数会将此值作为参数而非数组值提供。 |

3. 返回值：通过最后一次调用回调函数获得的累积结果。

4. 异常：当满足下列任一条件时，将引发 TypeError 异常：
   • callbackfn 参数不是函数对象。
   • 数组不包含元素，且未提供 initialValue。

5. 备注：

   • 如果提供了 initialValue，则 reduce 方法会对数组中的每个元素调用一次 callbackfn 函数（按升序索引顺序）。如果未提供 initialValue，则 reduce 方法会对从第二个元素开始的每个元素调用 callbackfn 函数。
   • 回调函数的返回值在下一次调用回调函数时作为 previousValue 参数提供。最后一次调用回调函数获得的返回值为 reduce 方法的返回值。
   • 不为数组中缺少的元素调用该回调函数。
   • reduceRight 方法 (Array) (JavaScript)按降序索引顺序处理元素。

6. 回调函数语法：function callbackfn(previousValue, currentValue, currentIndex, array1)；
   | 回调参数 | 定义 |
   | :——– | :——– |
   | previousValue | 通过上一次调用回调函数获得的值。如果向 reduce 方法提供 initialValue，则在首次调用函数时，previousValue 为 initialValue。 |
   | currentValue | 当前数组元素的值。 |
   | currentIndex | 当前数组元素的数字索引。 |
   | array1 | 包含该元素的数组对象。 |

7. 第一次调用回调函数：在第一次调用回调函数时，作为参数提供的值取决于 reduce 方法是否具有 initialValue 参数。

   1. 如果向 reduce 方法提供 initialValue：
      • previousValue 参数为 initialValue。
      • currentValue 参数是数组中的第一个元素的值。
   2. 如果未提供 initialValue：
      • previousValue 参数是数组中的第一个元素的值。
      • currentValue 参数是数组中的第二个元素的值。

8. 修改数组对象：数组对象可由回调函数修改。
   | reduce 方法启动后的条件 | 元素是否传递给回调函数 |
   | :——– | :——– |
   | 在数组的原始长度之外添加元素。 | 否 |
   | 添加元素以填充数组中缺少的元素。|是，如果该索引尚未传递给回调函数。 |
   | 元素被更改。 | 是，如果该元素尚未传递给回调函数。 |
   | 从数组中删除元素。 | 否，除非该元素已传递给回调函数 |

9. 示例：
   下面的示例将数组值连接成字符串，各个值用“::”分隔开。由于未向 reduce 方法提供初始值，第一次调用回调函数时会将“abc”作为 previousValue 参数并将“def”作为 currentValue 参数。

   // Define the callback function.
   function appendCurrent (previousValue, currentValue) {
       return previousValue + "::" + currentValue;
       }
   
   // Create an array.
   var elements = ["abc", "def", 123, 456];
   
   // Call the reduce method, which calls the callback function
   // for each array element.
   var result = elements.reduce(appendCurrent);
   
   document.write(result);
   
   // Output:
   //  abc::def::123::456

下面的示例向数组添加舍入后的值。使用初始值 0 调用 reduce 方法.

// Define the callback function.
function addRounded (previousValue, currentValue) {
    return previousValue + Math.round(currentValue);
    }

// Create an array.
var numbers = [10.9, 15.4, 0.5];

// Call the reduce method, starting with an initial value of 0.
var result = numbers.reduce(addRounded, 0);

document.write (result);
// Output: 27

下面的示例向数组中添加值。 currentIndex 和 array1 参数用于回调函数。

function addDigitValue(previousValue, currentDigit, currentIndex, array) {
    var exponent = (array.length - 1) - currentIndex;
    var digitValue = currentDigit * Math.pow(10, exponent);
    return previousValue + digitValue;
    }

var digits = [4, 1, 2, 5];

// Determine an integer that is computed from values in the array.
var result = digits.reduce(addDigitValue, 0);

document.write (result);
// Output: 4125

下面的示例获取一个数组，该数组仅包含另一个数组中的介于 1 和 10 之间值。提供给 reduce 方法的初始值是一个空数组。

function Process(previousArray, currentValue) {
    // If currentValue is between 1 and 10, 
    // append currentValue to the array.
    var nextArray;
    if (currentValue >= 1 && currentValue <= 10)
        nextArray = previousArray.concat(currentValue);
    else
        nextArray = previousArray;

    // If this is not the last call by the reduce method,
    // the returned array is previousArray on the next call.
    // If this is the last call by the reduce method, the
    // returned array is the return value of the reduce method.
    return nextArray;
}

// Create an array.
var numbers = [20, 1, -5, 6, 50, 3];

// Call the reduce method, starting with an initial empty array.
var emptyArray = new Array();
var resultArray = numbers.reduce(Process, emptyArray);

document.write("result array=" + resultArray);

// Output:
// result array=1,6,3

10. reduceRight方法和reduce方法原理一样，只不过是倒序进行。下面给一个示例：

    // Define the callback function.
    function appendCurrent (previousValue, currentValue) {
        return previousValue + "::" + currentValue;
        }
    
    // Create an array.
    var elements = ["abc", "def", 123, 456];
    
    // Call the reduceRight method, which calls the callback function
    // for each array element, in descending index order.
    var result = elements.reduceRight(appendCurrent);
    
    document.write(result);
    
    // Output:
    //  456::123::def::abc

slice方法

返回数组中的一部分

1. 语法： arrayObj.slice(start,[end]);
2. 参数：
   • arrayObj
     必需。一个 Array 对象。
   • start
     必需。 arrayObj 的指定部分的开头。
   • end
     可选。 arrayObj 的指定部分的结尾。

3. 备注：

   • slice 方法返回一个 Array 对象，其中包含了 arrayObj 指定部分。
   • slice 方法一直复制到 end 所指示的元素，但是不包括该元素。如果 start 为负，则将其视为 length + start，其中 length 为数组的长度。如果 end 为负，则将其视为 length + end，其中 length 为数组的长度。如果省略 end，则将一直提取到 arrayObj 的结尾。如果 end 出现在 start 之前，则不会将任何元素复制到新数组中。

4. 示例：

   var origArray = [3, 5, 7, 9];
   var newArray = origArray. slice(0, -1);
   document.write(origArray);
   document.write("<br/>");
   newArray = origArray. slice(-2);
   document.write(newArray);
   
   // Output:
   // 3,5,7,9
   // 7,9

splice方法

从一个数组中移除元素，如有必要，在所移除元素的位置上插入新元素，并返回所移除的元素。

1. 语法：arrayObj.splice(start, deleteCount, [item1[, item2[, . . . [,itemN]]]]);
2. 参数：
   | 参数 | 定义 |
   | :——– | :——–|
   | arrayObj | 必需。一个 Array 对象。 |
   | start | 必需。数组中移除元素操作的起点，从 0 开始。 |
   | deleteCount | 必需。要移除的元素数。 |
   | item1,item2,…itemN | 可选。插入数组中代替已移除元素的元素。 |
3. 备注：splice 方法通过移除从 start 位置开始的指定个数的元素并插入新元素来修改 arrayObj。返回值是一个由所移除的元素组成的新 Array 对象。
4. 示例：

   var arr = new Array("4", "11", "2", "10", "3", "1");
   arr.splice(2, 2, "21", "31");
   document.write(arr);
   
   // Output: 4,11,21,31,3,1

some方法

确定指定的回调函数是否为数组中的任何元素均返回 true。

1. 语法： array1.some(callbackfn [ , thisArg ]);
2. 参数：
   | 参数 | 定义 |
   | :——– | :——–|
   | array1 | 必需。一个数组对象。 |
   | callbackfn | 必需。一个接受最多三个参数的函数。 some 方法会为 array1 中的每个元素调用 callbackfn 函数，直到 callbackfn 返回 true，或直到到达数组的结尾。 |
   | thisArg | 可选。可在 callbackfn 函数中为其引用 this 关键字的对象。如果省略 thisArg，则 undefined 将用作 this 值。 |
3. 返回值：如果 callbackfn 函数为任何数组元素均返回 true，则为 true；否则为 false。
4. 异常：如果 callbackfn 参数不是函数对象，则将引发 TypeError 异常。

5. 备注：

   • some 方法会按升序索引顺序对每个数组元素调用 callbackfn 函数，直到 callbackfn 函数返回 true。如果找到导致 callbackfn 返回 true 的元素，则 some 方法会立即返回 true。如果回调不对任何元素返回 true，则 some 方法会返回 false。
   • 不为数组中缺少的元素调用该回调函数。
   • 除了数组对象之外，some 方法可由具有 length 属性且具有已按数字编制索引的属性名的任何对象使用。
   • 可以使用 every 方法 (Array) (JavaScript)检查回调函数是否对数组的所有元素都返回 true。

6. 回调函数语法：function callbackfn(value, index, array1)；
   | 回调参数 | 定义 |
   | :——– | :——–|
   | Value | 数组元素的值。 |
   | index | 数组元素的数字索引。 |
   | array1 | 包含该元素的数组对象。 |

7. 修改数组对象
   | some方法启动后的条件 | 元素是否传递给回调函数 |
   | :——– | :——– |
   | 在数组的原始长度之外添加元素。 | 否 |
   | 添加元素以填充数组中缺少的元素。|是，如果该索引尚未传递给回调函数。 |
   | 元素被更改。 | 是，如果该元素尚未传递给回调函数。 |
   | 从数组中删除元素。 | 否，除非该元素已传递给回调函数 |

8. 示例：

   // The callback function.
   function CheckIfEven(value, index, ar) {
       if (value % 2 == 0){
           console.log(index);
           return true;
        }
   }
   
   var numbers = [1, 15, 4, 10, 11, 22];
   
   var evens = numbers.some(CheckIfEven);
   document.write(evens);
   
   // Output:
   // true

下面的示例演示如何使用 thisArg 参数，该参数指定 this 关键字可引用的对象。它检查数组中是否有数字位于传递的对象所提供的范围之外。

// Create a function that returns true if the value is 
// outside the range.
var isOutsideRange = function (value) {
    return value < this.minimum || value > this.maximum;
}

// Create an array of numbers.
var numbers = [6, 12, 16, 22, -12];

// The range object is to be the 'this' object.
var range = { minimum: 10, maximum: 20 };

document.write(numbers.some(isOutsideRange, range));

// Output: true

9. some方法可以判断一个数组中是否含有符合条件的值存在。存在就返回true,而且还可以拿到第一个满足条件的索引。

sort方法

对数组排序

1. 语法： arrayObj.sort( sortFuntion);

2. 参数：

   • arrayObj
     必需。任意 Array 对象。
   • sortFunction
     可选。用来确定元素顺序的函数的名称。如果省略 ASCII 字符顺序，则将按升序对这些元素进行排序。

3. 返回值：已排好序的数组。

4. 备注：

   • sort 方法就地对 Array 对象进行排序；在执行过程中不会创建新 Array 对象。
   • 如果在 sortFunction 参数中提供一个函数，则该函数必须返回下列值之一：

     1. 如果所传递的第一个参数小于第二个参数，则返回负值。
     2. 如果两个参数相等，则返回零。
     3. 如果第一个参数大于第二个参数，则返回正值。
     

5. 示例：

   var a = new Array(4, 11, 2, 10, 3, 1);
   
   var b = a.sort();
   document.write(b);
   document.write("<br/>");
   
   // This is ASCII character order.
   // Output: 1,10,11,2,3,4)
   
   // Sort the array elements with a function that compares array elements.
   b = a.sort(CompareForSort);
   document.write(b);
   document.write("<br/>");
   // Output: 1,2,3,4,10,11.
   
   // Sorts array elements in ascending order numerically.
   function CompareForSort(first, second)
   {
       if (first == second)
           return 0;
       if (first < second)
           return -1;
       else
           return 1; 
   }

toString方法

返回数组的字符串表示形式

1. 语法：array.toString()
2. 参数： array 必需。要表示为字符串的数组。
3. 返回值： 数组的字符串表示形式。
4. 备注：将array的元素转换为字符串。结果字符串被链接起来，用逗号分隔。

5. 示例：

   var arr = [1, 2, 3, 4];
   var s = arr.toString();
   document.write(s);
   
   // Output: 1,2,3,4

6. 比较鸡肋，一般不用，一般使用join方法。

valueOf方法

返回指定对象的基元值。

1. 语法：array.valueOf();
2. 参数:此方法没有参数。
3. 返回值：返回数组实例。
4. 备注：实例化的数组对象与此方法的返回值相同。

5. 实例：

   var arr = [1, 2, 3, 4];
   var s = arr.valueOf();
   
   if (arr === s)
   document.write("same");
   else
   document.write("different");
   
   // Output:
   // same

6. 说简单点就是数组的元素被转换为字符串，这些字符串由逗号分隔，连接在一起。其操作与 Array.toString 和 Array.join方法相同。具体参考地址

copyWithin方法

数组实例的copyWithin方法，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。

1. 语法: Array.prototype.copyWithin( target , start ,end );
2. 参数：
   | 参数 | 定义 |
   | :——– | :——– |
   | target | 必须，从该位置开始替换数据。 |
   | start | 可选，从该位置开始读取数据，默认为0。如果为负值，表示倒数。 |
   | end | 可选，到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。 |
3. 备注： 这三个参数都应该是数值，如果不是，会自动转为数值。
4. 实例：

   [1, 2, 3, 4, 5].copyWithin(0, 3)
   // [4, 5, 3, 4, 5]
   // 将3号位复制到0号位
   [1, 2, 3, 4, 5].copyWithin(0, 3, 4)
   // [4, 2, 3, 4, 5]
   
   // -2相当于3号位，-1相当于4号位
   [1, 2, 3, 4, 5].copyWithin(0, -2, -1)
   // [4, 2, 3, 4, 5]
   
   // 将3号位复制到0号位
   [].copyWithin.call({length: 5, 3: 1}, 0, 3)
   // {0: 1, 3: 1, length: 5}
   
   // 将2号位到数组结束，复制到0号位
   var i32a = new Int32Array([1, 2, 3, 4, 5]);
   i32a.copyWithin(0, 2);
   // Int32Array [3, 4, 5, 4, 5]
   
   // 对于没有部署TypedArray的copyWithin方法的平台
   // 需要采用下面的写法
   [].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
   // Int32Array [4, 2, 3, 4, 5]

find方法

数组实例的find方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。

1. 语法：array.find(callbackfn);
2. 参数：array–>必须。要寻找的数组对象。callbackfn–>回调函数。
3. 备注：find方法的回调函数可以接受三个参数，依次为当前的值、当前的位置和原数组。

4. 示例：

   [1, 4, -5, 10].find((n) => n < 0)
   // -5
   [1, 5, 10, 15].find(function(value, index, arr) {
     return value > 9;
   }) // 10

5. find方法和findIndex方法非常相似，可以结合对比使用。

includes方法

Array.prototype.includes方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。该方法属于ES7，但Babel转码器已经支持。

1. 语法: arrayObj.includes( targt ,[ start]);
2. 参数：
   • 该方法的第二个参数表示搜索的起始位置，默认为0。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为-4，但数组长度为3），则会重置为从0开始。
   • 第一个参数为要检索的值。
3. 备注：
   • 没有该方法之前，我们通常使用数组的indexOf方法，检查是否包含某个值。
   • indexOf方法有两个缺点，一是不够语义化，它的含义是找到参数值的第一个出现位置，所以要去比较是否不等于-1，表达起来不够直观。二是，它内部使用严格相当运算符（===）进行判断，这会导致对NaN的误判。
   • includes使用的是不一样的判断算法，就没有这个问题。
4. 示例：

   [1, 2, 3].includes(3, 3);  // false
   [1, 2, 3].includes(3, -1); // true
   [NaN].indexOf(NaN)
   // -1
   [NaN].includes(NaN)
   // true

5. 下面代码用来检查当前环境是否支持该方法，如果不支持，部署一个简易的替代版本。

   const contains = (() =>
     Array.prototype.includes
       ? (arr, value) => arr.includes(value)
       : (arr, value) => arr.some(el => el === value)
   )();
   contains(["foo", "bar"], "baz"); // => false

6. 另外，Map和Set数据结构有一个has方法，需要注意与includes区分。

   • Map结构的has方法，是用来查找键名的，比如Map.prototype.has(key)、WeakMap.prototype.has(key)、Reflect.has(target, propertyKey)。
   • Set结构的has方法，是用来查找值的，比如Set.prototype.has(value)、WeakSet.prototype.has(value)。
7. 参考地址

一些基本方法

• concat 合并数组。
• join 拼接数组。
• indexOf 返回第一个匹配项的索引
• lastIndexOf 返回最后一个匹配项的索引
• forEach 遍历数组，得到索引和对应值
• pop 移除最后一个元素并返回
• push 将新元素追加到一个数组中，并返回新的数组长度。
• shift 从数组中移除第一个元素并返回该元素。
• unshift 在数组的开头插入新元素。
• reverse 反转Array中的元素。

关于数组的空位

数组的空位指，数组的某一个位置没有任何值。比如，Array构造函数返回的数组都是空位。

Array(3) // [, , ,]

上面代码中，Array(3)返回一个具有3个空位的数组。

注意，空位不是undefined，一个位置的值等于undefined，依然是有值的。空位是没有任何值，in运算符可以说明这一点。

0 in [undefined, undefined, undefined] // true
0 in [, , ,] // false
上面代码说明，第一个数组的0号位置是有值的，第二个数组的0号位置没有值。

ES5对空位的处理，已经很不一致了，大多数情况下会忽略空位。

• forEach(), filter(), every() 和some()都会跳过空位。
• map()会跳过空位，但会保留这个值
• join()和toString()会将空位视为undefined，而undefined和null会被处理成空字符串。

// forEach方法
[,'a'].forEach((x,i) => console.log(i)); // 1

// filter方法
['a',,'b'].filter(x => true) // ['a','b']

// every方法
[,'a'].every(x => x==='a') // true

// some方法
[,'a'].some(x => x !== 'a') // false

// map方法
[,'a'].map(x => 1) // [,1]

// join方法
[,'a',undefined,null].join('#') // "#a##"

// toString方法
[,'a',undefined,null].toString() // ",a,,"

ES6则是明确将空位转为undefined。

Array.from方法会将数组的空位，转为undefined，也就是说，这个方法不会忽略空位。
Array.from(['a',,'b'])
// [ "a", undefined, "b" ]
扩展运算符（…）也会将空位转为undefined。
[...['a',,'b']]
// [ "a", undefined, "b" ]
copyWithin()会连空位一起拷贝。
[,'a','b',,].copyWithin(2,0) // [,"a",,"a"]
fill()会将空位视为正常的数组位置。
new Array(3).fill('a') // ["a","a","a"]
for…of循环也会遍历空位。

let arr = [, ,];
for (let i of arr) {
  console.log(1);
}
// 1
// 1

上面代码中，数组arr有两个空位，for...of并没有忽略它们。如果改成map方法遍历，空位是会跳过的。

entries()、keys()、values()、find()和findIndex()会将空位处理成undefined。

// entries()
[...[,'a'].entries()] // [[0,undefined], [1,"a"]]

// keys()
[...[,'a'].keys()] // [0,1]

// values()
[...[,'a'].values()] // [undefined,"a"]

// find()
[,'a'].find(x => true) // undefined

// findIndex()
[,'a'].findIndex(x => true) // 0

由于空位的处理规则非常不统一，所以建议避免出现空位。

数组的所有参考地址

本文大部分摘自.aspx)
es6