创建数组方法
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)