JavaScript基础——数组

一、数组创建

　　（一）创建数组

　　　方法有两种：

　　创建方法一：使用 Array()函数构造法

　　带new操作符的数组

var colors = new Array();
var colors = new Array("red", "blue", "green");// 创建一个包含 3 项的字符串的数组
var colors = new Array(3); // 创建一个包含 3 项的数组
var names = new Array("Greg"); // 创建一个包含 1 项，即字符串"Greg"的数组

　　不带new操作符的数组

var colors = Array(3); // 创建一个包含 3 项的数组
var names = Array("Greg"); // 创建一个包含 1 项，即字符串"Greg"的数组

　　创建方法二：使用数组字面量表示法

　　数组字面量由一对包含数组项的方括号表示，多个数组项之间以逗号隔开，

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
var names = []; // 创建一个空数组
var values = [1,2,]; // 不推荐不使用！这样会创建一个包含 2 或 3 项的数组
var options = [,,,,,]; // 不推荐不使用！这样会创建一个包含 5 或 6 项的数组

　　（二）读取数组、修改数组

var colors = ["red", "blue", "green"]; // 定义一个字符串数组
alert(colors[0]); // 显示第一项
colors[2] = "black"; // 修改第三项
colors[3] = "brown"; // 新增第四项

　　方括号中的索引表示要访问的值。索引值从0开始。

　　（三）取数组长度

　　取数组的长度用用数组的length 属性，length属性的值是大于0或等于0。

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
var names = []; // 创建一个空数组
alert(colors.length); //3 
alert(names.length); //0

　　通过设置length属性，可以从数组的末尾移除项或向数组中添加新项。

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
colors.length = 2; 
alert(colors[2]); //undefined

　　如果将其 length 属性设置为大于数组项数的值，则新增的每一项都会取得 undefined 值。

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
colors.length = 4; 
alert(colors[3]); //undefined

　　利用 length 属性也可以方便地在数组末尾添加新项。

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
colors[colors.length] = "black"; //（在位置 3）添加一种颜色
colors[colors.length] = "brown"; //（在位置 4）再添加一种颜色

二、数组检测

　　使用 Array.isArray()方法

if (Array.isArray(value)){ 
 //对数组执行某些操作
}

三、数组转换

　　所有对象都具有 toLocaleString()、toString()和 valueOf()方法。

（一）toString()方法

　　数组的 toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串。

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
alert(colors.toString()); // red,blue,green 
alert(colors.valueOf()); // red,blue,green 
alert(colors); // red,blue,green

（二）valueOf()方法

　　数组的valueOf()返回的还是数组。

　　

（三） toLocaleString()方法

　　toLocaleString()方法经常也会返回与 toString()和 valueOf()方法相同的值，但也不总是如此。当调用数组的 toLocaleString()方法时，它也会创建一个数组值的以逗号分隔的字符串。而与前两个方法唯一的不同之处在于，这一次为了取得每一项的值，调用的是每一项的 toLocaleString()方法，而不是 toString()方法。　　

var person1 = { 
 　　toLocaleString : function () { 
 　　return "Nikolaos"; 
 }, 
 
 　　toString : function() { 
 　　return "Nicholas"; 
 } 
}; 
var person2 = { 
 　　toLocaleString : function () { 
 　　return "Grigorios"; 
 }, 
 
 　　toString : function() { 
 　　return "Greg"; 
 } 
}; 
　　var people = [person1, person2]; 
alert(people); //Nicholas,Greg 
alert(people.toString()); //Nicholas,Greg 
alert(people.toLocaleString()); //Nikolaos,Grigorios

（四）join()方法

　　自定义分隔符来分割数组值。来实现toLocaleString()、toString()和 valueOf()方法的从定义默认的逗号分隔。

var colors = ["red", "green", "blue"]; 
alert(colors.join(",")); //red,green,blue 
alert(colors.join("||")); //red||green||blue

　　如果数组中的某一项的值是 null 或者 undefined，那么该值在 join()、toLocaleString()、toString()和 valueOf()方法返回的结果中以空字符串表示。

四、棧方法

　　栈是一种 LIFO（Last-In-First-Out，后进先出/先进后出）的数据结构，也就是最新添加的项最早被移除。

　　而栈中项的插入（叫做推入）和移除（叫做弹出），只发生在一个位置——栈的顶部。

　　数组专门提供了 push()和 pop()方法

（一）push()方法

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

var colors = new Array(); // 创建一个数组
var count = colors.push("red", "green"); // 推入两项
alert(count); //2 
count = colors.push("black"); // 推入另一项
alert(count); //3 
var item = colors.pop(); // 取得最后一项
alert(item); //"black" 
alert(colors.length); //2

（二）pop()方法

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

　　示例同上。

　　可以将栈方法与其他数组方法连用。

var colors = ["red", "blue"]; 
colors.push("brown"); // 向数组尾部添加另一项
colors[3] = "black"; // 向数组尾部添加一项
alert(colors.length); // 4 
var item = colors.pop(); // 取得最后一项
alert(item); //"black"

五、队列方法

　　栈数据结构的访问规则是 LIFO（后进先出），而队列数据结构的访问规则是 FIFO（First-In-First-Out，先进先出）。

　　队列在列表的末端添加项，从列表的前端移除项。

　　由于 push()是向数组末端添加项的方法，因此要模拟队列只需一个从数组前端取得项的方法。

　　实现这一操作的数组方法就是 shift()，它能够移除数组中的第一个项并返回该项，同时将数组长度减 1。

 （一）shift()方法

 　　shift（）方法，实现这一操作的数组方法就是 shift()，它能够移除数组中的第一个项并返回该项，同时将数组长度减 1。

var colors = new Array(); //创建一个数组
var count = colors.push("red", "green"); //推入两项
alert(count); //2 
count = colors.push("black"); //向数组尾部推入另一项
alert(count); //3 
var item = colors.shift(); //取得第一项
alert(item); //"red" 
alert(colors.length); //2
alert(colors.lcolors);//"green,black"

（二） unshift()方法 

　　unshift()与 shift()的用途相反：它能在数组前端添加任意个项并返回新数组的长度。

　　因此，同时使用 unshift()和 pop()方法，可以从相反的方向来模拟队列，即在数组的前端添加项，从数组末端移除项，

var colors = new Array(); //创建一个数组
var count = colors.unshift("red", "green"); //推入两项
alert(count); //2

count = colors.unshift("black"); //推入另一项
alert(count); //3 

var item = colors.pop(); //取得最后一项
alert(item); //"green" 
alert(colors.length); //2
alert(colors);//"black,red"

六、数据排序方法

　　数组中已经存在两个可以直接用来重排序的方法：reverse()和 sort()。

（一）reverse()方法

　　reverse()方法：把数组值原来的排列顺序反过来（12345  ---->   54321，或54321  ---> 12345）

var values = [1, 2, 3, 4, 5]; 
values.reverse(); 
alert(values); //5,4,3,2,1

（二）sort()方法

　　这个方法的作用相当直观明了，但不够灵活，因此才有了 sort()方法。

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; 
     } 
}

var values = [0, 1, 5, 10, 15]; 
values.sort(compare);
alert(values); //0,1,5,10,15

　　降序排列

function compare(value1, value2) { 
     if (value1 < value2) { 
     return 1; 
     } else if (value1 > value2) { 
     return -1; 
     } else { 
     return 0; 
     } 
} 
var values = [0, 1, 5, 10, 15]; 
values.sort(compare); 
alert(values); // 15,10,5,1,0

（三）valueOf()方法

　　valueOf()方法会返回数值类型的对象类型，可以使用一个更简单的比较函数。这个函数只要用第二个值减第一个值即可。

function compare(value1, value2){ 
     return value2 - value1; 
}

七、数组操作方法

 concat()方法、slice()方法、

（一）concat()方法

 　　这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。

　　在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。

　　如果传递给 concat()方法的是一或多个数组，则该方法会将这些数组中的每一项都添加到结果数组中。

　　如果传递的值不是数组，这些值就会被简单地添加到结果数组的末尾。

　　个人理解：将两个数组合并成一个新数组。

var colors = ["red", "green", "blue"]; 
var colors2 = colors.concat("yellow", ["black", "brown"]); 
alert(colors); //red,green,blue 
alert(colors2); //red,green,blue,yellow,black,brown

（二）slice()方法

普通用法：

　　slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。

　　在只有一个参数的情况下，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。

　　如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。注意，slice()方法不会影响原始数组。

　　slice()方法的其他用法。删除、插入、替换。

var colors = ["red", "green", "blue", "yellow", "purple"]; 
var colors2 = colors.slice(1); 
var colors3 = colors.slice(1,4); 
alert(colors2); //green,blue,yellow,purple 
alert(colors3); //green,blue,yellow

其它用法：

　　splice()的主要用途是向数组的中部插入项，但使用这种方法的方式则有如下 3 种。
　　 删除：可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。
　　例如，splice(0,2)会删除数组中的前两项。
　　

　　 插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、0（要删除的项数）和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多个项。

　　例如，splice(2,0,"red","green")会从当前数组的位置 2 开始插入字符串"red"和"green"。
　　

　　 替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。

　　例如，splice (2,1,"red","green")会删除当前数组位置 2 的项，然后再从位置 2 开始插入字符串"red"和"green"。

var colors = ["red", "green", "blue"]; 
var removed = colors.splice(0,1); // 删除第一项
alert(colors); // green,blue 
alert(removed); // red，返回的数组中只包含一项

removed = colors.splice(1, 0, "yellow", "orange"); // 从位置 1 开始插入两项
alert(colors); // green,yellow,orange,blue 
alert(removed); // 返回的是一个空数组

removed = colors.splice(1, 1, "red", "purple"); // 插入两项，删除一项
alert(colors); // green,red,purple,orange,blue 
alert(removed); // yellow，返回的数组中只包含一项

八、位置方法

　　数组查找

　　Java中字符串中子串的查找共有四种方法，如下：
　　1、int indexOf(String str) ：返回第一次出现的指定子字符串在此字符串中的索引。 
　　2、int indexOf(String str, int startIndex)：从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。 
　　3、int lastIndexOf(String str) ：返回在此字符串中最右边出现的指定子字符串的索引。 
　　4、int lastIndexOf(String str, int startIndex) ：从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。 

　　indexOf()方法：从前往后查找

　　lastIndexOf()方法：从后往前查找

var numbers = [1,2,3,4,5,4,3,2,1]; 

alert(numbers.indexOf(4)); //3　　在数组的值中，从前往后查找，返回第一个4所在的位置。
alert(numbers.lastIndexOf(4)); //5 　　在数组的值中，从后往前查找，最右边4所在的位置。

alert(numbers.indexOf(4, 4)); //5 　　
alert(numbers.lastIndexOf(4, 4)); //3 

var person = { name: "Nicholas" }; 
var people = [{ name: "Nicholas" }]; 

var morePeople = [person]; 

alert(people.indexOf(person)); //-1 
alert(morePeople.indexOf(person)); //0

 九、迭代方法

　　（一）迭代方法名称： 

　　5 个迭代方法every()、filter()、forEach()、map()、some()

 　　（二）作用：

　　 every()：对数组中的每一项运行给定函数，如果该函数对每一项都返回 true，则返回 true。（全部为真，返回真）只返回真与假
　　 filter()：对数组中的每一项运行给定函数，返回该函数会返回 true 的项组成的数组。(仅返回为真的数组值)返回数组
　　 forEach()：对数组中的每一项运行给定函数。这个方法没有返回值。
　　 map()：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。（返回函数结果的数组）返回数组
　　 some()：对数组中的每一项运行给定函数，如果该函数对任一项返回 true，则返回 true。（其中任意一项为真，返回真）只返回真与假
　　以上方法都不会修改数组中的包含的值。

　　every() some()

var numbers = [1,2,3,4,5,4,3,2,1]; 

var everyResult = numbers.every(function(item, index, array){ 
 return (item > 2); 
}); 

alert(everyResult); //false 

var someResult = numbers.some(function(item, index, array){ 
 return (item > 2); 
}); 

alert(someResult); //true

　　filter()

var numbers = [1,2,3,4,5,4,3,2,1]; 

var filterResult = numbers.filter(function(item, index, array){ 
 return (item > 2); 
}); 

alert(filterResult); //[3,4,5,4,3]

　　map()

var numbers = [1,2,3,4,5,4,3,2,1]; 

var mapResult = numbers.map(function(item, index, array){ 
 return item * 2; 
}); 

alert(mapResult); //[2,4,6,8,10,8,6,4,2]

　　forEach()

　　它只是对数组中的每一项运行传入的函数。这个方法没有返回值，本质上与使用 for 循环迭代数组一样。

var numbers = [1,2,3,4,5,4,3,2,1]; 

numbers.forEach(function(item, index, array){ 
 //执行某些操作 
});

 十、归并方法

 　　两个归并数组的方法：reduce()和 reduceRight()。

 　　这两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。传给 reduce()和 reduceRight()的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象。

　　这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数就是数组的第二项。

 　　reduce()方法

　　reduce()方法从数组的第一项开始，逐个遍历到最后。（前---->后遍历）

var values = [1,2,3,4,5]; 

var sum = values.reduce(function(prev, cur, index, array){ 
 return prev + cur; 
}); 
alert(sum); //15　　1+2+3+4+5=15

　　reduceRight()方法

　　reduceRight()则从数组的最后一项开始，向前遍历到第一项。（后---->前遍历）

var values = [1,2,3,4,5]; 

var sum = values.reduceRight(function(prev, cur, index, array){ 
 return prev + cur; 
}); 
alert(sum); //15　　5+4+3+2+1=15

【数组思维导图】

【注解词汇】

1、new    英 [njuː]   美 [nuː] 　　新的

2、array　　英 [əˈreɪ]   美 [əˈreɪ] 　　数组

3、length　　英 [leŋθ]   美 [leŋθ] 　　长度

4、slice　　英 [slaɪs]   美 [slaɪs] 

5、every()　　英 [ˈevri]   美 [ˈevri]　　每一个

6、filter()　　英 [ˈfɪltə(r)]   美 [ˈfɪltər]

7、forEach()

8、map()

9、some()　　英 [səm , sʌm]   美 [səm , sʌm]