copywithin(copywithin 去重)

js哪些方法改变原数组哪些不改变原数组

1、shift：将第一个元素删除并且返回删除元素，空即为undefined

2、unshift：向数组开头添加元素，并返回新的长度

3、pop：删除最后一个并返回删除的元素

4、push：向数组末尾添加元素，并返回新的长度

5、reverse：颠倒数组顺序

6、sort：对数组排序

7、splice:splice(start,length,item)删，增，替换数组元素，返回被删除数组，无删除则不返回

8、copyWithin:方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。

9、fill:用一个元素填充原来的数组

1、concat：targetArr.concat(otherArr[,anyOtherArr])连接多个数组，返回新的数组

2、join：将数组中所有元素以参数作为分隔符放入一个字符

3、slice：slice(start,end)，返回选定元素

4、map,filter,forEach,some,every,reduce等不改变原数组

JS 数组相关操作

push()可以将某些值加入到数组的最后一个位置，并且不限制添加数量（注：数组长度是有限制的），如果需要添加多项内容使用逗号隔开即可，加入后数组长度会增加。

let a=[1,2,3,4,5,6,7,8];

a.push(9,10);

console.log(a);// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

pop()会移除数组的最后一个元素。

let a=[1,2,3,4,5,6,7,8];

a.pop();

console.log(a);// [1, 2, 3, 4, 5, 6, 7]

shift() 会移除数组的第一个元素。

let a=[1,2,3,4,5,6,7,8];

a.shift();

console.log(a);// [2, 3, 4, 5, 6, 7, 8]

unshift() 会将指定的元素添加到数组的第一个位置。

let a=[1,2,3,4,5,6,7,8];

a.unshift(100,200,300);

console.log(a);// [100, 200, 300, 1, 2, 3, 4, 5, 6, 7, 8]

reverse()会将数组反转

let a=[1,2,3,4,5,6,7,8];

a.reverse();

console.log(a);// [8, 7, 6, 5, 4, 3, 2, 1]

splice()可以移除或新增数列的元素，它包含了三个参数，第一个是要移除或要添加的序列号( 必填)，第二个是要移除的长度( 选填，若不填则从第一个参数序号位置开始，后方的所有元素都会被移除，若设定为0则不会有元素被移除)，第三个是要替换的内容( 选填 )

let a=[1,2,3,4,5,6,7,8];

a.splice(5,1);

console.log(a);// [1, 2, 3, 4, 5, 7, 8] ( 6 被移除了 )

添加第三个参数就能够添加或替换元素。

let a=[1,2,3,4,5,6,7,8];

a.splice(5,1,100);

console.log(a);// [1, 2, 3, 4, 5, 100, 7, 8] ( 6 被移除，100加到第5个位置 )

let b=[1,2,3,4,5,6,7,8];

b.splice(5,3,100,200,300);

console.log(b);// [1, 2, 3, 4, 5, 100, 200, 300] ( 6,7,8 被移除，100,200,300 加到第 5,6,7 个位置 )

let c=[1,2,3,4,5,6,7,8];

c.splice(5,0,100);

console.log(c);// [1, 2, 3, 4, 5, 100, 6, 7, 8] ( 没有元素被移除，100 加到第 5 个位置 )

sort()可以针对数组的元素进行排序，里头包含了一个排序用的判断函数，函数内必须包含两个参数，这两个参数分别代表数组里的第n个和第n+1 个元素，通过比较第n和第n+1个元素的大小来进行排序。

let a=[1,3,8,4,5,7,6,2];

a.sort((x,y)=y-x);

console.log(a);// [8, 7, 6, 5, 4, 3, 2, 1]

a.sort((x,y)=x-y);

console.log(a);// [1, 2, 3, 4, 5, 6, 7, 8]

如果不使用判断函数， 默认会将元素转换成字串，并采用unicode来判断 ，这也会造成某些数字的排序错误，如下段示例：

let a=[1,3,8,4,5,7,6,2,9,10,11];

a.sort();

console.log(a);// [1, 10, 11, 2, 3, 4, 5, 6, 7, 8, 9]

copyWithin()能复制数组中的某些元素，并将它们放到同一个数组指定的位置，copyWithin()有三个参数，第一个是要置换的位置(必填)，第二个是从什么位置开始复制(选填，预设0 )，第三个是停止复制的元素的前一个位置(选填，默认值等于数组长度)。

let a=[1,2,3,4,5,6,7,8];

a.copyWithin(2);

console.log(a);// [1,2,1,2,3,4,5,6] ( 因 7 和 8 超过数组长度，只出只复制到6 )

let b=[1,2,3,4,5,6,7,8];

b.copyWithin(3,1,3);

console.log(b);// [1,2,3,2,3,6,7,8] ( 复制 2,3 取代 4,5 )

fill()会把数组中所有元素，置换为指定的值，fill()有三个参数，第一个是准备要置换的内容(必填)，第二个是从什么位置开始置换(选填，不设定就全部置换) ，第三个是停止置换的元素的前一个位置(选填，预设等于数组长度)。

let a=[1,2,3,4,5,6,7,8];

a.fill('a');

console.log(a);// ['a','a','a','a','a','a','a','a']

let b=[1,2,3,4,5,6,7,8];

b.fill('b',3,5);

console.log(b);// [1,2,3,'b','b',6,7,8]

length可以取得数组的长度。

let a=[1,2,3,4,5,6,7,8];

console.log(a.length);// 8

indexOf() 会判断数组中是否包含某个值，判断的方式为「由左而右」，如果有包含就返回这个值在数组中的索引值，如果没有就返回-1，有两个参数，第一个参数表示要判断的值( 必填)，第二个参数表示从数组的哪个位置开始判断( 选填，预设为0 )。

let a=[1,2,3,4,5,6,7,8];

console.log(a.indexOf(4));// 3

console.log(a.indexOf(4,5));// -1 ( 在6,7,8中搜索有没有4 )

lastIndexOf() 会判断数组中是否包含某个值，判断的方式为「由右而左」，如果有包含就返回这个值在数组中的索引值，如果没有就返回-1，这个方法有两个参数，第一个参数表示要判断的值( 必填)，第二个参数表示判断从数组的哪个位置开始从右往左查找( 选填，默认为整个数组长度-1 )。

let a=[1,2,3,4,5,6,7,8];

console.log(a.lastIndexOf(3));// 2

console.log(a.lastIndexOf(3,1));// -1 ( 只在1,2中判断，所以没有 3 )

find()会将数组中的「每一个」元素带入指定的函数内做判断，并会返回第一个符合判断条件的元素，如果没有元素符合则会返回undefined。

let a=[1,2,3,4,5,6,7,8];

console.log(a.find(e=e3));// 4

console.log(a.find(e=e0));// undefined

findIndex()会将数组中的「每一个」元素带入指定的函数内做判断，并会返回第一个符合判断条件元素的位置索引，如果没有元素符合则会返回-1。

let a=[1,2,3,4,5,6,7,8];

console.log(a.findIndex(e=e3));// 3

console.log(a.findIndex(e=e0));// -1

filter()会将数组中的「每一个」元素带入指定的函数内做判断，如果元素符合判断条件则会返回，组成一个新的数组。

let a=[1,2,3,4,5,6,7,8];

console.log(a.filter(e=e3));// [4, 5, 6, 7, 8]

console.log(a.filter(e=e%2==0));// [2, 4, 6, 8]

forEach()会将数组中每个元素套用到指定的函数里进行运算，函数有三个参数，第一个参数表示每个元素的值( 必填)，第二个参数为该元素的索引值( 选填)，第三个参数则表示原本的数组( 选填)。

let a=[1,2,3,4,5];

let b=0;

a.forEach(item={b=b+item;});

console.log(b);// 15 ( 1+2+3+4+5 )

如果结合第二和第三个参数进行搭配使用，就能做到改变原本数组的效果。

let a=[1,2,3,4,5];

a.forEach((item,index,arr)={arr[index]=item*10;});

console.log(a);// [10,20,30,40,50]

join()可以将数组中所有元素，变成由指定的字符分割合并在一起组合成字符串进行呈现，若没有指定字符默认会用「逗号」合并。

let a=[1,2,3,4,5,6,7,8];

console.log(a.join());// 1,2,3,4,5,6,7,8

console.log(a.join(''));// 12345678

console.log(a.join('@@'));// 1@@2@@3@@4@@5@@6@@7@@8

concat()可以将两个数组合并在一起，如果是使用ES6语法也可以用扩展运算符...来代替。

let a=[1,2,3,4,5];

let b=[6,7,8,9];

let c=a.concat(b);

let d=[...a,...b];// 使用 ...

console.log(c);// [1,2,3,4,5,6,7,8,9]

console.log(d);// [1,2,3,4,5,6,7,8,9]

slice()可以截取出数组某部份的元素为一个新的数组，有两个必填的参数，第一个是起始位置，第二个是结束位置( 操作时数字减1 )。

let a=[1,2,3,4,5,6,7,8];

let b=a.slice(2,4);

console.log(b);// [3, 4]

map()会处理数组中每个元素，最后返回一个新的数组，里头有一个函数( 必填) 和一个返回函数里的this参数( 选填)，函数内又包含三个参数，第一个是每个元素的值( 必填)，第二个是当前元素的索引值( 选填)，第三个是当前的数组( 选填)。

let a=[1,2,3,4,5,6,7,8];

let b=a.map(e={returne+10;});

console.log(b);// [11, 12, 13, 14, 15, 16, 17, 18]

使用第二个和第三个参数的示例:

let a=[1,2,3,4,5,6,7,8];

let b=a.map((e,i,arr)={return`${e}${i}${arr.find(e=e%5==1)}`;// 组合成「元素 + 索引值 + 除以五余数为1的第一个元素」});

console.log(b);// ['101', '211', '321', '431', '541', '651', '761', '871']

如果要使用回调函数里this的参数，则「不能使用」箭头函数，因为箭头函数的this指向和函数的this指向不同，所以要用一般的函数处理。

let a=[1,2,3,4,5,6,7,8];

let b=a.map(function(e){

????returne+this;// 此处的 this为10

},10);

console.log(b);// [11, 12, 13, 14, 15, 16, 17, 18]

reduce() 可以将数组中每个元素进行计算，每次计算的结果会再与下个元素作计算，直到结束为止，里头包含一个函数( 必填) 和初始计算的数值( 选填)，函数内有四个参数，第一个是计算的值( 必填)，第二个是取得的元素(必填)，第三个是该元素的索引值( 选填)，第四个是原本的数组(选填)。

let a=[1,2,3,4,5,6,7,8];

let b=a.reduce(function(total,e){returntotal+e;});

console.log(b);// 36 ( 1+2+3+4+5+6+7+8=36 )

reduceRight() 和reduce()大同小异，只是其计算方式是由右到左，对于加法来说没什么影响，但对于减法而言就有差异。

let a=[1,2,3,4,5,6,7,8];

let b=a.reduce(function(total,e){returntotal-e;});

console.log(b);// -34 ( 1-2-3-4-5-6-7-8 = -34 )

let c=a.reduceRight(function(total,e){returntotal-e;});

console.log(c);// -20 ( 8-7-6-5-4-3-2-1 = -20 )

flat()可以将一个多维数组的深度转成一维(扁平化或称作降维)，它有一个选填的参数，代表要转换的深度数字，预设为1（只展开一层放到一维数组里，如果是2，只展开2层放到一维数组里），如果深度有很多层，可使用Infinity来全部展开成一维数组。

let a=[1,2,[3],[4,[5,[6]]]];

let b=a.flat();

let c=a.flat(2);

let d=a.flat(Infinity);

console.log(b);// [1, 2, 3, 4, [5, [6]]]

console.log(c);// [1, 2, 3, 4, 5, [6]]

console.log(d);// [1, 2, 3, 4, 5, 6]

flatMap()的方法等于map()和flat()的组合，在运算后直接将数组扁平化处理。

let a=[1,2,[3],[4,5]];

let b=a.flatMap(e=e+1);

let c=a.map(e=e+1).flat();

console.log(b);// [2, 3, "31", "4,51"] ( 可以看到 b 和 c 得到的结果相同 )

console.log(c);// [2, 3, "31", "4,51"]

Array.isArray()能判断一个元素是否为数组，如果是就返回true，不然就返回false。

let a=[1,2,3,4,5,6,7,8];

let b=123;letc='hello';

let d={d1:1,d2:2};

console.log(Array.isArray(a));// true

console.log(Array.isArray(b));// false

console.log(Array.isArray(c));// false

console.log(Array.isArray(d));// false

Array.from()会将「类数组」或是「可迭代的对象」转换成数组，Array.from()有两个参数，第一个参数为「类数组对象」或「可迭代的对象」(必填)，第二个参数则是改变转换成数组元素的函数(选填)。

类数组对象具有length 属性以及索引化index 的元素，可迭代对象表示具有可以利用迭代的方式取得它自己本身的元素，例如Map 和Set...等。( 参考MDN 说法 )

let a='abcde';

let b=Array.from(a);

console.log(b);// ['a','b','c','d','e']

let c=Array.from(a,e=e+e);

console.log(c);// ['aa','bb','cc','dd','ee']

类数组对象写法必须包含length 属性，且对象的key须为0开始的数字，对应转换后的元素索引。

let a={'0':14,'2':13,'1':7,'3':9,'4':6,length:5};

let b=Array.from(a);

console.log(b);// [14,7,13,9,6]

Array.of()可以快速将数字、字串等内容，转换成数组。

let a=Array.of(1,'a',2,'b',3);

console.log(a);// [1, "a", 2, "b", 3]

toString()会把整个数组转换成字符串。

let a=[1,2,3,4,5,6,7,8];

let b=a.toString();

console.log(b);// 1,2,3,4,5,6,7,8

every()会将数组中的「每一个」元素带入指定的函数内做判断，只要有任何一个元素不符合判断条件，会回返回false，如果全部符合，就会回传true。

let a=[1,2,3,4,5,6];

console.log(a.every(e=e3));// fasle ( 因为1、2 小于 3，3 等于 3 )

console.log(a.every(e=e0));// true

some()会将数组中的「每一个」元素带入指定的函数内做判断，只要有任何一个元素符合判断条件，就会返回true，如果全都不符合，才会返回false。

let a=[1,2,3,4,5,6];

console.log(a.some(e=e3));// 返回 true，因为 4、5、6 大于 3

console.log(a.some(e=e6));// 返回 fasle，因为全都小于或等于 6

includes()会判断数组中是否包含某个值，如果有包含就返回true，否则返回false，有两个参数，第一个参数表示要判断的值( 必填)，第二个参数表示从数组的哪个位置开始判断( 选填)。

let a=[1,2,3,4,5,6,7,8];

console.log(a.includes(2));// true

console.log(a.includes(2,2));// false ( 在 3,4,5,6,7,8 查找有没有 2 )

valueOf()会返回数组的原始值，如果原本的数组有修改，那么返回的原始值也会跟着改变（相当浅复制）

let a=[1,2,3,4,5,6,7,8];

let b=a.valueOf();

console.log(a);// [1, 2, 3, 4, 5, 6, 7, 8]

let c=a.valueOf();

a.shift();

console.log(a);// [2, 3, 4, 5, 6, 7, 8]

console.log(b);// [2, 3, 4, 5, 6, 7, 8] ( 因为 a 的原始值更新了，所以 b 也变了 )

console.log(c);// [2, 3, 4, 5, 6, 7, 8]

keys()会返回数组中的每一个索引值( key )成为一个新的Array Iterator对象，因为是Array Iterator对象，可以使用for...of进行迭代。

let a=['a','b','c','d','e'];

let b=a.keys();

for(let key of b){

????console.log(key);// 1、2、3、4、5

}

数组的常用方法123

concat(数组1，数组2，...)，用于合并两个或多个数组，返回一个全新的数组

copyWithin()方法，从数组的指定位置拷贝元素到数组的另一个指定位置中，第一个参数是目标位置，第二个参数是拷贝元素的起始位，第三个参数是拷贝元素的结束位置，如果不设置第三个参数，拷贝元素结束位置就是目标位置的前一位

fill()方法，使用一个固定值来填充数组

从数组中检查指定的数据是否存在，存在返回true，不存在返回false

1）学号不可以重复 通过includes()查找nos这个数组总共是否已存在，存在返回ture，不存在返回false。

2）输出长度为7的数组 str ，且七位数组内容不重复

1）str.indexOf（a）返回的值是在数组 str 中第一个数据 a 对应的下标（索引）位置

2）str.lestindexOf（a）返回的值是在数组 str 中最后一个数据 a 对应的下标（索引）位置

isArray（a）检查 a 是否为数组，是返回true，不是返回false

join()将一个数组根据某个字符串拼接成字符串，默认为逗号

返回结果分别是：

11你好22你好33你好44你好55你好66你好77你好88

1122334455667788

11,22,33,44,55,66,77,88

split()方法，用于将字符串根据某个字符串打散成数组

1）split('')表示将字符串中的所有字符打散成数组，

返回结果：['好', '好', '学', '习', '，', '天', '天', '向', '上']

2）split('喜欢')表示将字符串根据“喜欢”打散成数组，

返回结果：?['我', '吃苹果，', '吃桃子，', '吃香蕉']

1）删除，该方法需要传两个参数：第一个是起始位置，第二个是删除长度；如果第二个参数不传，就表示从起始位置往后全部删除

splice(起始位置，删除内容长度)，数组 str 返回结果为[11, 22, 33, 66]

2）修改，splice(起始位置，删除内容长度，替换内容)，数组 str 返回结果为[11, 22, 99, 33, 66]

3）添加，splice(起始位置，0，添加内容)，数组 str 返回结果为[11, 22, 33, 99, 44, 55, 66]

push()方法，向数组的末尾添加一个或更多元素，并返回新的数组，添加多个元素用逗号隔开

pop()方法，删除数组最后一个元素并返回新的数组

unshift()方法，向数组的开头添加一个或更多元素，并返回新数组，添加多个元素用逗号隔开

shift()方法，删除数组的第一个元素并返回新的数组

reverse()方法，反转数组的元素顺序

例：打印输出：[55, 44, 33, 22, 11]

slice()方法，选取数组的一部分，并返回一个新数组，原数组不变，该方法第一个参数是起始位置，第二个参数是结束位置，但取不到结束位置，如果省略第二个参数，只输入一个参数表示从起始位置开始到最后全部返回

例：

输出结果：

toString()方法，把数组转换为字符串，并返回结果，和join()方法类似，使用join()方法较多

js数组中有哪些方法呢？

Array.from()

Array.isArray()

Array.of()

Array.prototype.concat()

Array.prototype.copyWithin()

Array.prototype.entries()

Array.prototype.every()

Array.prototype.fill()

Array.prototype.filter()

Array.prototype.find()

Array.prototype.findIndex()

Array.prototype.flat()

Array.prototype.flatMap()

Array.prototype.forEach()

Array.prototype.includes()

Array.prototype.indexOf()

Array.prototype.join()

Array.prototype.keys()

Array.prototype.lastIndexOf()

Array.prototype.map()

Array.prototype.pop()

Array.prototype.push()

Array.prototype.reduce()

Array.prototype.reduceRight()

Array.prototype.reverse()

Array.prototype.shift()

Array.prototype.slice()

Array.prototype.some()

Array.prototype.sort()

Array.prototype.splice()

Array.prototype.toLocaleString()

Array.prototype.toSource()

Array.prototype.toString()

Array.prototype.unshift()

Array.prototype.values()

非常多。自己搜索一下就知道了。没有判断数组的方法，但是可以判断数组方法有很多，例如[1, 2, 3, 4, 5].constructor.name

JS数组方法

数组的创建方式

1.字面量的形式： var arr=[1,2,3];

1.构造函数： var arr1=new Array();//不常用

Array构造函数有一个很大的缺陷，就是不同的参数，会导致它的行为不一致。

1.单个数值作为参数，参数表示数组的元素个数

可以看到，Array作为构造函数，行为很不一致。因此，不建议使用它生成新数组，直接使用数组字面量是更好的做法。

push/pop/unshift/shift//增加、删除元素 （数组的方法，所以使用时应调用

数组名.方法名（））

arr. slice/splice//截取元素

arr.slice(); 原数组不发生改变

无参数时，返回原数组，相当于数组的复制。

一个参数时，从参数作为下标的元素截取，至数组结束。

二个参数时，从第一个参数作为下标（索引）的元素开始截取，到第二个参数作为下标的元素结束，但不包括第二个参数作为下标的函数。 （起始元素包含，结尾元素不包含）

多个参数时，前两个参数起效，后边的参数无效。

arr.splice(); 原数组改变

无参数时，返回空数组。

一个参数时，从参数作为下标的元素截取，至数组结束。

二个参数时，从第一个参数作为下标（索引）的元素开始截取，即表示截取的起始位置，第二个参数表示截取的元素个数。

多个参数时，前两个参数起效，后边的参数从原数组的截取起始位置开始填充，填充到原数组。

reverse/sort//改变元素位置

arr.reverse(); //数组翻转(元素位置颠倒)

arr.sort(); 从小到大排序，但遵循的是字符串的按位比较规则，所以排序结果容易出现异常。

join();//不改变原数组

join() 以指定参数作为连接符，将所有数组成员连接为一个字符串返回。如果不提供参数，默认用逗号分隔。

concat();//拼接数组 不改变原数组

ES5新增数组操作方法

indexOf (item) 返回元素在数组中对应的索引值，找不到的话，返回-1，用以测试元素是否存在于数组中

forEach(function(item,index)) 遍历数组,没有返回值

map(function(item,index)) 遍历数组,存在返回值

filter(function(item)) {return item2} 返回大于2的元素

some 返回布尔值，条件部分成立|| arr.some(function(item){return item2} )

every 返回布尔值，条件全部成立 arr.every(function(item){return item2} )

reduce (对数组中的所有元素调用指定的回调函数。该回调函数的返回值为累积结果，并且此返回值在下一次调用该回调函数时作为参数提供。)arr.reduce(function(a,b){return a+b;});

toString()和toLocaleString()

功能：将数组的每个元素转化为字符串，并且输出用逗号分隔的字符串列表。功能类似join()；

参数：无

输出：字符串

indexOf()和lastIndexOf()

功能：搜索整个数组中具有给定值的元素，返回找到的第一个元素的索引或者如果没有找到就返回-1；lastIndexOf为反向搜索。

参数：元素的值，起点索引（可选）

输出：索引值或-1

Array.from()

功能：将两类对象转为真正的数组：类似数组的对象和可遍历的对象

参数：待转换的对象，第二个参数可选，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组。

输出：数组

Array.of()

功能：将一组值，转换为数组。

参数：数组元素

输出：数组

copyWithin()

功能：在当前数组内部，将指定位置的成员复制到其他位置，返回变化后的数组。

参数：索引（从该位置开始替换数据）；索引（从该位置开始读取数据，默认为0，负值表示倒数）；索引（到该位置前停止读取，默认为最大索引）

输出：返回当前替换后的数组。

注意：改变了当前数组

find()和findIndex()

功能：找到第一个符合条件的数组成员。

参数：回调函数，所有数组成员依次执行该函数，直到找到第一个返回值为true的成员。回调函数可以接受三个参数，依次为值，位置，原数组。

输出：find()返回找到的成员；findIndex()返回成员的位置。

fill()

功能：使用给定的值，填充一个数组。

参数：第一个参数为待填充的值，第二和第三参数可选，分别表示填充的起始和结束位置(不包括)。

输出：填充后的数组

entries()、keys()、values()

功能：用于遍历数组，可以用for…of循环进行遍历。区别是keys()是对键名的遍历、values是对键值的遍历、entries()是对键值对的遍历。

参数：无

输出：遍历器对象

includes()

功能：表示某个数组是否包含给定的值

参数：第一个参数必选（待检查的给定值），第二个参数可选，表示搜索的起始位置，默认为0，负数表示倒数的位置。

输出：一个布尔值。

注意：和indexOf的区别，indexOf进行了运算符的强比对，会导致对NaN误判。