new Array( ) 使用

引用来自：http://uule.iteye.com/blog/1154009

new Array( )          博客分类：

 

数组有四种定义的方式

使用构造函数： var a = new Array(); var b = new Array(8); var c = new Array("first", "second", "third"); 或者数组直接量： var d = ["first", "second", "third"];

 

属性

Array只有一个属性，就是length，length表示的是数组所占内存空间的数目，而不仅仅是数组中元素的个数

Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( " first " , " second " , " third " )  
  3. a [ 48 ] = " 12 "  
  4. document . write ( a . length )  
  5. //显示的结果是49  
  6. < / script>  
< script >
var a = new Array ( " first " , " second " , " third " )
a [ 48 ] = " 12 "
document . write ( a . length )
//显示的结果是49
< / script>
 数组的length属性是可写的，这是一个非常有意思的属性，我们可以通过这种方法来截取数组
Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( " first " , " second " , " third " )  
  3. delete a [ 1 ]  
  4. document . write ( a . length )  
  5. //显示的结果是3，说明即使删除也无法改变数组的长度  
  6. for(var i in a){  
  7.     alert(a[i]); //剩下first/third  
  8. }  
  9.   
  10. var a = new Array ( " first " , " second " , " third " )  
  11. a . length = 1  
  12. document . write ( a . length )  
  13. //显示的结果是1，说明只剩下一个元素了  
  14. < / script>  
< script >
var a = new Array ( " first " , " second " , " third " )
delete a [ 1 ]
document . write ( a . length )
//显示的结果是3，说明即使删除也无法改变数组的长度
for(var i in a){
	alert(a[i]); //剩下first/third
}

var a = new Array ( " first " , " second " , " third " )
a . length = 1
document . write ( a . length )
//显示的结果是1，说明只剩下一个元素了
< / script>
 
即使删除元素也无法改变数组的长度  但可通过重写数组长度实现元素增减
 

方法

toString()：把数组转换成一个字符串 toLocaleString()：把数组转换成一个字符串 join()：把数组转换成一个用符号连接的字符串 shift()：从数组头部删除一个元素 unshift()：在数组的头部添加若干元素 pop()：从数组尾部删除一个元素 push()：把一个元素添加到数组的尾部 concat()：给数组添加元素 slice()：返回数组的部分 reverse()：将数组反向排序 sort()：对数组进行排序操作 splice()：插入、删除或者替换一个数组元素

 

 

toString() 方法，toLocaleString()方法的作用类似，FF下的作用是完全相同的，IE的话如果元素是字符串，会在“,”后 面加上一个空格，如果元素是数字，会扩展到两位小数，两者都会改变字符串的length属性，所以考虑到兼容性，尽量不要使用 toLocaleString()方法。

Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( 1 , 2 , 3 , [ 4 , 5 , [ 6 , 7 ]])  
  3. var b = a . toString () //b为字符串形式的 "1, 2, 3, 4, 5, 6, 7"  
  4. var c = new Array ( 1 , 2 , 3 , [ 4 , 5 , [ 6 , 7 ]])  
  5. var d = c . toLocaleString () //d为字符串形式的 "1, 2, 3, 4, 5, 6, 7"  
  6. //toString()方法和toLocaleString()方法都可以拆解多维数组  
  7. < / script>  
< script >
var a = new Array ( 1 , 2 , 3 , [ 4 , 5 , [ 6 , 7 ]])
var b = a . toString () //b为字符串形式的 "1, 2, 3, 4, 5, 6, 7"
var c = new Array ( 1 , 2 , 3 , [ 4 , 5 , [ 6 , 7 ]])
var d = c . toLocaleString () //d为字符串形式的 "1, 2, 3, 4, 5, 6, 7"
//toString()方法和toLocaleString()方法都可以拆解多维数组
< / script>
 

join() 方法将数组中的所有元素转换成字符串，然后连接起来，这刚好和String的split()方法是一个相反的操作。join()默认是使用“,”作为分隔符，当然你也可以在方法中指定分隔符

Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( " first " , " second " , " third " )  
  3. var s = a . join ( " ... " )  
  4. document . write ( s )  
  5. //显示的结果是“first...second...third”  
  6. < / script>  
< script >
var a = new Array ( " first " , " second " , " third " )
var s = a . join ( " ... " )
document . write ( s )
//显示的结果是“first...second...third”
< / script>
 

pop() 方法可以从数组尾部 删除若干个元素 ，push() 方法 把一个元素添加到数组的尾部 ，这两个方法刚好是两个相反的操作。两个都是对原来的数组进行操作，但是要注意

push()方法返回的是新的数组的长度 ，

而pop()方法则返回被删去的那个元素 。

Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( 1 , 2 , 3 )  
  3. var b = a . push ( 4 , 5 , [ 6 , 7 ]) //a为[1, 2, 3, 4, 5, [6, 7]]  b为6  注意push()方法不会帮你打开一个数组  
  4. var b = a.push("4,5,[6,7]")     //b为4  
  5. var c = new Array ( 1 , 2 , 3 , 4 , " first " )  
  6. var d = c . pop () //c为[1, 2, 3, 4]  d为字符串形式的"first"  
  7. < / script>  
< script >
var a = new Array ( 1 , 2 , 3 )
var b = a . push ( 4 , 5 , [ 6 , 7 ]) //a为[1, 2, 3, 4, 5, [6, 7]]  b为6  注意push()方法不会帮你打开一个数组
var b = a.push("4,5,[6,7]")     //b为4
var c = new Array ( 1 , 2 , 3 , 4 , " first " )
var d = c . pop () //c为[1, 2, 3, 4]  d为字符串形式的"first"
< / script>
 

shift() 方法可以从数组头部删除一个元素 ，unshift() 方法把若干元素添加到数组的头部 ，这两个方法刚好是两个相反的操作。两个都是对 原来的数组进行操作，但是要注意

unshift()方法返回的是新的数组的长度 ，

而shift()方法则返回被删去的那个元素 。

Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( 1 , 2 , 3 )  
  3. var b = a . unshift ( 4 , 5 , [ 6 , 7 ]) //a为[4, 5, [6, 7], 1, 2, 3]  b为6  注意unshift()方法不会帮你打开一个数组，还有就是被插入数值的顺序  
  4. var c = new Array ( " first " , 1 , 2 , 3 , 4 )  
  5. var d = c . shift () //c为[1, 2, 3, 4]  d为字符串形式的"first"  
  6. < / script>  
< script >
var a = new Array ( 1 , 2 , 3 )
var b = a . unshift ( 4 , 5 , [ 6 , 7 ]) //a为[4, 5, [6, 7], 1, 2, 3]  b为6  注意unshift()方法不会帮你打开一个数组，还有就是被插入数值的顺序
var c = new Array ( " first " , 1 , 2 , 3 , 4 )
var d = c . shift () //c为[1, 2, 3, 4]  d为字符串形式的"first"
< / script>
 

concat() 方法可以返回一个在原有数组上增添了元素的数组，元素用“,”分隔，元素中如果有数组，将被展开并继续添加，但不支持多维数组形式的展开添加

Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( " first " , " second " , " third " )  
  3. s = a . concat ( " fourth " , [ " fifth " , " sixth " ] , [ " seventh " , [ " eighth " , " ninth " ]])  
  4. document . write ( s [ 7 ])  
  5. // 显示的结果是“eighth, ninth”，说明“eighth, ninth”是以数组的形式被添加了进去，此是s的值为["first", "second", "third", "fourth", "fifth", "sixth", "seventh", ["eighth", "ninth"]]  
  6. < / script>  
< script >
var a = new Array ( " first " , " second " , " third " )
s = a . concat ( " fourth " , [ " fifth " , " sixth " ] , [ " seventh " , [ " eighth " , " ninth " ]])
document . write ( s [ 7 ])
// 显示的结果是“eighth, ninth”，说明“eighth, ninth”是以数组的形式被添加了进去，此是s的值为["first", "second", "third", "fourth", "fifth", "sixth", "seventh", ["eighth", "ninth"]]
< / script>
 

slice() 方法返回数组的一个片断，或者说是子数组 。如果只有一个参数，就表示从该处开始一直取到最后，如果参数出现负数，则表示倒数的某个位置。

     stringObj.slice(start, [end])
如果省略 end ，那么 slice 方法将一直复制到 arrayObj 的结尾。 否则一直复制到 end 所指定的元素，但是不包括 该元素 。
str1.slice(0,-1) // -1 指向 str1 中的最后一个字符

Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( 1 , 2 , 3 , 4 , 5 )  
  3. var b = a . slice ( 3 )   //b为[4, 5]  
  4. var c = a . slice ( - 3 ) //c为[3, 4, 5]  
  5. var d = a . slice ( 1 ,- 1 ) //d为[2, 3, 4]  
  6. var e = a . slice ( - 3 ,- 1 ) //e为[3, 4]  
  7. < / script>  
< script >
var a = new Array ( 1 , 2 , 3 , 4 , 5 )
var b = a . slice ( 3 )   //b为[4, 5]
var c = a . slice ( - 3 ) //c为[3, 4, 5]
var d = a . slice ( 1 ,- 1 ) //d为[2, 3, 4]
var e = a . slice ( - 3 ,- 1 ) //e为[3, 4]
< / script>
 

reverse() 方法将数组反向排序，他并不创建和返回一个新的数组，而是在原有的数组上进行操作

Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( " first " , " second " , " third " )  
  3. a . reverse ()  
  4. document . write ( a )  
  5. //显示的结果是“third,second,first”，这时候数组的顺序已经颠倒了  
  6. < / script>  
< script >
var a = new Array ( " first " , " second " , " third " )
a . reverse ()
document . write ( a )
//显示的结果是“third,second,first”，这时候数组的顺序已经颠倒了
< / script>
 

sort() 方法的作用是对数组进行排序，

  sort()方法的参数是一个有两个参数，并且有返回值的函数 ，

     a. 如果返回的值大于零，则说明前一个参数比后一个参数大，

     b. 等于零则相等，

     c.小于零说明前一个参数比后一个小，而相对小的那个参数将出现在排序的前列。 sort()方法直接在数组上进行操作，同时也返回值，但是两者似乎是等价的。sort()方法默认是用字母的顺序进行排序

Java代码 复制代码 收藏代码
  1. <script type="text/javascript">  
  2. function AscSort(x, y) {  
  3.   return x == y ? 0 : (x > y ? 1 : -1);  
  4. }  
  5. function DescSort(x, y) {  
  6.   return x == y ? 0 : (x > y ? -1 : 1);  
  7. }  
  8. function RandomSort(x, y) {  
  9.   return Math.floor(Math.random() * 2 - 1 );  
  10. }  
  11. var array = [2,4,3,5,1,6,9,0,8];  
  12. document.write("<p>正序：" + array.sort(AscSort) + "</p>");  
  13. document.write("<p>倒序：" + array.sort(DescSort) + "</p>");  
  14. document.write("<p>随机排序：" + array.sort(RandomSort) + "</p>");  
  15. </script>  
<script type="text/javascript">
function AscSort(x, y) {
  return x == y ? 0 : (x > y ? 1 : -1);
}
function DescSort(x, y) {
  return x == y ? 0 : (x > y ? -1 : 1);
}
function RandomSort(x, y) {
  return Math.floor(Math.random() * 2 - 1 );
}
var array = [2,4,3,5,1,6,9,0,8];
document.write("<p>正序：" + array.sort(AscSort) + "</p>");
document.write("<p>倒序：" + array.sort(DescSort) + "</p>");
document.write("<p>随机排序：" + array.sort(RandomSort) + "</p>");
</script>
 

splice() 方法的作用是插入、删除或者替换一个数组元素，他不光会在原有的数组上进行修改，还会返回被处理掉的内容，因此这是一个功能强大，但是不容易使用的方法，splice()方法用前两个参数进行定位，余下的参数表示插入部分。

Java代码 复制代码 收藏代码
  1. < script >  
  2. var a = new Array ( 1 , 2 , 3 , 4 , 5 )  
  3. var b = a . splice ( 2 ) //a为[1, 2]  b为[3, 4, 5]  
  4. var c = new Array ( 1 , 2 , 3 , 4 , 5 )  
  5. var d = c . splice ( 2 , 2 ) //c为[1, 2, 5]  d为[3, 4]  
  6. var e = new Array ( 1 , 2 , 3 , 4 , 5 )  
  7. var f = f . splice ( - 4 , 2 ) //e为[1, 4, 5]  f为[2, 3]  
  8. var g = new Array ( 1 , 2 , 3 , 4 , 5 )  
  9. var h = g . splice ( - 2 ,- 2 ) //第二个参数表示长度，因此负数在此无效  
  10.    
  11. var i = new Array ( 1 , 2 , 3 , 4 , 5 )  
  12. var j = i . splice ( 2 , 2 , " first " , " second " , " third " ) //i为[1, 2, "first", "second", "third", 5]  j为[3, 4]  后面部分会自动前后移动，以保持数组的连续性  
  13. var k = new Array ( 1 , 2 , 3 , 4 , 5 )  
  14. var l = k . splice ( 2 , 2 , [ " first " , " second " ] , " third " ) //k为[1, 2, ["first", "second"], "third", 5]  l为[3, 4]  splice()方法不会展开数组，只直接写入  
  15. < / script>  
< script >
var a = new Array ( 1 , 2 , 3 , 4 , 5 )
var b = a . splice ( 2 ) //a为[1, 2]  b为[3, 4, 5]
var c = new Array ( 1 , 2 , 3 , 4 , 5 )
var d = c . splice ( 2 , 2 ) //c为[1, 2, 5]  d为[3, 4]
var e = new Array ( 1 , 2 , 3 , 4 , 5 )
var f = f . splice ( - 4 , 2 ) //e为[1, 4, 5]  f为[2, 3]
var g = new Array ( 1 , 2 , 3 , 4 , 5 )
var h = g . splice ( - 2 ,- 2 ) //第二个参数表示长度，因此负数在此无效
 
var i = new Array ( 1 , 2 , 3 , 4 , 5 )
var j = i . splice ( 2 , 2 , " first " , " second " , " third " ) //i为[1, 2, "first", "second", "third", 5]  j为[3, 4]  后面部分会自动前后移动，以保持数组的连续性
var k = new Array ( 1 , 2 , 3 , 4 , 5 )
var l = k . splice ( 2 , 2 , [ " first " , " second " ] , " third " ) //k为[1, 2, ["first", "second"], "third", 5]  l为[3, 4]  splice()方法不会展开数组，只直接写入
< / script>
 
来源：http://blog.csdn.net/zi_jin/article/details/3907905
 
 
Java代码 复制代码 收藏代码
  1. var arr = [2,4,6,7];  
  2.       Array.prototype.remove = function(from,to){  
  3.         var ret = arr.slice((to || from) + 1 || this.length);  
  4.         this.length = from<0 ? this.length + from : from;  
  5.         alert(ret+"  "+this.length);  
  6.         return this.push.apply(this,ret);  
  7.       }  
  8.       
  9.       //arr.remove(1);  
  10.       //此时ret = [6,7]  
  11.       //this.length = 1; 此时arr为[2]  
  12.       //最后apply，arr为[2,6,7]  
  13.         
  14.           
  15.       arr.remove(1,2);  
  16.       //此时ret = [7]  
  17.       //this.length = 1,此时arr为[2]  
  18.       //最后arr = [2,7]  
  19.       //alert(arr);  
var arr = [2,4,6,7];
      Array.prototype.remove = function(from,to){
      	var ret = arr.slice((to || from) + 1 || this.length);
      	this.length = from<0 ? this.length + from : from;
      	alert(ret+"  "+this.length);
      	return this.push.apply(this,ret);
      }
    
      //arr.remove(1);
      //此时ret = [6,7]
      //this.length = 1; 此时arr为[2]
      //最后apply，arr为[2,6,7]
      
        
      arr.remove(1,2);
      //此时ret = [7]
      //this.length = 1,此时arr为[2]
      //最后arr = [2,7]
      //alert(arr);
 .

JavaScript中清空数组的三种方式

方式1，splice

 

Js代码  收藏代码
  1. var ary = [1,2,3,4];  
  2. ary.splice(0,ary.length);  
  3. console.log(ary); // 输出 []，空数组，即被清空了  
 

方式2，length赋值为0
这种方式很有意思，其它语言如Java，其数组的length是只读的，不能被赋值。如

Java代码  收藏代码
  1. int[] ary = {1,2,3,4};  
  2. ary.length = 0;  

 

Java中会报错，编译通不过。
而JS中则可以，且将数组清空了，如

Js代码  收藏代码
  1. var ary = [1,2,3,4];  
  2. ary.length = 0;  
  3. console.log(ary); // 输出 []，空数组，即被清空了  

 

目前 Prototype中数组的 clear 方法和mootools库中数组的 empty 方法使用这种方式清空数组。

方式3，赋值为[]

 

Js代码  收藏代码
  1. var ary = [1,2,3,4];  
  2. ary = []; // 赋值为一个空数组以达到清空原数组  

 

Ext库Ext.CompositeElementLite类的 clear 方法使用这种方式清空。

 

方式2 保留了数组其它属性，方式3 则未保留。

 

很多人认为方式2的效率很高些，因为仅仅是给length重新赋值了，而方式3则重新建立个对象。经 测试 恰恰是方式3的效率高。测试代码：

 

Js代码  收藏代码
  1. var a = [];  
  2. for (var i=0; i< 1000000; i++){  
  3.     a.push(i);  
  4. }  
  5. var start = new Date();  
  6. //a = [];  
  7. a.length = 0;  
  8. var end = new Date();  
  9. alert(end - start);  
 

测试结果：

  IE6 IE7 IE8 IE9 Firefox Safari Chrome
a.length=0 94 29 14 1 4 3 1
a=[] 0 0 0 0 0 0 0

 

 

JavaScript中清空数组的三种方式

posted @ 2016-01-26 14:10  iDennis  阅读(5185)  评论(0)  编辑  收藏  举报