javscript之数组

Posted 2021-09-07 月疯

声明一个数组：

创建一个空数组有两种语法：

let arr = new Array();

let arr = [];

数组的操作：

 数组的首端或尾端添加和删除元素的方法

• arr.push(...items) —— 从尾端添加元素，
• arr.unshift(...items) —— 从首端添加元素
• arr.pop() —— 从尾端提取元素，
• arr.shift() —— 从首端提取元素，

delete删除元素：

let arr = ["I", "go", "home"];

delete arr[1]; // remove "go"

alert( arr[1] ); // undefined

// now arr = ["I", , "home"];

alert( arr.length ); // 3 

因为 delete obj.key 是通过 key 来移除对应的值。对于对象来说是可以的。但是对于数组来说，我们通常希望剩下的元素能够移动并占据被释放的位置 

splice（添加，删除和插入元素）

arr.splice(start[, deleteCount, elem1, ..., elemN])

它从索引 start 开始修改 arr：删除 deleteCount 个元素并在当前位置插入 elem1, ..., elemN。最后返回已被删除元素的数组。

splice删除一个元素：

 let arr = ["I", "study", "javascript"];

arr.splice(1, 1); // 从索引 1 开始删除 1 个元素

alert( arr ); // ["I", "JavaScript"]

splice删除了 3 个元素，并用另外两个元素替换：

let arr = ["I", "study", "JavaScript", "right", "now"]; // 删除三个元素并且那俩个元素去替换

arr.splice(0, 3, "Let's", "dance");//具体操作

alert( arr ) // now ["Let's", "dance", "right", "now"]//前三个被删除，然后这俩个被替换掉了

splice 返回了已删除元素的数组 

let arr = ["I", "study", "JavaScript", "right", "now"]; // 删除前两个元素

let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- 被从数组中删除了的元素

deleteCount 设置为 0，splice 方法就能够插入元素而不用删除任何元素 

let arr = ["I", "study", "JavaScript"]; // 从索引 2 开始 // 删除 0 个元素 // 然后插入 "complex" 和 "language"

arr.splice(2, 0, "complex", "language");

alert( arr ); // "I", "study", "complex", "language", "JavaScript" 

注意啦： splice允许负向索引

let arr = [1, 2, 5]; // 从索引 -1（尾端前一位） // 删除 0 个元素， // 然后插入 3 和 4 arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

arr.slice方法比 arr.splice 简单得多 

语法是：

arr.slice( [start],  [end] )

它会返回一个新数组，将所有从索引 start 到 end（不包括 end）的数组项复制到一个新的数组。start 和 end 都可以是负数，在这种情况下，从末尾计算索引。

它和字符串的 str.slice 方法有点像，就是把子字符串替换成子数组。

 let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s（复制从位置 1 到位置 3 的元素）

alert( arr.slice(-2) ); // s,t（复制从位置 -2 到尾端的元素）

arr.concat创建一个新数组，其中包含来自于其他数组和其他项的值。[数组的合并]

语法：

 arr.concat(arg1, arg2...)

它接受任意数量的参数 —— 数组或值都可以。

结果是一个包含来自于 arr，然后是 arg1，arg2 的元素的新数组。

如果参数 argN 是一个数组，那么其中的所有元素都会被复制。否则，将复制参数本身。

 let arr = [1, 2]; //创建一个数组[3,4]

alert( arr.concat([3, 4]) ); // arr数组合并[3,4]

alert( arr.concat([3, 4], [5, 6]) ); // arr合并[3,4],合并[5,6]

alert( arr.concat([3, 4], 5, 6) ); // 1,2,3,4,5,6数组和字符串合并

数组的遍历;for each方法允许为数组的每个元素都运行一个函数。

arr.forEach(function(item, index, array) {

// ... do something with item

});

// 对每个元素调用

alert ["Bilbo", "Gandalf", "Nazgul"].forEach(alert); 

数组中的位置：

["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {

alert(`${item} is at index ${index} in ${array}`);

}); 

数组中的搜索 ：indexOf

• arr.indexOf(item, from) 从索引 from 开始搜索 item，如果找到则返回索引，否则返回 -1。
• arr.lastIndexOf(item, from) —— 和上面相同，只是从右向左搜索。
• arr.includes(item, from) —— 从索引 from 开始搜索 item，如果找到则返回 true（译注：如果没找到，则返回 false）

arr.includes检查是否包含元素 

alert( arr.includes(NaN) );// true（这个结果是对的）

find和findIndex 

语法：

let result = arr.find(function(item, index, array) {

// 如果返回 true，则返回 item 并停止迭代 // 对于假值（falsy）的情况，则返回 undefined

});

依次对数组中的每个元素调用该函数：

• item 是元素。
• index 是它的索引。
• array 是数组本身。

如果它返回 true，则搜索停止，并返回 item。如果没有搜索到，则返回 undefined。

 我们有一个存储用户的数组，每个用户都有 id 和 name 字段。让我们找到 id == 1 的那个用户：

let users = [ {id: 1, name: "John"}, {id: 2, name: "Pete"}, {id: 3, name: "Mary"} ];

let user = users.find(item => item.id == 1);

alert(user.name); // John

arr.findindex 方法（与 arr.find 方法）基本上是一样的，但它返回找到元素的索引，而不是元素本身。并且在未找到任何内容时返回 -1。 

filter（filter 返回的是所有匹配元素组成的数组）

let results = arr.filter(function(item, index, array) {

// 如果 true item 被 push 到 results，迭代继续 // 如果什么都没找到，则返回空数组

});

let users = [ {id: 1, name: "John"}, {id: 2, name: "Pete"}, {id: 3, name: "Mary"} ];

// 返回前两个用户的数组

let someUsers = users.filter(item => item.id < 3);

alert(someUsers.length); // 2