Array 范例

除了Object 以外，Array 范例也是相称经常运用的范例了。ECMAScript 数组的每一项可以保留任何范例的数据。且数组大小也可以动态调解的。

建立数组、读取和设置数组的值

建立数组

建立数组的基本体式格局有两种：

1. 运用Array 组织函数：var colors = new Array()；

2. 运用数组字面量示意法；

关于第一种要领，假如晓得数组要保留多少个项目，也可以给组织函数通报参数，比如要建立length 值为10 的数组：

var colors = Array(10);
//new 操纵符可以省略。

也可以向Array 组织函数通报包含的项。如：

var colors = Array("yellow","red","green");

关于第二种要领，数组字面量由方括号示意，用逗号离隔。如：

var colors = [
    "red",
    "green",
    "blue"
]
console.log(colors); //["red", "green", "blue"]
var boys = [];
document.write(boys.length); //0

读取和设置数组的值

运用方括号和基于0 的数字索引。如：

var colors = [
    "red",
    "blue",
    "yellow"
]
document.write(colors[1]); //"blue" 接见第二项
document.write(colors.length); //3 
colors[3] = "cc";
document.write(colors.length); //4 建立一个新的项
document.write(colors[3]); //"cc"

length属性，数组的项数就保留在length 属性中，这个属性返回0 或更大的值。且该属性可写的，可以从数组的末尾移除或增添项。如：

var colors = [
    "red",
    "blue"
]
colors[colors.length] = "yellow";
console.log(colors); // ["red", "blue", "yellow"] 在末尾增添了一项"yellow"
colors.length = 2;
console.log(colors); // ["red", "blue"] 在末尾削减了一项
colors.length = 3;
console.log(colors); //["red", "blue", undefined × 1] 在末尾增添了一项undefined

应用length属性，可以方便地在数组末尾增加新项，如：

var colors = ["red"];
colors[colors.length] = "yellow";

《js 高等程序设计》提到：

数组最多可以包含4 294 967 295 个项。

检测数组

1. 运用instanceof操纵符：if (value instanceof Array) {}；

2. 运用ECMAScript 5 新增的Array.isArray()要领：if (Array.isArray(value))；

检测数组instanceof操纵符的题目，在这里不穷究。支撑Array.isArray()要领的浏览器有IE9、FIrefox 4+、Safari 5+、Opera 10.5+和Chrome。

数组的转换

一般，用toString()要领会返回数组中每一个值的字符串情势拼接而成的以逗号分离隔来的字符串；用valueOf()要领则依然返回数组。

var colors = ["red","yellow"];
var color1 = colors.toString();
document.write(typeof color1); //string 运用toString() 要领，返回的是用逗号支解的字符串；

var color2 = colors.valueOf();
document.write(typeof color2); //object
console.log(color2) //运用valueOf() 要领，返回的依然是数组;

别的，还可以运用toLocaleString()要领，如：

var person = {
    toLocaleString:function(){
        return "Oliver";
    },
    toString:function(){
        return "Troy";
    }
};
var age = {
    toLocaleString:function(){
        return "adult";
    },
    toString:function(){
        return "children";
    }
};
var people = [person,age];
document.write(people.toString()); //Troy,children 返回每一个数组内里的每一个对象的toString 返回的值
document.write(people.toLocaleString()); //Oliver,adult 返回每一个数组内里的每一个对象的toLocaleString 返回的值
document.write(people.valueOf()); //Troy,children
document.write(people.join(" is a ")); //Troy is a children 转变两个数组链接起来的分开符

可以运用join()要领来掌握数组的连接符。

栈要领和行列要领

栈要领（表现的像栈一样）

ECMAScript 数组可以表现的像栈一样。栈是一种LIFO（Last-In-First—Out，后进先出），只发生在一个位置——栈的顶部。

有两个要领push()和pop()要领。详细的来讲，push()要领可以吸收恣意数目的参数，把它们逐一增加到数组的末尾，并返回修正后的数组的长度；pop()要领则可以从数组的末尾移除末了一项，削减数组的length 值，并返回移除的项。如：

增加项：

var array = [1,2,3,4];

console.log(array); //[1, 2, 3, 4] 现在该array 有4项

var count = array.push("str","34"); //末尾增添了一项"str"和一项"34"
console.log(count); //6 这时候返回的长度增添2
console.log(array); //[1, 2, 3, 4, "str", "34"]
console.log(array.length); //6

削减项：

var array = [1,2,3,4];

console.log(array); //[1, 2, 3, 4] 现在该array 有4项

var count = array.pop();
console.log(count); //4 削减了一个"4"
console.log(array); //[1, 2, 3]

行列要领

行列数据结构的接见规则是FIFO（First-In-First-Out），连系运用shift()和push()要领，可以像运用行列一样运用数组。shift()可以移除数组中的第一个项，并返回该项。如：

var array = [];
var count = array.push("1","2");
document.write(count);
document.write(array); //[1,2]

count = array.push("3");
document.write(count);
document.write(array); //[1,2,3]

var item = array.shift();
document.write(item); //1
document.write(array); //[2,3]

别的，另有一个叫unshift()要领，同时运用unshift()和pop()要领，可以从相反的方一直模仿行列，即在前端增加项，末尾移除项。如：

var array = [];
var count = array.unshift(1,2,3);
document.write(count); //3
document.write(array); //[1,2,3]

count = array.unshift(0);
document.write(count); //4
document.write(array); //[0,1,2,3]

item = array.pop();
document.write(item); //3
document.write(array); //[0,1,2]

须要注重的是：

• shift()返回的是前端删除的项的值；

• unshift()返回的是前端增添后数组的长度；

• pop()返回的是末尾删除的项的值；

• push()返回的是末尾增添后数组的长度。

• 总的来讲就是“删除返回项的值，增添则返回长度”

重排序要领

有两个重排序要领：reverse()和sort()。

sort()要领根据升序分列数组项，如：

var array = [4321,3,43,"56",6543,32,65,765];
array.sort(); //3,32,43,4321,56,65,6543,765

杂乱无章，只比较了第一位数。

比较函数吸收两个参数，假如第一个参数应该位于第二个之前，则返回一个复数，假如两个参数相称则返回0，假如第一个参数应该位于第二个参数背面，则返回一个正数。一般返回第二个参数减掉第一个参数的值就可以了（在数值范例或其valueOf()要领返回数值范例的对象范例的情况下）。如：

var array = [3,1,6,"10"];
array.sort(compare);

function compare(value1,value2){
    return value1 - value2; //假如value1 - value2 是正数，则申明value1 大于value2，value1 应该排在背面。为升序分列；
};

document.write(array); //[1,3,6,10]

假如想要降序分列，则修正一下compare函数成value2 – value1 就可以了。如：

var array = [3,1,6,"10"];
array.sort(compare);

function compare(value1,value2){
    return value2 - value1; //假如value2 - value1 是正数，则申明value2 大于value1，value1 应该排在背面。为降序分列；
};

document.write(array); //[10,6,3,1]

然则假如是恣意范例，则不能运用这类要领。而应该对参数举行比较。如：

var array = ["Oliver","Troy",{name:"troy"},"Alice"];
array = array.sort(compare);
document.write(array); //Alice,Oliver,Troy,[object Object]

function compare(x,y){
    if(x > y){
        return 1;
    }else if(x < y){
        return -1;
    }else{
        return 0;
    }
}

或许：

var array = ["Oliver","Troy",{name:"troy"},"Alice"];
array = array.sort(compare);
document.write(array); //Alice,Oliver,Troy,[object Object]

function compare(x,y){
    if(x < y){
        return 1;
    }else if(x > y){
        return -1;
    }else{
        return 0;
    }
}

假如只是想翻转本来数组的递次，运用reverse()要领就好了，如：

var array = [3,1,6,"10"];
array.reverse();
document.write(array); //10,6,1,3

操纵要领

concat()要领，重要作用就是复制当前的数组并返回副本。如：（不影响原始数组）

var array = ["abc",123,{name:"Oliver"}];
var newArray = array.concat("abc",[123,32,{age:18}]);
document.write(newArray); // abc,123,[object Object],abc,123,32,[object Object]

slice()要领，重要作用是基于当前数组中的一个或多个项建立的一个新数组。如：（不影响原始数组）

var array = ["a","b","c","d"];
var newArray = array.slice(2);
document.write(newArray); //c,d
newArray = array.slice(1,2);
document.write(newArray); //b

假如只要一个参数，返回从该参数指定位置到数组末尾的一切项;假如有两个参数，返回肇端位置和完毕位置之间的项，但不包含完毕位置的项。假如，参数中有负数，则用数组长度加上该数来肯定响应的位置。

splice()的重要用法：

• 删除，2个参数：要删除的第一项和要删除的项数；

• 插进去，3个参数：肇端位置、0（要删除的项数）和要插进去的项；

• 替代，3个参数：肇端位置、要删除的项数和要插进去的恣意数目的项；

该要领一直都邑返回一个数组。举个例子：

删除：

var cars = ["宝马","奔驰","沃尔沃"];
var deleteCar = cars.splice(1, 2);
console.log(deleteCar); //["奔驰", "沃尔沃"]

插进去：

var cars = ["宝马","奔驰","沃尔沃"];
var addCar = cars.splice(1, 0, "特斯拉","保时捷");
console.log(cars); //["宝马", "特斯拉", "保时捷", "奔驰", "沃尔沃"]

替代：

var cars = ["宝马","奔驰","沃尔沃"];
var replaceCar = cars.splice(1, 1, "保时捷");
console.log(replaceCar); //["奔驰"] 删除了奔驰
console.log(cars); //["宝马", "保时捷", "沃尔沃"] 用保时捷替代了奔驰

位置要领

indexOf()要领和lastIndexOf()要领。一个是从数组的开首（位置0）最先向后查找；另一个则是从数组的末尾最先向前查找。有两个参数：要查找的项和示意查找出发点的位置索引。在比较第一个参数与数组中的每一项时，会运用全等操纵符。如：

var numbers = [1,2,3,4,5,3];
document.write(numbers.indexOf(4)); //3
document.write(numbers.indexOf(4,5)); //-1 从第5索引最先查找，找不到就返回-1

document.write(numbers.lastIndexOf(3)); //5
document.write(numbers.lastIndexOf(3,0)); //-1 从第0索引最先反向查找，找不到就返回-1

document.write(numbers.indexOf(3)); //2 这里有两个3 然则当搜刮到第一个时就会住手搜刮

Mark！！！！！！

Mark！！！！！！

Mark！！！！！！

var oliver = {name:"oliver"};
var person = [{name:"oliver"}];

var people = [oliver];

document.write(person.indexOf({name:"oliver"})); //-1
document.write(person.indexOf(oliver)); //-1

document.write(people.indexOf({name:"oliver"})); //-1
document.write(people.indexOf(oliver)); //0 必需变量搜刮变量

迭代要领和合并要领

迭代要领

有5 个迭代要领，每一个要领吸收两个参数：要在每一项上运转的函数和作用域对象（可选）；传入这些要领中的函数则吸收三个参数：数组项的值（item）、索引位置（index）、数组对象自身（array）。

• every()：每一项运转该函数，假如都返回true，则返回true；（返回Noolean）（重如果考证）

• some()：每一项运转该函数，假如个中任一项返回true，则返回true；（返回Boolean）（重如果考证）

• filter()：每一项运转该函数，关于那些返回true的项，构成一个数组；（返回Array）（重如果考证）

• map()：每一项运转该函数，返回的效果构成一个数组；（返回Array）(对数组操纵)

• forEach()：每一项运转该函数，没有返回值；（不返回）（对数组操纵）(本质上与for 语句相似)

下面是例子：

every()：

var numbers = [1,3,2,5,4];
var result = numbers.every(function(item, index, array){
    return item > 0;
});
document.write(result); //都大于零，返回true

some()：

var numbers = [1,5,4,32];
var result = numbers.some(function(item, index, Array){
    return item > 31;
});
document.write(result); //true 数组中至少有一项满足前提，返回true

filter()：

var array = [123,"Oliver","Troy",true];
var newArray = array.filter(function(item, index, array){
    return typeof item == "string";
});
console.log(newArray); //["Oliver", "Troy"] 把满足前提的部份返回一个数组

map()：

var array = [123,"Oliver","Troy",true];
var newArray = array.map(function(item, index, array){
    return item += " (Oliver)";
});
console.log(newArray); //["123 (Oliver)", "Oliver (Oliver)", "Troy (Oliver)", "true (Oliver)"]

forEach()：

    var array = [123,"Oliver","Troy",true];
array.forEach(function(item, index, array){
    if (typeof item == "number"){
        document.write((item + 877) + "<br/>");
    }else if (typeof item == "string"){
        document.write("This is a string: " + item + "<br/>")
    }else{
        document.write(item + "ly")
    }
});

/*
1000
This is a string: Oliver
This is a string: Troy
truely
*/

合并要领（ECMAScript 5 新增）

两个要领：reduce()和reduceRight()，这两个要领都邑迭代数组的一切项，然后构建一个终究返回的值。前者是从数组的第一项最先，后者是从数组的末了一项最先。他们有两个参数：一个在每一项上挪用的函数和最为合并基本的初始值。函数则包含4 个参数：前一个值（prev）、当前值（cur）、项的索引（index）、数组自身（array）。如：

var numbers = [1,3,2,4,5,7,6];
var result = numbers.reduce(function(prev, cur, index, array){
    return prev + cur;
});
console.log(result); //28

又如：

var array = [321,false,"Oliver",21];
var newArray = array.reduce(function(prev, cur, index, array){
    return prev + cur;
});
console.log(newArray); //321Oliver21
newArray = array.reduceRight(function(prev, cur, index, array){
    return prev + cur;
});
console.log(newArray); //21Oliverfalse321 这里涌现了false 是因为+ 操纵符的缘由
console.log(21+"oliver"+false+321); //false 被转换成字符串
console.log(321+false+"oliver"+21); //false 被转换成数值
console.log(321+(false+"oliver"+21)); //false 被转换字符串，括号的缘由

（本日内容还真是有点多，看007去了，返来再温习）