JavaScript中的Array40个原型方法、静态方法、属性

 控制台输出：Array.prototype会得到Array的所有方法（谷歌浏览器）

序号	方法	参数	返回值
1	at(index)	索引	对应索引值
2	concat(arr2[,arr3])	传入1或者多个数组 let arr3 = arr.contact(arr1[,arr2])	将传入的数组拼接到arr后面，不改变arr，返回新数组
3	constructor()	--------------------------	返回构造函数
4	copyWithin(i,j,k)	用从索引j到k（不包括k）的元素替换从i开始的对应元素； j,k不填则为第一个到最后一个； k不填为从j到最后	返回改变后的原数组
5	entries（）	-------------------------	返回一个Array迭代器对象，这个对象的键是数组索引，值为对应的数组值； 用于数组遍历
6	every(callback)	传入一个回调函数	如果每个元素都符合回调函数的筛选则返回布尔值true，否则为false并立即终止遍历
7	fill(val,i,j)	val要填充的值，将索引在[i,j)中的元素替换为val	返回改变后的原数组
8	filter(callback)	传入一个回调函数	返回一个通过回调函数测试的新数组
9	find(callback)	传入一个回调函数	返回通过回调函数测试的第一个元素，没有一个通过返回undefined
10	findIndex(callback)	传入一个回调函数	返回通过回调函数测试的第一个元素的索引，没有一个通过返回-1
11	findLast(callback)	传入一个回调函数	返回通过回调函数测试的最后一个元素，没有一个通过返回undefined
12	findLastIndex(callback)	传入一个回调函数	返回通过回调函数测试的最后一个元素的索引，没有一个通过返回-1
13	flat(n)	传入一个数值n，代表要下降的维数	将一个多维数组下降指定维数，返回新数组，不传参和传入Infinity则降到一维；用于数组扁平化
14	flatMap(callback)	传入一个回调函数	产生经过回调函数加工的新数组，并将新数组扁平化最终返回新数组
15	forEach(callback)	传入一个回调函数	数组遍历，无返回值
16	includes(val[,index])	传入一个值val和开始查找的索引值index	如果包含值val返回布尔值true，否则false
17	indexOf(val)	值val	返回这个值第一次出现的索引，没有返回-1
18	join(str)	字符串str	将一个数组或者类似数组的对象转化为一个以str分隔的字符串
19	keys()	-------------------------------	返回一个Array迭代器对象，这个对象包含数组的所有索引
20	lastIndexOf(val)	传入一个值val	返回这个值最后一次出现的索引，没有返回-1
21	map(callback)	传入一个回调函数	返回经过回调函数加工的新数组
22	pop()	----------------------	删除最后一个元素，并返回这个元素
23	push(val)	传入一个值	再数组末尾添加这个元素，返回这个元素的索引(arr.length - 1)
24	reduce((pre,cur,curIndex,arr)=>{})	传入回调函数，函数参数如下： pre上一次计算返回结果， cur当前遍历到的元素值， curIndex当前元素的索引， arr即调用reduce的数组	返回最终计算的结果值, 可用于累加和数组扁平化
25	reduceRight(callback[,initVal])	传入回调函数和初始值	倒序遍历 返回最终计算的结果值, 可用于累加和数组扁平化
26	reverse()	-----------------------------	返回元素颠倒后的原数组
27	shift()	---------------------------------	删除第一个元素，并返回这个元素， 原数组改变
28	slice(i,j)	起始索引i，终止索引j	对[i,j)内的元素进行浅拷贝，返回新数组
29	some(callback)	回调函数	如果有符合回调函数测试的元素，终止遍历返回布尔值true，否则返回false
30	sort([callback])	回调函数或空	无参数默认将原数组按照字符集编码顺序排列元素返回排序后的原数组， 有参数按照回调函数排序返回原数组
31	splice(startIndex[,n[,item1,...]])	startIndex修改的起始索引， 要删除的元素数量， 要添加的值	原数组改变， 从起始位置删除n个元素并添加值， 返回删除的值（删除一个）或删除的值构成的数组
32	toLocaleString()	-----------------------------	此方法会调用数组每一个元素的toString()方法，把结果拼接成以逗号相隔的字符串返回
33	toString()	----------------------------	返回由原数组元素构成的字符串
34	unshift(val)	要添加的值val	添加元素后数组最后一个元素的索引
35	values()	--------------------------	返回一个Array迭代器对象
36	Symbol(Symbol.iterator)	待续....	待续....
37	Symbol(Symbol.unscopables)	待续....	待续....

序号	静态方法和属性	参数	返回值
1	length	------------------------	数组长度
2	Array.from(obj)	数组，类数组，Set，Map等可迭代或类似数组的对象	传入参数的浅复制的新数组形式的返回
3	Array.of(val[,val2[,val3[...]]])	一组值，数组，类数组等	返回一个由参数构成的新数组
4	Array.isArray(arr)	要检测的变量	是数组返回布尔值true，否则false

参考代码：

         let p = (...args) => {
            console.log(...args);
            document.write(...args);
            document.write('
');
        }
        
        p(Array.prototype);
        
        let arr = [1,2,3,4,5,6,7,8,9,10,3];
        let arr2 = [9,9]
        // p(arr.at());
        // p(arr.concat(arr2));
        // p(arr.constructor());
        // p(arr.copyWithin(0,6,8));
        // p(arr);
        
        // for (let item of arr.entries()) {
        //     p(item);
        // }
        
        // p(arr.every(item => item > 3 ));
        // p(arr.fill(1,3,5));
        // p(arr);
        
        // p(arr.filter(item => item > 4));
        // p(arr.find(item => item > 66));
        // p(arr.findIndex(item => item > 99));
        
        // p(arr.findLast(item => item > 200));
        // p(arr.findLastIndex(item => item > 2));
        
        // const arr3 = [0, 1, 2, [[[3, 4]]]];
        // p(arr3.flat(0));
        // p(arr3.flat(1));
        // p(arr3.flat(2));
        // p(arr3.flat(3));
        // p(arr3.flat(Infinity));
        // p(arr3);
        
        // p(arr.flatMap(item => [item,item * 10]));
        // arr.forEach(item => p(item));
        
        // p(Array.from("hello"));
        // p(Array.from(new Set(arr)));
        
        // p(arr.includes(3,1));
        // p(arr.indexOf(3));
        
        // p(Array.isArray(arr));
        // p(arr.join("-"));
        
        // for (let s of arr.keys()) {
        //     p(s);
        // }
        
        // p(arr.lastIndexOf(3));
        // p(arr.map(x => x *100));
        // p(arr.pop());
        // p(arr.push(99)); 
        
        // arr.reduce((pre,cur,curIndex,arr) => {
        //     p(pre,cur,curIndex,arr);
        //     return pre + cur;
        // })
        
        // p(arr.reduceRight((pre,cur) => {//累加
        //     p(pre,cur);
        //     return pre + cur;
        // }));
        
        // arr = [[1,2],[3,4],[5,6]];
        // p(arr.reduceRight((pre,cur) => {
        //     return pre.concat(cur);
        // }))
        
        // p(arr.reverse());
        // p(arr.shift());
        // p(Array.of(arr));
        // p(Array.of(1,2,3));
        
        // p(arr.slice(2,4));
        // p(arr.some(item => {
        //     return item > 100;
        // }))
        
        // p(arr.sort());
        // p(arr.sort((pre,cur) => {
        //     return pre - cur;
        // }))
        
        // p(arr);
        // p(arr.splice(2,4,11));
        // p(arr.toLocaleString());
        
        // arr = [{a:1},2,3,[5,6],{w:3}];
        // p(arr.toString());
        
        // p(arr.unshift(1));
        for (let s of arr.values()) {
            p(s);
        }