JavaScript中的Array类型很灵活，和C语言不同，同一个Array每个位置可以存储不同的变量类型，而且数组长度可变。

声明数组的方法：

var colors = new Array()

var colors = new Array(20) //长度为20的数组

var colors = new Array("red","blue","green")

var colors = ["red","blue","green"]

var colors = Array(3)

var colors = Array("bue")

arrays.length 可以获取colors数组的长度。这个长度不是只读的，而是可变的！

var arrays = ["red","blue","green"] // 有三个元素，长度为3

arrays.length = 2 //将arrays数组长度设为2后

alert(arrays[2]) //Undefined 第三个元素为Undefined

将长度增大或者缩短之后超出原来数组长度或者小于新数组长度的部分的值为undefined

检测当前对象事都是数组的方法：

if(value instanceif Array){

}

if(Array.isArray(value)){

}

value为要检测的对象

JavaScript的数组可以当做栈来处理，也可以当做队列或者双向队列处理，甚至能把栈，队列，双向队列的特点和方法集合起来。

我们可以用下面的一些方法来对数组进行任意的插入删除操作。

栈方法：后进先出

push() ：方法可以接收任意数量的参数，把他们添加到数组末尾，并返回修改后数组的长度。

pop() ：方法则从数组末尾移除最后一项，减少数组的length，然后返回移除的项。

队列方法：先进先出

shift()：移除数组中的第一个项并返回该项，长度减1

结合使用shift()和push()方法，可以想使用队列一样使用数组，后端添加，前端删除

Unshift()：在数组前端添加任意个项并返回新数组的长度

结合使用unshift()和pop()方法，从相反的方向来模拟队列，即在数组的前端添加项，在后端移除

var colors = new Array()

var count = colors.push("red","green")

alert(count) //2

var item = colors.shift() //队列出队操作

alert(item) //"red"

colors.unshift("red") //从前边插入

重排序方法：

sort()方法：

sort在排序时都用toString把数据转换成字符串形式：

var values = [0,1,5,10,15]

values.sort()

alert(values) // 0 ,1 ,10, 15 ,5

要实现对数的排序，需要写一个比较函数：

function compare(value1,value2){

if(value1 <value2){

return -1

}else if(value1 >value2){

return 1

}else return 0

}

values.sort(compare)

reverse()方法：反转数组项的顺序

操作方法：

1、contact（）：基于当前数组中的所有项创建一个新数组，而不是在当前数组上直接拼接。

colors.contact(["black","yellow"]) //contact用来拼接数组，把参数数组拼接到colors的后面

2、slice（）：基于当前数组中的一个或多个项创建一个新数组，可接收一或两个参数，即要返回项的起始和结束位置。若参数中有一个负数，则用数组长度加上该数来确定相应的位置

var colors = ["red","blue","green"]

var colors2 = colors.slice(1) //返回从数组下标1到最后缩构成的一个数组

var colors3 = colors.slice(1,4) //

返回从数组下标1--3构成的一个数组

3、splice()方法：删除、插入、替换

删除：当splice方法指定两个参数时，color.splice(1,3)表明删除从下标1开始连续三项

插入：当splice指定三个参数：起始位置、0、插入的项，color.splice(2,0,"red","green") 表明从下标2开始插入“red”和“green”

替换：color.splice(1,2,"red","green") 表明先删除下标1开始的连续两项，在从下标1开始插入“red”和“green”

位置方法：

indexOf()方法：

colors.indexOf(value) 从数组开头开始查找value，返回value的下标，如果没找到返回-1 。在查找时要求严格查找，相当于===

lastIndexOf()方法：从数组的末尾开始向前查找

/**

** 加法函数，用来得到精确的加法结果

** 说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。

** 调用：accAdd(arg1,arg2)

** 返回值：arg1加上arg2的精确结果

**/function accAdd(arg1, arg2) {    var r1, r2, m, c   try {

r1 = arg1.toString().split(".")[1].length

}    catch (e) {

r1 = 0

}    try {

r2 = arg2.toString().split(".")[1].length

}    catch (e) {

r2 = 0

}

c = Math.abs(r1 - r2)

m = Math.pow(10, Math.max(r1, r2)) 

if (c >0) {        var cm = Math.pow(10, c)       if (r1 >r2) {

arg1 = Number(arg1.toString().replace(".", ""))

arg2 = Number(arg2.toString().replace(".", "")) * cm

} else {

arg1 = Number(arg1.toString().replace(".", "")) * cm

arg2 = Number(arg2.toString().replace(".", ""))

}

} else {

arg1 = Number(arg1.toString().replace(".", ""))

arg2 = Number(arg2.toString().replace(".", ""))

}    return (arg1 + arg2) / m

}//给Number类型增加一个add方法，调用起来更加方便。

Number.prototype.add = function

(arg) {    return accAdd(arg, this)

}

扩展资料

var a = 1, 

var b = 2, 

var c = a + b 

这样c得出来的解果是12，

使用Number()函数可以解决这个问题，如下 

var c = Number(a) + Number(b) 

这样c得出来的解果是3，

JavaScript Number() 函数对象的值转换为数字。

<script type="text/javascript">

var test1= new Boolean(true)

var test2= new Boolean(false)

var test3= new Date()

var test4= new String("999")

var test5= new String("999 888")

document.write(Number(test1)+ "<br />")

document.write(Number(test2)+ "<br />")

document.write(Number(test3)+ "<br />")

document.write(Number(test4)+ "<br />")

document.write(Number(test5)+ "<br />")</script>

<!--封装集合类-->

//我们的集合里面不允许有重复的元素

    function Set(){

//    属性

        this.items={}

//    add方法

        Set.prototype.add=value=>{

//判断当前集合是否包含了该元素

            if (this.has(value))return false

            //将元素添加到集合中

            this.items[value]=value//集合中，键为value，值为value

            return true

        }

//        has方法--判断集合中是否有某一个元素！

        Set.prototype.has=(value)=>{

return this.items.hasOwnProperty(value)

}

//        remove方法

        Set.prototype.remove=(value)=>{

//  1.判断集合中是否包含该元素

            if (!this.has(value))return false

        //  2.包含则删除集合中的属性，delete是js中的属性

            delete this.items[value]

return true

        }

//        clear方法

        Set.prototype.clear=()=>{

this.items={}

}

//        size方法

        Set.prototype.size=()=>{

return Object.keys(this.items).length

        }

//        获取集合中所有的值

        Set.prototype.values=()=>{

return Object.keys(this.items)

}

}

---