1.如何添加元素到数组的开头或末尾 push unshift

2.如何删除数组开头和结尾位置上的元素 pop shift

3.如何在数组中的任意位置上删除或添加元素呢 splice (不能使用delete操作符)

splice()方法
splice: 胶接处; 粘接处; 绞接处,绞接
注意：
这种方法会改变原始数组。
如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。啥都不删除的话，返回的是空数组（[]）

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.splice(5, 3);
console.log(numbers);//[0, 1, 2, 3, 4, 8, 9, 10]
     //这行代码删除了从数组索引 5 开始的 3 个元素。这就意味着 numbers[5]、numbers[6]和numbers[7]从数组中删除了。

    // delete numbers[0];
    // console.log(numbers);//[empty, 1, 2, 3,  4, 8, 9, 10]
    // console.log(numbers[0]);//undefined

     /* 
     对于 JavaScript 数组和对象，我们还可以用 delete 运算符删除数组中的元素，
      例如 delete numbers[0]。然而，数组位置 0 的值会变成 undefined，也就
      是说，以上操作等同于 numbers[0] = undefined。
      */
console.log(numbers);//[0, 1, 2, 3, 4, 8, 9, 10]
numbers.splice(5, 0, 2, 3, 4)
console.log(numbers);//[0, 1, 2, 3, 4, 2, 3, 4, 8, 9, 10]
      /* splice 方法接收的第一个参数，表示想要删除或插入的元素的索引值。第二个参数是删除
元素的个数（这个例子里，我们的目的不是删除元素，所以传入 0）。第三个参数往后，就是要
添加到数组里的值（元素 2、3、4）。 */

numbers.splice(5, 3, 2, 3, 4);
console.log(numbers);//[0, 1, 2, 3, 4, 8, 9, 10] => [0, 1, 2, 3, 4, 2, 3, 4, 8, 9, 10]
//我们从索引 5 开始删除了 3 个元素，包括索引5，变成了[0, 1, 2, 3, 4, 8, 9, 10]，然后从索引5之前插入【2，3，4】

4.连接两个或多个数组 concat

concat 连接 2 个或更多数组，并返回结果,不改变原数组

let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let arr3 = [7, 8, 9];
let num = 10;

let result = arr1.concat(arr2, arr3, num)
console.log(result);// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

//注意：原数组不会发生改变
console.log(arr1);//[1, 2, 3]
console.log(arr2);//[4, 5, 6]
console.log(arr3);//[7, 8, 9]

//注意：concat不会把数组里的嵌套元素也给合并到一起：比如
let arr1 = [1,2,3];
let arr2 = [4,[5,6]];
let num = 7;
let arr3 = [8,9];
 
console.log(arr1.concat(arr3));
// Array: arr1+arr3：[1,2,3,8,9]
console.log(arr1.concat(arr2));
// Array: arr1+arr2：[1,2,3,4,[5,6]]  [1, 2, 3, 4, Array(2)]
console.log(arr1.concat(num)); 
// Array: arr1+num：[1,2,3,7]
console.log(arr1.concat(arr2,arr3));
// Array: arr1+arr2+arr3：[1,2,3,4,[5,6],8,9]
console.log(arr1.concat(arr2,num,arr3));
// Array: arr1+arr2+num+arr3：[1,2,3,4,[5,6],7,8,9]
console.log(arr1.concat(arr2,num,arr3)[4]);//[5, 6]

5.对数组中的每个元素运行给定函数，如果该函数对每个元素都返回 true，则返回 true every

every()方法的定义与用法：

• every()方法用于检测数组中的所有元素是否都满足指定条件（该条件为一个函数）。
• every()方法会遍历数组的每一项，如果有有一项不满足条件，则表达式返回false,剩余的项将不会再执行检测；如果遍历完数组后，每一项都符合条，则返回true。

注意： every() 不会对空数组进行检测。

注意： every() 不会改变原始数组。

//array.every(function(currentValue,index,arr), thisValue
/* Tips:

every() 不会对空数组进行检测
every() 不会改变原始数组 */

let arr1 = [1000, 2000, 3000];
let res = arr1.every(function(currentValue, index, arr) {
  return currentValue > 1500 //如果是900的话，那么res的结果是true
})
console.log(res);//false

6.对数组中的每个元素运行给定函数，返回该函数会返回 true 的元素组成的新数组 filter

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

注意： filter() 不会对空数组进行检测。

注意： filter() 不会改变原始数组。

array.filter(function(currentValue,index,arr), thisValue)

let ages = [32, 33, 16, 40];

let res = ages.filter(function(currentValue, index, arr) {
  return currentValue >= 18;
})

console.log(res);// [32, 33, 40]
console.log(ages);// [32, 33, 16, 40]

7.对数组中的每个元素运行给定函数。这个方法没有返回值 forEach

array.forEach(function(currentValue, index, arr), thisValue)

计算数组所有元素相加的总和：

    let sum = 0;
    arr5.forEach(function(currentValue, index, arr) {
      sum += currentValue
    })

    console.log(sum);

8.将所有的数组元素连接成一个字符串 join

不会改变原数组
array.join(separator分隔符)

separator 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。

    let fruits = ["Banana", "Orange", "Apple", "Mango"];
    let energy = fruits.join();
    console.log(energy);//Banana,Orange,Apple,Mango
    energy = fruits.join(' and ')//
    console.log(energy)//Banana and Orange and Apple and Mango
    console.log(fruits);// ['Banana', 'Orange', 'Apple', 'Mango']

    let arr6 = [60, 70, 80, 90, 100];
    console.log(arr6.join());//60,70,80,90,100

9.返回第一个与给定参数相等的数组元素的索引，没有找到则返回-1 indexOf

1.概念

该方法返回某个元素在数组中的位置。

2.语法

array.indexOf(item,start)

3.参数值

参数 描述
参数 描述
指定要开始查找的位置，默认为0。如果为负值，则表示从倒数第几个开始查找，此时查找的方向不变，还是从前往后查找。

4. 返回值

首个被找到的元素在数组中的索引，没找到返回 -1

  let arr7 = [60, 70, 80, 90, 100];
  console.log(arr7.indexOf(60));//0
  console.log(arr7.indexOf(70));//1
  console.log(arr7.indexOf(80));//2
  console.log(arr7.indexOf(90));//3
  console.log(arr7.indexOf(100));//4
  console.log(arr7.indexOf(110));//-1

  arr = ['a', 'b', 'c', 'b', 'c', 'd', 'e']
console.log(arr.indexOf('b') ) // 1
console.log(arr.indexOf('b', 2) ) // 3
console.log(arr.indexOf('c', -2) ) // -1 从倒数第二个开始找c，也就是d之后
console.log(arr.indexOf('c', -3) ) // 4 从c开始找c
console.log(arr.indexOf('e', -2) ) // 6

10.返回在数组中搜索到的与给定参数相等的元素的索引里最大的值 lastIndexOf

1.概念

lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，从该数组的后面向前查找。

2.语法

array.lastIndexOf(item,start)

3.参数

index：指定要查找的元素的位置，从此位置开始逆向查找。默认为数组的长度减去1(array.length - 1)。如果为负值，则表示从倒数第几个开始向前查找，此时查找的方向不变还是从后向前查找。

4.返回值

返回元素最后一次在数组出现的索引，没找到返回 -1

    fruits=["Banana","Orange","Apple","Mango","Banana","Orange","Apple"];
    var a = fruits.lastIndexOf("Apple");
    console.log(a)//6 从后往前查找元素的位置

    //从数组中的第四个位置(arr[3])查找字符串 "Apple"出现的位置：
     fruits=["Banana","Orange","Apple","Mango","Banana","Orange","Apple"];
     a = fruits.lastIndexOf("Mango",3);
    console.log(a);//3 从arr[3]mango开始向前找mango


    const arr = ['a', 'b', 'c', 'b', 'c', 'd', 'e']
    console.log(arr.lastIndexOf('c'))  // 4
    console.log(arr.lastIndexOf('c', -4))  // 2  
    //如果为负值，则表示从倒数第几个开始向前查找，此时查找的方向不变还是从后向前查找。 从b开始向前开始查找
    //-1 是倒数第一个元素，-4就是倒数第四个元素
    console.log(arr.lastIndexOf('e', -4)) //-1
    console.log(arr.lastIndexOf('c', 2))  // 2
    console.log(arr.lastIndexOf('c', 1))  // -1
    console.log(arr.lastIndexOf('A'))  // -1

11.对数组中的每个元素运行给定函数，返回每次函数调用的结果组成的数组 map

1.返回一个新数组
2.不会对空数组进行检测，对空数组检测的化，返回值也是空数组，
3.不会改变原数组

 let arr = [1, 2, 3, 4, 5];
 let res = arr.map( function(currentValue, index, arr) {
  return currentValue * 2
 })

 console.log(res)//[2, 4, 6, 8, 10]

12.颠倒数组中元素的顺序，原先第一个元素现在变成最后一个，同样原先的最后一个元素变成了现在的第一个 reverse

1. reverse() 方法反转数组中元素的顺序。

2. reverse() 方法将改变原始数组

 let arr = [1, 2, 3, 4, 5];
 let res = arr.reverse()

 console.log(res)// [5, 4, 3, 2, 1]
 console.log(arr)// [5, 4, 3, 2, 1]

13.传入索引值，将数组里对应索引范围内的元素作为新数组返回 slice

slice 把…切成(薄)片; 片

slice() 方法可从已有的数组中返回选定的元素。

array.slice(start, end) 截取的元素包含start，但是不包含end
start 可选。规定从何处开始选取。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。

slice 不会修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。原数组的元素会按照下述规则拷贝：

如果该元素是个对象引用 （不是实际的对象），slice 会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。如果被引用的对象发生改变，则新的和原来的数组中的这个元素也会发生改变。

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

14.对数组中的每个元素运行给定函数，如果任一元素返回 true，则返回 true some

some() 方法会依次执行数组的每个元素：

• 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。
• 如果没有满足条件的元素，则返回false。

注意： some() 不会对空数组进行检测。

注意： some() 不会改变原始数组。

var a = [1,15,4,10,11,22];


var evens = a.some(function(currentvalue, index, arr) {
  return currentvalue % 2 === 0

});
console.log(evens)//true
//如果把数组换成[1, 15, 15, 3, 17, 11] ,结果是false

15.按照字母顺序对数组排序，支持传入指定排序方法的函数作为参数 sort

sort方法会改变原始数组
可以按照字母升序，字母降序
数字升序和数字降序
默认情况下该方法是将数组元素转换成字符串，然后按照ASC码进行排序。

var fruits = ["Banana", "Orange", "Apple", "Mango"];
console.log(fruits.sort())//['Apple', 'Banana', 'Mango', 'Orange']

function sortNumber(a, b){
   return a - b; //这里返回的是他们的差值，如果是大于0的值，
//就会将b排在前面，如果小于0,
  // 就会将a排在前面，如果是0的话，就随便。（冒泡排序法！！）
}

如果返回值大于 0，则位置互换。
如果返回值小于 0，则位置不变。

var points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b});
console.log(points)
//排序结果: 1,5,10,25,40,100
points.sort(function(a,b){return b-a});
console.log(points)// [100, 40, 25, 10, 5, 1]

  var fruits = ["Banana", "Orange", "Apple", "Mango"];
    fruits.sort();
    fruits.reverse();
  console.log(fruits)//['Orange', 'Mango', 'Banana', 'Apple']
  </script>

16. 将数组作为字符串返回 toString

数字的字符串表示
number.toString(radix)

  console.log([1, 2, 3].toString())//1,2,3
  console.log([].toString())//空字符串
  console.log(typeof ( [].toString()))//string