js切割数组 js切割数组的方法

js数组移除制定对象 数组拆分成多个数组

var arr="sdhgfhf"var arr1=arr.substr(1，3)console.log(arr1)// "dhg" 从下标1开始取后面所有的 同理如果为负值，比如（-6，3）则为"hjf";后面的始终为长度

一般的方法此处也不列举了，还是有很多的，如双层循环判断是否相等，或新建数组比较再push等等，需要注意的是，使用spl方法移除元素时，有可能会导致数组塌陷问题，需要处理一下

js切割数组 js切割数组的方法

js切割数组 js切割数组的方法

本文中介绍了多种数组去重的方法，使用了较多的高阶方法及API，并给出相应解释及语法，还有其他多种组合调用方式，原理逻辑其实都不多，其中for循环可以与forEach方法相互转换，因此此处便不再一一列举，大家如果有更好的算法，可以留言给我，虚心请教！！

给定一个数组 [1,2,2,4,null,null,’3′,’abc’,3,5,4,1,2,2,4,null,null,’3′,’abc’,3,5,4] 去除重复项

let arr = [1,2,2,4,null,null,’3′,’abc’,3,5,4,1,2,2,4,null,null,’3′,’abc’,3,5,4]

let obj = {};

for (let i = 0; i < arr.length; i++) {

let = arr[i]

arr.spl(i, 1);

i–; // 解决删除元素后，数组塌陷问题

continue;

}obj[] =

2. 交换元素位置从而替换调 spl方法上述方法存在一定的性能问题，也就是说，基于spl实现删除性能不太好，当前项被删除后，随后每一项的索引都要向前移动一位，数据量较庞大时，一定会影响性能。

let obj = {};

for (let i = 0; i < arr.length; i++) {

let = arr[i]

arr[i] = arr[arr.length-1]

arr.length–;

i–;

continue;

}obj[] =

3. Array.filter + Array.indexOffilter() 方法：创建一个新数组，新数组中的元素是指定数组中符合某种条件的所有元素。如果没有符合条件的元素则返回空数组。

语法：array.filter(function(,index,arr))

filter() 不会对空数组进行检测。

filter() 不会改变原始数组。

let newArr = arr.filter((, index) => arr.indexOf() === index);

4. Array.filter + Object.hasOwnPropertyhasOwnProperty() 方法：返回一个布尔值，表示对象自身属性中是否具有指定的属性

原理：利用对象的键名不可重复的特点

let obj = {}

5. Array.reduce + Array.includesreduce() 方法：接收一个函数作为累加器，数组中的每个值从左到右开始计算，最终计算为一个值。

total：必需。初始值, 或者计算结束后的返回值

currValue：必需。当前元素

currIndex：可选。reduce() 对于空数组是不会执行回调函数的。当前元素的索引

arr ：可选。当前数组对象。

let newArr = arr.reduce((accu, cur) => {

return accu.includes(cur) ? accu : accu.concat(cur); // 1. 拼接方法

// return accu.includes(cur) ? accu : […accu, cur]; // 2. 扩展运算

}, []);

6. Array.indexOfindexOf() 方法：返回数组中某个指定的元素位置。该方法遍历数组，查找有无对应元素并返回元素次出现的索引，未找到指定元素则返回 -1。

for (var i = 0; i < arr.length; i++) {

if (newArr.indexOf(arr[i]) === -1) newArr.push(arr[i])

}//等同于 forEach 写法

arr.forEach( => newArr.indexOf() === -1 ? newArr.push() : ”)

console.log(newArr) // [1, 2, 4, null, “3”, “abc”, 3, 5]

7. Array.includesincludes() 方法：用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

for (var i = 0; i < arr.length; i++) {

if (!newArr.includes(arr[i])) newArr.push(arr[i])

}//等同于 forEach 写法

arr.forEach( => !newArr.includes() ? newArr.push() : ”)

console.log(newArr) // [1, 2, 4, null, “3”, “abc”, 3, 5]

8. new Set + 扩展运算符 || Array.fromES6 提供了新的数据结构 Set。类似于arr.filter( => obj.hasOwnProperty(typeof + ) ? false : (obj[typeof + ] = true))数组，但是成员的值都是的，没有重复的值。

Set本身是一个构造函数，可以接受一个具有 iterable 接口数据结构作为参数（如数组，字符串），用来初始化。

let newArr = […new Set(arr)]; // [1, 2, 4, null, “3”, “abc”, 3, 5]

let newArr = Array.from(new Set(arr)); // [1, 2, 4, null, “3”, “abc”, 3, 5]

let newStr = […new Set(‘ababbc’)].join(”) // ‘abc’

9. new MapES6 提供了新的数据结构 Map。类似于对象，也是键值对的，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。

set方法设置键名key对应的键值为value，然后返回整个 Map 结构。如果key已经有值，则键值会被更新，否则就新生成该键。

get方法读取key对应的键值，如果找不到key，返回undefined。

has方法返回一个布尔值，表示某个键是否在当前 Map 对象之中。

let map = new Map();

let newStr = [];

for (let i = 0; i < arr.length; i++) {

if (!map.has(arr[i])) {

newStr.push(arr[i]);

}}

console.log(newArr) // [1, 2, 4, null, “3”, “abc”, 3, 5]

关于JS截取字符串以及截取数组项的几种常见方法解析

var arr = [1,2,3,4,5];

：读取数组 for循环

let newArr = []

var ay=[1,"sdsd","sdsd"]for (var i=0;iif (obj[] !== undefined) {

console.log("index:"+i+" "+ay[i]) //index：0 1 index：1 sdsd index：2 sdsd

}第二：合并数组 concat

var arr1=['w','e','s'];

var arr2=['e','y','u'];var arr3=arr1.concat(arr2);console.log(arr3) //['w','e','s''e','y','u'];第三：数组变为字符串格式 join

var arr1=['w','e','s'];

var arr4=arr1.join()console.log(arr4) //w,e,s

第四：删除一个元素,针对老数组是删除一个,针对新数组是返回一个 pop

var arr6=["d","s","t"];var arr7=arr6.pop();console.log(arr6) // ["d","s"];console.log(arr7);// t

第五：添加一个元素，针对老数组一个元素后面添加一个元素，新数组返回元素个数 push

var arr8=["i","u","t"];

var arr9=arr8.push("k");

console.log(arr8); //["i","u","t","k"];

console.log(arr9); // 4

第六：shift() 和pop()一样，不同的是作的是开头删除的元素shift（）；具体作不在展示第七：unshiift()和push一样，不同的是作的是开头添加的元素unshift（）；具体作不再展示

第八：反转数组 rrse

var arr1=['w','e','s'];

var arr10=arr1.rrse()

第九：数组排序 sort a-b正向 b-a 反向

正向

var arr11=[3,1,5,8,28]var arr12=arr11.sort(function (a,b) {return a-b;})console.log(arr12) //[1,3,5,8,28];

反向

var arr13=arr11.sort(function (a,b) {return b-a;})console.log(arr13) //[28,8,5,3,1]

第十：数组截取 数组截取的方法主要有sl 和spl，另外说到截取我这里随便也把字符串截取带上，字符串截取的方法主要有substr 和substring

示例如下：

①只有起起始值，并且为正，默认的从起始位置一直到整个数组结束，起始下标从0开始

var arr=[2,3,5,6,8,9]var arr1=arr.sl(1)console.log(arr) // [2,3,5,6,8,9] 老数组是没有变化的，下面不在列举，都是一样的console.log(arr1) //[3,5,6,8,9] 只有起始参数，并且为正值，返回新数组从下标1开始截取

②只有起始值，并且为负，默认的是从起始位置一直到整个数组结束，此处没有起始值，数组的一个下标是-1，比如此例，如果从-6开始取，必定是整个数组

var arr=[2,3,5,6,8,9]var arr1=arr.sl(-1)console.log(arr1) //[9] 只有起始参数，并且为负值，从数组尾部截取元素

③有起始值和结束值，并且为正，此处需注意下标是从小到大，比如你（3，1）肯定是取不到值的，另外截取的下标个数并不包含一个下标

var arr=[2,3,5,6,8,9]var arr1=arr.sl(1,4)console.log(arr1) //[3,5,6] 此时是从下标1开始到下标4，但是需要注意的是并不包含下标4，准确的说是1-3的下标

④有起始值和结束值，并且为负，此处需注意下秒也是从小到大，同理，比如（-1，-6）也是肯定取不到值的，另外截取的下标个数也并不包含一个下标

var arr=[2,3,5,6,8,9]var arr1=arr.sl(-6,-1)console.log(arr1) //[2,3,5,6,8]

负值到0

var arr=[2,3,5,6,8,9]var arr1=arr.sl(-1,0)

//刚刚都看到了，数组下标都是从小到大的，所以说如果正负都有的情况下，理论上应该可以取值的，比如这个例子，-1为9的小标，0为2的下标，所以取值应该为 [9]，但是结果并不是这样的console.log(arr1) //[ ] 从这里可以看出他的结果是为空的，所以从负值到0结果是取不到的

负值到正直

var arr=[2,3,5,6,8,9]

var arr1=arr.sl(-1,2)

//那从负值到正值呢，同样也是取不到值的

正直到负值

var arr=[2,3,5,6,8,9]

var arr1=arr.sl(2,-1)

//那从正直到负值，这个理论上是取不到的，但是看下结果

console.log(arr1) //[ 5，6，8] 从结果可以看出是可以取的 原理是2的下标为5，-1的下标为9，不包含结束位置下标

总结：这个方法看着可能会麻烦些（也可能被我写的麻烦啦），比如正到负等，不知道大家都是怎么作，我一般用这个取值都是只截取正的，所以这个实际作还是非常简单的。

（2）spl 像数组中添加或者删除元素 arr.spl(m,n,index,index1,...,indexx) m是起始位置，n是删除元素的个数，index是要添加的元素，在不添加元素的前提下，只有个参数是必须的，后面两个都不是必须的，在需要添加元素的情况下，三个元素都是必须的，此方法和sl是不一样的，这个返回的是被删除的元素

示例如下：

只删除不添加

注意看此例，是（1，2）删除两个，如果是（1，0），则表示删除零个，也就是不删除的意思，如果只有一个参数则表示从这里开始删除，比如是（1）则为[2]，当然这个也是可以取负值，但是这个和sl是不一样的，只能起始位置取负值，因为删除的个数不可能为负值，sl可以取（2，-1），这个就截然不同啦，但是刚刚也说啦，sl是不可以起始位置取负值，结束位置取正的，但是这个是可以的，比如（-1，0）则表示从-1开始删除零个，结果为[2,3,5,6,8,9]，（-6，2),结果为[5,6,8,9]，另外这个删除的第二个值如果写的过大，也只是删除从本下标到一个，比如（2，78）为[2,3]

删除加添加 具体的和上面的不多，主要添加了添加元素的效果，这个也可以添加多个元素

var arr=[2,3,5,6,8,9]var arr1=arr.spl(1,2,"il")console.log(arr) //[2,"li",6,8,9] console.log(arr1) //[3,5]

总结：此方法用的时候，一般也都是只取正值

（3）substr 这个是字符串的用法 用法arr.substr(m,n) m必选也可以负值 n选填，注意看这个并不是结束为止而是截取的个数

示例如下：

只有一个参数 默认从此下标开始，取后面所有的

正值

var arr="sdhgfhf"var arr1=arr.substr(1)console.log(arr)// "sdhgfhf"这个是不变的，下面不再列举console.log(arr1)// "dhgfhf" 从下标1开始取后面所有的

负值

两个参数，从个下标开始，截取到下标2的长度

（4）substring 用法arr.substring(m,n) 两个参数，m必须，起始位置 ，n选填，截取下标的结束位置，此用法和上面sl有点类似，但是需要注意的是此方法是不支持负值的

示例如下：

只有一个参数

var arr="sdhgfhf"var arr1=arr.substring(1)console.log(arr1)//"dhgfhf"从下标1开始取后面所有的

两个参数

var arr="sdhgfhf"var arr1=arr.substring(1,3)console.log(arr1)// "dh"从下标1开始截取到下标3，但是不包含3

总结：此方法不支持负值，只针对下标来截取的

怎么把js数组分割成多个数组

原理：返回 次出现的位置等于当前的index的元素

/

将一个数组分成几个同等长度的数组

array[分割的原数组]

size[每个子数组的长度]

/function slArray(array, size) {

var result = [];

for (var x = 0; x < Math.ceil(array.length / size); x++) {

var start = x size}// arr:基于以上考虑，交换元素的位置，效率会更高一点， 若当前元素重复，则与数组一位元素交换位置，i–再次进行判断即可，同时length–,作数组的长度实现删除数组的一个元素，这样便不会影响到数组中其他元素 [1, 2, 4, null, “3”, “abc”, 3, 5];

var end = start + size;

result.push(array.sl(start, end));

}return result;

}

js如何将数组按照每行切割分组?

// [1, 2, 4, null, “3”, “abc”, 3, 5]

var example =

strs=str.split(","); //字符分割

[[0,0,0,2,2,2,3,3,3],

alert(kk[0]);//a

[0,0,0,2,2,2,3,3,3],

[0,0,0,2,2,2,3,3,3],

[0,0,0,2,2,2,3,3,3],

];

var arr = [].concat.apply([],example).sort();

console.log(arr);

js如何把带有换行符的和逗号的字符串切割成每行一个数组的二维数组，如图，在线等

使用split()分割

语法：arr.reduce(function(total, currValue, currIndex, arr), initValue)str="2,2,3,5,6,6"; //这是一字符串

var strs= new Array(); //定义一数组

for (i=0;i

{document.write(strs[i]+""); //分割后的字符输出

}输出结果就是 2 2 3 5 6 6 js split就是将一字符串以特定的字符分割成多个inivar arr=[2,3,5,6,8,9]var arr1=arr.spl(1,2)console.log(arr) // [2,6,8,9] 注意看此处才是我们要的数组，从下标1开始删除删除两个console.log(arr1) //[3,5] 此处是我们删除掉的数组tValue：可选。累加器初始值字符串

定义和用法 split() 方法用于把一个字符串分割成字符串数组。 语法 stringObject.split(separator,howmany) 参数 描述 separator 必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。 howmany 可选。该参数可指定返回的数组的长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。 返回值 一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 separator 自身。 但是，如果 separator 是包含子表达式的正则表达式，那么返回的数组中包括与这些子表达式匹配的字串（但不包括与整个正则表达式匹配的文本）

js将一个数组根据某值拆分成多个数组

⑤有起始值和结束值，并且正负都有

用js的reduce方法，reduce 为数组中的每一个元素依次执行回调函数，不包括数组中被删除或从未被赋值的元素，接受四个参数：初始值（或者上一次回调函数的返回值），当前元素值，当前索引，调用 reduce 的数组。

语法:方法如下：

previousValue （上一次调用回调返回的值，或者是提供的初始值（initialValue））

currentValue （数组中当前被处理的元素）

index initialValue （作为次调用 callback 的个参数。）（当前元素在数组中的索引）

array （调用 reduce 的数组）

使用方法

js的split怎么用。

（1）sl 使用方法arr.sl(m,n);其中arr为数组，m，n为两个参数，意思是从已有数组中返回选定的元素，截取位置均为下标，其中m必须，为起始位置，可以为负值，n为结束位置（截取位置并不包含）。

spmap.set(arr[i], true);lit函数是根据某个字符串进行拆分成数组

总结：此方法需注意不要和数组的混淆，这个是截取长度的

举例

var str = "a,b,c";

var kk = str.split(",");//以逗号作为分隔字符串

alert(kk[1]);//b

alert(kk[2]);//c

var arr="1|2|2|3|6|9".split("|");

搞定。

js截取数组的一部分

js获取数组中的一部分元素，有2种方法：sl和filter函数，下面分别介绍。

sl1. 利用对象的 key 众所周知，对象的key不可重复，否则后者将覆盖前者。利用该特console.log(arr10) //['s','e','w'];性，实现数组去重，遍历数组，将数组的每一项做为对象的key值sl的定义和用法如下，用于截取数组的一段

执行

ar Array = [1,2,3,4,5,6,7,8,9,10,11,12];;rr.sl(1,4);

这2行代码，可以看到截取了1到4下标的代码

filterfilter则用于过滤数组中的一部分元素，剩下的元素就是需要的那部分元素。

现在尝试下面代码，可以将一个数字数组中的偶数过滤掉，只留下奇数。

arr.filter(e=>e%2==0)

js将一个数组分成多个数组

关于js数组的用法有很多，下面主要针对一些简单的作，比如合并，反转，添加删除等简单的作总结一下。

1,将数组array分成长度为subGroupLength的小数组并返回新数组

var arr="sdhgfhf"var arr1=arr.substr(-2)console.log(arr1)// "hf" 从下标-2开始取后面所有的

function group(array, subGroupLength) {

let index = 0;

let newArray = [];

while(indconsole.log(arr1) //[ ]ex < array.length) {

newArray.push(array.sl(index, index += subGroupLength));

}return newArray;

}2,例如：

var groupedArray = group(Array, 6);

得到的groupedArray 数组为：

groupedArray[[1,2,3,4,5,6],[7,8,9,10,11,12]]