Object
显示的创建Object的实例方法：
- new操作符和Object构造函数
let person = new Object(); person.name = 'Jason'; person.age = 42
- 对象字面量
let person = { name:'Jason', age:42}存取属性的方法一般有两种：点语法和中括号。
let person = { name:'Jason', age:42}; console.log(person.name); console.log(person['name']);从功能上讲两种存取属性的方法没有区别，使用中括号的主要优势就是可以通过变量访问属性。
let propertyName = "name"; console.log(person[propertyName]); // "Jason"
Array
创建数组的方法：
- Array构造函数创建
let colors = new Array();
- 数组字面量表示法
let colors = ['red','blue','pink']
- Array.from(),第一个参数是一个类数组对象，即任何可迭代的结构，或者有一个length属性和可索引元素的结构。
console.log(Array.from("Matt")); // ["M", "a", "t", "t"] // 可以使用 from()将集合和映射转换为一个新数组 const m = new Map().set(1, 2) .set(3, 4); const s = new Set().add(1) .add(2) .add(3) .add(4); console.log(Array.from(m)); // [[1, 2], [3, 4]] console.log(Array.from(s)); // [1, 2, 3, 4] // Array.from()对现有数组执行浅复制 const a1 = [1, 2, 3, 4]; const a2 = Array.from(a1); console.log(a1); // [1, 2, 3, 4] alert(a1 === a2); // false // 可以使用任何可迭代对象 const iter = { *[Symbol.iterator]() { yield 1; yield 2; yield 3; yield 4; } }; console.log(Array.from(iter)); // [1, 2, 3, 4]// arguments 对象可以被轻松地转换为数组 function getArgsArray() { return Array.from(arguments); } console.log(getArgsArray(1, 2, 3, 4)); // [1, 2, 3, 4] // from()也能转换带有必要属性的自定义对象 const arrayLikeObject = { 0: 1, 1: 2, 2: 3, 3: 4, length: 4 }; console.log(Array.from(arrayLikeObject)); // [1, 2, 3, 4]Array.from()还接收第二个可选的映射函数参数。这个函数可以直接增强新数组的值，而无须像调用 Array.from().map()那样先创建一个中间数组。还可以接收第三个可选参数，用于指定映射函数中 this 的值。但这个重写的 this 值在箭头函数中不适用。const a1 = [1, 2, 3, 4]; const a2 = Array.from(a1, x => x**2); const a3 = Array.from(a1, function(x) {return x**this.exponent}, {exponent: 2}); console.log(a2); // [1, 4, 9, 16] console.log(a3); // [1, 4, 9, 16]
- Array.of()可以把一组参数转换为数组
检索数组内容的方法：
- keys(),返回数组索引的迭代器
- values()，返回数组元素的迭代器
- entries()，返回索引/值对的迭代器
const a = ["foo", "bar", "baz", "qux"]; // 因为这些方法都返回迭代器，所以可以将它们的内容 // 通过 Array.from()直接转换为数组实例 const aKeys = Array.from(a.keys()); const aValues = Array.from(a.values()); const aEntries = Array.from(a.entries()); console.log(aKeys); // [0, 1, 2, 3] console.log(aValues); // ["foo", "bar", "baz", "qux"] console.log(aEntries); // [[0, "foo"], [1, "bar"], [2, "baz"], [3, "qux"]]复制和填充方法：
批量复制方法copyWithin()，会按照指定范围浅复制数组中的部分内容，然后将它们插入到指
定索引开始的位置。填充数组方法fill()，可以向一个已有的数组中插入全部或部分相同的值。开始索引用于指定开始填充的位置，它是可选的。如果不提供结束索引，则一直填充到数组末尾。负值索引从数组末尾开始计算。
const zeroes = [0, 0, 0, 0, 0]; // 用 5 填充整个数组 zeroes.fill(5); console.log(zeroes); // [5, 5, 5, 5, 5] zeroes.fill(0); // 重置 // 用 6 填充索引大于等于 3 的元素 zeroes.fill(6, 3); console.log(zeroes); // [0, 0, 0, 6, 6] zeroes.fill(0); // 重置 // 用 7 填充索引大于等于 1 且小于 3 的元素 zeroes.fill(7, 1, 3); console.log(zeroes); // [0, 7, 7, 0, 0]; zeroes.fill(0); // 重置 // 用 8 填充索引大于等于 1 且小于 4 的元素 // (-4 + zeroes.length = 1) // (-1 + zeroes.length = 4) zeroes.fill(8, -4, -1); console.log(zeroes); // [0, 8, 8, 8, 0]; fill()静默忽略超出数组边界、零长度及方向相反的索引范围： const zeroes = [0, 0, 0, 0, 0]; // 索引过低，忽略 zeroes.fill(1, -10, -6); console.log(zeroes); // [0, 0, 0, 0, 0] // 索引过高，忽略 zeroes.fill(1, 10, 15); console.log(zeroes); // [0, 0, 0, 0, 0] // 索引反向，忽略 zeroes.fill(2, 4, 2); console.log(zeroes); // [0, 0, 0, 0, 0] // 索引部分可用，填充可用部分 zeroes.fill(4, 3, 10) console.log(zeroes); // [0, 0, 0, 4, 4]栈方法
- push(),接收任意数量的参数，并将它们添加到数组末尾，返回数组的最新长度.
- pop(),用于删除数组的最后一项，同时减少数组的 length 值，返回被删除的项.
let colors = []; let count = colors.push('red','green') console.log(count);//2 let item = colors.pop() console.log(item);//green队列方法
- shift(),删除数组的第一项并返回它，然后数组长度减 1
let colors = []; let count = colors.push('red','blue'); let item = colors.shift(); console.log(item);//red
- unshift(),在数组开头添加任意多个值，然后返回新的数组长度
let colors = []; let count = colors.unshift('red','blue'); let item = colors.pop(); console.log(item);//blue排序方法
- reverse(),是将数组元素反向排列。
let values = [1, 2, 3, 4, 5]; values.reverse(); alert(values); // 5,4,3,2,1
- sort(),按照升序重新排列数组元素。sort()会在每一项上调用 String()转型函数，然后比较字符串来决定顺序。即使数组的元素都是数值，也会先把数组转换为字符串再比较、排序。
let values = [0, 1, 5, 10, 15]; values.sort(); alert(values); // 0,1,10,15,5sort()方法可以接收一个比较函数，用于判断哪个值应该排在前面。
let values = [0, 1, 5, 10, 15]; values.sort((a, b) => a < b ? 1 : a > b ? -1 : 0); alert(values); // 15,10,5,1,0操作 方法
- concat()方法可以在现有数组全部元素基础上创建一个新数组。它首先会创建一个当前数组的副本，然后再把它的参数添加到副本末尾，最后返回这个新构建的数组。如果传入一个或多个数组，则 concat()会把这些数组的每一项都添加到结果数组。如果参数不是数组，则直接把它们添加到结果数组末尾。
打平数组参数的行为可以重写，方法是在参数数组上指定一个特殊的符号： Symbol.isConcat-Spreadable。这个符号能够阻止 concat() 打平参数数组。相反，把这个值设置为 true 可以强制打平类数组对象：let colors = ["red", "green", "blue"]; let newColors = ["black", "brown"]; let moreNewColors = { [Symbol.isConcatSpreadable]: true, length: 2, 0: "pink", 1: "cyan" }; newColors[Symbol.isConcatSpreadable] = false; // 强制不打平数组 let colors2 = colors.concat("yellow", newColors); // 强制打平类数组对象 let colors3 = colors.concat(moreNewColors); console.log(colors); // ["red", "green", "blue"] console.log(colors2); // ["red", "green", "blue", "yellow", ["black", "brown"]] console.log(colors3); // ["red", "green", "blue", "pink", "cyan"]
let colors = ["red", "green", "blue", "yellow", "purple"]; let colors2 = colors.slice(1); let colors3 = colors.slice(1, 4); alert(colors2); // green,blue,yellow,purple alert(colors3); // green,blue,yellow/*如果 slice()的参数有负值，那么就以数值长度加上这个负值的结果确定位置。比 如，在包含 5 个元素的数组上调用 slice(-2,-1)，就相当于调用 slice(3,4)。如果结 束位置小于开始位置，则返回空数组。*/
- splice(),主要目的是在数组中间插入元素，有3种不同的方式使用这个方法。
- 删除。需要给splice()传2个参数：要删除的第一个元素的位置和要删除的元素数量。
- 插入。需要给splice()传3个参数：开始位置、0和要插入的元素，可以在数组中指定的位置插入元素。
- 替换。splice()在删除元素的同时可以在指定位置插入新元素，同样要传入3个参数：开始位置、要删除元素的数量和要插入的任意多个元素。
let colors = ["red", "green", "blue"]; let removed = colors.splice(0,1); // 删除第一项 alert(colors); // green,blue alert(removed); // red，只有一个元素的数组 removed = colors.splice(1, 0, "yellow", "orange"); // 在位置 1 插入两个元素 alert(colors); // green,yellow,orange,blue alert(removed); // 空数组 removed = colors.splice(1, 1, "red", "purple"); // 插入两个值，删除一个元素 alert(colors); // green,red,purple,orange,blue alert(removed); // yellow，只有一个元素的数组搜索和位置方法
- 严格相等
- indexOf(),从数组前头开始向后搜索，返回要查找的元素在数组中的位置，如果没找到返回-1.
- lastIndexOf()，从数组末尾开始向前搜索，返回要查找的元素在数组中的位置，如果没找到返回-1.
- includes()，从数组前头开始向后搜索，返回布尔值，表示是否至少找到一个于指定元素匹配的项。
都接收两个参数：要查找的元素和一个可选的起始搜索位置。
let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; alert(numbers.indexOf(4)); // 3 alert(numbers.lastIndexOf(4)); // 5 alert(numbers.includes(4)); // true alert(numbers.indexOf(4, 4)); // 5 alert(numbers.lastIndexOf(4, 4)); // 3 alert(numbers.includes(4, 7)); // false let person = { name: "Nicholas" }; let people = [{ name: "Nicholas" }]; let morePeople = [person]; alert(people.indexOf(person)); // -1 alert(morePeople.indexOf(person)); // 0 alert(people.includes(person)); // false alert(morePeople.includes(person)); // true
- 断言函数接收3个参数：元素、索引和数组本身。
- find(),从数组最小的索引开始，返回第一个匹配的元素，找到一个后不在继续搜索
- findIndex(),从数组最小的索引开始，返回第一个匹配元素的索引，找到一个后不在继续搜索
const people = [ { name: "Matt", age: 27 }, { name: "Nicholas", age: 29 } ]; alert(people.find((element, index, array) => element.age < 28)); // {name: "Matt", age: 27} alert(people.findIndex((element, index, array) => element.age < 28)); // 0迭代方法
let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; let everyResult = numbers.every((item, index, array) => item > 2); alert(everyResult); // false let someResult = numbers.some((item, index, array) => item > 2); alert(someResult); // true ------------------ let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; let filterResult = numbers.filter((item, index, array) => item > 2); alert(filterResult); // 3,4,5,4,3------------------ let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; let mapResult = numbers.map((item, index, array) => item * 2); alert(mapResult); // 2,4,6,8,10,8,6,4,2 ------------------- let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; numbers.forEach((item, index, array) => { // 执行某些操作 });归并方法
- reduce()，从第一项开始遍历到末尾
- reduceRight()，从最后一项开始遍历到开头
这两个方法都接收两个参数：对每一项都会运行的归并函数，以及可选的以之为归并起点的初始值。 传给 reduce() 和 reduceRight() 的函数接收 4 个参数：上一个归并值、当前项、当前项的索引和数组本身。let values = [1, 2, 3, 4, 5]; let sum = values.reduce((prev, cur, index, array) => prev + cur); alert(sum); // 15let sum1 = values.reduceRight(function(prev, cur, index, array){ return prev + cur; }); alert(sum1); // 15
