常用数组方法一.不会改变原始数组的方法：

即访问方法，下面的这些方法绝对不会改变调用它们的对象的值，只会返回一个新的数组或者返回一个其它的期望值。

1. concat()

** 语法：** JavaScript,defaultvar new_array = old_array.concat(value1[, value2[, ...[, valueN]]])

参数: valueN(可选)将数组和/或值连接成新数组。如果省略了valueN参数参数，则concat会返回一个它所调用的已存在的数组的浅拷贝

*返回值 *返回新的数组实例。原始数组/值在连接时保持不变。此外，对于新数组的任何操作（仅当元素不是对象引用时）都不会对原始数组产生影响，反之亦然。

实例：

  let obj={a:1}  const arr=["a","b",obj]; //obj为对象的引用，原始数组arr同新数组arr2引用相同对象，其更改对于原始数组和新数组是可见的  const arr1=[1,2,3,4];  const arr2=arr1.concat(obj);  obj.a=2;                 console.log(arr2);        //['a','b',{a:2},1,2,3,4]    console.log(arr);       //['a','b',{a:2}]

2.slice()

** 语法：** arr.slice(begin, end)

参数:*begin(可选) *如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素)。

如果省略 begin，则 slice 从索引 0 开始。

如果 begin 大于原数组的长度，则会返回空数组。

*end(可选) *在该索引处结束提取原数组元素。slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素 （索引为 1, 2, 3的元素)。

如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。

如果 end 被省略，则 slice 会一直提取到原数组末尾。

如果 end 大于数组的长度，slice 也会一直提取到原数组末尾.

*返回值 *slice 不会修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。拷贝规则同concat()

实例：

  var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];  var citrus = fruits.slice(1, 3);// fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']// citrus contains ['Orange','Lemon']

3.join()

语法：arr.join([separator])*参数: * separator（可选）指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果缺省该值，数组元素用逗号（,）分隔。如果separator是空字符串("")，则所有元素之间都没有任何字符

*返回值 *将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。如果 arr.length 为0，则返回空字符串

实例：

  var a = ['Wind', 'Rain', 'Fire'];  var myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"  var myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"  var myVar3 = a.join(' + '); // myVar3的值变为"Wind + Rain + Fire"  var myVar4 = a.join('');    // myVar4的值变为"WindRainFire"

4.toString()

** 语法：** arr.toString()

*返回值 *返回一个字符串，表示指定的数组及其元素。

实例：

   const array1 = [1, 2, 'a', '1a'];   console.log(array1.toString());// "1,2,a,1a"

5.indexof()

** 语法：** arr.indexOf(searchElement,fromIndex)

参数:*searchElement *要查找的元素

fromIndex(可选)开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。

如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找 ，以此类推。

注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。

如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0

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

实例：

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

6.lastIndexOf()

** 语法：** arr.lastIndexOf(searchElement,fromIndex)参数:*searchElement *要查找的元素

fromIndex(可选)从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找。

如果该值大于或等于数组的长度，则整个数组会被查找。

如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。

如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。

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

实例：

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

二.会改变原始数组的方法:

下面的这些方法会改变调用它们的对象自身的值：

1.splice()

** 语法：** array.splice(start,deleteCount, item1,item2, ..)参数:* start*指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；

如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；

如果负数的绝对值大于数组的长度，则表示开始位置为第0位。

* deleteCount(可选)*整数，表示要移除的数组元素的个数。 如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。

如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。

如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。

*返回值 *通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容，如果只删除了一个元素，则返回只包含一个元素的数组。

如果没有删除元素，则返回空数组。此方法会改变原数组。

实例：

//1.从第 2 位开始删除 0 个元素，插入“drum”var myFish = ["angel", "clown", "mandarin",    "sturgeon"];    //1-5同var removed = myFish.splice(2, 0, "drum");// 运算后的 myFish: ["angel", "clown", "drum", "mandarin", "sturgeon"]// 被删除的元素: [], 没有元素被删除    --removed的返回值下同//2.从第 2 位开始删除 0 个元素，插入“drum” 和 "guitar"var removed = myFish.splice(2, 0, 'drum', 'guitar');// 运算后的 myFish: ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"]// 被删除的元素: [], 没有元素被删除//3.从第 3 位开始删除 1 个元素var removed = myFish.splice(3, 1);// 运算后的 myFish: ["angel", "clown", "drum", "sturgeon"]// 被删除的元素: ["mandarin"]//4.从第 2 位开始删除 1 个元素，插入“trumpet”var removed = myFish.splice(2, 1, "trumpet");// 运算后的 myFish: ["angel", "clown", "trumpet", "sturgeon"]// 被删除的元素: ["drum"]//5.从第 0 位开始删除 2 个元素，插入"parrot"、"anemone"和"blue"var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');// 运算后的 myFish: ["parrot", "anemone", "blue", "trumpet", "sturgeon"]// 被删除的元素: ["angel", "clown"]//6.从第 2 位开始删除 2 个元素var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon'];var removed = myFish.splice(myFish.length - 3, 2);// 运算后的 myFish: ["parrot", "anemone", "sturgeon"]// 被删除的元素: ["blue", "trumpet"]//7.从倒数第 2 位开始删除 1 个元素var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];var removed = myFish.splice(-2, 1);// 运算后的 myFish: ["angel", "clown", "sturgeon"]// 被删除的元素: ["mandarin"]//8.从第 2 位开始删除所有元素var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];var removed = myFish.splice(2);// 运算后的 myFish: ["angel", "clown"]// 被删除的元素: ["mandarin", "sturgeon"]

2.pop()

** 语法：** arr.pop()

*返回值 *从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度。当数组为空时返回undefined

实例：

let myFish = ["angel", "clown", "mandarin", "surgeon"];let popped = myFish.pop();console.log(myFish); // ["angel", "clown", "mandarin"]console.log(popped); // surgeon

3.push()

** 语法：** arr.push(element1, ..., elementN)

参数:elementN 被添加到数组末尾的元素。

返回值 * 将一个或多个元素添加到数组的末尾，并返回该数组的新长度。新的 length 属性值将被返回。***

实例：

var sports = ["soccer", "baseball"];var total = sports.push("football", "swimming");console.log(sports); // ["soccer", "baseball", "football", "swimming"]console.log(total);  

4.shift()

** 语法：** arr.shift()

*返回值 *从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。如果数组为空则返回undefined

实例：

let myFish = ['angel', 'clown', 'mandarin', 'surgeon'];console.log('调用 shift 之前: ' + myFish);// "调用 shift 之前: angel,clown,mandarin,surgeon"var shifted = myFish.shift(); console.log('调用 shift 之后: ' + myFish); // "调用 shift 之后: clown,mandarin,surgeon" console.log('被删除的元素: ' + shifted); // "被删除的元素: angel"

5.unshift()

** 语法：** arr.unshift(element1, ..., elementN)

参数:elementN 要添加到数组开头的元素或多个元素。

返回值 * 将一个或多个元素添加到数组的开头，并返回该数组的新长度***(该方法修改原有数组)。当一个对象调用该方法时，返回其 length 属性值。

实例：

let arr = [1, 2];arr.unshift(0); // result of the call is 3, which is the new array length// arr is [0, 1, 2]arr.unshift(-2, -1); // the new array length is 5// arr is [-2, -1, 0, 1, 2]arr.unshift([-4, -3]); // the new array length is 6// arr is [[-4, -3], -2, -1, 0, 1, 2]arr.unshift([-7, -6], [-5]); // the new array length is 8// arr is [ [-7, -6], [-5], [-4, -3], -2, -1, 0, 1, 2 ]

6.reverse()

** 语法：** arr.reverse()

*返回值 *颠倒后的数组。 将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组。

实例：

const array1 = ['one', 'two', 'three'];console.log('array1:', array1);// expected output: "array1:" Array ["one", "two", "three"]const reversed = array1.reverse();console.log('reversed:', reversed);// expected output: "reversed:" Array ["three", "two", "one"]// Careful: reverse is destructive -- it changes the original array.console.log('array1:', array1);// expected output: "array1:" Array ["three", "two", "one"]

7.sort()

** 语法：** arr.sort(function(a,b){....})

参数function(){}可选用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。

a第一个用于比较的元素。

b第二个用于比较的元素。

如果指明了 compareFunction(即function(a,b)) ，那么数组会按照调用该函数的返回值排序。即 a 和 b 是两个将要被比较的元素：

如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。备注： ECMAScript 标准并不保证这一行为，而且也不是所有浏览器都会遵守（例如 Mozilla 在 2003 年之前的版本）；如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。

*返回值 *用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的

//比较函数格式如下function compare(a, b) {  if (a < b ) {           // 按某种排序标准进行比较, a 小于 b    return -1;      }  if (a > b ) {    return 1;  }  // a must be equal to b  return 0;}

实例：

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]

面试资料可私聊我，Java，资料，面试