摘要:对象构造函数是的原生对象,同时也是一个构造函数,可以用它生成新的数组。典型的伪数组有函数的对象,以及大多数元素集,还有字符串。,返回一个布尔值,表示判断数组成员是否符合某种条件。二是,它内部使用严格相等运算符进行判断,这会导致对的误判。
Array对象 构造函数
Array是 JavaScript 的原生对象,同时也是一个构造函数,可以用它生成新的数组。
如果没有使用new,运行结果也是一样的。
var arr = new Array(2); // 等同于var arr = Array(2);
Array构造函数有一个很大的缺陷,就是不同的参数,会导致它的行为不一致。
// 无参数时,返回一个空数组 new Array() // [] // 单个正整数参数,表示返回的新数组的长度 new Array(1) // [ empty ] new Array(2) // [ empty x 2 ] // 非正整数的数值作为参数,会报错 new Array(3.2) // RangeError: Invalid array length new Array(-3) // RangeError: Invalid array length // 单个非数值(比如字符串、布尔值、对象等)作为参数, // 则该参数是返回的新数组的成员 new Array("abc") // ["abc"] new Array([1]) // [Array[1]] // 多参数时,所有参数都是返回的新数组的成员 new Array(1, 2) // [1, 2] new Array("a", "b", "c") // ["a", "b", "c"]
可以看到,Array作为构造函数,行为很不一致。因此,不建议使用它生成新数组,直接使用数组字面量是更好的做法。
// bad var arr = new Array(1, 2); // good var arr = [1, 2];
注:ES6 引入了Array.of( )方法来解决这个问题。该方法的作用非常类似Array构造器,但在使用单个数值参数的时候并不会导致特殊结果。Array.of( )方法总会创建一个包含所有传入参数的数组,而不管参数的数量与类型:
let items = Array.of(1, 2); console.log(items.length); // 2 console.log(items[0]); // 1 console.log(items[1]); // 2 items = Array.of(2); console.log(items.length); // 1 console.log(items[0]); // 2
Array.of基本上可以用来替代Array()或newArray(),并且不存在由于参数不同而导致的重载,而且他们的行为非常统一。
静态方法 Array.isArray()Array.isArray方法返回一个布尔值,表示参数是否为数组。它可以弥补typeof运算符的不足。
var arr = [1, 2, 3]; typeof arr // "object" Array.isArray(arr) // true`Array.from()
ES6特性,将伪数组对象或可遍历对象转换为真数组。如果一个对象的所有键名都是正整数或零,并且有length属性,那么这个对象就很像数组,称为伪数组。典型的伪数组有函数的arguments对象,以及大多数 DOM 元素集,还有字符串。
ES6特性,
valueOf方法是一个所有对象都拥有的方法,表示对该对象求值。不同对象的valueOf方法不尽一致,数组的valueOf方法返回数组本身。
var arr = [1, 2, 3]; arr.valueOf() // [1, 2, 3]
toString方法也是对象的通用方法,数组的toString方法返回数组的字符串形式。
var arr = [1, 2, 3]; arr.toString() // "1,2,3" var arr = [1, 2, 3, [4, 5, 6]]; arr.toString() // "1,2,3,4,5,6"push()、pop()
push、pop均是在数组末尾进行增删元素,都会改变原数组。push方法用于在数组的末端添加一个或多个元素,并返回添加新元素后的数组长度。pop方法用于删除数组的最后一个元素,并返回该元素。
var arr = []; arr.push(1) // 1 arr.push("a") // 2 arr.push(true, {}) // 4 arr // [1, "a", true, {}] var arr = ["a", "b", "c"]; arr.pop() // "c" arr // ["a", "b"]
push和pop结合使用,就构成了“后进先出”的栈结构(stack)。
shift()、unshift()shift、unshift均是在数组头进行增删元素,都会改变原数组。shift()方法用于删除数组的第一个元素,并返回该元素。unshift()方法用于在数组的第一个位置添加元素,并返回添加新元素后的数组长度。
var a = ["a", "b", "c"]; a.shift() // "a" a // ["b", "c"] var a = ["a", "b", "c"]; a.unshift("x"); // 4 a // ["x", "a", "b", "c"]
push()和shift()结合使用,就构成了“先进先出”的队列结构(queue)。
join()join()方法以指定参数作为分隔符,将所有数组成员连接为一个字符串返回。如果不提供参数,默认用逗号分隔。
var a = [1, 2, 3, 4]; a.join(" ") // "1 2 3 4" a.join(" | ") // "1 | 2 | 3 | 4" a.join() // "1,2,3,4"concat()
concat方法用于多个数组的合并。它将新数组的成员,添加到原数组成员的后部,然后返回一个新数组,原数组不变。
["hello"].concat(["world"]) // ["hello", "world"] ["hello"].concat(["world"], ["!"]) // ["hello", "world", "!"] [].concat({a: 1}, {b: 2}) // [{ a: 1 }, { b: 2 }] [2].concat({a: 1}) // [2, {a: 1}] [1, 2, 3].concat(4, 5, 6) // [1, 2, 3, 4, 5, 6]reverse()
reverse方法用于颠倒排列数组元素,返回改变后的数组。注意,该方法将改变原数组。
var a = ["a", "b", "c"]; a.reverse() // ["c", "b", "a"] a // ["c", "b", "a"]slice()、splice()
slice方法用于提取目标数组的一部分,返回一个新数组,原数组不变。
arr.slice(start, end);
它的第一个参数为起始位置(从0开始),第二个参数为终止位置(但该位置的元素本身不包括在内)。如果省略第二个参数,则一直返回到原数组的最后一个成员。如果slice方法的参数是负数,则表示倒数计算的位置。
var a = ["a", "b", "c"]; a.slice(0) // ["a", "b", "c"] a.slice(1) // ["b", "c"] a.slice(1, 2) // ["b"] a.slice(2, 6) // ["c"] a.slice() // ["a", "b", "c"] var a = ["a", "b", "c"]; a.slice(-2) // ["b", "c"] a.slice(-2, -1) // ["b"]
splice方法用于删除原数组的一部分成员,并可以在删除的位置添加新的数组成员,返回值是被删除的元素。注意,该方法会改变原数组。
arr.splice(start, count, addElement1, addElement2, ...);
splice的第一个参数是删除的起始位置(从0开始),第二个参数是被删除的元素个数。如果后面还有更多的参数,则表示这些就是要被插入数组的新元素。起始位置如果是负数,就表示从倒数位置开始删除。如果只是单纯地插入元素,splice方法的第二个参数可以设为0。如果只提供第一个参数,等同于将原数组在指定位置拆分成两个数组。
var a = ["a", "b", "c", "d", "e", "f"]; a.splice(4, 2) // ["e", "f"] a // ["a", "b", "c", "d"] var a = ["a", "b", "c", "d", "e", "f"]; a.splice(4, 2, 1, 2) // ["e", "f"] a // ["a", "b", "c", "d", 1, 2] var a = ["a", "b", "c", "d", "e", "f"]; a.splice(-4, 2) // ["c", "d"] var a = [1, 1, 1]; a.splice(1, 0, 2) // [] a // [1, 2, 1, 1] var a = [1, 2, 3, 4]; a.splice(2) // [3, 4] a // [1, 2]sort()
sort方法对数组成员进行排序,默认是按照字典顺序排序。排序后,原数组将被改变。
["d", "c", "b", "a"].sort() // ["a", "b", "c", "d"] [4, 3, 2, 1].sort() // [1, 2, 3, 4] [11, 101].sort() // [101, 11] [10111, 1101, 111].sort()
数值会被先转成字符串,再按照字典顺序进行比较,所以101排在11的前面。
如果想让sort方法按照自定义方式排序,可以传入一个函数作为参数。
[10111, 1101, 111].sort(function (a, b) { return a - b; }) // [111, 1101, 10111] [ { name: "张三", age: 30 }, { name: "李四", age: 24 }, { name: "王五", age: 28 } ].sort(function (o1, o2) { return o1.age - o2.age; }) // [ // { name: "李四", age: 24 }, // { name: "王五", age: 28 }, // { name: "张三", age: 30 } // ]map()、forEach()
map方法和forEach方法很相似,也是对数组的所有成员依次执行参数函数。map方法将数组的所有成员依次传入参数函数,然后把每一次的执行结果组成一个新数组返回。forEach方法不返回值,只用来操作数据。这就是说,如果数组遍历的目的是为了得到返回值,那么使用map方法,否则使用forEach方法。
map、forEach方法接受一个函数作为参数。该函数调用时,map方法向它传入三个参数:当前成员、当前位置和数组本身。
[1, 2, 3].map(function(elem, index, arr) { return elem * index; }); // [0, 2, 6] function log(element, index, array) { console.log("[" + index + "] = " + element); } [2, 5, 9].forEach(log); // [0] = 2 // [1] = 5 // [2] = 9
上面代码中,map、forEach方法的回调函数有三个参数,elem为当前成员的值,index为当前成员的位置,arr为原数组([1, 2, 3])。map方法还可以接受第二个参数,用来绑定回调函数内部的this变量。
var arr = ["a", "b", "c"]; [1, 2].map(function (e) { return this[e]; }, arr) // ["b", "c"] var out = []; [1, 2, 3].forEach(function(elem) { this.push(elem * elem); }, out); out // [1, 4, 9]
map、forEach方法不会跳过undefined和null,但是会跳过空位。
注:forEach方法无法中断执行,总是会将所有成员遍历完。如果希望符合某种条件时,就中断遍历,要使用for循环。
var arr = [1, 2, 3]; for (var i = 0; i < arr.length; i++) { if (arr[i] === 2) break; console.log(arr[i]); } // 1fliter
filter方法用于过滤数组成员,满足条件的成员组成一个新数组返回。它的参数是一个函数,所有数组成员依次执行该函数,返回结果为true的成员组成一个新数组返回。该方法不会改变原数组。
[1, 2, 3, 4, 5].filter(function (elem, index, arr) { return index % 2 === 0; }); // [1, 3, 5]
filter方法还可以接受第二个参数,用来绑定参数函数内部的this变量。
some(),every()返回一个布尔值,表示判断数组成员是否符合某种条件。它们接受一个函数作为参数,所有数组成员依次执行该函数。该函数接受三个参数:当前成员、当前位置和整个数组,然后返回一个布尔值。some方法是只要一个成员的返回值是true,则整个some方法的返回值就是true,否则返回false。
every方法是所有成员的返回值都是true,整个every方法才返回true,否则返回false。
var arr = [1, 2, 3, 4, 5]; arr.every(function (elem, index, arr) { return elem >= 3; }); // false
some和every方法还可以接受第二个参数,用来绑定参数函数内部的this变量。
indexOf(),lastIndexOf()indexOf方法返回给定元素在数组中第一次出现的位置,如果没有出现则返回-1。indexOf方法还可以接受第二个参数,表示搜索的开始位置。
var a = ["a", "b", "c"]; a.indexOf("b") // 1 a.indexOf("y") // -1 ["a", "b", "c"].indexOf("a", 1) // -1
lastIndexOf方法返回给定元素在数组中最后一次出现的位置
var a = [2, 5, 9, 2]; a.lastIndexOf(2) // 3 a.lastIndexOf(7) // -1find() 和 findIndex()
二者皆是ES6新特性,数组实例的find方法,用于找出第一个符合条件的数组成员。它的参数是一个回调函数,所有数组成员依次执行该回调函数,直到找出第一个返回值为true的成员,然后返回该成员。如果没有符合条件的成员,则返回undefined。
数组实例的findIndex方法的用法与find方法非常类似,返回第一个符合条件的数组成员的位置,如果所有成员都不符合条件,则返回-1。
[1, 4, -5, 10].find((n) => n < 0) // -5 [1, 5, 10, 15].findIndex(function(value, index, arr) { return value > 9; }) // 2includes()
ES6新特性,Array.prototype.includes方法返回一个布尔值,表示某个数组是否包含给定的值。该方法的第二个参数表示搜索的起始位置,默认为0。如果第二个参数为负数,则表示倒数的位置,如果这时它大于数组长度(比如第二个参数为-4,但数组长度为3),则会重置为从0开始。
[1, 2, 3].includes(2) // true [1, 2, 3].includes(3, -1); // true [1, 2, 3, 5, 1].includes(1, 2); // true
没有该方法之前,我们通常使用数组的indexOf方法,检查是否包含某个值。indexOf方法有两个缺点,一是不够语义化,它的含义是找到参数值的第一个出现位置,所以要去比较是否不等于-1,表达起来不够直观。二是,它内部使用严格相等运算符(===)进行判断,这会导致对NaN的误判。
[NaN].indexOf(NaN) // -1 [NaN].includes(NaN) // truereduce(),reduceRight()
reduce方法和reduceRight方法依次处理数组的每个成员,最终累计为一个值。它们的差别是,reduce是从左到右处理(从第一个成员到最后一个成员),reduceRight则是从右到左(从最后一个成员到第一个成员),其他完全一样。
[1, 2, 3, 4, 5].reduce(function (a, b) { console.log(a, b); return a + b; }) // 1 2 // 3 3 // 6 4 // 10 5 //最后结果:15数组实例的 entries(),keys() 和 values()
ES6 提供entries(),keys()和values(),用于遍历数组。它们都返回一个遍历器对象,可以用for...of循环进行遍历,唯一的区别是keys()是对键名的遍历、values()是对键值的遍历,entries()是对键值对的遍历。
for (let index of ["a", "b"].keys()) { console.log(index); } // 0 // 1 for (let elem of ["a", "b"].values()) { console.log(elem); } // "a" // "b" for (let [index, elem] of ["a", "b"].entries()) { console.log(index, elem); } // 0 "a" // 1 "b"总结
push、pop、shift、unshift、reverse、splice、sort会改变原数据,其余不会;
常见工具方法 字符串、类数组对象拼接Array.prototype.join.call("hello", "-") // "h-e-l-l-o" var obj = { 0: "a", 1: "b", length: 2 }; Array.prototype.join.call(obj, "-") // "a-b"类数组对象转为数组
Array.prototype.slice.call({ 0: "a", 1: "b", length: 2 }) // ["a", "b"] Array.prototype.slice.call(document.querySelectorAll("div")); Array.prototype.slice.call(arguments);找出字符长度最长的数组成员
function findLongest(entries) { return entries.reduce(function (longest, entry) { return entry.length > longest.length ? entry : longest; }, ""); } findLongest(["aaa", "bb", "c"]) // "aaa"
文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。
转载请注明本文地址:https://www.ucloud.cn/yun/101072.html
摘要:它主要用在以类数组对象和可迭代对象为蓝本,创建对应的数组。类数组对象我们最熟悉的类数组对象,应该就是的对象了。 在ES6之前,创建数组的方式有2种:一: 通过数组字面量 let array = [1,2,3]; console.log(array);//[1,2,3] 二: 通过new Array()创建数组 let array = new Array(1, 2, 3); conso...
摘要:对象方法数组创建与修改创建创建一个新数组实例将类数组类似数组的对象和可遍历的对象转为真正的数组。返回一个新的对象,该对象包含数组每个索引的值。遍历键遍历值遍历键值对参考文档标准库对象 Array 对象方法 数组创建与修改 1. 创建 var arr = []; var arr = new Array() Array.of(el1[,el2[...]]) //创建一个新数组实例 Ar...
摘要:数组学习记录是的实例属性。对数组元素进行排序,并返回当前数组。返回一个由所有数组元素组合而成的字符串。为数组中的每个元素执行一次回调函数。返回一个数组迭代器对象,该迭代器会包含所有数组元素的键值对。 JavaScript数组学习记录 Array.length Array.length 是Array的实例属性。返回或设置一个数组中的元素个数。该值是一个无符号 32-bit 整数,并且总是...
摘要:关于我的博客掘金专栏路易斯专栏原文链接深度长文数组全解密全文共字,系统讲解了数组的各种特性和。构造器构造器用于创建一个新的数组。中声明的数组,它的构造函数是中的对象。 本文首发于CSDN网站,下面的版本又经过进一步的修订。 关于 我的博客:louis blog 掘金专栏:路易斯专栏 原文链接:【深度长文】JavaScript数组全解密 全文共13k+字,系统讲解了JavaScrip...
摘要:简单总结一下的对象属性数组指定创建一个数组的函数。方法数组返回一个迭代器,它返回数组的键值对。方法数组返回满足回调函数中指定的测试条件的第一个数组元素的索引值。该回调函数的返回值为累积结果,并且此返回值在下一次调用该回调函数时作为参数提供。 简单总结一下JS的Array对象 constructor 属性(数组) 指定创建一个数组的函数。该属性可用于判断某个对象是否为数组与arr ins...
作者:陈大鱼头 github: KRISACHAN 背景 在最近的项目中,有这么一个功能点,就是要获取在WEB IDE里用户所写的注释中的一段特殊规则,然后解析成一段JS config 对象 例如: //% width=100px height=200px //% pos.top=50px pos.left=50px //% writable=true //% q.b.d.w.r.f=30...
阅读 4555·2021-09-26 09:55
阅读 1310·2019-12-27 12:16
阅读 851·2019-08-30 15:56
阅读 1862·2019-08-30 14:05
阅读 942·2019-08-30 13:05
阅读 1225·2019-08-30 10:59
阅读 1399·2019-08-26 16:19
阅读 1842·2019-08-26 13:47