jS数组

1.特点

无类型：数组元素是任意类型（数值、对象、数组等），同一数组不同元素可以是不同类型。

索引：0—2的32次方减2。

动态的：定义时可以不指定大小，操作时动态改变大小。

稀疏和非稀疏：稀疏数组元素不是连续的，用delete删除数组元素将会使数组成为稀疏数组；非稀疏数组元素是连续的并且length属性为元素个数。

类数组对象：数组可以看成对象，它的索引即为对象属性，值为对象值。同理，可以用[]来将对象当成数组使用。

 

2.创建数组

2.1 直接法

var a = [];
var a = [1, 2, 3, 4, 5, ];
var a = [1.1, 'true', { name: 'mlh', age: 23 }];
var b= 10;
var a = [b + 1, b + 2, b + 3];
var a = [ 1,  , 3 ];//三个元素
var a = [ , , ];//两个元素，结尾逗号可选

2.2 构造函数Array

 //三个构造函数
 var a = new Array();  
 var a = new Array(20);//指定length
 var a = new Array(1,3,5,7,9); 

3.数组遍历

3.1 for循环

   for (var i = 0, len = a.length; i < len; i++) {
                    //循环体
                }

3.2 for in 循环

 for (var i in a) {
       //i代表属性名，for in 适合遍历对象，不适合数组
 }

3.3 forEach 循环

  var data = [1, 2, 3, 4, 5];
      var sum = 0;
       data.forEach(function (i) {
        sum += i;
                });

4.数组方法

4.1 join方法

Array.join()方法将数组中所有元素都转化为字符串并连接在一起，返回最后生成的字符串。可以指定分隔符，如果不指定，默认使用逗号。

 var a = [1, 2, 3, 4, 5];
 document.write("a.join()：" + a.join()); //1,2,3,4,5
 document.write("a.join(\" \")：" + a.join(" ")); //1 2 3 4 5
 document.write("a.join(\"\")：" + a.join(""));//12345
 document.write("a.join(\"-\")：" + a.join("-"));//1-2-3-4-5
  document.write("a.join(\",\")：" + a.join(","));//1,2,3,4,5

4.2 reverse()

Array.reverse()方法将数组中的元素颠倒顺序，返回逆序的数组。

4.3 sort()

Array.sort()方法将数组中的元素排序并返回排序后的数组。当不带参数调用sort()时，数组元素以字母顺序排序。

如果数组包含undefine元素，它们会被排到数组的尾部。为了按照其他方式排序，必须给sort()方法传递一个比较函数。

  var a = [33, 44, 11111,222];
  var ar = a.sort();
  document.write("</br>ar.join()：" + ar.join());//11111,222,33,44
  var ar2 =  a.sort(function (a, b) {
      return a - b;
  });
  document.write("</br>ar2.join()：" +  ar2.join());//33,44,222,11111

4.4 concat()

Array.concat()方法创建并返回一个新数组，它的元素包括调用concat()的原始数组的元素和concat()的每个参数。如果

这些参数中的任何一个自身是数组，则连接的是数组的元素，而非数组本身。注，concat()不会修改原始数组。

 var a = [1, 2, 3];
 var a1 =  a.concat(4, 5);  //1,2,3,4,5
 var a2 =  a.concat([4, 5]); //1,2,3,4,5
 var a3 = a.concat([4, 5], [6, 7]); //1,2,3,4,5,6,7
 var a4 = a.concat(4, [5, [6, 7]]); //1,2,3,4,5,[6,7]

4.5 slice()

Array.slice()方法返回指定数组的一个片段或子数组。它的两个参数分别指定了片段的开始和结束位置。返回的数组

包括第一个参数指定的位置和所有到但不含第二个参数指定的位置之间的所有数组元素。如参数中出现负数，它表示

相对于数组中最后一个元素的位置。如，参数-1指定了最后一个元素，而-3指定了倒数第三个元素。注，slice()不会

修改调用的数组。

  var a = [1, 2, 3, 4, 5];
  var a1 = a.slice(0, 3); //1,2,3
  var a2 = a.slice(3); //4,5
  var a3 = a.slice(1, -1);//2,3,4
  var a4 = a.slice(-3, -2);//3
 document.write("</br>a1.join()：" + a1.join());
 document.write("</br>a2.join()：" + a2.join());
 document.write("</br>a3.join()：" + a3.join());
 document.write("</br>a4.join()：" + a4.join());

4.6 splice()

Array.splice()是在数组中插入或删除元素的通用方法。splice()会修改调用的数组。splice()的第一个参数指定了插入

和（或）删除的起始位置。第二个参数指定了应该从数组中删除的元素的个数。如果省略第二个参数，从起始点开始到

数组结尾的所有元素都将被删除。splice()返回一个由删除元素组成的数组，或者如果没有删除元素就返回一个空数组。

splice()第三到任意个参数指定了需要插入到数组中的元素，从第一个参数指定的位置开始插入。

  //删除
 var a = [1, 2, 3, 4, 5, 6, 7, 8];
 var a1 = a.splice(4);
 document.write("</br></br>a1.join()：" + a1.join()); //5,6,7,8
 document.write("</br>a.join()：" + a.join());//1,2,3,4
 var a2 = a.splice(1, 2);
 document.write("</br></br>a2.join()：" + a2.join()); //2,3
 document.write("</br>a.join()：" + a.join()); //1,4
 var a3 = a.splice(1, 1);
 document.write("</br></br>a3.join()：" + a3.join()); //4
 document.write("</br>a.join()：" + a.join()); //1

  //新增
 var a = [1, 2, 3, 4, 5];
 var a1 = a.splice(2, 0, 'a', 'b');
 document.write("</br></br>a1.join()：" + a1.join()); //[]
 document.write("</br>a.join()：" + a.join()); //1,2,a,b,3,4,5
 var a2 = a.splice(2, 2, [1, 2], 3);  
 document.write("</br></br>a2.join()：" + a2.join());//a,b
 document.write("</br>a.join()：" + a.join());  //a为1,2,[1,2],3,3,4,5 ;splice会插入数组本身而非数组的元素。

4.7 push()和pop()

把数组当作栈来用，push()方法在数组的尾部添加一个或多个元素，并返回数组新的长度。

pop方法删除数组的最后一个元素，减小数组长度并返回它删除的值。注，两个方法都修改并替换

原始数组而非生成一个修改版的新数组。

 

4.8 unshift()和shift()

unshift()和shift()方法的行为非常类似于push()和pop(),unshift()在数组的头部添加一个或多个元

素，并将已存在的元素移动到更高索引的位置来获得足够的空间，最后返回数组新的长度。shift()删除

数组的第一个元素并将其返回，然后把所有随后的元素下移一个位置来填补数组头部的空缺。

注：当使用多个参数调用unshift()时，参数是一次性插入的（就像splice()方法），而非一次一个的插入

，这意味着数组中插入的元素的顺序和它们在参数列表中的顺序一致。

 

4.9 toString()和toLocaleString()

针对数组，toString()将其每个元素转化为字符串并且输出用逗号分隔的字符串列表。

 

5.ECMAScript5中的数组方法

首先，大多数方法的第一个参数接收一个函数，并且对数组的每个元素调用一次该函数（对稀疏数组

，对不存在的元素不调用传递的函数）。

大多数情况下，调用提供的函数使用三个参数：数组元素，元素的索引和数组本身。

5.1 forEach()

forEach()从头至尾遍历数组，为每个元素调用指定的函数。

 var data = [1, 2, 3, 4, 5];
 data.forEach(function (value, index, data) {
     data[index] = value + 1;
 });
document.write("</br></br>data.join()：" + data.join());

注：forEach()无法在所有元素都传递给调用的函数之前终止遍历。

 

5.2 map()

map()方法将调用的数组的每个元素传递给指定的函数，并返回一个数组，它包含该函数的返回值。

  var data = [1, 2, 3, 4, 5];
  var d = data.map(function (x) {
     return x * x;
 });
  document.write("</br></br>d.join()：" + d.join());

注：map()返回的是新数组，不改变原始数组。

 

5.3 filter()

fliter()方法返回的数组元素是调用的数组的一个子集。传递的函数是用来逻辑判定的：该函数返回true或false。

 var data = [1, 2, 3, 4, 5];
 var d = data.filter(function (x) {
     return x>2;
 });
 document.write("</br></br>d.join()：" + d.join()); //[3,4,5]

5.4 every()和some()

every()和some()方法是数组的逻辑判定：它们对数组元素应用指定的函数进行判定，返回true或false。

 var a = [1, 2, 3, 4, 5];
 var a1 = a.every(function (x) { return x < 10; }); //true
 var a2 =  a.every(function (x) { return x % 2 == 0; });//false
 var a3 = a.some(function (x) { return x % 2 == 0 });//true

注：一旦every和some确定该返回什么值它们就会停止遍历数组元素。

 

5.5 reduce()和reduceRight()

reduce()和reduceRight()方法使用指定的函数将数组元素进行组合，生成单个值。reduce需要两个参数。第一个是执行化简操作的函数，第二个（可选）是一个传递给函数的初始值。

var a = [1, 2, 3, 4, 5];
var sum = a.reduce(function (x, y) { return x + y; }, 0);//数组求和
var product = a.reduce(function (x, y) { return x * y }, 1);//数组求积
var max = a.reduce(function (x, y) { return (x > y) ? x : y; });//求最大值
document.write("</br></br>sum：" + sum);
document.write("</br></br>product：" + product);
document.write("</br></br>max：" + max);

5.6 indexOf()和lastIndexOf()

indexOf()和lastIndexOf()搜索整个数组中具有给定值的元素，返回找到的第一个元素的索引或者如果

没有找到就返回-1。indexOf()从头至尾搜索，而lastIndexOf()则反向搜索。

第一个参数是需要搜索的值。

第二个参数是可选的：它指定数组中的一个索引，从那里开始搜索。如果省略该参数，indexOf()从头开始搜索，而lastIndexOf()从末尾开始搜索。第二个参数也可以是负数，它代表相对数组末尾的偏移量。

 

6.数组去重的方法

       //方法1： indexOf1
      var a = [1, 1, 1, 2, 2, 1, 1, 3, 4, 3, 3, 5];
      Array.prototype.unique1 = function () {
          var temp = [];
          for (var i = 0 ; i < this.length; i++) {
              if (temp.indexOf(this[i]) == -1) {   //若果当前项不在临时数组中
                  temp.push(this[i]);
              }
          }
          return temp;
      };
      document.write("</br></br>unique1:" + a.unique1().join());

       //方法2：indexOf2
      var a = [1, 1, 1, 2, 2, 1, 1, 3, 4, 3, 3, 5];
      Array.prototype.unique2 = function () {
          var temp = [];
          for (var i = 0 ; i < this.length; i++) {
              //如果当前数组的第i项在当前数组中第一次出现的位置不是i，
              //那么表示第i项是重复的，忽略掉。否则存入结果数组
              if (this.indexOf(this[i]) == i) {
                  temp.push(this[i]);
              }
          }
          return temp;
      };
      document.write("</br></br>unique2:" + a.unique2().join());

       //方法3：hash表  空间换时间
      var a = [1, 1, 1, 2, 2, 1, 1, 3, 4, 3, 3, 5];
      Array.prototype.unique3 = function () {
          var r = {}, n = [];
          for (var i = 0; i < this.length; i++) {
              if (!r[this[i]]) { //如果hash表中没有当前项
                  r[this[i]]= true;
                  n.push(this[i]);
              }
          }
          return n;
      };
      document.write("</br></br>unique3:" + a.unique3().join());

       //方法4：sort() 效率最好
      var a = [1, 1, 1, 2, 2, 1, 1, 3, 4, 3, 3, 5];
      Array.prototype.unique4 = function () {
          this.sort();  //将当前数组排序
          var temp = [this[0]];
          for (var i = 0; i < this.length; i++) {
              if (this[i] != temp[temp.length - 1]) { //如果当前项在临时数组中没有出现
                  temp.push(this[i]);
              }
          }
          return temp;
      };
      document.write("</br></br>unique4:" + a.unique4().join());

http://blog.csdn.net/chengxuyuan20100425/article/details/8497277