JS Array(数组)所有操作方法，改变数组方法、不改变数组方法

Posted 2023-04-23

参考技术A

定义：返回由所有参数值组成的数组，如果没有参数，就返回一个空数组。
目的：Array.of() 出现的目的是为了解决上述构造器因参数个数不同，导致的行为有差异的问题。

参数：
第一个参数(必需):要转化为真正数组的对象。
第二个参数(可选): 类似数组的map方法，对每个元素进行处理，将处理后的值放入返回的数组。
第三个参数(可选): 用来绑定this。

ps：splice方法从数组中添加/删除项目，然后返回被删除的项目

语法： array.splice(index,howmany,item1,.....,itemX)
参数:
index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany：必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, …, itemX： 可选。向数组添加的新项目。
返回值: 如果有元素被删除,返回包含被删除项目的新数组。

删除元素

删除并添加

不删除只添加

ps：方法接受两个参数，一个从哪里开始，一个是到哪里结束（但是不包括这个结束的元素本身）。如果是负数，就从倒数第几个。

参数可选: 规定排序顺序的比较 函数 。
默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符。

比较函数的两个参数
sort的比较函数有两个默认参数，要在函数中接收这两个参数，这两个参数是数组中两个要比较的元素，通常我们用 a 和 b 接收两个将要比较的元素：

sort排序常见用法
数组元素为数字的升序、降序:

数组多条件排序

自定义比较函数

定义: 在当前数组内部，将指定位置的成员复制到其他位置,并返回这个数组。
语法: array.copyWithin(target, start = 0, end = this.length)
参数:
三个参数都是数值，如果不是，会自动转为数值.
target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。
end（可选）：到该位置前停止读取数据，默认等于数组长度。使用负数可从数组结尾处规定位置。
浏览器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持

从上述例子:
第一个参数是开始被替换的元素位置
要替换数据的位置范围:从第二个参数是开始读取的元素，在第三个参数前面一个元素停止读取
数组的长度不会改变
读了几个元素就从开始被替换的地方替换几个元素

参数:
第一个元素(必须): 要填充数组的值
第二个元素(可选): 填充的开始位置,默认值为0
第三个元素(可选)：填充的结束位置，默认是为this.length

使用join方法或者下文说到的toString方法时，当数组中的元素也是数组或者是对象时会出现什么情况？

join()/toString()方法在数组元素是数组的时候，会将里面的数组也调用join()/toString(),如果是对象的话，对象会被转为[object Object]字符串。

如上述栗子：调用数组的toLocaleString方法，数组中的每个元素都会调用自身的toLocaleString方法，对象调用对象的toLocaleString,Date调用Date的toLocaleString。

该方法的效果和join方法一样，都是用于数组转字符串的，但是与join方法相比没有优势，也不能自定义字符串的分隔符，因此不推荐使用。
ps：当数组和字符串操作的时候，js 会调用这个方法将数组自动转换成字符串

ps：字符串也有一个slice() 方法是用来提取字符串的，不要弄混了。
参数:
begin(可选): 索引数值,接受负值，从该索引处开始提取原数组中的元素,默认值为0。
end(可选):索引数值(不包括),接受负值，在该索引处前结束提取原数组元素，默认值为数组末尾(包括最后一个元素)。

如上：新数组是浅拷贝的，元素是简单数据类型，改变之后不会互相干扰。

如果是复杂数据类型(对象,数组)的话，改变其中一个，另外一个也会改变

原因在定义上面说过了的：slice()是浅拷贝，对于复杂的数据类型浅拷贝，拷贝的只是指向原数组的指针，所以无论改变原数组，还是浅拷贝的数组，都是改变原数组的数据。

ES6扩展运算符...合并数组：
因为ES6的语法更简洁易懂，所以现在合并数组我大部分采用...来处理，...运算符可以实现cancat的每个栗子，且更简洁和具有高度自定义数组元素位置的效果。

参数:
searchElement(必须):被查找的元素
fromIndex(可选):开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0。
严格相等的搜索:
数组的indexOf搜索跟字符串的indexOf不一样,数组的indexOf使用严格相等===搜索元素，即数组元素要完全匹配才能搜索成功。
注意：indexOf()不能识别NaN

参数:
searchElement(必须): 被查找的元素
fromIndex(可选): 逆向查找开始位置，默认值数组的长度-1，即查找整个数组。
关于fromIndex有三个规则:
正值。如果该值大于或等于数组的长度，则整个数组会被查找。
负值。将其视为从数组末尾向前的偏移。(比如-2，从数组最后第二个元素开始往前查找)
负值。其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。

参数：
searchElement(必须):被查找的元素
fromIndex(可选):默认值为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值绝对值超过长数组度，重置从0开始搜索。
includes方法是为了弥补indexOf方法的缺陷而出现的:
indexOf方法不能识别NaN
indexOf方法检查是否包含某个值不够语义化，需要判断是否不等于-1，表达不够直观

数组的方法

数组在我们js中的的地位很好，而且我们对于数组的操作过于频繁，所以我们应该总结一下数组的方法

数组尾操作

Array.push()，向数组的末尾添加一个或多个元素，输出是返回新的数组长度。并且数组发生改变

var arr=[1,11,111,1111]
arr.push(2,22,222)
//arr发生改变
arr=[1,11,111,1111,2,22,222]

Array.pop()，删除并返回数组的最后一个元素，若该数组为空，就返回undefined。并且原数组改变。

var arr=[1,11,111,1111,2]
var arr1=arr.pop()
    //arr1=2
    //arr=[1,11,111,1111]

 数组首操作

Array.unshift()，向数组的开头添加一个或多个元素，并返回新的数组长度。原数组改变。

var arr=[1,11,111,1111]
var arr1=arr.unshift(0)
    //arr1=2
    //arr=[2,1,11,111,1111]

Array.shift()，删除数组的第一项，并返回第一个元素的值。若该数组为空，则返回undefined。原数组改变。

var arr=[1,11,111,1111]
var arr1=arr.shift()
    //arr1=1
    //arr=[11,111,1111]

 连接两个或多个数组

Array.concat(arr1,arr2...)，合并两个或多个数组，生成一个新的数组。原数组不变。

var arr=[1,11,111,1111]
var arr1=[2,3,4]
var arr2=arr.concat(arr1)
    //arr2=[1,11,111,1111,2,3,4]
    //arr=[1,11,111,1111]

join()

Array.join()，将数组的每一项用指定字符连接形成一个字符串。默认连接字符为 “,” 逗号。

var arr=[1,11,111,1111]
var arr1=arr.jojn()
var arr2=arr.jojn("-")
    //arr1=[1,11,111,1111]
    //arr2=[1-11-111-1111]

排序

Array.sort()，对数组元素进行排序。按照字符串UniCode码排序，原数组改变。

　　①从小到大排

var arrNum = function(a,b){
    return a-b
}
arr.sort(arrNum);//[1,11,111,1111]

　　②从大到小排

var arrNum = function(a,b){
    return b-a
}
arr.sort(arrNum);//[1111,111,11,1]

　　③按照数组对象中的某个值进行排序

var arr=[
    {name:"11",age"15"},
    {name:"15",age"25"},
    {name:"18",age"19"}
]
function com(param){
    return function sortAge(a,b){
        return a[param]-b[param];
    }
}
arr.sort(com("age"));


//输出
//{name:"11",age"15"}
//{name:"18",age"19"}
//{name:"15",age"25"}

 反转数组

Array.reverse()，将数组倒序。原数组改变。

var arr=[1,11,111,1111]
arr.reverse()
    //arr=[1111,111,11,1]

Array.slice(start,end)，从start开始，end之前结束，不到end；如果不给end值，从start开始到数组结束。start可以给负值，-1表示数组最后位置，-2表示倒数第二个，以此类推，顾前不顾后

    var arr=[1,11,111,1111]
    var a=arr.slice(-3,-1)
    //[11,111]

 Array.splice(index,howmany,arr1,arr2...) ，删除元素并添加元素，从index位置开始删除howmany个元素，并将arr1、arr2...数据从index位置依次插入。howmany为0时，则不删除元素。原数组改变。

 

ES5数组新增方法：

Array.filter(function)，过滤数组中，符合条件的元素并返回一个新的数组。

    var arr=[1,2,3,4,5]
    var a=arr.fliter(x=> x>3)
    //[4,5]

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

    var arr=[1,2,3,4,5]
    var a=arr.reduce((a,b)=>{
    a=b
})
    //15

Array.forEach(function)，用于调用数组的每个元素，并将元素传递给回调函数。原数组不变。（注意该方法和map的区别，若直接打印Array.forEach，结果为undefined）。

Array.every(function)，对数组中的每一项进行判断，若都符合则返回true，否则返回false。

Array.some(function)，对数组中的每一项进行判断，若都不符合则返回false，否则返回true。

ES6数组新增方法

Array.from()方法是用于类似数组的对象（即有length属性的对象）和可遍历对象转为真正的数组。

let json ={
	    '0':'1',
	    '1':'2',
	    '2':'3',
	    length:3
	}
	let arr = Array.from(json);
	console.log(arr); // ["1", "2", "3"]	

Array.of()方法是将一组值转变为数组，参数不分类型，只分数量，数量为0返回空数组。

	let arr1 = Array.of(1,2,3);	
	let arr2 = Array.of([1,2,3]);
	let arr3 = Array.of(undefined);
	let arr4 = Array.of();
	console.log(arr1); // [1, 2, 3]
	console.log(arr2); // [[1, 2, 3]]
	console.log(arr3); // [undefined]
	console.log(arr4); // []