数组的方法整理
原创
join()
把数组转换成字符串 [ 原数组不变 ]
join：把数组转换成字符串，然后给他规定个连接字符，默认的是逗号( ，)
书写格式：join(" ")，括号里面写字符串 ("要加引号"),
var arr = [1, 2, 3]
var arr1 = arr.join();
var arr2 = arr.join("-");
var arr3 = arr.join("=");
console.log(arr1); // 1,2,3
console.log(arr2); // 1-2-3
console.log(arr3); // 1=2=3
console.log(arr); // [1, 2, 3]push()
在原数组末尾添加一个元素 [ 会改变原数组 ]
push：把内容添加到数组末尾，并返回修改后的数组的长度
注意：如果没有清空之前的数据，push之后会不断的往数组里面继续添加
var arr = [1, 2, 3]
var arr1 = arr.push(4);
console.log(arr1); // 返回数组的长度 4
console.log(arr); // [1, 2, 3,4]pop()
删除原数组最后一个元素 [ 会改变原数组 ]
pop：移除数组最后一项，并返回移除的那个值，减少数组的 length
var arr = [1, 2, 3]
var arr1 = arr.pop();
console.log(arr1); // 返回删除的元素 3
console.log(arr); // [1, 2]unshift()
在原数组开头添加一个元素 [ 会改变原数组 ]
unshift：将参数添加到原数组开头，并返回数组的长度
var arr = [1, 2, 3]
var arr1 = arr.unshift(0);
console.log(arr1); // 返回数组的长度 4
console.log(arr); // [0, 1, 2, 3]shift()
删除原数组第一项 [ 会改变原数组 ]
shift：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined
var arr = [1, 2, 3]
var arr1 = arr.shift();
console.log(arr1); // 返回删除元素的值 1
console.log(arr); // [2, 3]sort()
原数组排序 [ 会改变原数组 ]
sort()：将数组里的项从小到大排序
// 默认情况下，不传参数的话，默认按字母升序
// 若为非字符串,则先调用toString()将元素转化为字符串的 Unicode ,再进行字符串比较
var arr = ["a", "c", "d", "b"]
var arr1 = arr.sort()
console.log(arr1); // ["a", "b", "c", "d"]
console.log(arr); // ["a", "b", "c", "d"]
// 数组的升序与降序排序
var arr2 = [10, 40, 30, 20]
var arr3 = arr2.sort();
console.log(arr3); // [10, 20, 30, 40]
console.log(arr2); // [10, 20, 30, 40]
// 数组升序
var arr4 = [1, 0, 5, 4, 9, 45, 78, 6, 14, 2];
arr4.sort((a, b) => a - b)
console.log(arr4)//[0, 1, 2, 4, 5, 6, 9, 14, 45, 78]
// 数组降序
arr4.sort((a,b)=>b-a)
console.log(arr4); // [78, 45, 14, 9, 6, 5, 4, 2, 1, 0]
//按年龄排序，若年龄相同，就女士(sex属性为0) 排在男士(sex属性为1)之前
let arr5 = [{ age: 18, sex: 0 }, { age: 19, sex: 0 }, { age: 20, sex: 0 }, { age: 18, sex: 1 }, { age: 19, sex: 1 }];
arr5.sort((a, b) => {
if (a.age === b.age) { //若年龄相同就按性别排，女士优先
return a.sex - b.sex;
} else { //年龄不相同就默认按年龄排升序
return a.age - b.age;
}
})
console.log(arr5)
reverse()
反转数组项的顺序 [ 会改变原数组 ]
var arr1 = [10, 40, 30, 20]
var arr2 = arr1.reverse();
console.log(arr1); // [20, 30, 40, 10]
console.log(arr2); // [20, 30, 40, 10]concat()
合并多个数组或，返回新数组 [ 不改变原数组 ]
concat() ：将参数添加到原数组中。这个方法会先创建当前数组一个副本
然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。
在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。
var arr = [10, 40, 30, 20]
var copyArr = arr.concat();
var copyArr1 = arr.concat(1, [50, 60]);
console.log(copyArr); // [10, 40, 30, 20] 如果concat中没有传值，会得到一个当前数组的副本
console.log(arr === copyArr); //false 使用了contact后得到的数组指向不同的地址
console.log(copyArr1); // [10, 40, 30, 20, 1, 50, 60] 合并数组
console.log(arr); // [10, 40, 30, 20] 原数组未被改变splice()
向/从数组中添加/删除元素，返回被删除的元素 [ 会改变原数组 ]
表达式 arr.splice(index, num, item1, item2, ...);
参数说明
第一个参数为 一个整数，用来指定添加/删除元素的位置，可以用负数来从尾部开始数 必填参数
第二个参数为 删除元素的数量，若不想删除可以设置为0 可选参数
再后面的参数为 向数组添加的元素 可选参数
如果是删除操作,那么会把删除的元素放在一个新数组中返回。
1.操作的元素会包括开始的元素
2.如果数组的元素不够，会一直删除到数组的最后一位
var arr = [10, 40, 30, 20]
// ==============================================================================
// 传入1个参数，默认从数组的0下标开始，删除后面所有的元素
// var arr1 = arr.splice(1);
// console.log(arr1); // 传入1，从1位开始，删除后面所有元素，返回被删除的元素 [40, 30, 20]
// console.log(arr); // 原数组变为 [10]
// var arr2 = arr.splice(2);
// console.log(arr2); // 传入2，从2位开始，删除后面所有元素，返回被删除的元素 [30, 20]
// console.log(arr); // 原数组变为 [10, 40]
// ==============================================================================
// 传入2个参数
// var arr3 = arr.splice(2,1);
// console.log(arr3); // 传入2和1，从2位开始，删除1个，返回删除的元素，得到 [30]
// console.log(arr); // 原数组变为 [10, 40, 20]
// var arr4 = arr.splice(3,1);
// console.log(arr4); // 传入3和1，从3位开始，删除1个，返回删除的元素，得到 [20]
// console.log(arr); // 原数组变为 [10, 40, 30]
// ==============================================================================
// 传入负数
// var arr5 = arr.splice(-1)
// console.log(arr5) // 传入-1，从最后1位开始，删除1个，返回删除的元素，得到 [20]
// console.log(arr);; // 原数组变为 [10, 40, 30]
var arr6 = arr.splice(-2)
console.log(arr6) // 传入-2，从最后倒数第2位开始，删除2个，返回删除的元素，得到 [30, 20]
console.log(arr);; // 原数组变为 [10, 40]
// ==============================================================================
// 往数组中添加元素
var nameArr = ['George','John','Thomas','James','Adrew','Martin']
// var nameArr1 = nameArr.splice(2,0,"William") // 在第2位的前面添加一个元素
// console.log(nameArr); // ["George", "John", "William", "Thomas", "James", "Adrew", "Martin"]
// console.log(nameArr1); // 无删除的元素 返回 []
// 删除位于 index 2 的元素，并添加一个新元素来替代被删除的元素
// var nameArr2 = nameArr.splice(2,1,"William")
// console.log(nameArr); // ["George", "John", "William", "James", "Adrew", "Martin"]
// console.log(nameArr2); // 返回删除的元素 ["Thomas"]
// 删除从 index 2 ("Thomas") 开始的三个元素，并添加一个新元素 ("William") 来替代被删除的元素
var nameArr3 = nameArr.splice(2,3,"William")
console.log(nameArr); // ["George", "John", "William", "Martin"]
console.log(nameArr3); // 返回删除的元素 ["Thomas", "James", "Adrew"]
slice()
拷贝数组元素 [不改变原数组]
表达式 arr.splice(start, end);
两个参数为 复制索引开始 和 复制索引结束 （不包括结束索引的元素）
start：必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推
end：可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。
如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。
var arr = [10, 40, 30, 20]
var arr1 = arr.slice(0,2)
console.log(arr) // [10, 40, 30, 20]
console.log(arr1); // [10, 40]
var arr2 = arr.slice(2)
console.log(arr); // [10, 40, 30, 20]
console.log(arr2); // [30, 20]toString()
可把数组转换为字符串，并返回结果。
[不改变原数组]
var arr = ['a', 'b', 'c', 2]
var arr1 = arr.toString()
console.log(arr1) // a,b,c,2
console.log(arr) // ['a', 'b', 'c', 2]indexOf()
查找数组中某元素的第一个索引值。如果没有就返回-1
第一个参数为查找的值 第二个参数为查找的起始位
[不改变原数组]
let arr = [1, 2, 3, 4, 3, 5, 6]
console.log(arr.indexOf(3)) //2
console.log(arr.indexOf(3, 3)) //4
console.log(arr.indexOf(3, 5)) //-1
console.log(arr.indexOf('3')) //-1
console.log(arr.indexOf(8)) //-1lastIndexOf()
逆向查找指定元素在数组中的第一个位置。[不改变原数组]
let arr = [1, 1, 3, 4, 5, 1];
console.log(arr.lastIndexOf(1))//5
console.log(arr.lastIndexOf(1, -2))//1includes()
查找数组是否包含某个元素。[不改变原数组]
第一个参数为要查找的值 必填
第二个为查找的起始位置
返回值 true或false
let arr = [1, NaN, 100, '42'];
console.log(arr.includes(1)); //true
console.log(arr.includes(NaN)); //true
console.log(arr.includes(1, 3)); //falsefill()
数组的填充 [改变原数组、ES6]
语法：arr.fill(value, start, end)
value 必需。填充的值。
start 可选。开始填充位置。
end 可选。停止填充位置 (默认为 array.length)
let arr = new Array(3)
arr.fill('填充')
console.log(arr) //["填充", "填充", "填充"]
arr.fill('位置', 0, 1)
console.log(arr) // ["位置", "填充", "填充"]
arr.fill('位置', 0)
console.log(arr) // ["位置", "位置", "位置"] 没有传 end 值，默认填充数组的长度copyWithin()
数组的指定位置复制[改变原数组、ES6]
语法：arr.copyWithin(index, start, end)
第一个参数：复制到指定目标索引位置。
第二个参数：元素复制的起始位置 (可选)
第三个参数：停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。(可选)
let arr = [1, 2, 3, 4, 5, 6];
let a = arr.copyWithin(2, 0, 3);
console.log(arr)// [1, 2, 1, 2, 3, 6]Array.isArray()
用于确定传递的值是否是一个 Array。
console.log(Array.isArray([1, 2, 3])); // true
Array.isArray({foo: 123}); // false
Array.isArray("foobar"); // false
Array.isArray(undefined); // falseArray.of()
返回一个由参数组成的数组
let arr = Array.of(1, 2, 3)
console.log(arr); // [1,2,3]
let arr1 = Array.of('1','2','3')
console.log(arr1); // ["1", "2", "3"]Array.from()
将数组对象转换为数组 不改变原对象 返回新数组
将一个类数组对象转换为一个真正的数组，必须具备以下条件：
1、该类数组对象必须具有length属性，用于指定数组的长度。如果没有length属性，那么转换后的数组是一个空数组。
2、该类数组对象的属性名必须为数值型或字符串型的数字
ps: 该类数组对象的属性名可以加引号，也可以不加引号
// 将类数组对象转换为真正数组：
let a = { 0: '1', 1: '2', 2: '3', 'length': 3 };//对象
let arr5 = Array.from(a)
console.log(arr5) // ["1", "2", "3"]
// ==========================================================
let b = {
'name': 'tom',
'age': '65',
'sex': '男',
'friends': ['jane','john','Mary'],
length: 4
}
let arr6 = Array.from(b)
console.log(arr6); // [undefined, undefined, undefined, undefined]
// ==========================================================
// 向 Array from 传入一个数组 Array.from会返回一个一模一样的新数组
let oldArr = [1,2,3,4]
let newArr = Array.from(oldArr)
console.log(oldArr === newArr); // false
// 将字符串转换为真正的数组
let c = Array.from('hello')//字符串
console.log(c) // ["h", "e", "l", "l", "o"]
// 将Set结构的数据转换为真正的数组：
let arr = [11,22,33,44,55,66,77]
let set = new Set(arr)
console.log(Array.isArray(set)); // false
console.log(Array.isArray( Array.from(set))); // true
console.log(Array.from(set)) // [11,22,33,44,55,66,77]
let arrset = Array.from(new Set('func'))
console.log(arrset) // ["f", "u", "n", "c"]
let arrMap = Array.from(new Map().set([1, 2], [3, 4], [5, 6]))
console.log(arrMap) // [ [1,2],[3,4] ]
//Array.from还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组
let thearr = Array.from([1, 2, 3], x => x * 2)
console.log(thearr) // [2, 4, 6]参考：https://blog.csdn.net/qq_39408204/article/details/89468377
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。