网站首页 | 工作总结 | 工作报告 | 工作计划 | 演讲稿 | 自我鉴定 | 思想汇报 | 心得体会 | 书信范文 | 职场知识 | 作文大全 | 述职报告 | 读后感
一起看范文网

javascript数组

第一篇:javascript数组

Javascript 数组及其操作 1.如何创建数组 2.如何对数组进行操作(添加,删除,读取) 3.数组常见方法和属性 如何创建一个数组,一般地根据初始化设定简单分为 3 种

1.单纯创建数组

var arr=new Array(); 要点:用 new 关键字创建数组对象 Array(),Array()对象是一个本地类,可以用 new 创建一个对象后使用 2.创建数组的同时规定数组大小

var arr=new Array(10);//这里就创建了一个初始化大小为 10 的数组 注意:当使用数组大小操作初始化大小时,数组会自动被撑大,不会像 C 语言那样发 生错误.动态增长是 js 数组的一个性质.另外,js 中支持最大数组长度为 4294967295 3.直接初始化

var arr=new Array("love","hate","pain");//这里就直接初始化了数组 或 var arr=["happy","cute","scare"];//括号也可以声明一个数组对象 当然,类似 C 语言,可以定义 2 维 3 维和多维的数组,例如

<script language=Javascript> var myArray = new Array(); for(var i=0;i<10;i++ )...{ myArray[i]=new Array(); myArray[i][0]=Math.floor(Math.random()*10); myArray[i][1]=Math.floor(Math.random()*10); myArray[i][2]=Math.floor(Math.random()*10); myArray[i][3]=Math.floor(Math.random()*10); myArray[i][4]=Math.floor(Math.random()*10); myArray[i][5]=Math.floor(Math.random()*10); myArray[i][6]=Math.floor(Math.random()*10); myArray[i][7]=Math.floor(Math.random()*10); myArray[i][8]=Math.floor(Math.random()*10); } myArray.sort( function(x, y) ...{ return (x[0]==y[0])?((x[4]==y[4])?(x[8]-y[8]):(x[4]-y[4])):(x[2]-y[2]) }); for(var i=0;i<myArray.length;i++ )...{ document.write(myArray[i].join(",") + "<br/>"); } </script> 数组的属性:length arr.length 返回数组 arr 的长度,常见于循环中对数组的遍历,比如

for(var i=0;i<arr.length;i++){ 执行部分 } 数组元素的访问

arr[index],其中 index 表示索引即数组基数,从 0 开始,共有 arr.length 个元素.比如

arr[0]访问第一个数组元素,arr[1]访问第二个数组元 素....依次类推 数组的操作方法:先概览下下面的这些操作数组常用的方法(13 个) toString(),valueOf(),toLocalString(),join(),split(),slice(),concat(), pop(),push(),shift(),unshift(),sort(),splice() 下面逐一分析这些方法的功能和用法. toString(),valueOf(),toLocalString()

功能:返回数组的全部元素 注:数组名也可以返回整个数组 代码

var m=["am","bm","cm"];//用括号声明一个数组对象 alert(m.toString());//toString()返回数组对象的所有内容,用逗号分割,即 am,bm,cm alert(m.valueOf());//valueOf()也返回数组对象的所有内容 alert(m.toLocaleString());//toLocaleString()也返回数组对象的所有内容, 但有地区语言区别,暂不研究 alert(m);//数组名也返回数组对象的所有内容 join()

功能:把数组各个项用某个字符(串)连接起来,但并不修改原来的数组 代码: var m=["am","bm","cm"];//用括号声明一个数组对象 var n=m.join("---");//用---连接 am,bm,cm. alert(m.toString());//m 并没有被修改,返回 am,bm,cm alert(n);//n 是一个字符串,为 am---bm---cm split()

功能:把一个字符串按某个字符(串)分割成一个数组,但不修改原字符串 代码

var str="I love maomao,I am caolvchong"; var arr=str.split("o");//按字符 o 把 str 字符串分割成一个数组 alert(arr);//输出整个数组 slice():返回某个位置开始(到某个位置结束)的数组部分,不修改原数组 代码

var m=["am","bm","cm","dm","em","fm"]; var n=m.slice(2);//返回第二个元素 bm 后面的元素,即 cm,dm,em,fm var q=m.slice(2,5);//返回第二个元素后到第五个元素,即 cm,dm,em alert(n); alert(q); 数组对象的栈操作

push():数组末尾添加一个项 pop():删除数组最后一个项 代码

var m=["am","bm","cm","dm","em","fm"]; m.push("gm");//在数组末尾添加元素 gm alert(m); m.pop();//删除数组最后一个元素 gm alert(m); 数组对象的队列操作

unshift():数组头添加一个项 shift():删除数组第一个项 代码: var m=["am","bm","cm","dm","em","fm"]; m.unshift("gm");//在数组第一个元素位置添加元素 gm alert(m); m.shift();//删除数组第一个元素 gm alert(m); sort():数组按字符的 ASCII 码进行排序,修改数组对象 注:即便是数字数组,也将转化为字符串来进行比较排序 代码

var m=["am","fm","gm","bm","em","dm"]; m.sort();//按字母序排序 alert(m); concat():在数组尾添加元素,但不修改数组对象 代码

var m=["am","bm"] var n=m.concat("cm");//添加一项 cm,并且赋予新数组对象 alert(m);//原数组没有被修改 alert(n);//输出新数组对象 splice():在数组的任意位置进行添加,删除或者替换元素,直接修改数组对象 细节

splice()有三个参数或三个以上参数,前两个是必须的,后面参数是可选的 进行添加:splice(起始项,0,添加项) 进行删除:splice(起始项,要删除的项个数) 进行替换:splice(起始项,替换个数,替换项) 这个其实是添加删除的共同结果 代码

var m=["am","bm"] m.splice(1,0,"fm","sm");//在第一项后面添加 fm 和 sm,返回 am,fm,sm,bm alert(m); m.splice(2,1);//删除第二项后面一项(即第三项 sm,返回 am,fm,bm) alert(m); m.splice(2,1,"mm");//替换第二项后面一项(即第三项,返回 am,fm,mm) alert(m); JavaScript 数组操作函数 join(delimiter)

把数组中各个元素使用分隔符(delimiter)拼成字符串 concat(array1, array2, ...)

合并数组,对原数组不影响,只是返回合并后的新 数组 pop()

删除并返回最后一个元素 push(element1, element2, ...)

在数组末尾追加元素 shift()

删除并返回第一个元素 unshift(element1, element2, ...)

在数组开始位置添加元素 reverse()

将数组元素顺序首尾反转 sort(function)

给数组排序 如果不给参数,默认按字符排序(所有元素是数字也不会按数字排序的) 参数必须是一个函数,类似 function(a, b) {},在函数中判断 a, b 的大小, a>b 返回正数,a<b 返回负数,a=b 返回 0 slice(start, end)

返回一个新的数组,将 start 开始,到 end 结束(不包括 end) 之间的元素复制到新数组中 splice(start, count, replaceElement1, replaceElement2, ...)

删除或者替换 数组元素,从 start 开始,对 count 个元素进行删除或替换 如果提供 replaceElement 参数则进行替换, 否则进行删除操作, 被替换的元素 个数和 replaceElements 的个数不必相等 返回一个数组,包含被删除或替换掉的元素 判断是否数组的方法 var arrayVar = ["aaa", "bbb", "ccc"]; var nonArrayVar = { length:4, otherAttribute:"attr" }; document.write(arrayVar.constructor==Array); document.write("<br />"); document.write(nonArrayVar.constructor==Array); 结果是 true, false grep、map Perl 语言带出来的东西,jQuery 实现 selector 时用了这种方式 grep 对数组的 grep 操作,指类似这样的代码

Array newArray = grep(condition, oldArray),这个操作将对 oldArray 数组的每 个元素进行遍历,如果当前处理元素符合条件 condition,则加入到返回数组中 jQuery 中的 grep 类似这样

function( elems, callback), elems 是 DOM 元素集合, callback 是实现 selector 的一些表达式函数,如果 callback 返回 true 则表明当 前处理的元素符合 selector 表达式 map 与 grep 不同的是,map 不进行条件判断,只是对数组中每个元素执行指定的操作, 就是将一个循环过程进行改装 喜欢动态语言风格的,可以给数组加个 grep 和 map 方法,例如

Array.prototype.grep = function(condition, operation, inverse){ if(arguments.length<1) return []; var tester; if( typeof condition=="function" ) tester=condition; else if( condition.constructor==RegExp ) tester = function(e, i) { return condition.test(e); }; else if( typeof condition=="string" ) try{ tester = eval_r( "false||function(e, i){ return " + condition + "; }" ); }catch(e) { } else tester = function(e, i) { return false; }; if(!tester) return []; var command; if( typeof operation=="function" ) command=operation; else if(typeof operation=="string") try{ command = eval_r( "false||function(e, i){ " + operation + "; return e; }" ); }catch(e) { } if(typeof command!="function") command=function(e, i) { return e; }; var result = [], match, t; for(var i=0; i<this.length; i++){ match = tester(this[i], i); if(match) t = command(this[i], i); if(match && !inverse && t!=null) t.constructor==Array ? result.concat(t)

result.push(t); else if(!match && inverse) result.push(this[i]); } return result; }; Array.prototype.map = function(callback){ if(!callback || typeof callback!="function") return this; for(var i=0; i<this.length; i++) callback( this[i], i); return this; };使用示例

var oldArray = [ 2, 7, 8, 5, 1, 9, 2, 6, 0 ]; var newArray1 = oldArray.grep("i%2==0"); //返回索引为偶数的所有元素 var newArray2 = oldArray.grep("e%2==1"); //返回数组元素的值为奇数的所有元 素 document.write(newArray1 + "<br />"); //2,8,1,2,0 document.write(newArray2 + "<br />"); //7,5,1,9 oldArray = [ "aa", "bbbb", "abcdefg", "ccccc", "111121111", "999999999" ]; var newArray3 = oldArray.grep(/(\w)\1{4,}/); document.write(newArray3 + "<br />"); //ccccc,999999999 典型 jQuery 风格的 代码

var obj = document.createElement_x("ul"); obj.innerHTML = '<li>AAAAAA</li> <li style="display

none;">BBBBBB</li> <li>CCCCCC</li> <li>DDDDDD</li>'; document.body.appendChild(obj); window.setInterval(function(){ //把 NodeList 转换成数组 var liList = obj.getElementsByTagName_r("li"); var liArray = []; for(var i=0; i<liList.length; i++) liArray.push( liList[i] ); //示例 grep 的使用 liArray .grep('e.style["display"]=="none"', 'e.style["display"] = "";', true) .map(function(e, i){ e.style["display"] = "none"; }); }, 1500);

第一篇:javascript数组

Javascript 数组操作整理 Array 对象属性 属性 描述 返回对创建此对象的数组函数的引用。 FF 1 1 1 IE 4 4 4 4 4 constructor index input length prototype 设置或返回数组中元素的数目。

使您有能力向对象添加属性和方法。 1 1 1.1 length 说明:Length 属性表示数组的长度,即其中元素的个数。因为数组的索引总是由 0 开 始, 所以一个数组的上下限分别是

和 length-1。

0 和其他大多数语言不同的是, JavaScript 数组的 length 属性是可变的,这一点需要特别注意。当 length 属性被设置得更大时,整个 数组的状态事实上不会发生变化, 仅仅是 length 属性变大; length 属性被设置得比原来 当 小时,则原先数组中索引大于或等于 length 的元素的值全部被丢失。

下面是演示改变 length 属性的例子

var arr=[12,23,5,3,25,98,76,54,56,76];//定义了一个包含 10 个数字的数组 alert(arr.length); //显示数组的长度 10 arr.length=12; //增大数组的长度 alert(arr.length); //显示数组的长度已经变为 12 alert(arr[8]); //显示第 9 个元素的值,为 56 arr.length=5; //将数组的长度减少到 5,索引等于或超过 5 的元素被丢弃 alert(arr[8]); //显示第 9 个元素已经变为"undefined" arr.length=10; //将数组长度恢复为 10 alert(arr[8]); //虽然长度被恢复为 10, 但第 9 个元素却无法收回, 显示"undefined" 由上面的代码我们可以清楚的看到 length 属性的性质。

length 对象不仅可以显式的 但 设置,它也有可能被隐式修改。JavaScript 中可以使用一个未声明过的变量,同样,也可 以使用一个未定义的数组元素(指索引超过或等于 length 的元素) ,这时,length 属性的 值将被设置为所使用元素索引的值加 1。

例如下面的代码

var arr=[12,23,5,3,25,98,76,54,56,76];//定义了一个包含 10 个数字的数组 alert(arr.length);// 显示 10 arr[15]=34; alert(arr.length);//显示 16 代码中同样是先定义了一个包含 10 个数字的数组,通过 alert 语句可以看出其长度为 10。随后使用了索引为 15 的元素,将其赋值为 15,即 arr[15]=34,这时再用 alert 语句 输出数组的长度,得到的是 16。无论如何,对于习惯于强类型编程的开发人员来说,这是 一个很令人惊讶的特性。事实上,使用 new Array()形式创建的数组,其初始长度就是为 0, 正是对其中未定义元素的操作,才使数组的长度发生变化。

由上面的介绍可以看到,length 属性是如此的神奇,利用它可以方便的增加或者减少 数组的容量。因此对 length 属性的深入了解,有助于在开发过程中灵活运用。 1.2 prototype 说明:prototype 是在 IE 4 及其以后版本引入的一个针对于某一类的对象的方法, 而且特殊的地方便在于

它是一个给类的对象添加方法的方法! 这一点可能听起来会有点乱, 别急,下面我便通过实例对这一特殊的方法作已下讲解

首先,我们要先了解一下类的概念,JavaScript 本身是一种面向对象的语言,它所涉 及的元素根据其属性的不同都依附于某一个特定的类。我们所常见的类包括:数组变量 (Array)、 逻辑变量 (Boolean)、 日期变量(Date)、 结构变量(Function)、 数值变量(Number)、 对象变量(Object)、字符串变量 (String) 等,而相关的类的方法,也是程序员经常用到的 (在这里要区分一下类的注意和属性发方法)例如数组的 push 方法、 , 日期的 get 系列方法、 字符串的 split 方法等等, 但是在实际的编程过程中不知道有没有感觉到现有方法的不足?prototype 方法应运 而生!下面,将通过实例由浅入深讲解 prototype 的具体使用方法

1、最简单的例子,了解 prototype

(1) Number.add(num)

作用,数字相加 实现方法

Number.prototype.add = function(num){return(this+num);} 试验:alert((3).add(15)) -> 显示 18 (2) Boolean.rev()

作用,布尔变量取反 实现方法

Boolean.prototype.rev = function(){return(!this);} 试验:alert((true).rev()) -> 显示 false 是不是很简单?这一节仅仅是告诉读者又这么一种方法,这种方法是这样运用的。

2、已有方法的实现和增强,初识 prototype

(1) Array.push(new_element) 作用:在数组末尾加入一个新的元素 实现方法: Array.prototype.push = function(new_element){ this[this.length]=new_element; return this.length; } 让我们进一步来增强他,让他可以一次增加多个元素! 实现方法

Array.prototype.pushPro = function(arguments) { var currentLength = this.length; for (var i = 0; i < arguments.length; i++) { this[currentLength + i] = arguments[i]; } return this.length; } (2)javascript 中无法通过一个索引去移除一个无素.通过对 ARRAY 的扩展.实现了对 javascript Array 对象通过索引移除数组中的一个元素. 让我们来实现他! 实现方法

Array.prototype.remove=function(index) { if(isNaN(index)|| index >this.length){return false;} for(var i=0,n=0;i<this.length;i++) { if(this[i]!=this[index]) { this[n++]=this[i] } } this.length-=1 } (3) String.length 作用:这实际上是 String 类的一个属性,但是由于 JavaScript 将全角、半角均视为 是一个字符,在一些实际运用中可能会造成一定的问题,现在我们通过 prototype 来弥补 这部不足。

实现方法

String.prototype.cnLength = function(){ var arr=this.match(/[^\x00-\xff]/ig); return this.length+(arr==null?0:arr.length); } 试验

alert("EaseWe 空间 Spaces".cnLength()) -> 显示 16 这里用到了一些正则表达式的方法和全角字符的编码原理, 由于属于另两个比较大的类 别,本文不加说明,请参考相关材料。

3、新功能的实现,深入 prototype:在实际编程中所用到的肯定不只是已有方法的增强, 更多的实行的功能的要求,下面我就举两个用 prototype 解决实际问题的例子

(1) String.left() 问题:用过 vb 的应该都知道 left 函数,从字符串左边取 n 个字符,但是不足是将全 角、半角均视为是一个字符,造成在中英文混排的版面中不能截取等长的字符串 作用:从字符串左边截取 n 个字符,并支持全角半角字符的区分 实现方法

String.prototype.left = function(num,mode){ if(!/\d+/.test(num))return(this); var str = this.substr(0,num); if(!mode) return str; var n = str.Tlength() - str.length; num = num - parseInt(n/2); return this.substr(0,num); } 试验

alert("EaseWe 空间 Spaces".left(8)) -> 显示 EaseWe 空间 alert("EaseWe 空间 Spaces".left(8,true)) -> 显示 EaseWe 空 本方法用到了上面所提到的 String.Tlength()方法, 自定义方法之间也能组合出一些 不错的新方法呀! (2) Date.DayDiff() 作用:计算出两个日期型变量的间隔时间(年、月、日、周) 实现方法

Date.prototype.DayDiff = function(cDate,mode){ try{ cDate.getYear(); }catch(e){ return(0); } var base =60*60*24*1000; var result = Math.abs(this - cDate); switch(mode){ case "y"

result/=base*365; break; case "m"

result/=base*365/12; break; case "w"

result/=base*7; break; default

result/=base; break; } return(Math.floor(result)); } 试验

alert((new Date()).DayDiff((new Date(2002,0,1)))) -> 显示 329 alert((new Date()).DayDiff((new Date(2002,0,1)),"m")) -> 显示 10 当然,也可以进一步扩充,得出响应的小时、分钟,甚至是秒。

(3) Number.fact() 作用:某一数字的阶乘 实现方法

Number.prototype.fact=function(){ var num = Math.floor(this); if(num<0)return NaN; if(num==0 || num==1) return 1; else return (num*(num-1).fact()); } 试验

alert((4).fact()) -> 显示 24 这个方法主要是说明了递归的方法在 prototype 方法中也是可行的! 1.3 Constructor 说明:表示创建对象的函数。始终指向创建当前对象的构造函数。

比如下面例子

// 等价于 var foo = new Array(1, 56, 34, 12); var arr = [1, 56, 34, 12]; console.log(arr.constructor === Array); // true // 等价于 var foo = new Function(); var Foo = function() { }; console.log(Foo.constructor === Function); // true // 由构造函数实例化一个 obj 对象 var obj = new Foo(); console.log(obj.constructor === Foo); // true // 将上面两段代码合起来,就得到下面的结论 console.log(obj.constructor.constructor === Function); // true 但是当 constructor 遇到 prototype 时,有趣的事情就发生了。

我们知道每个函数都有一个默认的属性 prototype, 而这个 prototype 的 constructor 默认 指向这个函数。

如下例所示

function Person(name) { this.name = name; }; Person.prototype.getName = function() { return this.name; }; var p = new Person("ZhangSan"); console.log(p.constructor === Person); // true console.log(Person.prototype.constructor === Person); // true // 将上两行代码合并就得到如下结果 console.log(p.constructor.prototype.constructor === Person); // true 当时当我们重新定义函数的 prototype 时(注意:和上例的区别,这里不是修改而是覆 盖) ,constructor 属性的行为就有点奇怪了, 如下示例

function Person(name) { this.name = name; }; Person.prototype = { getName

function() { return this.name; } }; var p = new Person("ZhangSan"); console.log(p.constructor === Person); // false console.log(Person.prototype.constructor === Person); // false console.log(p.constructor.prototype.constructor === Person); // false 怎么修正这种问题呢?方法也很简单,重新覆盖 Person.prototype.constructor 即可, 如下示例: function Person(name) { this.name = name; }; Person.prototype = new Object({ getName

function() { return this.name; } }); Person.prototype.constructor = Person; var p = new Person("ZhangSan"); console.log(p.constructor === Person); // true console.log(Person.prototype.constructor === Person); // true console.log(p.constructor.prototype.constructor === Person); // true 说到了 constructor 我们就说是它与 typeof 函数的区别。

首先我们运行一下下面这段代码

var i; alert(typeof(i)); alert(i.constructor); 这 3 行代码告诉你什么情况下可以用 constructor。

你可以看到第 2 行返回了字符串’undefined’,而第三行则发生了错误,原因是 i 变 量还没有类型定义,自然也没有 constructor 的存在。从这一点上看,typeof 可以检查到 变量是否有定义,而 construct 只能检查已定义变量的类型。

再运行一下下面这段代码

var i = 2; alert(typeof(i)); alert(i.constructor); alert(typeof(i.constructor)); 你会看到第 2 行返回了字符串’number’ ,第 3 行返回了一串类似函数定义的代码字符 串(这就是跟《精通 JavaScript》一书中介绍的不一样的地方) 。

我们再用 typeof 检查一下 constructor 到底是个什么样类型的属性, 4 行返回结果’ 第 function’ ,也就是说,实际上 constructor 是一个函数,更确切地说是一个构造函数。这 时你就可以知道,为什么 constructor 可以检查出各种类型了。

有经验的程序员看到这里应该知道要怎么利用 constructor 来检查变量类型了。

方法有 多种,这里提供一种比较容易理解的方法。

其实想法很简单,就是把 construcor 转化为字符串,通过寻找匹配字符串(function 名)来确定是否指定类型。

如下例子

function user() {}; var i = new user(); alert((i.constructor+”).match(/user/) == null); 这仅仅是个简单的例子。

如果返回 true 则变量 i 不是 user 类型, 返回 false 则变量是 user 类型。

当然,这样检测是不够精确的,比如其实他是一个 myuser 类型的时候,同样会被认为 是 user 类。所以你需要书写更精确的正则表达式去进行匹配。

可以这样简单改进你的正则表达式

/function user\(\)/ 替换上面代码段中的/user/。当然,如果你的构造函数原型是 user(a),那么应该这样 书写你的正则表达式

/function user\(a\)/ 提醒

Object / Array / Function / String / Number / Boolean 在你的正则表达式中, 一定要将这些单词的首字母大写! 而如果该类型是自定义类型, ! 则根据你定义的时候标识符的写法确定。 Array 对象方法 方法 concat() join() pop() push() reverse() shift() slice() sort() splice() toSource() toString() toLocaleString() unshift() valueOf() 描述 连接两个或更多的数组,并返回结果。 FF 1 IE 4 4 5.5 5.5 4 5.5 4 4 5.5 4 4 6 4 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。

1 删除并返回数组的最后一个元素 向数组的末尾添加一个或更多元素,并返回新的长度。

颠倒数组中元素的顺序。

删除并返回数组的第一个元素 从某个已有的数组返回选定的元素 对数组的元素进行排序 删除元素,并向数组添加新元素。

返回该对象的源代码。

把数组转换为字符串,并返回结果。

把数组转换为本地数组,并返回结果。

向数组的开头添加一个或更多元素,并返回新的长度。

返回数组对象的原始值 1 1 1 1 1 1 1 1 1 1 1 1 1.4 concat() 语法

array.concat(value, ...) 其中 value, ... 要添加到 array 中的值,可以是任意多个。

方法 concat()将创建并返回一个新数组, 这个数组是将所有参数都添加到 array 返回值

一个新数组,是把指定的所有参数添加到 array 中构成的。

描述: 中生成的。它并不修改 array。如果要进行 concat()操作的参数是一个数组,那 么添加的是数组中的元素,而不是数组。

例子

var a = [1,2,3]; a.concat(4, 5); // Returns [1,2,3,4,5] a.concat([4,5]); // Returns [1,2,3,4,5] a.concat([4,5], [6,7]); // Returns [1,2,3,4,5,6,7] a.concat(4,[5, [6,7]]); // Returns [1,2,3,4,5,[6,7]] 1.5 join () 语法

array.join() array.join(separator) separator 在返回的字符串中用于分隔数组元素的字符或字符串,这是选用的。如果省 略了这个参数,用逗号作为分隔符。 返回值

一个字符串,通过把 array 的每个元素转换成字符串,然后把这些字符串连接起 来,在两个元素之间插入 separator 字符串而生成。

描述

方法 join()把每个数组元素转换成一个字符串,然后把这些字符串连接起来, 在两个元素之间插入 separator 字符串。返回生成的字符串。

可以用 String 对象的 split()方法执行相反的操作,即把一个字符串分割成数 组元素。详情参见“String.split()”。

var a = new Array(1, 2, 3, "testing"); var s = a.join("+"); // s is the String "1+2+testing" 例子: 1.6 pop() 语法

arrayObject.pop() 其中 value, ... 要添加到 array 中的值,可以是任意多个。

pop() 方法将删除 arrayObject 的最后一个元素,把数组长度减 1,并且返回 它 删 除 的 元 素 的 值 。

如 果 数 组 已 经 为 空 , 则 pop() 不 改 变 数 组 , 并 返 回 undefined 值。

var arr = new Array(["George","John","Thomas"]) document.write(arr) // Returns George,John,Thomas document.write(arr.pop())// Returns Thomas document.write(arr) // Returns George,John 返回值

arrayObject 的最后一个元素。

描述: 例子: 1.7 push() 语法

array.push(value, ...) value, ... 描述: 要添加到 array 尾部的值,可以是一个或多个。 返回值

把指定的值添加到数组后的新长度。

方法 push()将马它的参数顺次添加到 array 的尾部。它直接修改 array,而不是 创建一个新的数组。方法 push()和方法 pop()用数组提供先进后出栈的功能。参 阅"Array.pop()"中的示例。

var a = [1,2,3]; a.concat(4, 5); // Returns [1,2,3,4,5] a.concat([4,5]); // Returns [1,2,3,4,5] a.concat([4,5], [6,7]); // Returns [1,2,3,4,5,6,7] a.concat(4,[5, [6,7]]); // Returns [1,2,3,4,5,[6,7]] 例子: 1.8 reverse() 语法

返回值

描述

Array 对象的方法 reverse()将颠倒数组中元素的顺序。它在原数组上实现这一 操作作为替代:重排指定的 array 的元素,但并不创建新数组。如果对 array 有 多个引用,那么通过所有引用都可以看到数组元素的新顺序。

a = new Array(1, 2, 3); a.reverse(); // a[0] == 1, a[2] == 3; // Now a[0] ==3, a[2] == 1; array.reverse() 该方法会改变原来的数组,而不会创建新的数组。 例子: 1.9 shift() 语法

描述

array.shift() 方法 shift()将把 array 的第一个元素移出数组,返回那个元素的值,并且将余 下的所有元素前移一们,以填补数组头部的空缺。如果数组是空的,shift()将 不进行任何操作,返回 undefiend 值。注意,该方法不创建新的数组,而是直接 修改原有的 array。

方法 sihft()和方法 Array.pop()相似,只不过它在数组头部操作,而不是在尾 部操作。该方法常常和 unshift()一起使用。

var a = [1, [2,3], 4]; a.shift(); // Return 1; a = [[2,3], 4]; a.shift(); // Return [2,3]; a = [4]; 返回值

数组原来的第一个元素。 例子: 1.10 slice() 语法

array.slice(start, end) start 数组片段开始处的数组下标。如果是负数,它声明从数组尾部开始算起的位 置。也就是说-1 指最后一个元素,-2 指倒数第二个元素,以此类推。

end 数组片段结束处的后一个元素的数组下标。如果没有指定这个参数,切分的 数组包含从 start 开始到数组结束的所有元素。如果这个参数是负数,它声明的 是从数组尾部开始算起的元素。

返回值

一个新数组,包含从 start 到 end(不包括该元素)指定的 array 元素。

描述

方法 slice()将返回 array 的一部分,或者说是一个子数组。返回的数组包含从 start 开始到 end 之间的所有元素,但是不包括 end 所指的元素。如果没有指定 end,返回的数组包含从 start 开始到原数组结尾的所有元素。

注意,该方法并不修改数组。如果想删除数组中的一段元素,应该使用方法 Array.splice()。

var a = [1,2,3,4,5]; a.slice(0,3); // Return [1,2,3] a.slice(3); // Return [4,5] a.slice(1,-1); // Return [2,3,4] a.slice(-3,-2); // Return [3]; buggy in IE 4

return [1,2,3] 例子: 1.11 sort() 语法

array.sort() array.sort(orderfunc) orderfunc 用来指定按什么顺序进行排序的函数,可选。

方法 sort()将在原数组上对数组元素进行排序,即排序时不创建新的数组副本。

如果调用方法 sort()时没使用参数,将按字母顺序(更精确地说,是按 照字符 编码的顺序)对数组中的元素进行排序。要实现这一点,首先应把数组的元素都 转成字符串(如果有必要的话) ,以便进行比较。

如果想按照特别的顺序进行排序,就必须提供比较函数,该函数要比较两个值, 然后返回一个用于说明这两个值的相对顺序的数字。

比较函数应该具有两个参数 a 和 b,其返回值如下

● 如果根据你的评判标准,a 小于 b,在排序后的数 例子

下面的代码展示了如何编写按数字顺序, 而不是按字母顺序对数组进行排序的比 较函数

//An ordering function for a numerical sort function numberorder(a, b){ return a - b; } var a = new Array(33, 4, 1111, 222); a.sort(); //Alphabetical sort

1111, 222, 33, 4 a.sort(numberorder); //Numerical sort

4, 返回值

对数组的引用。注意,数组在原数组上进行排序,不制作副本。

描述: 33, 222, 1111 1.12 splice(start, deleteCount, value, ...) 语法

array.splice(start, deleteCount, value, ...) start 开始插入和(或)删除的数组元素下标。

deleteCount 从 start 开始,包括 start 所指的元素在内要删除的元素个数。这个参数是 先用的,如果没有指定它,splice()将删除从 start 开始到原数组结尾的所有元 素。

value, ...要插入数组的零个或多个值,从 start 所指的下标处开始插入。

方法 splice()将删除从 start 开始(包括 start 所指的元素在内)的零个或多 个元素,并且用参数列表中声明的一个或多个值来替换那些被删除的 元素。位 于插入或删除的元素之后的数组元素都会被移动, 以保持它们与数组其它元素的 连续性。注意,虽然 splice()方法与 slice()方法名称很相 似,但作用不同, 方法 splice()直接修改数组。

var a = [1,2,3,4,5,6,7,8]; a.splice(4); a.splice(1,2); a.splice(1,1); a.splice(1,0,2,3); // Returns [5,6,7,8] ; a is [1,2,3,4] // Returns [2,3] ; a is [1,4] // Returns [4] ; a is [1] // Returns [] ; a is [1,2,3] 返回值

如果从 array 中删除了元素,则返回的是含有被删除的元素的数组。

描述: 例子: 1.13 toSource() 语法

object.toSource() 注释:该方法在 Internet Explorer 中无效。

toSource() 方法表示对象的源代码。

该原始值由 Array 对象派生的所有对象继 承。toSource() 方法通常由 JavaScript 在后台自动调用,并不显式地出现在 代码中。

function employee(name,job,born){ this.name=name; this.job=job; this.born=born; } var bill=new employee("Bill Gates","Engineer",1985); document.write(bill.toSource()); Return

// ({name:"Bill Gates", job:"Engineer", born:1985}) 返回值

一个新数组,是把指定的所有参数添加到 array 中构成的。

描述: 例子: 1.14 toString() 语法

array.toString() TypeError 调用该方法时,若对象不是 Array,则抛出该异常。

数组的 toStirng()方法将把数组转换成一个字符串,首先是把每个数组元素转 换为字符串并且返回这个字符串。当数组用于字符串环境中,JavaScript 会调 用这一方法将数组自动转换成一个字符串。但在某些情况下,需要显式地调用这 个方法。

toString() 在把数组转换成字符串时,首先要将数组的每个元素都转换成字符 串(通过调用这些元素的 toString()方法) 。当每个元素都被转换成字符串时, 它就以 列表的形式输出这些字符串,字符串之间用逗号分隔。返回值与没有参 数的 join()方法返回的字符串相同。 返回值

array 的字符串表示。

描述: 例子: 1.15 toLocaleString() 语法

array.toLocaleString() TypeError 调用该方法时,若对象不是 Array,则抛出该异常。

数组的方法 toLocaleString()将返回数组的局部字符串表示。它首先调用每个 数组元素的 toLocaleString()方法,然后使用地区特定的分隔符把生成的字符 串连接起来,形成一个新字符串。 返回值

数组 array 的局部字符串表示。

描述: 例子: 1.16 unshift() 语法

array.unsift(value, ...) 其中 value, ... 要插入数组头部的一个或多个值。

方法 unshift()将把它的参数插入 array 的头部,并将已经存在的元素顺次地移 到较高的下标处,以便留出空间。该方法的第一个参数将成为数组新的 元素 0, 如果还有每二个参数,它将成为新的元素 1,以经类推。注意,unshift()不创 建新数组,而是直接修改原有数组。

方法 unshift()通常和方法 shift()一起使用。

var a = []; // a

[] a.unshift(1); // a

[1] Return 1 a.unshift(22); // a

[22,1] Return 2 a.shift(); // a

[1] Return 22 a.unshift(33,[4,5]); // a

[33,[4,5],1] Return 3 返回值

数组的新长度。

描述: 例子: 1.17 valueOf() 语法

描述

例子

arrayObject.valueOf() 该 原 始 值 由 Array 对 象 派 生 的 所 有 对 象 继 承 。

valueOf() 方 法 通 常 由 JavaScript 在后台自动调用,并不显式地出现在代码中。 返回值

valueOf() 方法返回 Array 对象的原始值。

第一篇:javascript数组

认识 Javascript 数组 转载:/tech/web/2009/6958.asp 1.认识数组 认识数组 数组就是某类数据的集合,数据类型可以是整型、字符串、甚至是对象 Javascript 不支持多维数组,但是因为数组里面可以包含对象(数组也是一个对象) ,所以数 组可以通过相互嵌套实现类似多维数组的功能 1.1 定义数组 声明有10个元素的数组 var a = new Array(10); 此时为 a 已经开辟了内存空间, 包含10个元素, 用数组名称加 [下标] 来调用, 例如 a[2] 但 此时元素并未初始化,调用将返回 undefined 以下代码定义了个可变数组,并进行赋值 var a = new Array(); a[0] = 10; a[1] = "aaa"; a[2] = 12.6; 上面提过了,数组里面可以放对象,例如下面代码 var a = a[0] a[1] a[2] a[3] new Array(); = true; = document.getElementById("text"); = {x:11, y:22}; = new Array(); 数组可以实例化的时候直接赋值,例如 var a = new Array(1, 2, 3, 4, 5); var b = [1, 2, 3, 4, 5]; a 和 b 都是数组,只不过 b 用了隐性声明,创建了另一个实例,此时如果用 alert(a==b)将 弹出 false 1.2 多维数组 其实 Javascript 是不支持多维数组的,在 asp 里面可以用 dim a(10,3)来定义多维数组,在 Javascript 里面,如果用 var a = new Array(10,3) 将报错 但是之前说过,数组里面可以包含对象,所以可以把数组里面的某个元素再声明为数组,例 如 var a = new Array(); a[0] = new Array(); a[0][0] = 1; alert(a[0][0]); //弹出 1 声明的时候赋值 var a = new Array([1,2,3], [4,5,6], var b = [[1,2,3], [4,5,6], [7,8,9]]; [7,8,9]); 效果一样,a 采用常规实例化,b 是隐性声明,结果都是生成一个多维数组 1.3 Array literals 这个还真不知中文怎么叫,文字数组? 说到数组,不得不说到 Array Literals,数组其实是特殊的对象,对象有特有属性和方法, 通过 对象名.属性 、对象.方法() 来取值和调用,而数组是通过下标来取值,Array Literals 跟数组有很多相似,都是某数据类型的集合,但是 Array Literals 从根本来说,是个对象, 声明和调用,跟数组是有区别 var aa = new Object(); aa.x = "cat"; aa.y = "sunny"; alert(aa.x); //弹出 cat 创建一个简单的对象, 一般调用是通过 aa.x, 而如果当成 Array literals 的话, alert(aa[“x”]) 用 一样会弹出 cat var a = {x:"cat", y:"sunny"}; alert(a["y"]); //弹出 sunny 这是另一种创建对象的方法,结果是一样的 2.数组元素的操作 数组元素的操作 上面已经说过,可以通过 数组[下标] 来读写元素 下标的范围是 0 – (23(上标2) -1),当下标是负数、浮点甚至布尔值的时候,数组会自动转换 为对象类型,例如 var b b[2.2] = new Array(); = "XXXXX"; alert(b[2.2]); //-> XXXXX 此时相当于 b[“2.2”] = “XXXXX” 2.1数组的循环 数组的循环 var a = [1,2,3,4,5,6]; for(var i =0; i<a.length; i++){ alert(a[i]); } 这是最常用的,历遍数组,代码将依次弹出1至6 还有一种常用的 var a = [1,2,3,4,5,6]; for(var e in a){ alert(e); } 还是依次弹出1至6,for…in 是历遍对象(数组是特殊的对象)对象,用在数组上,因为数 组没有属性名,所以直接输出值,这结构语句用在对象上,例如下面 var a = {x:1,y:2,z:3}; for(var e in a){ alert(e } + ":" + a[e]); 此时 e 取到的是属性名,即 x、y、x,而要取得值,则采用 数组名[属性],所以 a[e] 等同 于 a[“x”]、a[“y”]、a[“z”] 2.2数组常用函数 数组常用函数 concat 在现有数组后面追加数组,并返回新数组,不影响现有数组 var a = [123]; var b = "sunnycat"; var c = ["www",21,"ido"]; var d = {x:3.14, y:"SK"}; var e = [1,2,3,4,[5,6,[7,8]]]; alert(a.concat(b)); alert(a); // -> 123 // -> sunnycatwww,21,ido[object // -> www,21,ido,sunnycat ")); // -> 1 # 2 # 3 # 4 # 5,6,7,8 # 11 # 22 Object] alert(b.concat(c, d)); alert(c.concat(b)); # 33 // -> 123,sunnycat alert(e.concat(11,22,33).join(" # 需要注意的是只能用于数组或字符串,如果被连接(前面的 a)的是数值、布尔值、对象, 就会报错,字符串连接数组时,字符串会跟数组首元素拼接成新元素,而数组连接字符串则 会追加新元素(这点我也不清楚原委,知情者请透露) ,对于数组里面包含数组、对象的, 连接后保持原样 join 用指定间隔符连起来,把数组转为字符串 var a = ['a','b','c','d','e','f','g']; lert(a.join(",")); // -> a,b,c,d,e,f,g 相当于 a.toString() alert(a.join(" x ")); // -> a x b x c x d x e x f x g 这个很容易理解,但需要注意的是只转换一维数组里面,如果数组里面还有数组,将不是采 用 join 指定的字符串接,而是采用默认的 toString(),例如 var a = ['a','b','c','d','e','f','g',[11,22,33]]; 11,22,33 alert(a.join(" * ")); // -> a * b * c * d * e * f * g * 数组里面的数组,并没用 * 连接 pop 删除数组最后一个元素,并返回该元素 var a = ["aa","bb","cc"]; // -> cc // -> aa, bb document.write(a.pop()); document.write(a); 如果数组为空,则返回 undefined push 往数组后面添加数组,并返回数组新长度 var a = ["aa","bb","cc"]; // -> 4 // -> aa,bb,cc,dd // -> aa,bb,cc,dd,1,2,3 document.write(a.push("dd")); document.write(a); document.write(a); document.write(a.push([1,2,3])); // -> 5 跟 concat 的区别在于,concat 不影响原数组,直接返回新数组,而 push 则直接修改原数组, 返回的是数组新长度 sort 数组排序,先看个例子 var a = [11,2,3,33445,5654,654,"asd","b"]; alert(a.sort()); // -> 11,2,3,33445,5654,654,asd,b 结果是不是很意外,没错,排序并不是按整型大小,而是字符串对比,就是取第一个字符的 ANSI 码对比,小的排前面,相同的话取第二个字符再比,如果要按整型数值比较,可以这 样 var a = [11,2,3,33445,5654,654]; a.sort(function(a,b) { return a - b; }); alert(a); // -> 2,3,11,654,5654,33445 sort()方法有个可选参数,就是代码里的 function,这是个简单的例子,不可对非数字进行排 序,非数字需要多做判断,这里就不多讲 reverse 对数组进行反排序跟,sort()一样,取第一字符 ASCII 值进行比较 var a = [11,3,5,66,4]; alert(a.reverse()); // -> 4,66,5,3,11 如果数组里面还包含数组,则当为对象处理,并不会把元素解出来 >var a = ['a','b','c','d','e','f','g',[4,11,33]]; alert(a.reverse()); // -> 4,11,33,g,f,e,d,c,b,a alert(a.join(" * ")); // -> 4,11,33 * g * f * e * d * c * b * a 按理应该是11排最后面,因为这里把 4,11,33 当做完整的对象比较,所以被排在第一位。看 不明白的话,用 join()串起来,就明了多 shift 删除数组第一个元素,并返回该元素,跟 pop 差不多 var a = ["aa","bb","cc"]; // -> aa // -> bb,cc document.write(a.shift()); document.write(a); 当数组为空时,返回 undefined unshift 跟 shift 相反,往数组最前面添加元素,并返回数组新长度 var a = ["aa","bb","cc"]; // -> 4 注:IE 下返回 undefined // -> 11,aa,bb,cc // -> 5 // -> 11,22,11,aa,bb,cc // -> cat,11,22,11,aa,bb,cc document.write(a.unshift(11)); document.write(a); document.write(a); document.write(a); document.write(a.unshift([11,22])); document.write(a.unshift("cat")); // -> 6 注意该方法,在 IE 下将返回 undefined,貌似微软的 bug,我在 firefox 下则能正确发挥数组 新长度 slice 返回数组片段 var a = ['a','b','c','d','e','f','g']; alert(a.slice(1,2)); // -> b alert(a.slice(2)); alert(a.slice(-4)); alert(a.slice(-2,-6)); // -> c,d,e,f,g // -> d,e,f,g // -> 空 a.slice(1,2),从下标为1开始,到下标为2之间的数,注意并不包括下标为2的元素 如果只有一个参数,则默认到数组最后 -4是表示倒数第4个元素,所以返回倒数的四个元素 最后一行,从倒数第2开始,因为是往后截取,所以显然取不到前面的元素,所以返回空数 组,如果改成 a.slice(-6,-2) 则返回 b,c,d,e splice 从数组删除某片段的元素,并返回删除的元素 var a = [1,2,3,4,5,6,7,8,9]; document.write(a.splice(3,2)); document.write(a); document.write(a); document.write(a); document.write(a); document.write(a); document.write(a); // -> 4,5 // -> 1,2,3,6,7,8,9 // -> 1,2,3,6 // -> 1 // -> 3 // -> 2,3,6 // -> 2,aa,bb,cc,6,7,8,9 // -> 2,ee,7,8,9 // -> 2,cc,aa,tt,8,9 document.write(a.splice(4)); // -> 7,8,9 注:IE 下返回空 document.write(a.splice(0,1)); document.write(a.splice(1,1,["aa","bb","cc"])); document.write(a.splice(1,2,"ee").join("#")); // -> aa,bb,cc#6 document.write(a.splice(1,2,"cc","aa","tt").join("#")); // -> ee#7 注意该方法在 IE 下,第二个参数是必须的,不填则默认为0,例如 a.splice(4),在 IE 下则返 回空,效果等同于 a.splice(4,0) toString 把数组转为字符串,不只数组,所有对象均可使用该方法 var a = [5,6,7,8,9,["A","BB"],100]; // -> 5,6,7,8,9,A,BB,100 // -> Sat Aug 8 17:08:32 UTC+0800 2009 document.write(a.toString()); var b = new Date() document.write(b.toString()); var c = function(s){ alert(s); } document.write(c.toString()); // -> function(s){ alert(s); } 布尔值则返回 true 或 false,对象则返回[object objectname] 相比 join()方法,join()只对一维数组进行替换,而 toString()则把整个数组(不管一维还是多 维)完全平面化 同时该方法可用于10进制、2进制、8进制、16进制转换,例如 var a = [5,6,7,8,9,"A","BB",100]; + " 的二进制是 " + a[i].toString(2) + " ,八进制是 " + -> 4,5 for(var i=0; i<a.length; i++){ document.write(a[i].toString() a[i].toString(8) + " ,十六进制是 " + a[i].toString(16)); // } 输出结果 5 的二进制是 101 ,八进制是 5 ,十六进制是 5 6 的二进制是 110 ,八进制是 6 ,十六进制是 6 7 的二进制是 111 ,八进制是 7 ,十六进制是 7 8 的二进制是 1000 ,八进制是 10 ,十六进制是 8 9 的二进制是 1001 ,八进制是 11 ,十六进制是 9 A 的二进制是 A ,八进制是 A ,十六进制是 A BB 的二进制是 BB ,八进制是 BB ,十六进制是 BB 100 的二进制是 1100100 ,八进制是 144 ,十六进制是 64 转换只能在元素进行,如果对整个数组进行转换,则原封不动返回该数组 toLocaleString 返回本地格式字符串,主要用在 Date 对象上 var a = new Date(); document.write(a.toString()); // -> Sat Aug 8 17:28:36 UTC+0800 // -> 2009年8月8日 17:28:36 // -> 2009年8月8日 2009 document.write(a.toLocaleString()); document.write(a.toLocaleDateString()); 区别在于, toString()返回标准格式, toLocaleString()返回本地格式完整日期 【控制面板】 (在 >> 【区域和语言选项】通过修改[时间]和[长日期]格式)toLocaleDateString()跟 toLocaleString() , , 一样,只是少了时间 valueOf 根据不同对象返回不同原始值, 用于输出的话跟 toString()差不多, 但是 toString()是返回 string 类型,而 valueOf()是返回原对象类型 var a = [1,2,3,[4,5,6,[7,8,9]]]; var b = new Date(); var c = true; var d = function(){ alert("sunnycat"); }; document.write(a.valueOf()); document.write(b.valueOf()); document.write(c.valueOf()); document.write(d.valueOf()); // -> 1,2,3,4,5,6,7,8,9 // -> 1249874470052 // -> true // -> function () { alert("sunnycat"); } document.write(typeof (a.valueOf())); // -> object document.write(typeof(b.valueOf())); // -> number document.write(typeof(c.valueOf())); // -> boolean document.write(typeof(d.valueOf())); // -> function 数组也是对象,所以 typeof (a.valueOf())返回 object,返回的依然是个多维数组 var a = [1,2,3,[4,5,6,[7,8,9]]]; var aa = a.valueOf(); document.write(aa[3][3][1]); // -> 8 Date 对象返回的是距离1970年1月1日的毫秒数, Math 和 Error 对象没有 valueOf 方法
javascript数组》由(一起看范文网)整理提供,版权归原作者、原出处所有。
Copyright © 一起看范文网 All Rights Reserved.