JS Array

JavaScript

声明数组的方法有两种：

• 使用 Array构造函数：

      var color = new Array();
  

  如果预先知道数组的项数，可以给该构造函数传递项数，传入的数字会自动变成 length属性 的值：

      var colors = new Array(20);     //创建了一个 length值 为20的数组
  

  也可以向 Array构造函数 中传入数组中该包含的项：

      var colors = new Array('red','blue','black');
  

  当传入的参数不止一个时，参数中的数字作为对应位置的项；当传入的参数只有一个时，参数中的数字会变成 length属性 的值：

      var colorsAndNums = Array('red','blue',3,'4')   //使用 Array构造函数 时不用 new操作符 也可以 
  

• 使用字面量语法：

      var colors = ['red','blue','black]; 
      var name = [];                      //创建一个空数组
      var values = ['red',,''black]       //第二个位置为 undefined
  

在读取和设置数组的值时，使用方括号和基于0的数字索引：

        var  colors = ['red','blue'];
        alert(colors[0]);                //red
        var colors[1] = 'black';             //把第二项改为 black
        var colors[2] = 'green';             //新增数组第三个位置，并赋字符串 green

数组的项数保存在其 length属性 中：

        var colors = ['red','blue'];
        var names = [];
        document.write(color.length);   //2
        document.write(names.length);   //0

可以通过设置 length属性 来改变数组的长度。或在数组后新增一个位置；或除去数组最后一个位置的元素：

        var colors = ['red','blue','green'];
        colors.length = 2;
        alert(colors[3]);   //undefined

        var colors = ['red','blue','green'];
        colors[99] = 'black';
        alert(colors.length);   //100，中间未声明的均为undefined

检测数组：

使用 Array.isArray() 方法

        if (Array.isArray(colors)){
            //对数组进行某些操作
        }

转换方法:

每个对象都具有 toLoacleString()、toString()、valueOf() 方法。

• toString() 方法：返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串。
• toLocaleString() 方法：转化为由某符号分隔的字符串。
• valueOf() 方法：返回字符串，数值或对象。

两种转化成字符串的方法调用的函数不同

使用 join() 方法可以使用不同的符号来构建转化后的字符串：

        var color = ['red','green','black'];
        alert(color.join('||'));    //使用 || 来分隔
        alert(color.join('/'));     //使用 /  来分隔

如果不传入带引号的 join() 方法参数，则默认以逗号分隔

栈方法：

• pop()、push():
  操作数组中最后一项，同时返回所操作项或新数组的长度。

  • push() 方法可以接收任意数量的参数，把他们逐个添加到数组末尾，并返回新数组的长度。
  • pop() 方法则从数组末尾移除一项，并返回该项。

• shift()、unshift():
  操作数组中的第一项，同时返回所操作项或新数组的长度。

  • unshift() 方法能在数组前端添加任意个项并返回新数组的长度。
  • shift() 方法能移除数组的第一个项，并返回该项。

队列方法：

结合 push() 方法和 shift() 方法，就能像操作队列一样操作数组（前出后进）

重排序方法（都会改变原数组）：

• reverse()、sort():
  反转数组顺序或按一定规则重新排列。

  • reverse() 属于数组内置的方法，作用是反转数组的顺序。

  • sort() 也是数组内置的方法，作用是重新排列数组，返回排序后的数组：

    var values = [0,2,15,3,10,5];
    values.sort();
    alert(values);
    

  内置排序方法为冒泡排序。
  数组在重排时会先调用每个项的 toString() 方法，故实际上是字符串的Unicode节点比较，按照3.5.6的介绍，这种比较并不能得到让人满意的结果，故添加一个 比较函数 作为 sort() 方法的参数：

      function compare(a,b){
          if (a < b){
              return -1;
          }
          else if (a > b){
              return 1;
          }
          else  {
              return 0;
          }
  

  如果compare(a,b)小于0，那么a排在b前；若大于0，b排在a前。
  若只比较数字，比较函数可写成：

      var values = [0,2,15,3,10,5];
      function sortValues(a,b){
          return b-a;
      }
      values.sort(sortValues);
      alert(values);  //15,10,5,3,2,0
  

操作方法：

• concat():
  创建一个调用数组的副本，然后把接收到的参数添加到该副本末尾，并且返回该数组。
  用例：

      var colors = ['red','blue'];
      var anotherColors = ['green','orange'];
      var newColors = colors.concat(anotherColors);
      alert(newColors);   //red,blue,green,orange
  

参数可以不止一个数组。

• slice():
  基于原始数组创建一个新数组。接收两个参数——返回项的起始位置和结束后一位置。

  注：包括起始位置，不包括结束位置。

      var values = [1,2,3,4,5,6,7,8,9,0];
      var values1 = values.slice(1,5);    //2,3,4,5
      var values2 = values.slice(1);      //2,3,4,5,6,7,8,9,0
  

  如果起始位置是一个负数，则由 数组的长度 + 该负数 来确定起始位置。

      var values3 = values.slice(-3,8);
      document.write(values3);            //8
  

  如果省略起始位置，则从数组的第一项开始；如果省略结束位置，则直到最后一项。

• splice():
  可向操作数组中插入项，删除项或替换项，可接受三个参数——删除起始位置，删除项数，要插入的任意项。注意，splice() 返回被删除的项。（先在指定位置插入再删除原来指定的项）

      var values = [2,1,5,6,7,9,4,0];
      var newValues = values.splice(1,1,5,3);     //从values[1]开始将1项替换成[5, 3]
      document.write(newValues);          //1
      document.write(values)           //2,5,3,5,6,7,9,4,0
  

  若不传入第三个参数，则只删除指定位置的指定项。
  若设置删除项数为1，则可以做到替换指定项。

位置方法：

下列两个方法都接收两个参数：要查找的项和（可选的）表示查找起点的索引（也会被查找）。并且都返回查找结果在数组中的索引值，在没找到的情况下返回 -1 在比较第一个参数（查找项）和数组中的每一项时，会使用全等操作符。

• indexOf():
  此方法从数组的开头开始向后查找。

      var numbers = [1,2,3,4,3,2,1];
      alert(number.indexOf(3));          //2
      alert(number.indexOf(3,4));        //4
  

• lastIndexOf():
  此方法从数组的末尾开始向前查找。

      var numbers = [1,2,3,4,3,2,1];
      alert(number.lastIndexOf(3));      //4
      alert(number.lastIndexOf(3,4));    //从4号开始往前找，4
  

迭代方法：

• every():
  对数组中每一项运行给定函数，若每一项都使函数返回 true，则返回 true。

• some():
  对数组中每一项运行给定函数，若任一项使函数返回 true，则返回 true。

• filter():
  对数组中每一项运行给定函数（作为参数传递给该函数，可通过形参接收），返回由使函数返回 true 的项所组成的新数组。

• map():
  对数组中每一项运行给定函数，返回由函数返回值构成的数组。

            var numbers = [1,2,3,4,5,4,3,2,1];
            /* every() */
            var everyResult = numbers.every(function(item,index,array){
                return (item > 2);
            });
            alert(everyResult);     //false
            /* some() */
            var someResult = numbers.some(function(item,index,array){
                return (item > 2);
            });
            alert(someResult);      //true
            /* filter() */
            var filterResult = numbers.filter(function(item,index,array){
                return (item > 2);
            });
            alert(filterResult);    //[3,4,5,4,3]
            /* map() */
            var mapResult = numbers.map(function(item,index,array){
                return (item*2);
            }); 
            alert(mapResult);

归并方法：

下列两个方法都接收两个参数——在每一项上调用的函数和（可选的）作为归并基础的初始值。
所调用的函数包含 callback(acc,cur,index,array) 四个参数和默认为0的 initialValue，表示 累计值、当前值、索引值、数组、第一个值传入时的 acc ，返回 acc。

而且，这个函数每次返回的值都会更新 acc（累计值） 传递给下一次执行。

• reduce():
  从数组开始项遍历到最后一项。可以执行例如数组求和等递归操作（ initial 值作为第一个参数传入时的 prev，默认为 0，可选设置）：

      var values = [1,2,3,4,5];
      var  sum = values.reduce(function(acc,cur,index,array){
          return acc+cur;
      }[, initial]);
      alert(sum);             //15
  

• reduceRight():
  从数组最后一项开始，向前遍历到第一项。

      var values = [1,2,3,4,5,6];
      var sum = values.reduceRight(function(acc,cur,index,array){
          return cur-acc;
      }[, initial]);                     
      sum;        //-3
  

利用 indexOf() 和递归方法结合，可以实现对数组的 去重 等操作。

Array.prototype.flat(depth = 1)

将指定深度的嵌套数组连接，会将处理到的空项移除：

var arr1 = [1, 2, [3, 4, , [5, 6]]];
arr1.flat();    // [1,2,3,4,[5,6]]
arr1.flat(2);   // [1,2,3,4,5,6]

快速排序

//quick sort
function quickSort(arr, left, right){
    if (left === right || arr.length === 0) return arr;
    var book = arr[0], i = left, j = right;
    while (i !== j){
        while (arr[j] >= book && j > i){
            j--;
        }
        while (arr[i] <= book && i < j){
            i++;
        }
        if (i !== j){
            var t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }
    if (i !== 0){
        arr[0] = arr[i];
        arr[i] = book;
        return quickSort(arr.slice(0, i), 0, i-1).concat(arr[i], quickSort(arr.slice(i+1), 0, arr.length-i-2));
    } else {
        return arr.slice(0, 1).concat(quickSort(arr.slice(i+1), 0, arr.length-2));
    }
}
var a = [1,5,3,4,7,4,6,8,2,4,8,9,0];
quickSort(a, 0, a.length-1);    //[0, 1, 2, 3, 4, 4, 4, 5, 6, 7, 8, 8, 9]