数组方法

toString()

把数组转换为字符串，JavaScript 方法 把数组转换为数组值（逗号分隔）的字符串。

join()

方法也可将所有数组元素结合为一个字符串。
它的行为类似 toString()，但是您还可以规定分隔符：

pop()

方法从数组中删除最后一个元素：

  1. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  2. fruits.pop();              // 从 fruits 删除最后一个元素（"Mango"）
  3. pop() 方法返回“被弹出”的值：
  4. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  5. var x = fruits.pop();      // x 的值是 "Mango"

push()

方法（在数组结尾处）向数组添加一个新的元素：

  1. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  2. fruits.push("Kiwi");       //  向 fruits 添加一个新元素
  3. push() 方法返回新数组的长度：
  4. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  5. var x =  fruits.push("Kiwi");   //  x 的值是 5

shift()

方法会删除首个数组元素，并把所有其他元素“位移”到更低的索引。

  1. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  2. fruits.shift();            // 从 fruits 删除第一个元素 "Banana"
  3. shift() 方法返回被“位移出”的字符串：
  4. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  5. fruits.shift();             // 返回 "Banana"

unshift()

方法（在开头）向数组添加新元素，并“反向位移”旧元素：

  1. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  2. fruits.unshift("Lemon");    // 向 fruits 添加新元素 "Lemon"
  3. unshift() 方法返回新数组的长度。
  4. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  5. fruits.unshift("Lemon");    // 返回 5

splice()

拼接数组,可用于向数组添加新项：

  1. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  2. fruits.splice(2, 0, "Lemon", "Kiwi");
  3. 第一个参数（2）定义了应添加新元素的位置（拼接）。
  4. 第二个参数（0）定义应删除多少元素。
  5. 其余参数（“Lemon”，“Kiwi”）定义要添加的新元素。
  6. splice() 方法返回一个包含已删除项的数组：
  7. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  8. fruits.splice(2, 2, "Lemon", "Kiwi");

使用 splice() 来删除元素

  1. 通过聪明的参数设定，您能够使用 splice() 在数组中不留“空洞”的情况下移除元素：
  2. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  3. fruits.splice(0, 1);        // 删除 fruits 中的第一个元素
  4. 第一个参数（0）定义新元素应该被添加（接入）的位置。
  5. 第二个参数（1）定义应该删除多个元素。
  6. 其余参数被省略。没有新元素将被添加。

concat()

合并（连接）数组方法通过合并（连接）现有数组来创建一个新数组：

  1. var myGirls = ["Cecilie", "Lone"];
  2. var myBoys = ["Emil", "Tobias", "Linus"];
  3. var myChildren = myGirls.concat(myBoys);   // 连接 myGirls 和 myBoys
  4. concat() 方法不会更改现有数组。它总是返回一个新数组。
  5. concat() 方法可以使用任意数量的数组参数：
  6. 实例（合并三个数组）
  7. var arr1 = ["Cecilie", "Lone"];
  8. var arr2 = ["Emil", "Tobias", "Linus"];
  9. var arr3 = ["Robin", "Morgan"];
  10. var myChildren = arr1.concat(arr2, arr3);   // 将arr1、arr2 与 arr3 连接在一起
  11. concat() 方法也可以将值作为参数：
  12. 实例（将数组与值合并）
  13. var arr1 = ["Cecilie", "Lone"];
  14. var myChildren = arr1.concat(["Emil", "Tobias", "Linus"]);

裁剪数组

slice() 方法用数组的某个片段切出新数组。

  1. 本例从数组元素 1 （"Orange"）开始切出一段数组：
  2. var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
  3. var citrus = fruits.slice(1);
  4. slice() 方法创建新数组。它不会从源数组中删除任何元素。
  5. 本例从数组元素 3 （"Apple"）开始切出一段数组：
  6. var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
  7. var citrus = fruits.slice(3);
  8. slice() 可接受两个参数，比如 (1, 3)。
  9. 该方法会从开始参数选取元素，直到结束参数（不包括）为止。
  10. var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
  11. var citrus = fruits.slice(1, 3);
  12. 如果结束参数被省略，比如第一个例子，则 slice() 会切出数组的剩余部分。
  13. var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
  14. var citrus = fruits.slice(2);

数组排序

sort()

sort() 方法以字母顺序对数组进行排序：

  1. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  2. fruits.sort();            // 对 fruits 中的元素进行排序
  3. //Apple，Banana，Mango，Orange

sort() 方法对数组进行排序：

  1. 升序排序
  2. var arr = [1,3,524,5,21,611,-2]
  3.             console.log(arr.sort((a,b)=>{
  4.                 return a-b
  5.             }))
  6. // [-2, 1, 3, 5, 21, 524, 611]
  8. 降序排序
  9. var arr = [1,3,524,5,21,611,-2]
  10.             console.log(arr.sort((a,b)=>{
  11.                 return b-a
  12.             }))
  14. 以随机顺序排序数组
  15. var points = [40, 100, 1, 5, 25, 10];
  16. points.sort(function(a, b){return 0.5 - Math.random()}); 
  18. 查找最高（或最低）的数组值
  19. JavaScript 不提供查找数组中最大或最小数组值的内建函数。
  20. 不过，在对数组进行排序之后，您能够使用索引来获得最高或最低值。
  21. var points = [40, 100, 1, 5, 25, 10];
  22. points.sort(function(a, b){return a - b});
  23. // 现在 points[0] 包含最低值
  24. // 而 points[points.length-1] 包含最高值

如果您仅仅需要找到最高或最低值，对整个数组进行排序是效率极低的方法。

对数组使用 Math.max()

可以使用 Math.max.apply 来查找数组中的最高值：

  1. function myArrayMax(arr) {
  2.     return Math.max.apply(null, arr);
  3. }
  4. Math.max.apply([1, 2, 3]) 等于 Math.max(1, 2, 3)。
  5. var a = [1,3,524,5,21,611,-2]
  6. console.log(Math.max.apply(null,a))
  7. //611

对数组使用 Math.min()

您可以使用 Math.min.apply 来查找数组中的最低值：

  1. function myArrayMin(arr) {
  2.     return Math.min.apply(null, arr);
  3. }
  4. Math.min.apply([1, 2, 3]) 等于 Math.min(1, 2, 3)。
  5. var a = [1,3,524,5,21,611,-2]
  6. console.log(Math.min.apply(null,a))
  7. //-2

排序对象数组

JavaScript 数组经常会包含对象：

  1. var cars = [
  2. {type:"Volvo", year:2016},
  3. {type:"Saab", year:2001},
  4. {type:"BMW", year:2010}];
  5. 即使对象拥有不同数据类型的属性，sort() 方法仍可用于对数组进行排序。
  6. 解决方法是通过比较函数来对比属性值：
  7. cars.sort(function(a, b){return a.year - b.year});
  8. 比较字符串属性会稍复杂：
  9. cars.sort(function(a, b){
  10.    var x = a.type.toLowerCase();
  11.    var y = b.type.toLowerCase();
  12.    if (x < y) {return -1;}
  13.    if (x > y) {return 1;}
  14.    return 0;
  15. });

reverse()

反转数组方法反转数组中的元素。使用它以降序对数组进行排序：

  1. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  2. fruits.sort();            // 对 fruits 中的元素进行排序
  3. fruits.reverse();         // 反转元素顺序

数组迭代方法

array

Array.forEach()

forEach() 方法为每个数组元素调用一次函数（回调函数）。

语法：array.forEach(function(currentValue, index, arr), thisValue)

参数 描述
function(currentValue, index, arr) 必需。 数组中每个元素需要调用的函数。
函数参数:		 参数 描述
:—- :—-
currentValue 必需。当前元素
index 可选。当前元素的索引值。
arr 可选。当前元素所属的数组对象。

| | thisValue | 可选。传递给函数的值一般用 “this” 值。
如果这个参数为空， “undefined” 会传递给 “this” 值 |

  1. var txt = "";
  2. var numbers = [45, 4, 9, 16, 25];
  3. numbers.forEach(myFunction);
  4. function myFunction(value, index, array) {
  5.   txt = txt + value + "<br>"; 
  6. }
  7. 注释：该函数接受 3 个参数：
  8. • 项目值
  9. • 项目索引
  10. • 数组本身
  11. 上面的例子只用了 value 参数。这个例子可以重新写为：
  12. var txt = "";
  13. var numbers = [45, 4, 9, 16, 25];
  14. numbers.forEach(myFunction);
  15. function myFunction(value) {
  16.   txt = txt + value + "<br>"; 
  17. }
  18. 所有浏览器都支持 Array.forEach()，除了 Internet Explorer 8 或更早的版本：
  22.  var database = {
  23.                 users: ["张法法", "法法师", "嘎嘎"],
  24.                 sendEmail: function (user) {
  25.                     if (this.isValidUser(user)) {
  26.                         console.log("你好，" +user);
  27.                     } else {
  28.                         console.log("抱歉，" + user +"，你不是本家人");
  29.                     }
  30.                 },
  31.                 isValidUser: function (user) {
  32.                     return /^张/.test(user);
  33.                 }
  34.             };
  35.             // 给每个人法邮件
  36.             database.users.forEach( // database.users中人遍历
  37.                 database.sendEmail, // 发送邮件
  38.                 database
  39.                 // 使用database代替上面标红的this
  40.             );

Array.map()

map

语法：array.map(function(currentValue,index,arr), thisValue)

map() 方法通过对每个数组元素执行函数来创建新数组。
map() 方法不会对没有值的数组元素执行函数。
map() 方法不会更改原始数组。
这个例子将每个数组值乘以2：

参数 描述
function(currentValue, index,arr) 必须。函数，数组中的每个元素都会执行这个函数
函数参数:
 参数 描述
:—- :—-
currentValue 必须。当前元素的值
index 可选。当前元素的索引值
arr 可选。当前元素属于的数组对象

| | thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 “this” 的值。
如果省略了 thisValue，或者传入 null、undefined，那么回调函数的 this 为全局对象。 |

  1. var numbers1 = [45, 4, 9, 16, 25];
  2. var numbers2 = numbers1.map(myFunction);
  3. function myFunction(value, index, array) {
  4.   return value * 2;
  5. }

请注意，该函数有 3 个参数：

  • 项目值
  • 项目索引
  • 数组本身

当回调函数仅使用 value 参数时，可以省略索引和数组参数：

  1. var numbers1 = [45, 4, 9, 16, 25];
  2. var numbers2 = numbers1.map(myFunction);
  3. function myFunction(value) {
  4.   return value * 2;
  5. }
  6. 所有浏览器都支持 Array.map()，除了 Internet Explorer 8 或更早的版本

关联数组

很多编程元素支持命名索引的数组。
具有命名索引的数组被称为关联数组（或散列）。
JavaScript 不支持命名索引的数组。
在 JavaScript 中，数组只能使用数字索引。

  1. var person = [];
  2. person[0] = "Bill";
  3. person[1] = "Gates";
  4. person[2] = 62;
  5. var x = person.length;          // person.length 返回 3
  6. var y = person[0];              // person[0] 返回 "Bill"
  7. 警告！
  8. 假如使用命名索引，JavaScript 会把数组重定义为标准对象。
  9. 之后，所有数组的方法和属性将产生非正确结果。
  10. var person = [];
  11. person["firstName"] = "Bill";
  12. person["lastName"] = "Gates";
  13. person["age"] = 62;
  14. var x = person.length;         // person.length 将返回 0
  15. var y = person[0];              // person[0] 将返回 undefined

避免 new Array()

没有必要使用 JavaScript 的内建数组构造器 new Array()。
请使用 [] 取而代之！
new 关键词只会使代码复杂化。它还会产生某些不可预期的结果：

  1. var points = new Array(40, 100);  // 创建包含两个元素的数组（40 和 100）
  2. 假如删除其中一个元素会怎么样？
  3. var points = new Array(40);       // 创建包含 40 个未定义元素的数组！！！

识别数组

常见的问题是：我如何知晓某个变量是否是数组？问题在于 JavaScript 运算符 typeof 返回 “object”：

  1. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  2. typeof fruits;             // 返回 object
  3. typeof 运算符返回 "object"，因为 JavaScript 数组属于对象。
  4. 解决方案 1：
  5. 为了解决这个问题，ECMAScript 5 定义了新方法 Array.isArray()：
  6. Array.isArray(fruits);     // 返回 true
  7. 此方案的问题在于 ECMAScript 5 不支持老的浏览器。
  8. 解决方案 2：
  9. 创建 isArray() 函数以解决此问题：
  10. function isArray(x) {
  11. return x.constructor.toString().indexOf("Array") > -1;
  12. }
  13. 假如参数为数组，则上面的函数始终返回 true。
  14. 或者更准确的解释是：假如对象原型包含单词 "Array" 则返回 true。
  15. 解决方案 3：
  16. 假如对象由给定的构造器创建，则 instanceof 运算符返回 true：
  17. var fruits = ["Banana", "Orange", "Apple", "Mango"];
  18. fruits instanceof Array     // 返回 true