数组方法全集

理想今年妳几岁

已于 2023-03-20 22:51:27 修改

阅读量179

点赞数 1

分类专栏：笔记 js 文章标签：排序算法算法 javascript

于 2022-06-07 17:36:19 首次发布

本文链接：https://blog.csdn.net/m0_46691148/article/details/125166458

版权

笔记同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

10 篇文章 0 订阅

订阅专栏

创建数组方法

new Array():构造函数创建。括号里面参数若为一个数字,表示该数组的长度。如果为多个数字或一个(多个)非数字表示的是数组中包含的值。 let arr=[ ] //字面量

new Array(10).fill(null) // [null, null, null, null, null, null, null, null, null, null]
new Array('a','b') //[a,b]
new Array(3,4)   //[3,4]
arr=[3]  //[3]

1. 改变数组本身的方法

push，向数组的最后新增一个元素，返回值是改变后的该数组的length值
pop，从数组的最后删除一个元素，返回值是被删除的元素，减少数组的length

var arr = ["Lily","lucy","Tom"];
var count = arr.push("Jack","Sean");
console.log(count);   // 5
console.log(arr); 　　// ["Lily", "lucy", "Tom", "Jack", "Sean"]
var item = arr.pop();
console.log(item); 　　// Sean
console.log(arr); 　　// ["Lily", "lucy", "Tom", "Jack"]

unshift，向数组的头新增一个元素，返回值是改变后的该数组的length值 shift，从数组的头部删除一个元素，返回值是被删除的元素

var arr = ["Lily","lucy","Tom"];
var count = arr.unshift("Jack","Sean");
console.log(count); 　　// 5
console.log(arr); 　   //["Jack", "Sean", "Lily", "lucy", "Tom"]
var item = arr.shift();
console.log(item); 　　// Jack
console.log(arr); 　  // ["Sean", "Lily","lucy", "Tom"]

splice(index, num, item1, item2, …)，index是指定开始处理的索引位置，num指定删除多少项，从第三个元素开始都是新增的元素项。可以实现从指定的索引位置新增、删除、替换元素。返回值是被删除的元素组成的数组。

var arr = [1,3,5,7,9,11];
var arrRemoved = arr.splice(0,2);  //删除，返回删除的数组
console.log(arr); 　　　　//[5, 7, 9, 11]
console.log(arrRemoved);  //[1, 3]
var arrRemoved2 = arr.splice(2,0,4,6); //添加
console.log(arr); 　　　   // [5, 7, 4, 6, 9, 11]
console.log(arrRemoved2);  // []
var arrRemoved3 = arr.splice(1,1,2,4);  //替换
console.log(arr);     // [5, 2, 4, 4, 6, 9, 11]
console.log(arrRemoved3); //[7]

sort，对数组排序，默认按照升序排列，可以传递函数类型的参数决定排序的方式

function sortNumber(a,b){
　　return a - b
  }
// 举例：
arr = [13, 24, 51, 3]; 
console.log(arr.sort());   // [13, 24, 3, 51]  进制排序
console.log(arr.sort(sortNumber));  // [3, 13, 24, 51](数组被改变) sortNumber{return b - a} :降序

reverse，反转数组

 var arr = [13, 24, 51, 3];
console.log(arr.reverse()); 　//[3, 51, 24, 13]
console.log(arr);    //[3, 51, 24, 13](原数组改变)

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值

array.reduce(function(total, currentValue, currentIndex, arr), 	initialValue)
//total 上一次回调return的值，或者是第一次的初始值（initialValue）
//currentValue 数组中当前被处理的元素
//currentIndex  数组中当前被处理的索引
//arr 递归数组本身
//initialValue 初始值

var arr = [1, 2, 3, 4];
var sum = arr.reduce(function(prev, cur, index, arr) {
	return prev + cur; //prev 1,cur 2 ：没有初始值prev就为数组第一项，cur为数组第二项
})
console.log(sum);  //10

var arr = [1, 2, 3, 4];
var sum = arr.reduce(function(prev, cur, index, arr) {
	return prev + cur; //prev 0 ,cur 1 ：有初始值prev就为初始值，cur为数组第一项
}，0)
console.log(sum);  //10

//数组去重
let arr = [1,2,3,4,4,1]
let newArr = arr.reduce((pre,cur)=>{
    if(!pre.includes(cur)){
      return pre.concat(cur)
    }else{
      return pre
    }
},[])
console.log(newArr);// [1, 2, 3, 4]

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

let arr = [1, 2, 3];
let a = arr.join("-");
console.log(a);//输出 "1-2-3"
//当只有一个元素的时候
let arr1 = [1];
let b = arr1.join("-");
console.log(b);// "1" 输出该元素，但是该元素是字符串

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

let arr1 = [1, 2, 3, 4];
//fill三个参数，第一个参数是要填充的值，第二个参数：起始索引，默认值为0。第三个参数：终止索引，默认值为 this.length。
arr1.fill("a", 0, 2);
console.log(arr1);//输出 [ 'a', 'a', 3, 4 ]

2. 不改变数组本身返回新数组的方法

concat，concat的参数，可以是单个/多个基本类型的值，也可以是数组。对原数组和参数拼接，返回拼接后形成的新数组。

let arr = [1, 2, 3, 4, 5];
let arr1 = [6, 7, 8, 9];
let arr2 = arr.concat(arr1);
console.log(arr2); //[1, 2, 3, 4, 5, 6, 7, 8, 9]
var arrCopy = arr.concat(9,[11,13]); //[1, 2, 3, 4, 5,9,11,13]
console.log(arr)//[1, 2, 3, 4, 5]; 原数组不变

slice(startIndex, endIndex)，截取原数组的片段，前闭后开区间，包含startIndex索引的元素开始截取，一直到endIndex索引之前的那个元素

var arr = [1,3,5,7,9,11];
var arrCopy = arr.slice(1);
var arrCopy2 = arr.slice(1,4);
var arrCopy3 = arr.slice(1,-2);
var arrCopy4 = arr.slice(-4,-1);
console.log(arr); 　　　　　　　　　　//[1, 3, 5, 7, 9, 11](原数组没变)
console.log(arrCopy); 　　　　　　　 //[3, 5, 7, 9, 11]
console.log(arrCopy2); 　　　　　　　//[3, 5, 7]
console.log(arrCopy3); 　　　　　　  //[3, 5, 7]
console.log(arrCopy4); 　　　　　　　//[5, 7, 9]

循环遍历相关的方法

forEach((item, index) => {})方法，遍历数组的每个元素，参数为一个函数，参数函数的两个参数为数组项和对应的索引

    let arr = [1, 2, 3, 4, 5];
    arr.forEach(function(item, index) {
        // item == arr[index]   //true
        console.log(item, index);
    });
    // (1,2,3,4,5)  下标：(0,1,2,3,4)

map((item, index) => {})方法，遍历数组的每个元素，参数为一个函数，参数函数的两个参数为数组项和对应的索引，根据参数函数的执行结果，把这些结果组成一个新数组返回。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.map(function(item){
   return item*item;
});
console.log(arr2); 　　　　　//[1, 4, 9, 16, 25]

filter((item, index) => {})方法，遍历数组的每个元素，执行参数函数，将符合参数函数中定义条件的那些项留下，组成一个新数组返回

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(function(x, index) {
    return index % 3 === 0 || x >= 8;   //满足下标被3整除或x大于等于8
}); 
console.log(arr2); 　　　　//[1, 4, 7, 8, 9, 10]

some((item, index) => {})方法，循环数组，对每一项执行参数函数中的条件，有符合条件的项则立即返回true，不再继续遍历；如果全部遍历完还没有找到符合项则返回false

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some(function(x) {
return x < 3;  //只要有一条满足就返回true
}); 
console.log(arr2); 　　　　　　　　//true
var arr3 = arr.some(function(x) {
return x < 1;     //全部不满足才返回false
}); 
console.log(arr3); 　　　　　　　　// false

every((item, index) => {})，与some相反，every需要是数组中每一项都符合参数函数中的条件才返回true，如果遇见任何一项不符合立即返回false，也不再继续遍历后续项。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every(function(x) {
return x < 10;       //每一条都得满足才返回true
}); 
console.log(arr2); 　　　　　　　　//true
var arr3 = arr.every(function(x) {
return x < 3;      
}); 
console.log(arr3); 　　　　　　　　// false

indexOf，获取数组中某元素的索引，如果存在该元素则返回该元素的索引，不存在则返回-1.仅适用于数组元素为基本类型时 lastIndexOf：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中，从数组的末尾开始向前查找

var arr = [1,3,5,7,7,5,3,1];
console.log(arr.indexOf(5)); 　　　　　　//2
console.log(arr.lastIndexOf(5)); 　　　//5
console.log(arr.indexOf(5,3)); 　　　　 //5  第一个参数要查找的项，第二个参数查找起点位置的索引
console.log(arr.lastIndexOf(5,4)); 　　//2
console.log(arr.indexOf("5")); 　　　　 //-1

findIndex，是对indexOf方法的补充，indexOf能做的，findIndex都能做。findIndex方法接收一个函数，在函数中写查找逻辑，如arr.findIndex(item => item.id === 2)查找数组中含有属性id值为2的那个项的索引。返回值同indexOf,找到返回对应的索引值，找不到返回-1

    let arr = [1, 2, 3, 4, 5];
    let obj = arr.findIndex(function(item) {
        return item > 6;
    })
    console.log(obj);  // -1

数组经典排序

冒泡排序：数组中的当前项与后一项比较如果当前项比后一项大则俩项交换位置(大的靠后)

let sortArr = [12, 8, 34, 1, 9]
function sortFun(sortArr) {
  let temp = null
  for (let i = 0; i < sortArr.length - 1; i++) {   //比较轮数 比较length-1轮(5个数，只需把4个最大值依次放最末尾)
    for (let j = 0; j < sortArr.length - 1 - i; i++) {  //比较次数 第一轮比4次(与其他4个数比 出一个最大值)第二轮比3次 要减去比完的那个最大值
      if (sortArr[j] > sortArr[j + 1]) {
        temp = sortArr[j]
        sortArr[j] = sortArr[j + 1]
        sortArr[j + 1] = temp
      }
    }
  }
  return sortArr
}
console.log(sortFun(sortArr))

插入排序

function sortInsert(arr) {
  let handleArr = [].push(arr[0])  //定义容器放第一个值，第一个不用比
  for (let i = 1; i < arr.length; i++) { //第二项开始依次拿进来比
    let A = arr[i]
    for (let j = handleArr.length - 1; j >= 0; j--) { //依次跟手里的值从右到左比 大就放在左边 
      let B = handleArr[j]
      if (A > B) {
        handleArr.splice(j + 1, 0, A)
        break
      }
      if (j === 0) {
        handleArr.unshift(A)
      }
    }
  }
  return handleArr
}

快速排序

function fastSort(arr) {
  if (arr.length <= 1) {
    return arr
  }
  let middle = Math.floor(arr.length / 2)  //取出中间下标
  let middlVal = arr.splice(middle, 1)[0] //找到数组项 并在原有数组中移除
  let leftary = [], rightary = [];
  for (let i = 0; i < arr.length; i++) {
    let item = arr[i]
    item < middlVal ? leftary.push(item) : rightary.push(item)
  }
  return fastSort(leftary).concat(middlVal, fastSort(rightary))

}
let arr3 = [12, 8, 34, 1, 9]
console.log(fastSort(arr1))

数组去重

let ary = [12, 23, 12, 15, 25, 23, 25, 14, 16]

//Set   返回去重的类数组 再转成数组 Array.from  [... ]
let arr = [...new Set(ary)]

//indexOf / includes    indexOf(25,5)第二个参数从下标第5个开始查  lastIndexOf从后往前查
let arr1 = []
for (let i = 0; i < ary.length; i++) {
  if (arr1.indexOf(ary[i]) == -1) {
    arr1.push(ary[i])
  }
}
console.log(arr1)

//filter   indexOf 获取数据在数组中的第一个下标  没有返回-1
function unique1(arr) {
  return arr.filter((item, index) => {
    return arr.indexOf(item) === index
  })
}

//两次循环
function unique(arr) {
  for (var i = 0, len = arr.length; i < len; i++) {
    for (var j = i + 1, len = ar.length; j < len; j++) {
      if (arr[i] === arr[j]) {
        arr.splice(j, 1)
        i--
        len--
      }
    }
  }
}
unique(ary)