JavaScript数组对象学习总结

数组检测

对于IE9+的现代浏览器,Array.isArray()方法可以判断某个值是否为数组。如果是返回true,否则返回false。

Array.isArray([])  //true  
Array.isArray(new Array)   //true  
Array.isArray()   //false  

兼容所有浏览器的万能方法

function isArray (arr) {  
  return Object.prototype.toString.call(arr)=="[object Array]"
}
var a=[];  
console.log(isArray(a))   //true  

length属性

arrayObject.length  //返回arrayObject的最大下标加1的整数。  

javascript中数组的length属性值并不真实反映数组的元素个数,它只是返回数组最大下标加1。如果数组中元素是连续的,那length属性返回值等于数组元素个数。如果数组元素不连续,则length无法反映真实元素个数。此外,即使使用delete操作符删除数组中一些元素,依然无法改变数组的length值

var a=["aa","bb","cc","dd"]  
a.length    //  4


var b=[]  
b[5]="denpe.com"  
b[8]=2015  
b.length   //   值为最大下标加1= 9  
console.log(b) //,,,,,"denpe.com",,,2015


delete b[8]  
delete b[5]  
b.length   // 依然为9  
console.log(b)  //  ,,,,,,,,

绝大多数情况下,只有数组对象自带的添加删除元素方法才能改变length属性值。如pop(),shift(),splice(),push()等方法。另外js中数组对象的length值不是只读的。这意味可以设置数组length值。如果数组length被赋予一个比原先数值小的数,则数组中所有元素下标大于等于该数的元素都会被丢弃。如果数组的length被赋予一个比原值大的数,则数组形式上被扩展,但不创建新元素。数组length赋值不能小于0,否则会报错RangeError。

var a=[1,2,3,4,5,6,7,8,9]  
a.length=3  
console.log(a)  //[1,2,3]  
a.length=5  
console.log(a)  // [1,2,3,,]  

转换方法

toString()方法将数组的每一个元素转为字符串然后用英文逗号连接起来拼接成新字符串。

var arr=[1,2,3,45.00,{sex:"male"},function test(){alert("hi")}]

var a=arr.toString  
console.log(a)  
//运行结果
// 1,2,3,45,[object Object],function test(){alert("hi")}

toLocalString()方法和toString方法雷同。 valueOf()方法返回当前数组实例对象,也就是数组自己。

var a=[1,2,3,4,5]  
console.log(a.valueOf()===a)  //true  

join()方法会将数组中所有元素用指定分隔符连接起来组成一个字符串。如果没有指定分隔符则默认用英文逗号连接,如果数组空则返回一个空字符串。

var a=[1,2,3,4,5,"denpe.com"]  
console.log(a.join()) //   1,2,3,4,5,denpe.com  
console.log(a.join("-"))  //  1-2-3-4-5-denpe.com  
var b=[]  
console.log(3+b.join()+5)  //  35  
console.log(3+b.join(888)+5)  //  35  

栈方法

push()方法用于向当前数组的末尾添加一个或多个元素,并返回新数组长度。

注意:如果添加的元素类型为数组类型(Array),仍然会被当作一个元素看待,只是这个元素是数组类型而已.

pop()方法用于从当前数组中移除最后一个元素,并返回该元素。

var  arr=[1,"denpe.com",2,"ghost"]  
var re=arr.push(999,["mm"])  
console.log(re)   //  6  
console.log(arr)  // [ 1, 'denpe.com', 2, 'ghost', 999, [ 'mm' ] ]

var result=arr.pop()  
console.log(result)  //[ 'mm' ]  
console.log(arr)  //[ 1, 'denpe.com', 2, 'ghost', 999 ]  

队列方法

shift()方法用于从当前数组中移除第一个元素,并返回被移除的元素。如果该数组为空,则返回undefined。结合shift()和push()方法可以像操作队列一样来操作数组。 unshift()方法用于从当前数组的开头位置插入一个或多个元素,并返回插入后数组长度。(在IE7以下版本浏览器中返回值为undefined)

var arr=["denpe","com","ghost","blog"]  
var re=arr.shift()  
console.log(re)   //denpe  
console.log(arr)  //[ 'com', 'ghost', 'blog' ]  
var result=arr.unshift("hehe",7)  
console.log(result)  // 5  
console.log(arr)   //[ 'hehe', 7, 'com', 'ghost', 'blog' ]

var nothing=[]  
console.log(nothing.shift())  //undefined  

排序方法

reverse()方法将当前数组所有元素顺序反转,并返回翻转后的数组。sort()方法将当前数组按指定顺序排序,并返回排序后的数组。这两个方法都不创建新数组,返回的数组就是经过排序后数组本身。sort()方法的参数为一个比较函数,如果省略则元素将按ASCII字符顺序的升序进行排列。如果提供比较函数。则比较函数返回值必须为以下三种之一:

  1. 如果所传递的第一个参数位于第二个参数之前,则返回负值。
  2. 如果两个参数相等,则返回零。
  3. 如果第一个参数位于第二个参数之后,则返回正值。
var arr=[1,2,6,4,7,9,5,3,8]  
var re=arr.reverse()  
console.log(re) //[ 8, 3, 5, 9, 7, 4, 6, 2, 1 ]  
console.log(re===arr) //true

// 升序函数
function compare(a,b){  
  return a-b
}

var result=arr.sort(compare)  
console.log(result)  //[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]  
console.log(result===arr)  //true  

操作方法

concat()方法用于将当前数组和任意其他项组合拼接成新数组,这个操作不会改变当前数组,返回是拼接后的新数组。如果参数为数组类型,则将该参数数组中的所有元素依次拼接到当前数组的末尾;如果是其他类型,则将其本身作为元素添加到当前数组的末尾处。 如果当前数组中的元素是对象引用,则在返回的连接后的新数组中仍然是以对象引用的形式存在,并不会创建一个等同的对象。简而言之,如果当前数组中的元素是对象,新数组中的元素还是这个对象,它们指向同一个对象。

var arr=[ 1, 2, 3, 4, 5]  
var re=arr.concat(6,[7,8,[9]])  
console.log(re) //[ 1, 2, 3, 4, 5, 6, 7, 8, [ 9 ] ]  
console.log(arr) //[ 1, 2, 3, 4, 5 ]  
var obj={domain:"denpe.com"}  
var result=arr.concat(obj)  
console.log(result) //[ 1, 2, 3, 4, 5, { domain: 'denpe.com' } ]  
obj.server="linode"  
console.log(result) // [ 1, 2, 3, 4, 5, { domain: 'denpe.com', server: 'linode' } ]  

slice()方法返回当前数组的一部分。它接受一或两个slice(start,end) Number类型的参数,用于确定当前数组返回部分,从start开始(包含start元素)到end结束(不包括end元素)部分元素组成的数组。

var arr=[ 1, 2, 3, 4, 5]  
var re=arr.slice(1,3)  
console.log(re)  //[2,3]  
console.log(arr.slice(9,1))  //[] 空数组  

slice()还可以用来将类数组的对象转换成数组。
splice()方法用于从当前数组移除一部分连续元素,如有必要,还可以在所移除元素的位置上插入一个或多个新元素(改变当前数组)。该方法返回的是由被移除元素组成的数组。array.splice(start,deleteCount,item1,item2,item3,...)参数里start为移除元素的起点索引,deleteCount为删除的元素个数。items是可选参数,为要添加的新元素,可以有多个。

var arr=[ 1, 2, 3, 4, 5, 6, 7, 8]  
var re=arr.splice(1,3)  //从索引1开始删除三个元素  
console.log(re)  //[ 2, 3, 4 ]  
var result=arr.splice(1,3,"denpe")  //删除三个元素添加一个元素  
console.log(result)  // [ 5, 6, 7 ]  
console.log(arr) //  [ 1, 'denpe', 8 ]  

位置方法

indexOf(searchItem,fromIndex)方法返回指定元素在数组中首次出现的索引值,如果未找到返回-1。也可以指定开始查到的索引位置,fromIndex如果不设置默认为0 。lastindexOf()方法是从后往前查找指定元素并返回索引值。他们在判断参数和数组元素关系时用的是全等===。

var arr=[ 1, 2, 3, 4, 3, 2, 1, 0]  
var re=arr.indexOf(3)  
console.log(re)   // 2  
var result=arr.indexOf(3,3)  
console.log(result) // 4  
var re1=arr.lastIndexOf(0)  
console.log(re1)  // 7  
console.log(arr.indexOf(8)) //-1  

迭代方法

有五个迭代方法,每个方法都接受两个参数:要在每一项上运行的参数和(可选的)运行改函数的作用于对象--影响this的值。传入这些方法中的函数会接收三个参数:数组项的值,该项在数组中位置和数组本身。

  • filter()对组数中每一项运行给定函数,返回该函数会返回true的项组成的数组。
  • map()对数组中的每一项运行给定函数,返回每次函数调用的结果组成的数组。
  • some()对数组中的每一项运行给定函数,如果该函数对任意一项返回ture,则返回true。
  • every()对数组中的每一项运行给定函数,如果该函数对每一项都返回true,则返回true。
  • forEach()对数组中每一项运行给定函数,这个方法没有返回值。
var arr=[ 1, 2, 3, 4, 5, 6, 7, 8]  
//找出arr中大于3的所有项
arr.filter(function(item,index,array){return item>3})   //[4, 5, 6, 7, 8]  
//判断arr中是否所有项都大于0
arr.every(function(item,index,array){return item>0})  //true  
//判断arr中是否存在一项大于9
arr.some(function(item,index,array){return item>9}) //false  

调用forEach()方法前加入以下代码以完成低版本ie的兼容

if(!Array.prototype.forEach){  
    Array.prototype.forEach=function(fun,thisp){
        if({}.toString.call(fun)!=="[object Function]"){
            throw new TypeError(fun + "is not a function");
        }
        var len=this.length,thisp=thisp;
        for(var i=0;i<len;i++){
            if(Object.prototype.hasOwnProperty.call(this,i)){
                fun.call(thisp,this[i],i,this);
            }
        }
    }
}

归并方法

reduce()reduceright()方法都会迭代数组的所有项,然后构建一个最终返回值。其中reduce从数组的第一项开始,逐个遍历到最后。而reduceRight从数组的最后一项开始向前遍历到第一项。这两个方法都接受两个参数。一个在每一项上调用的函数和(可选的)作为归并基础的初始值。传给的函数接受四个参数:前一个值,当前值,项的索引和数组对象。这个函数返回的任何值都会作为第一个参数的自动传递给下一项。第一次迭代发生在数组的第二项上,因此第一个参数时数组的第一项,第二个参数就是数组的第二项。

var arr=[ 1, 2, 3, 4, 5, 6, 7, 8]  
var re=arr.reduce(function(prev,cur,index,arr){return prev+cur})  
console.log(re)   //36