数组的方法

区别：类数组:有length属性，键名通常是0,1,2,3，常见的arguments，字符串string

1、at()

参数： 要返回的数组元素的索引（位置）。当传递负数时，支持从数组末端开始的相对索引；也就是说，如果使用负数，返回的元素将从数组的末端开始倒数。

返回： 返回索引值，找不到返回undefined

 let arr=[1,3,5,7,9,11]
         console.log(arr.at(-1)) //11
         console.log(arr.at(100));//undefined

2、concat()

合并数组，不会改变原数组数组，返回新数组 参数： 数组或值，将被合并到一个新的数组中。如果省略了所有 valueN 参数，则 concat 会返回调用此方法的现存数组的一个浅拷贝

 let arr=[1,3,5,7,9,11]
         let arr2=[2,4,6,8,10]
         console.log(arr.concat());//[1, 3, 5, 7, 9, 11]
         console.log(arr.concat("zhopufeng"));//[1, 3, 5, 7, 9, 11,"zhopufeng"]
         console.log(arr.concat(arr2));/[1, 3, 5, 7, 9, 11, 2, 4, 6, 8, 10]
           /*合并多个数组*/
          let arr3=[0]
         arr.concat(arr2,arr3)[0，1, 3, 5, 7, 9, 11, 2, 4, 6, 8, 10]

可以合并多个数组,

3、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）。

4、entries()

entries() 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。

 const arr3 = ['zhou', 'huang', 'zhang']
         const item = arr3.entries()
         console.log(item);
  /*
            Array Iterator {}
 [[Prototype]]: Array Iterator
 next: ƒ next()
 length: 0
 name: "next"
 arguments: (...)
 caller: (...)
 [[Prototype]]: ƒ ()
 [[Scopes]]: Scopes[0]
 Symbol(Symbol.toStringTag): "Array Iterator"
 [[Prototype]]: Object */ 

5、every()和some()

0. **every()** 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

 let arr4=[1,2,3,4,5]
 console.log(arr4.every((item)=>{item%2===0})); 
 console.log(arr4.every(item=>typeof item==="number"));

类似于map和filter方法 ，every 不会改变原数组。

2. **some()** 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。 若用一个空数组进行测试，在任何情况下它返回的都是false。

 const array = [1, 2, 3, 4, 5];
 // checks whether an element is even
 const even = (element) => element % 2 === 0;
 console.log(array.some(even));
 // expected output: true

6、fill()

**fill()** 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。

参数：

• value：

用来填充数组元素的值。

• start 可选,start和end相等时，不填充

起始索引，默认值为0。

• end 可选

终止索引，默认值为 this.length。 不包括终止索引。

7、filter()

**filter()** 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素

8、map（）

**map()** 方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

参数：

callback(value,index,array), thisArg (可选)其中index和array也是可选

经典面试题：

 console.log(["1", "2", "3"].map(parseInt))
 /*你以为输出1,2,3就大错特错了
 我们要明白parseInt函数 函数可解析一个字符串，并返回一个整数。
 parseInt(string, radix)
 string，必需。要被解析的字符串。
 1、如果 string 以 "0x" 开头，parseInt() 会把 string 的其余部分解析为十六进制的整数。
 2、如果 string 以 0 开头，那么 ECMAScript v3 允许 parseInt() 的一个实现把其后的字符解析为八进制或十六进制的数字。
 3、如果 string 以 1 ~ 9 的数字开头，parseInt() 将把它解析为十进制的整数。
 radix，可选。表示要解析的数字的基数。该值介于 2 ~ 36 之间。当参数 radix 的值为 0，或没有设置该参数时，parseInt() 会根据 string 来判断数字的基数。
 ​
 注意： 只有字符串中的第一个数字会被返回。
 ​
 注意： 开头和结尾的空格是允许的。
 ​
 注意：如果字符串的第一个字符不能被转换为数字，那么 parseInt() 会返回 NaN。
 ​
 注意：在字符串以"0"为开始时旧的浏览器默认使用八进制基数。ECMAScript 5，默认的是十进制的基数
 ​
 所以即分析parseInt('1',0)radix是0，string以1开头，把1看做十进制，所以解析后是1；parseInt('2',1)radix不可能为1，NaN。parseInt('3',2)2进制中没3这个数，NaN
 */

9、find()

**find()** 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined， find方法不会改变数组。

 let arr5=['liming',6,'7',9]
 console.log(arr5.find(item=>typeof item==="number"));//6 找类型为number类型的第一个值

区别于includes()方法，其用来找一个元素是否存在于数组，存在返回true，不存在返回false

10、findIndex()

**findIndex()**方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1。

  let arr6=[5,2,1,100,65,-6]
  console.log(arr6.findIndex((value,index)=>{console.log(index);value>6}));//3 值大于6的第一个值是100，其索引是4

注意:回调函数的参数

11、flat()

**flat()** 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。 扁平化数组

 var arr7 = [1, 2, [3, 4]];
  console.log(arr7.flat());//[1, 2, 3, 4]

参数：

• depth 可选，指定要提取嵌套数组的结构深度，默认值为 1。
• 当参数是Infinity，可展开任意深度的嵌套数组

 var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
 arr4.flat(Infinity);

注意：flat() 方法会移除数组中的空项:

 var arr4 = [1, 2, , 4, 5];
 arr4.flat();
 // [1, 2, 4, 5]

12、flatMap()

**flatMap()** 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 连着深度值为1的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些。

简单来讲：先map()，再扁平化数组

 let arr9=[1,3,9,100,5]
 console.log(arr9.flatMap((item)=>[[item+1]])); //[[2],[4],[10],[101],[6]]

和map()的不同：

 let arr1 = ["it's Sunny in", "", "California"];
 arr1.map(x => x.split(" "));
 // [["it's","Sunny","in"],[""],["California"]]
 arr1.flatMap(x => x.split(" "));
 // ["it's","Sunny","in", "", "California"]

注意： flatMap 能用于在map期间增删项目（也就是修改items的数量）。换句话说，它允许你遍历很多项使之成为另一些项（靠分别把它们放进去来处理），而不是总是一对一。 从这个意义上讲，它的作用类似于 filter的对立面。只需返回一个1项元素数组以保留该项，返回一个多元素数组以添加项，或返回一个0项元素数组以删除该项。

 let a = [5, 4, -3, 20, 17, -33, -4, 18]
 //       |\  \  x   |  | \   x   x   |
 //      [4,1, 4,   20, 16, 1,       18]
 ​
 a.flatMap( (n) =>
   (n < 0) ?      [] :
   (n % 2 == 0) ? [n] :
                  [n-1, 1]
 )
 ​
 // expected output: [4, 1, 4, 20, 16, 1, 18]

13、forEach()

**forEach()** 方法对数组的每个元素执行一次给定的函数。 那些已删除或者未初始化的项将被跳过（例如在稀疏数组上）。

参数：

callback(value,index,array).thisArg

返回：

总是返回undefined

注意：

除了抛出异常以外，没有办法中止或跳出 forEach() 循环。如果你需要中止或跳出循环，forEach() 方法不是应当使用的工具

14、Array.from()

**Array.from()** 方法对一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。 不是原型链的方法了！！！

 /*字符串*/
 let s='zf is a handsome boy'
 console.log(Array.from(s)); 
 /*数组*/
 var arr=[-10,5,3]
 console.log(Array.from(arr,(x)=>x+x));//[-20, 10, 6]
 console.log( Array.from(arr, (v, i) => {return v}));//v是值，i是索引,[-10, 5, 3]
 /*类数组对象*/
 function f() {
   return Array.from(arguments);
 }
 ​
 f(1, 2, 3);
 /*Map*/
 const map = new Map([[1, 2], [2, 4], [4, 8]]);
 Array.from(map);
 // [[1, 2], [2, 4], [4, 8]]
 ​
 const mapper = new Map([['1', 'a'], ['2', 'b']]);
 Array.from(mapper.values());
 // ['a', 'b'];
 ​
 Array.from(mapper.keys());
 // ['1', '2'];
 /*Set*/
 const set = new Set(['foo', 'bar', 'baz', 'foo']);
 Array.from(set);
 // [ "foo", "bar", "baz" ]

15、includes()

**includes()** 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。

 var arr=[-10,5,3]
 console.log(arr.includes(3)); //true
 console.log(arr.includes(-10,1)); //false

参数：

• valueToFind需要查找的元素值。
• fromIndex 可选，从fromIndex 索引处开始查找 valueToFind。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜 （即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。默认为 0。例如fromIndex为-2，则从-2+length处搜索到length-1处

14、Array.from()

**Array.from()** 方法对一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。 不是原型链的方法了！！！

 /*字符串*/
 let s='zf is a handsome boy'
 console.log(Array.from(s)); 
 /*数组*/
 var arr=[-10,5,3]
 console.log(Array.from(arr,(x)=>x+x));//[-20, 10, 6]
 console.log( Array.from(arr, (v, i) => {return v}));//v是值，i是索引,[-10, 5, 3]
 /*类数组对象*/
 function f() {
   return Array.from(arguments);
 }
 ​
 f(1, 2, 3);
 /*Map*/
 const map = new Map([[1, 2], [2, 4], [4, 8]]);
 Array.from(map);
 // [[1, 2], [2, 4], [4, 8]]
 ​
 const mapper = new Map([['1', 'a'], ['2', 'b']]);
 Array.from(mapper.values());
 // ['a', 'b'];
 ​
 Array.from(mapper.keys());
 // ['1', '2'];
 /*Set*/
 const set = new Set(['foo', 'bar', 'baz', 'foo']);
 Array.from(set);
 // [ "foo", "bar", "baz" ]

15、includes()

**includes()** 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。

 var arr=[-10,5,3]
 console.log(arr.includes(3)); //true
 console.log(arr.includes(-10,1)); //false

参数：

• valueToFind需要查找的元素值。
• fromIndex 可选，从fromIndex 索引处开始查找 valueToFind。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜 （即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。默认为 0。例如fromIndex为-2，则从-2+length处搜索到length-1处

16、indexOf()

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

 onst beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];
 ​
 console.log(beasts.indexOf('bison'));
 // expected output: 1
 ​
 // start from index 2
 console.log(beasts.indexOf('bison', 2));
 // expected output: 4
 ​
 console.log(beasts.indexOf('giraffe'));
 // expected output: -1

参数

• searchElement

  要查找的元素

• fromIndex 可选

  开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找 ，以此类推。 注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0.

17、lastIndexOf()

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

参数：

• searchElement，被查找的元素。
• fromIndex可选

从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。

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

18、Array.isArray()

Array.isArray() 用于确定传递的值是否是一个 Array， 如果值是 Array，则为true; 否则为false。

 // 下面的函数调用都返回 true
 Array.isArray([]);
 Array.isArray([1]);
 Array.isArray(new Array());
 Array.isArray(new Array('a', 'b', 'c', 'd'))
 // 鲜为人知的事实：其实 Array.prototype 也是一个数组。
 Array.isArray(Array.prototype);
 ​
 // 下面的函数调用都返回 false
 Array.isArray();
 Array.isArray({});
 Array.isArray(null);
 Array.isArray(undefined);
 Array.isArray(17);
 Array.isArray('Array');
 Array.isArray(true);
 Array.isArray(false);
 Array.isArray(new Uint8Array(32))
 Array.isArray({ __proto__: Array.prototype });

19、join()

**join()** 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。

 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"
 console.log(myVar1);
 console.log(myVar2);
 console.log(myVar3);
 console.log(myVar4);

参数：

• separator 可选

  指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果缺省该值，数组元素用逗号（,）分隔。如果separator是空字符串("")，则所有元素之间都没有任何字符。

20、keys()

**keys()**方法返回一个包含数组中每个索引键的**Array Iterator**对象。

注意区别：

ES6 提供三个新的方法 —— entries()，keys()和values() —— 用于遍历数组。它们都返回一个遍历器对象，可以用for...of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。

 var arr3=['zhou','huang','ke']
 const it=arr3.keys()
 for(let i of it){
     console.log(i); //1 2 3
 }

索引迭代器会包含那些没有对应元素的索引:

 var arr = ["a", , "c"];
 var sparseKeys = Object.keys(arr);
 var denseKeys = [...arr.keys()];
 console.log(sparseKeys); // ['0', '2']
 console.log(denseKeys);  // [0, 1, 2]

21、values()

**keys()**方法返回一个包含数组中每个索引键的**Array Iterator**对象。

注意区别：

ES6 提供三个新的方法 —— entries()，keys()和values() —— 用于遍历数组。它们都返回一个遍历器对象，可以用for...of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。

 var arr3=['zhou','huang','ke']
 const it=arr3.values()
 for(let i of it){
     console.log(i); //'zhou' 'huang' 'ke'
 }

22、Array.of()

**Array.of()** 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。

区别：

**Array.of()** 和 **Array** 构造函数之间的区别在于处理整数参数：**Array.of(7)** 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个长度为7的空数组（注意： 这是指一个有7个空位(empty)的数组，而不是由7个undefined组成的数组）。

 Array.of(7);       // [7]
 Array.of(1, 2, 3); // [1, 2, 3]
 ​
 Array(7);          // [ , , , , , , ]
 Array(1, 2, 3);    // [1, 2, 3]

23、pop()和push()

0. pop()删除数组的最后的元素，返回这个删除的元素， 当数组为空时返回undefined

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

2. push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

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

24、reduce()和reduceRight()

reduce() 方法对数组中的每个元素按序执行一个由您提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。

参数

• callbackFn，一个 “reducer” 函数，包含四个参数：

0. previousValue：上一次调用callbackFn时的返回值。在第一次调用时，若指定了初始值initialValue，其值则为initialValue，否则为数组索引为 0 的元素array[0]`。
1. currentValue：数组中正在处理的元素。在第一次调用时，若指定了初始值 initialValue，其值则为数组索引为 0 的元素 array[0]，否则为 array[1]。
2. currentIndex：数组中正在处理的元素的索引。若指定了初始值initialValue`，则起始索引号为 0，否则从索引 1 起始。
3. array：用于遍历的数组。

• initialValue 可选

作为第一次调用 callback 函数时参数 previousValue 的值。若指定了初始值 initialValue，则 currentValue 则将使用数组第一个元素；否则 previousValue 将使用数组第一个元素，而 currentValue 将使用数组第二个元素。

注意：

• 如果数组仅有一个元素（无论位置如何）并且没有提供初始值 initialValue，或者有提供 initialValue 但是数组为空，那么此唯一值将被返回且 callbackfn 不会被执行。
• 数组为空且初始值 initialValue 未提供。

 let total = [ 0, 1, 2, 3 ].reduce(
   ( previousValue, currentValue ) => previousValue + currentValue,
   0
 )
 /*计算元素个数*/
 let names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice']
 ​
 let countedNames = names.reduce(function (allNames, name) {
   if (name in allNames) {
     allNames[name]++
   }
   else {
     allNames[name] = 1
   }
   return allNames
 }, {})
 /*数组去重*/
 let myArray = ['a', 'b', 'a', 'b', 'c', 'e', 'e', 'c', 'd', 'd', 'd', 'd']
 let myArrayWithNoDuplicates = myArray.reduce(function (previousValue, currentValue) {
   if (previousValue.indexOf(currentValue) === -1) {
     previousValue.push(currentValue)
   }
   return previousValue
 }, [])
 ​
 console.log(myArrayWithNoDuplicates)
 ​
 /*使用 .reduce() 替换 .filter().map()*/
 ​
 const numbers = [-5, 6, 2, 0];
 ​
 const doubledPositiveNumbers = numbers.reduce((previousValue, currentValue) => {
   if (currentValue > 0) {
     const doubled = currentValue * 2;
     previousValue.push(doubled);
   }
   return previousValue;
 }, []);
 ​
 console.log(doubledPositiveNumbers); // [12, 4]

**reduceRight() **方法接受一个函数作为累加器（accumulator）和数组的每个值（**从右到左） **将其减少为单个值。

25、reverse()

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

 const a = [1, 2, 3];
 console.log(a); // [1, 2, 3]
 a.reverse();
 console.log(a); // [3, 2, 1]

26、shift()和unshift()

0. **shift()** 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。

 const array1 = [1, 2, 3];
 ​
 const firstElement = array1.shift();
 ​
 console.log(array1);
 // expected output: Array [2, 3]
 ​
 console.log(firstElement);
 // expected output: 1

2. unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组 ) 。

 const array1 = [1, 2, 3];
 ​
 console.log(array1.unshift(4, 5));
 // expected output: 5
 ​
 console.log(array1);
 // expected output: Array [4, 5, 1, 2, 3]

27、slice()

**slice()** 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

参数

• begin 可选

提取起始处的索引（从 0 开始），从该索引开始提取原数组元素。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。如果省略 begin，则 slice 从索引 0 开始。如果 begin 超出原数组的索引范围，则会返回空数组。

• end 可选

提取终止处的索引（从 0 开始），在该索引处结束提取原数组元素。slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素 （索引为 1, 2, 3的元素）。如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。如果 end 被省略，则 slice 会一直提取到原数组末尾。如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。

28、sort()

**sort()** 方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的 。 由于它取决于具体实现，因此无法保证排序的时间和空间复杂性

 const months = ['March', 'Jan', 'Feb', 'Dec'];
 months.sort();
 console.log(months);
 // expected output: Array ["Dec", "Feb", "Jan", "March"]
 /*按照UTF-16代码，因此数字排序转换成字符串后，不是按照大小来的*/
 const array1 = [1, 30, 4, 21, 100000];
 array1.sort();
 console.log(array1);
 // expected output: Array [1, 100000, 21, 30, 4]

参数

• compareFunction` 可选,用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。

  • firstEl第一个用于比较的元素
  • secondEl第二个用于比较的元素。

比较函数

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

• 如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
• 如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。
• 如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
• compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。

 /*几种升序的比较函数的写法*/
 //1、
 function compare(a, b) {
   if (a < b ) {           // 按某种排序标准进行比较, a 小于 b
     return -1;
   }
   if (a > b ) {
     return 1;
   }
   // a must be equal to b
   return 0;
 }
 //2、function compareNumbers(a, b) {
   return a - b;
 }
 //3、函数表达式也可以
 var numbers = [4, 2, 5, 1, 3];
 numbers.sort(function(a, b) {
   return a - b;
 });
 console.log(numbers);
 //4、箭头函数表达式
 也可以写成：
 var numbers = [4, 2, 5, 1, 3];
 numbers.sort((a, b) => a - b);
 console.log(numbers);
 ​
 ​

 var mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];
 ​
 function compareNumbers(a, b)
 {
   return a - b;
 }
 console.log(mixedNumericArray.sort(compareNumbers));//[1, 5, '9', 40, '80', 200, '700']

29、toString()和toLocaleString()

0. **toString()** 返回一个字符串，表示指定的数组及其元素。

   参数： 无

    var str=['I','am','Chinese']
     console.log(str.join('-')); //I-am-Chinese
     console.log(str.toString());//I,am,Chinese
     console.log(str);//['I', 'am', 'Chinese']
   

1. **toLocaleString()** 返回一个字符串表示数组中的元素。数组中的元素将使用各自的 toLocaleString 方法转成字符串，这些字符串将使用一个特定语言环境的字符串（例如一个逗号 ","）隔开。arr.toLocaleString([locales[,options]]);

   本地化，参见MDN

   参数：

   • locales 可选

   带有BCP 47语言标记的字符串或字符串数组，关于locales参数的形式与解释，请看Intl页面。

   • options 可选

   一个可配置属性的对象，对于数字 Number.prototype.toLocaleString()，对于日期Date.prototype.toLocaleString().

30、splice()

splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。

参数

•  start
  

  指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。

• deleteCount 可选

  整数，表示要移除的数组元素的个数。如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。

• item1, item2, *...* 可选

  要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。

返回

• 由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。

 var city=['xinxiang','xiamen','wuhan']
  console.log(city.splice(0,-1,'bijie'));//[]，只增加，没删除，返回空数组。当第二个参数是0或者负数时候，不删除，这种情况下，至少应添加一个新元素。
 ​
 ​
 let name=['shen','zhou','zhang']
 console.log(name.splice(0,1,'zhu'));//['shen']从name[0]开始，删除1个元素，再插入'zhu'
 console.log(name); //['zhu', 'zhou', 'zhang']
 console.log(name.splice(1,1)); //['zhou']
 console.log(name);//['zhu', 'zhang']
 ​
 var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
 var removed = myFish.splice(-2, 2);
 console.log(removed);//['mandarin', 'sturgeon']
 console.log(myFish);//['angel', 'clown']

\