首页 / JAVASCRIPT / JS中集合对象(Array、Map、Set)及类数组对象的使用与对比

JS中集合对象(Array、Map、Set)及类数组对象的使用与对比

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JS中集合对象(Array、Map、Set)及类数组对象的使用与对比，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10224字，纯文字阅读大概需要15分钟。

内容图文

原文地址

在使用js编程的时候，常常会用到集合对象，集合对象其实是一种泛型，在js中没有明确的规定其内元素的类型，但在强类型语言譬如Java中泛型强制要求指定类型。

ES6引入了iterable类型，Array，Map，Set都属于iterable类型，它们可以使用for...of循环来遍历，都内置forEach方法。

数组

遍历

普通遍历

最简单的一种，也是使用频率最高的一种。

                
                    let arr = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
for (let i =0; i <arr.length; i++) {console.log(i,‘ => ‘, arr[i])
}

优化: 缓存数组长度:

                
                    let arr = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
for (let i =0, len =arr.length; i < len; i++) {console.log(i,‘ => ‘, arr[i])
}

使用临时变量，将长度缓存起来，避免重复获取数组长度，当数组较大时优化效果才会比较明显。

for-in

这个循环很多人爱用，但实际上，经分析测试，在众多的循环遍历方式中它的效率是最低的。

                
                    let arr = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
for (let i in arr) {console.log(i,‘ => ‘, arr[i])
}

for-of

这种方式是es6里面用到的，性能要好于forin，但仍然比不上普通for循环。

                
                    let arr = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
let index =0for (let item of arr) {console.log(index++,‘ => ‘, item)
}

forEach

数组自带的foreach循环，使用频率较高，实际上性能比普通for循环弱。

                
                    let arr = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
arr.forEach((v, k) =>{console.log(k,‘ => ‘, v)
})

forEach接受第三个参数，指向原数组，没有返回值，对其进行操作会改变原数组对象

                
                    let ary = [12,23,24,42,1]
let res =ary.forEach((item, index, input) =>{
   input[index] = item *10})
console.log(res) //-->undefinedconsole.log(ary) //-->会对原来的数组产生改变

如果版本低的浏览器不兼容(IE8-)，可以自定义方法实现:

                
                    /**
                    * forEach遍历数组
                    * 
                    @param
                    
                    callback
                     [function] 回调函数；
                    * 
                    @param
                    
                    context
                     [object] 上下文；
                    */
                    Array.prototype.myForEach=function (callback,context) {
  context = context || window;
  if(‘forEach‘inArray.prototype) {
    this.forEach(callback,context)
    return
  }
  // IE6-8下自己编写回调函数执行的逻辑
  for(let i =0,len =this.length; i < len; i++) {
    callback &&callback.call(context,this[i], i,this)
  }}let arr = [12,23,24,42,1]
arr.myForEach((v, k) =>{console.log(k,‘ => ‘, v)
})

map

map会返回一个全新的数组，同样接受第三个参数，如果对其进行操作会改变原数组。

                
                    let ary = [12,23,24,42,1]
let res =ary.map((item, index, input) =>{return item *10})
console.log(res) //-->[120,230,240,420,10]console.log(ary) //-->[12,23,24,42,1]

如果版本低的浏览器不兼容(IE8-)，可以自定义方法实现:

                
                    /**
                    * map遍历数组
                    * 
                    @param
                    
                    callback
                     [function] 回调函数；
                    * 
                    @param
                    
                    context
                     [object] 上下文；
                    */
                    Array.prototype.myMap=functionmyMap(callback,context){
  context = context || window
  if(‘map‘inArray.prototype) {
    return this.map(callback, context)
  }
  //IE6-8下自己编写回调函数执行的逻辑let newAry = []
  for(var i =0,len =this.length; i < len; i++) {
    if(typeof callback ===‘function‘) {
      var val =callback.call(context,this[i], i,this)
      newAry[newAry.length] = val
    }
  }
  return newAry
}arr.myMap((v, k) =>{console.log(k,‘ => ‘, v)
})

过滤

filter

对数组中的每个元素都执行一次指定的函数（callback），并且创建一个新的数组，该数组元素是所有回调函数执行时返回值为 true 的原数组元素。它只对数组中的非空元素执行指定的函数，没有赋值或者已经删除的元素将被忽略，同时，新创建的数组也不会包含这些元素。

                
                    let arr = [12,5,8,130,44]
let ret =arr.filter((el, index, array) =>{return el >10})
console.log(ret) // [12, 130, 44]

map

map也可以作为过滤器使用，不过返回的是对原数组每项元素进行操作变换后的数组，而不是每项元素返回为true的元素集合。

                
                    let strings = ["hello","Array","WORLD"]
functionmakeUpperCase(v) {returnv.toUpperCase()
}let uppers =strings.map(makeUpperCase)
console.log(uppers) // ["HELLO", "ARRAY", "WORLD"]

some

对数组中的每个元素都执行一次指定的函数（callback），直到此函数返回 true，如果发现这个元素，some 将返回 true，如果回调函数对每个元素执行后都返回 false ，some 将返回 false。它只对数组中的非空元素执行指定的函数，没有赋值或者已经删除的元素将被忽略。

                
                    // 检查是否有数组元素大于等于10：
                    function
                    isBigEnough(element, index, array) {return (element >=10)
}let passed1 = [2,5,8,1,4].some(isBigEnough) // passed1 is falselet passed2 = [12,5,8,1,4].some(isBigEnough) // passed2 is true

every

对数组中的每个元素都执行一次指定的函数（callback），直到此函数返回 false，如果发现这个元素，every 将返回 false，如果回调函数对每个元素执行后都返回 true ，every 将返回 true。它只对数组中的非空元素执行指定的函数，没有赋值或者已经删除的元素将被忽略。

                
                    // 测试是否所有数组元素都大于等于10：
                    function
                    isBigEnough(element, index, array) {return (element >=10)
}let passed1 = [12,5,8,1,4].every(isBigEnough) // passed1 is falselet passed2 = [12,15,18,11,14].every(isBigEnough) // passed2 is true

排序

                
                    let arr = [‘a‘,1,‘b‘,3,‘c‘,2,‘d‘,‘e‘]
console.log(arr) // ["a", 1, "b", 3, "c", 2, "d", "e"]console.log(arr.reverse()) // 反转元素(改变原数组) // ["e", "d", 2, "c", 3, "b", 1, "a"]console.log(arr.sort()) // 对数组元素排序(改变原数组) // [1, 2, 3, "a", "b", "c", "d", "e"]console.log(arr) // [1, 2, 3, "a", "b", "c", "d", "e"]

sort自定义排序

                
                    let arr = [1,100,52,6,88,99]
let arr1 =arr.sort((a, b) => a-b) // 从小到大排序console.log(arr1) // [1, 6, 52, 88, 99, 100]let arr2 =arr.sort((a, b) => b-a) // 从大到小排序console.log(arr2) // [100, 99, 88, 52, 6, 1]console.log(arr) // 原数组也发生改变

搜索

                
                    let arr = [12,5,4,8,1,4]
arr.indexOf(4) // 2，从前往后搜索，返回第一次搜索到的数组下标，搜索不到返回-1arr.lastIndexOf(4) // 5，从后往前搜索，返回第一次搜索到的数组下标，搜索不到返回-1arr.indexOf(0) // -1

增删、清空操作

添加元素

                
                    let arr = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
arr.push(10,11) // 模仿栈进行操作，往数组末尾添加一个或多个元素(改变原数组)arr.unshift(0,1) // 模仿队列进行操作，往数组前端添加一个或多个元素(改变原数组)console.log(arr) // [0, 1, "a", "b", ‘c‘, "d", "e", 10, 11]

删除元素

                
                    arr.pop() // 移除最后一个元素并返回该元素值(改变原数组)arr.shift() // 移除最前一个元素并返回该元素值，数组中元素自动前移(改变原数组)console.log(arr) // ["b", "c", "d"]

清空数组

将数组的length设置为0即可

                
                    let arr = [‘a‘,1,‘b‘,3,‘c‘,2,‘d‘,‘e‘]
arr.length=0

length详解:

因为数组的索引总是由0开始，所以一个数组的上下限分别是：0和length-1；

当length属性被设置得更大时，整个数组的状态事实上不会发生变化，仅仅是length属性变大；

当length属性被设置得比原来小时，则原先数组中索引大于或等于length的元素的值全部被丢失。

splice

既可以删除也可以添加元素

                
                    let arr = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
arr.splice(2,1,1,2,3)
console.log(arr) // ["a", "b", 1, 2, 3, "d", "e"]

splice(start, len, elems) : 删除并添加元素(改变原数组)

start: 起始位置

len: 删除元素的长度

elems: 添加的元素队列

几种形式:

splice(start, 0, elems) : 从start位置添加元素

splice(start, len) : 从start位置删除len个元素

截取、合并与拷贝

                
                    let arr = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
let arr1 =arr.slice(1,2) // 以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素(返回新数组)let arr2 =arr.concat([1,2,3]);// 将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组(返回新数组)console.log(arr) // ["a", "b", "c", "d", "e"]console.log(arr1) // ["b"]console.log(arr2) // ["a", "b", "c", "d", "e", 1, 2, 3]

其实slice和concat也可以作为数组的拷贝方法:

                
                    arr.slice(0) // 返回数组的拷贝数组，注意是一个新的数组，不是指向arr.concat() // 返回数组的拷贝数组，注意是一个新的数组，不是指向

Map

Map是一组键值对的结构，具有极快的查找速度。

创建

方法一: 创建的时候初始化

                
                    let mapObj =newMap([
  [‘a‘,1],
  [‘b‘,2],
  [‘c‘,3]
])
console.log(mapObj.size) // 3

方法二: 创建空Map，之后添加元素

                
                    let mapObj =newMap()
mapObj.set(‘a‘,1)
mapObj.set(‘b‘,2)
mapObj.set(‘c‘,3)
console.log(mapObj.size) // 3

注意: Map对象的长度不是length，而是size

基础操作

Map对象的创建、添加元素、删除元素...

                
                    mapObj.set(‘a‘,1) // 添加元素mapObj.delete(‘d‘) // 删除指定元素mapObj.has(‘a‘) // truemapObj.get(‘a‘) // 1

遍历

使用上面创建的Map进行操作

forEach

同数组的forEach遍历，三个参数分别代表: value、key、map本身

                
                    mapObj.forEach((e, index, self) =>{console.log(index,‘ => ‘, e)
})

打印出:

                a  =>1
b  =>2
c  =>3

for-of

                
                    for (const e of mapObj) {console.log(e)
}

打印出:

                ["a",1]
["b",2]
["c",3]

注意: for-of遍历出来的是一个数组，其中e[0]为key，e[1]为value

Set

Set和Map类似，但set只存储key，且key不重复。

创建

方法一: 创建的时候初始化

                
                    let setObj =newSet([1,2,3])
console.log(setObj.size)

方法二: 创建空Map，之后添加元素

                
                    let setObj =newSet()
setObj.add(1)
setObj.add(2)
setObj.add(3)
console.log(setObj.size)

注意: Map对象的长度不是length，而是size

基础操作

                
                    let s =newSet([1,2,3])
s.add(3) // 由于key重复，添加不进s.delete(3) // 删除指定keyconsole.log(s) // 1 2

遍历

使用上面创建的Set进行操作

forEach

Set与Array类似，但Set没有索引，因此回调函数的前两个参数都是元素本身

                
                    s1.forEach(function (element, sameElement, set) {console.log(element) // element === sameElement})
// 打印 1 2 3

for-of

                
                    for (const item of s1) {console.log(item)
}// 打印 1 2 3

类数组对象

JavaScript中，数组是一个特殊的对象，其property名为正整数，且其length属性会随着数组成员的增减而发生变化，同时又从Array构造函数中继承了一些用于进行数组操作的方法。而对于一个普通的对象来说:

如果它的所有property名均为正整数，同时也有相应的length属性，那么虽然该对象并不是由Array构造函数所创建的，它依然呈现出数组的行为，在这种情况下，这些对象被称为“类数组对象”。

形如:

                
                    let obj ={0:‘qzy‘,1:22,2:false,length:3}

类数组对象可以使用Array对象原生方法进行操作。

遍历

沿用上述对象进行操作

forEach

                
                    Array.prototype.forEach.call(obj,function(el, index){console.log(index,‘ => ‘, el)
})

map

                
                    Array.prototype.map.call(obj,function(el, index){console.log(index,‘ => ‘, el)
})

注意: 类数组对象不支持使用for-of进行遍历，否则会报错: [Symbol.iterator] is not a function

增删截取操作

沿用上述对象进行操作

                
                    Array.prototype.join.call(obj,‘-‘) // qzy-22-falseArray.prototype.slice.call(obj,1,2) // [22]Array.prototype.push.call(obj,5) // Object {0: "qzy", 1: 22, 2: false, 3: 5, length: 4}

String也是一个类数组对象

由于字符串对象也存在length，且序号从0开始增加，因此字符串也可以看做一个只读的类数组对象，这意味着String对象可以使用Array的所有原型方法。

                
                    let str =‘hello world‘console.log(Array.prototype.slice.call(str,0,5)) // ["h", "e", "l", "l", "o"]

String也可以使用for-of进行遍历

                
                    let str =‘hello world‘for (const s of str) {console.log(s)
}

String独有方法

除了使用Array原型对象的方法，String还包含其他一些自己独有的方法:

与Array使用方法相同的方法

搜索: indexOf()、lastIndexOf()、concat()

转换

toLowerCase()、toUpperCase()

截取

substr(start, len)

substring(start, end)

slice(start, end)

                
                    let str =‘hello world‘let ret1 =str.substr(6,5) // "world"let ret2 =str.substring(6,11) // "world"let ret3 =str.slice(3,8) // "lo wo"

substring 是以两个参数中较小一个作为起始位置，较大的参数作为结束位置。

slice 是第一参数为起始位置，第二参数为结束位置，如果结束位置小于起始位置返回空字符串

                
                    console.log(str.substring(11,6) ===str.substring(6,11)) // true

接收负数为参数时:

slice会将它字符串的长度与对应的负数相加，结果作为参数；

substr则仅仅是将第一个参数与字符串长度相加后的结果作为第一个参数；

substring则干脆将负参数都直接转换为0。

                
                    let str =‘hello world‘let ret1 =str.substr(-5) // "world"let ret2 =str.substr(-5,3) // "wor"let ret3 =str.substring(6,-1) // "hello"let ret4 =str.slice(6,-1) // "worl"console.log(ret1 ===str.substr(str.length-5)) // trueconsole.log(ret2 ===str.substr(str.length-5,3)) // trueconsole.log(ret3 ===str.substring(6,0)) // trueconsole.log(ret4 ===str.slice(6,str.length-1)) // true

正则

match()
replace()
search()

                
                    let str =‘hello world‘let ret0 =str.match(/r/) // 非全局搜索，返回匹配的第一个字符串数组(length为1)，包括index和inputlet ret1 =str.match(/o/g) // 全局搜索，返回匹配的字符串数组，length为搜索到的匹配正则表达式的长度let ret2 =str.replace(/o/g,‘e‘) // 全局替换let ret3 =str.replace(/O/i,‘e‘) // 不区分大小写，只替换搜索到的第一个字串let ret4 =str.search(/l/) // 返回搜索到的第一个匹配字串的索引let ret5 =str.search(/l/g) // 全局无效，同上console.log(ret0) // ["r", index: 8, input: "hello world"]console.log(ret1) // ["o", "o"]console.log(ret2) // "helle werld"console.log(ret3) // "helle world"console.log(ret4) // 2console.log(ret5) // 2console.log(str) // 不改变源字符串 ‘hello world‘

转化

Map => Object

                
                    let mapObj =newMap([ [‘a‘,1], [‘b‘,2], [‘c‘,3] ])

let obj ={}for (const item of mapObj) {
  obj[item[0]] = item[1]
}console.log(obj)

Set => Array

                
                    let setObj =newSet([1,2,3])

let arr = []
for (const item of setObj) {arr.push(item)
}console.log(arr)

Array => String

arr.join(separator)

                [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘].join(‘‘)
// toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用

String => Array

str.split(separator)

                
                    ‘hello world‘.split(‘ ‘) // ["hello", "world"]

参考资料

JavaScript中的数组遍历forEach()与map()方法以及兼容写法介绍

详谈js遍历集合(Array,Map,Set)

JavaScript中的Map、Set及其遍历

JavaScript创建Map对象

slice,substr和substring的区别

原文：http://www.cnblogs.com/xiaoyulive/p/7906548.html

内容总结

以上是互联网集市为您收集整理的JS中集合对象(Array、Map、Set)及类数组对象的使用与对比全部内容，希望文章能够帮你解决JS中集合对象(Array、Map、Set)及类数组对象的使用与对比所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1088474.html

来源：【匿名】

【上一篇】js 去掉前后空格【下一篇】javascript 怎么调用php方法

更多 ►

【JS中集合对象(Array、Map、Set)及类数组对象的使用与对比】教程文章相关的互联网学习教程文章

JavaScript之Array常用函数汇总【代码】

[20141121]JavaScript之Array常用功能汇总*:first-child {margin-top: 0 !important; }body>*:last-child {margin-bottom: 0 !important; }/* BLOCKS =============================================================================*/p, blockquote, ul, ol, dl, table, pre {margin: 15px 0; }/* HEADERS =============================================================================*/h1, h2, h3, h4, h5, h6 {margin: 20p...

怎么去掉javascript 的Array的重复项【代码】

//完美去除法：var arr=[1,3,2,2,11,4]; var arr1=[]; var arr2=arr.sort(function(a,b){return a-b; }); //把数组进行排序var num=1; for (var i=0;i<arr2.length;i++){if(arr2[i]!==arr2[(num++)]){arr1.push(arr[i]);} } console.log(arr1); 原文：http://www.cnblogs.com/weven/p/7183191.html

JavaScript的进阶之路（三）引用类型之Object类型和Array类型【代码】

引用类型Object类型function a(num){if(num>3){a(--num); }console.log(num); }a(5);//如何创建对象的实例var obj1= new Object();console.log(obj1);obj1.name="吴琼";obj1.age=28;console.log(obj1.name+" "+obj1.age);//对象字面量语法，有点封装的感觉var obj2 = {name:"吴琼",age:28};var obj3 = {age:28,age_wo:30};console.log(obj3["age_wo"]);console.log(obj2.name+" "+obj2.age);function show(arg){var s="";if(ar...

Javascript TypedArray 解惑：Uint8Array 与 Uint8ClampedArray 的区别

JS的类型数组大体可分为3类：无符号整数、有符号整数、浮点数。Int8Array; Uint8Array; Uint8ClampedArray; Int16Array; Uint16Array; Int32Array; Uint32Array; Float32Array; Float64Array;基本上都可以望文生义，看名字就知道怎么回事。但是有一个例外 Uint8ClampedArray ，它与 Uint8Array 颇为相似，但又有所区别。因为颜色数据刚好都是符合8位二进制的无符号整数，所以这两个类型在处理Canvas绘图数据时常常用到。Uint8Clamp...

JavaScript------去掉Array中重复值【代码】

转载：http://blog.csdn.net/teresa502/article/details/7926796代码：// 删除数组中重复数据function removeDuplElem(array){ for(var i=0; i<array.length; i++){for(var j=i+1; j<array.length;j++){if(array[i]==array[j]){array = removeElement(j,array);//删除指定下标的元素i=-1;break;}}　　}return array; } //删除数组用到的函数function removeElement(index,array){if(index>=0 && index<array.length){for(var i...

[LeetCode][JavaScript]Patching Array【代码】

Patching ArrayGiven a sorted positive integer array nums and an integer n, add/patch elements to the array such that any number in range [1, n] inclusive can be formed by the sum of some elements in the array. Return the minimum number of patches required.Example 1:nums = [1, 3], n = 6Return 1.Combinations of nums are [1], [3], [1,3], which form possible sums of: 1, 3, 4.Now if we add/patch 2 to n...

JavaScript Array 对象参考手册

JavaScript Array 对象Array 对象Array 对象用于在变量中存储多个值:var cars = ["Saab", "Volvo", "BMW"];第一个数组元素的索引值为 0，第二个索引值为 1，以此类推。更多有关JavaScript Array参考手册请参考 JavaScript Array 对象手册。Array 对象属性方法描述concat()连接两个或更多的数组，并返回结果。every()检测数值元素的每个元素是否都符合条件。filter()检测数值元素，并返回符合条件所有元素的数组。indexOf()搜索数组...

JS中集合对象(Array、Map、Set)及类数组对象的使用与对比【代码】

原文地址在使用js编程的时候，常常会用到集合对象，集合对象其实是一种泛型，在js中没有明确的规定其内元素的类型，但在强类型语言譬如Java中泛型强制要求指定类型。ES6引入了iterable类型，Array，Map，Set都属于iterable类型，它们可以使用for...of循环来遍历，都内置forEach方法。数组遍历普通遍历最简单的一种，也是使用频率最高的一种。let arr = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘] for (let i =0; i <arr.length; i++) {conso...

JavaScript Array -->map()、filter()、reduce()、forEach()函数的使用【代码】

题目：　　1、得到 3000 到 3500 之内工资的人。　　2、增加一个年龄的字段，并且计算其年龄。　　3、打印出每个人的所在城市　　4、计算所有人的工资的总和。测试数据： function getData() {var arr = [{id: 1,name: ‘ohzri‘,birth: ‘1999.09.09‘,city: ‘湖北‘,salary: 9379},{id: 2,name: ‘rqgfd‘,birth: ‘1999.10.28‘,city: ‘湖北‘,salary: 1060},{id: 3,name: ‘fwfsh‘,birth: ‘1999.09.17‘,city: ‘广西‘...

JavaScript手册 | JS Array 对象中的fill()方法

[ JavaScript中文参考手册 | JS 中的数组 Array 对象JS Array 对象中的fill()方法的定义和用法Array.fill()?函数用于使用给定的静态值填充数组。该值可用于填充整个数组，也可用于填充数组的一部分。JS Array 对象中的fill()方法浏览器的兼容性ChromeInter ExplorerFirefoxSafariOpera4512317.132JS Array 对象中的fill()方法的语法和例子Array fill()方法的语法：arr.fill(value, start, end)这里arr是要用静态值填充的数组。参数...

JS中数组Array的用法{转载}

JS中数组Array的用法{转载}js数组元素的添加和删除一直比较迷惑，今天终于找到详细说明的资料了，先给个我测试的代码^-^var arr = new Array();arr[0] = "aaa";arr[1] = "bbb";arr[2] = "ccc";//alert(arr.length);//3arr.pop();//alert(arr.length);//2//alert(arr[arr.length-1]);//bbbarr.pop();//alert(arr[arr.length-1]);//aaa//alert(arr.length);//1var arr2 = new Array();//alert(arr2.length);//0arr2[0] = "aaa";...

[Javascript] Array - join()【代码】

The join() method joins all elements of an array into a string. var name = ‘shane osbourne‘;var upper = name.split(‘ ‘) // [shane, osbourne] .map(x => x.charAt(0).toUpperCase() + x.slice(1)) // [Shane, Osbourne] .join(‘ ‘);console.log(upper); 原文：http://www.cnblogs.com/Answer1215/p/4862771.html

Javascript Array

ArraysArrays are zero-indexed, ordered lists of values. They are a handy way to store a set of related items of the same type (such as strings), though in reality, an array can include multiple types of items, including other arrays.To create an array, either use the object constructor or the literal declaration, by assigning the variable a list of values after the declaration.12345// A simpl...

javascript中 Array.prototype.slice的用法.【代码】

首先看到 www.w3school.cn上的解释:http://www.w3school.com.cn/jsref/jsref_slice_array.asp定义和用法slice() 方法可从已有的数组中返回选定的元素。语法arrayObject.slice(start,end)参数描述start必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。end可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数...

[Javascript] Yield an Array, String, or Any Iterable from a Generator (yield*)【代码】

Generators allow you to use the yield * syntax to yield each iteration of nested iterable as part of the main iterations. This enables you to combine multiple arrays, strings, or any iterable with anything you want to yield from your main generator. const abcs = ["A", "B", "C"]const reverseIterator = function* (array) {yield* arrayyield* array.map(letter => letter.toLowerCase())yield Math.random(...

首页 / JAVASCRIPT / JS中集合对象(Array、Map、Set)及类数组对象的使用与对比

JS中集合对象(Array、Map、Set)及类数组对象的使用与对比

内容导读

内容图文

数组

遍历

普通遍历

for-in

for-of

forEach

map

过滤

filter

map

some

every

排序

sort自定义排序

搜索

增删、清空操作

添加元素

删除元素

清空数组

splice

截取、合并与拷贝

Map

创建

基础操作

遍历

forEach

for-of

Set

创建

基础操作

遍历

forEach

for-of

类数组对象

遍历

forEach

map

增删截取操作

String也是一个类数组对象

String也可以使用for-of进行遍历

String独有方法

转换

截取

正则

转化

Map => Object

Set => Array

Array => String

String => Array

参考资料

内容总结

内容备注

内容手机端

【JS中集合对象(Array、Map、Set)及类数组对象的使用与对比】教程文章相关的互联网学习教程文章

ARRAY - 相关标签

MAP - 相关标签

数组 - 相关标签

JAVASCRIPT - 技术教程分类

JAVASCRIPT - 最新教程

JAVASCRIPT - 最热教程