javascript数组特性

　　数组是一段线性分配的内存, 它经过整数计算偏移并访问其中的元素. 数组是一种性能出色的数据结构.

1.数组字面量

　　数组字面量提供了一种很是方便地建立新数组的表示法. 多个用逗号分隔的值的表达式. 数组字面量容许出如今任何表达式能够出现的地方. 数组的第一个值将得到属性名'0', 第二个值将得到属性名'1', 以此类推:

 1             var empty = [];
 2             var numbers = [ 3 'zero', 'one', 'two', 'three', 'four', 4 'five', 'six', 'seven', 'eight', 'nine' 5  ]; 6 7 console.log(empty[1]); // undefined 8 console.log(numbers[1]);// 'one' 9 10 console.log(empty.length);// 0 11 console.log(numbers.length);// 10

　　对象字面量:

 1             var numbers_object = {
 2                 '0': 'zero', 3 '1': 'one', 4 '2': 'two', 5 '3': 'three', 6 '4': 'four', 7 '5': 'five', 8 '6': 'six', 9 '7': 'serven', 10 '8': 'eight', 11 '9': 'nine' 12 };

　　二者产生的结果类似, numbers和numbers_object都是包含10个属性的对象, 而且那些属性恰好有相同的名字和值. 可是他们也有一些显著的不一样, numbers继承自Array.prototype, 而numbers_object继承自Object.prototype, 因此numbers继承了大量有用的方法. 同时, numbers也有一个诡异的length属性, 而numbers_object则没有.

 　　在大多数语言中, 一个数组全部元素都要求是相同的类型. JavaScript容许数组里包含任意混合类型的值:

1                 var misc = [
2                     'string', 98.6, true, false, null, undefined, 3 ['nested', 'array'], {object: true}, NaN, 4  Infinity 5  ]; 6 7 console.log(misc.length);// 10

 　　在JavaScript中, 中括号[]表示一个数组, 也能够理解为数组对象; 花括号{}表示一个对象, []和{}一块儿使用, 能够造成一个对象数组, 如以上示例所示.

 

2.长度

　　每一个数字都有一个length属性, 和大多数其余语言不一样, JavaScript数组的length是没有上界的. 若是你用大于或等于当前length的数字做为下标来存储一个元素, 那么length值会被增大以容纳新元素, 不会发生数组越界错误.

　　length属性的值是这个数组的最大整数属性名加上1, 它不必定等于数组里的属性的个数:

1                 var myArray = [];
2                 console.log(myArray.length);// 0
3                 
4                 myArray[1000000] = true; 5 console.log(myArray.length);// 10000001 6 // myArray只包含一个属性

　　[]后置下标运算符把它所含的表达式转换成一个字符串, 若是该表达式有toString方法, 就使用该方法的值. 这个字符串被将用做属性名. 若是这个字符串看起来像一个大于等于这个这个数组当前的length且小于4294967295的正整数, 那么这个数组的length会被从新设置为新的下标加1, 不然length值为这个数组的长度.

 

3.删除

　　因为JavaScript的数组其实就是对象, 因此delete运算符能够用来从数组中移除元素:

1                 var numbers = ['zero', 'noe', undefined, 'shi', 'go'];
2                 delete numbers[2]; 3 console.log(numbers.length);// 5

　　不幸的是, 那样会在数组中留下一个空间. 这是由于排在被删除元素以后的元素保留着它们最初的属性. 而你一般想要的是递减后面每一个元素的属性.

　　幸运的是, JavaScript数组有一个splice方法. 它能够对数组作个手术, 删除一些元素并将它们替换为其余的元素. 第1个参数是数组中的一个序号, 第2个参数是要删除的元素个数. 任何额外的参数会在序号那个点的位置被插入到数组中:

1                 var numbers = ['zero', 'noe', undefined, 'shi', 'go'];
2                 numbers.splice(2, 1); 3 console.log(numbers.length);// 4

　　值为'shi'的属性的键值从'3'变到'2'. 由于被删除属性后面的每一个属性必须被移除, 而且以一个新的键值从新插入, 这对于大型数组来讲可能会效率不高.

 

4.容易混淆的地方

　　在JavaScript编程中, 一个常见的错误是在必须使用数组时使用了对象, 或者在必须使用对象时使用了数组. 其实规则很简单: 当属性名是小而连续的整数时, 你应该使用数组. 不然, 使用对象.

　　JavaScript自己对于数组和对象的区别是混乱的. typeof运算符报告数组的类型是'object', 这没有任何意义, JavaScript没有一个好的机制来区别数组和对象, 咱们能够经过定义本身的is_array函数来弥补这个缺陷:

 1                 var array = [
 2                     'zero', 'one'
 3  ]; 4 5 var obj = { 6 '0': 'zero', 7 '1': 'one' 8  }; 9 10 var is_array = function (value) { 11 return Object.prototype.toString.apply(value) === '[object Array]'; 12  }; 13 14 console.log(is_array(array));// true 15 console.log(is_array(obj));// false

 

5.方法

　　JavaScript提供了一套数组可用的方法. 这些方法是被储存在Array.prototype中的函数, Object.prototype和Array.prototype是能够被扩充的, 举例来讲, 假设咱们想要给array增长一个方法, 它容许咱们队数组进行计算:

 1                 //经过给Function.prototype增长方法来使得该方法对全部函数可用
 2                 Function.prototype.method = function (name, func) {
 3                     this.prototype[name] = func; 4 return this; 5  }; 6 7 Array.method('reduce', function (f, value) { 8 var i; 9 for (i = 0; i < this.length; i++) { 10 value = f(this[i], value); 11  } 12 return value; 13 });

　　经过给Array.prototype扩充了一个函数, 每一个数组都继承了这个方法. 在这个例子里, 咱们定义了一个reduce方法, 它接受一个函数和一个初始值做为参数,. 它便利这个数组, 以当前元素和该初始值为参数调用这个函数, 而且计算出一个新值. 当完成时, 它返回这个新值.

若是咱们传入一个把两个数字相加的函数, 它会计算出相加的和. 若是咱们传入把两个数组相乘的函数, 它会计算二者的乘积:

 1                 // 建立一个数组数组
 2                 var data = [4, 8, 15, 16, 23, 42];
 3                  
 4                 // 定义两个简单的函数, 一个是把两个数字相加, 另外一个是把两个数字相乘.
 5                 var add = function (a, b) { 6 return a + b; 7  }; 8 9 var mult = function (a, b) { 10 return a * b; 11  }; 12 13 // 调用data的reduce方法, 传入add函数. 14 var sum = data.reduce(add, 0); 15 console.log(sum);// 108 16 17 // 再次调用reduce方法, 此次传入mult函数 18 var product = data.reduce(mult, 1); 19 console.log(product);// 7418880 20 21 // 由于数组其实就是对象, 因此咱们能够直接给一个单独的数组添加方法: 22 data.total = function () { 23 return this.reduce(add, 0); 24  }; 25 26 console.log(data.total());// 108

 　　

6.指定初始值

　　JavaScript的数组一般不会预置值. 若是你用[]获得一个新数组, 它将是空的. 若是你访问一个不存在的元素, 获得的值则是undefined. 若是你知道这个问题, 或者你在尝试获取每一个元素以前都颇有预见性地设置他的值, 那就万事大吉了. 可是, 若是你实现的算法是假设每一个元素都从一个已知的值开始(例如0), 那么你必须本身准备好这个数组. JavaScript应该提供一些相似Array.dim这样的方法来作这件事情, 但咱们能够很容易纠正这个疏忽:

 1                 Array.dim = function (dimension, initial) {
 2                     var a = [], i; 3 for (i = 0; i < dimension; i++) { 4 a[i] = initial; 5  } 6 return a; 7  }; 8 9 // 建立一个包含10个0的数组 10 var myArray = Array.dim(10, 0);

　　JavaScript没有多维数组, 但就像大多数类C语言同样, 它支持元素为数组的数组:

1                 var matrix = [
2                     [0, 1, 2], 3 [3, 4, 5], 4 [6, 7, 8] 5  ]; 6 7 console.log(matrix[2] [1]);// 7

　　JavaScript对矩阵也提供了更好的支持:

 1                 Array.matrix = function (m, n, initial) {
 2                     var a, i, j, mat = []; 3 for (i = 0; i < m; i++) { 4 a = []; 5 for (j = 0; j < n; j++) { 6 a[j] = initial; 7  } 8 mat[i] = a; 9  } 10 return mat; 11  }; 12 13 // 构造一个用0填充的4 * 4矩阵 14 var myMatrix = Array.matrix(4, 4, 0); 15  console.log(myMatrix); 16 console.log(myMatrix[3] [3]);// 0

　　用0填充的4 * 4矩阵:

 

 1                 // 用来构造一个单位矩阵的方法
 2                 Array.identity = function (n) {
 3                     var i, mat = Array.matrix(n, n, 0); 4 for (i = 0; i < n; i++) { 5 mat[i] [i] = 1; 6  } 7 return mat; 8  }; 9 10 myMatrix = Array.identity(4); 11  console.log(myMatrix); 12 13 console.log(myMatrix[3] [3]);// 1

　　单位矩阵: