JavaScript 之 数组滴方法

创建数组及将其转为字符串

Array.from（）将一个类数组（有长度值，有索引值）或者连续的字符串的数据转为数组

Array.of（）将不连续的参数转为数组

console.log(Array.of(10)); // 得到一个存储了元素10的数组
console.log(new Array(10)); // 得到一个长度为10的空数组

因为数组也是对象类型，所以用type of来判断某个东西是不是数组是不行，得用isArray

任何数据跟字符串相加，都会转为字符串

var arr  = [1,2,3,4,5];
//直接把字符串转为数组，保留元素之间的逗号
console.log(arr + '100')//1,2,3,4,5100

var obj = { name： '100')
//任何对象跟字符串相加，直接转换为[object object]
console.log(obj + '100')//[object object]100

arr.join（分割的字符）可以用指定的分割字符，可以将数组转为字符串，若没指定分割的字符，默认用逗号分割，其效果相当于toString（）

数组首尾的插入和删除

——能改变原数组

从数组末尾添加元素：arr.push（参数1，参数2...）；相当于arr[arr.length] = 所需要加的字符

从数组末尾删除元素：arr.pop（无参数）；一次只能删一个元素

从数组开头增加元素：arr.unshift（）；可以增加多个

从数组开头删除元素：arr.shift（无参数）；一次只能删一个元素

在数组的任意位置进行删除、插入、替换

arr.splice（开始位置，删除个数）

arr.splice（开始位置，删除个数，插入的元素...）

arr.splice（arr.length,0,增加的元素）——相当于push

arr.splice（arr.length-1,1）——相当于pop

arr.splice（0,0,需要增加的元素）——相当于unshift

arr.splice（0,1）——相当于shift

检索数组元素位置

arr.indexOf（字符）；返回首次出现的字符的索引，不存在返回-1

arr.lastIndexOf（字符）；返回末尾出现的字符的索引，不存在返回-1

arr.includes（字符）；判断数组中是否存在该字符

数组截取

arr.slice(a,b):截取从开始位置（包含）到结束位置（不包含）之间的元素，返回新的数组对象，原数组不受影响

合并数组

arr.concat（）

arr.concat（[a,b,c],[1,2,3]）——[a,b,c,1,2,3]

扩展运算符

...  将一个数组转为用逗号分割的参数序列

...[a,b,c]——结果为a,b,c

[...[a,b,c],...[1,2,3]]——结果为[a,b,c,1,2,3]

[...'a,b,c']—— 结果为[a,b,c]

断言函数

断言函数接收 3 个参数：元素、索引和数组本身。其中元素是数组中当前搜索的元素，索引是当前元素的索引，而数组就是正在搜索的数组。断言函数返回真值，表示是否匹配。

find()和 findIndex()方法使用了断言函数。这两个方法都从数组的最小索引开始。find()返回第一个匹配的元素，findIndex()返回第一个匹配元素的索引。这两个方法也都接收第二个可选的参数，用于指定断言函数内部 this 的值。

1. arr.find(function(遍历到的元素，需要遍历到的元素索引，所要遍历的数组){}）；find方法常用于从数组中查找一个符合条件的元素，如果找不到返回undefined ；
2. arr.findIndexof(function(遍历到的元素，需要遍历到的元素索引，所要遍历的数组){}); 返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1。

数组排序

arr.reverse():颠倒反转元素的位置

arr.sort():用于对数组的元素进行排序。排序顺序可以是字母或数字，并按升序或降序。默认排序顺序为按字母升序

var points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b});//数字升序排列

points.sort(function(a,b){return b-a});//数字降序排列

冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果后面的数字比前面的数字小，那么小的数往前排，大的数往后走。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

function bubbleSort(arr) {
  var length = arr.length;
  for (var i = 0; i < length - 1; i++) {
    for (var j = 0; j < length - 1 - i; j++) {
      if (arr[j] > arr[j+1]) {  // 相邻元素两两对比
        var temp = arr[j+1];    // 元素交换
        arr[j+1] = arr[j];
        arr[j] = temp;
      }
    }
  }
  return arr;
}

数组迭代forEach...

forEach(): 没有返回值，本质上等同于 for 循环，对每一项执行 function 函数。即map是返回一个新数组，原数组不变，forEach 是改变原数组。不支持 continue，用 return false 或 return true 代替。不支持 break，用 try catch/every/some 代替：

arr.every(function(遍历的元素, index, array){ });

会遍历数组中的每个元素，若是全都符合条件，返回ture，若是找到一个条件不符合，返回false，因为它是every。

arr.some(function(遍历的元素, index, array){ });

会遍历数组中的每个元素，只要有一个符合条件，返回ture，若是全都不符合，返回false，因为它是some。

arr.filter(function(遍历的元素, index, array){ });

筛选过滤符合条件的元素返回到新数组中，若没有任何元素符合，返回空数组，在这过程中没有符合条件的会被跳过

arr.map(function(遍历的元素, index, array){ });

为数组中每个元素调用的函数。每次执行时，都会将返回的值添加到新数组中。

数组归并reduce

reduce()方法从数组第一项开始遍历到最后一项。而 reduceRight()从最后一项开始遍历至第一项。

reduce减少的意思，是指一种'累计'运算。

 arr.reduce(function(prev,current,index,Array){},prev_init)

        prev:上次迭代初始值

        current:当前值

        index:元素索引

        Array:数组本身

        prev_init:上一次迭代初始值

//计算每个元素出现的次数
let arr = ['word','space','power','summer','sun','light','gold'];
let res = arr.reduce(function (prev, current) {
  if (!prev[current]) {
       prev[current] = 1;
  } else {
       prev[current]++;
  }
       return prev;
  }, {})
    console.log(res);

var arr = [2, 20, 16, 30, 18];

// 情况1：不存在 initvalue
// 第一次遍历：prev的值是数组中第一元素的值，current的值是数组中第二个元素的值
// 从第二次遍历开始：current是数组中下一个元素的值，prev会存储是回调函数上一次return的值
result = arr.reduce(function (prev, current, index) {
  return prev + current;
});
console.log(result);// 186 数组中所有元素的和

// 情况2：存在initValue
// 第一次遍历：prev的是initValue的值10，current的值是数组中第一个元素的值
// 从第二次遍历开始：current是数组中下一个元素的值，prev会存储是回调函数上一次return的值
result = arr.reduce(function (prev, current, index) {
  return prev + current;
}, 10);
console.log(result);// 196