JS数组

1.创建数组

（1）语法：

var array-name = [item1, item2, ...];

例子：

 var cars = ["Saab", "Volvo", "BMW"];

（2）使用 JavaScript 关键词 new：（不建议使用，请使用 [] 取而代之！）

var cars = new Array("Saab", "Volvo", "BMW");

2.访问数组

（1）访问数组元素
通过引用索引号（下标号）来引用某个数组元素——array[i]
数组索引从 0 开始。

改变数组元素
array[i]=value，直接可以改值

（2）访问完整数组
通过引用数组名来访问完整数组——arrayname

3.数组与对象

（1）数组是对象
数组是一种特殊类型的对象。
在 JavaScript 中对数组使用 typeof 运算符会返回 "object"。

但是，JavaScript 数组最好以数组来描述。

数组使用数字来访问其“元素”。
对象使用名称来访问其“成员”。

在 JavaScript 中，数组使用数字索引。
在 JavaScript 中，对象使用命名索引。
数组是特殊类型的对象，具有数字索引。

（2）数组元素是对象
JavaScript 变量可以是对象。数组是特殊类型的对象。（三遍求记住！）

可以在相同数组中存放不同类型的变量。

！！！可以在数组保存对象、函数和数组。

myArray[0] = Date.now;//对象
myArray[1] = myFunction;//函数
myArray[2] = myCars;//数组

4.length属性

length 属性返回数组的长度（数组元素的数目）。
length 属性始终大于最高数组索引（下标）。

访问第一个数组元素 :array[0]
访问最后一个数组元素: array[array.length-1]

5.遍历数组元素

遍历数组的最安全方法是使用 "for" 循环。
也可以使用 Array.foreach() 函数。

var fruits, text;
fruits = ["Banana", "Orange", "Apple", "Mango"];

text = "<ul>";
fruits.forEach(myFunction);
text += "</ul>";

function myFunction(value) {
  text += "<li>" + value + "</li>";
}

6.添加数组元素

（1）向数组添加新元素的最佳方法是使用 push() 方法。
（2）可以使用 length 属性向数组添加新元素

fruits[fruits.length] = "Lemon";     // 向 fruits 添加一个新元素 (Lemon)

（3）添加最高索引的元素可在数组中创建未定义的“洞”，然后添加索引位置的新元素。注意：可能在中间产生undefined的数组元素。

7.关联数组

很多编程元素（python）支持命名索引的数组。
具有命名索引的数组被称为关联数组（或散列）。

JavaScript 不支持命名索引的数组。
在 JavaScript 中，数组只能使用数字索引。

var person = [];
person["firstName"] = "Bill";
person["lastName"] = "Gates";
person["age"] = 62;
var x = person.length;         // person.length 将返回 0
var y = person[0];              // person[0] 将返回 undefined

如果希望元素名为 字符串（文本） 则应该使用 对象。
如果希望元素名为数字则应该使用数组。

8.识别数组

typeof 运算符返回 "object"，因为 JavaScript 数组属于对象。
怎么办呢？
（1）ES5的Array.isArray()：

Array.isArray(fruits);     // 返回 true

（2）创建 isArray() 函数

function isArray(x) {
    return x.constructor.toString().indexOf("Array") > -1;
}
也可以是这样：
function isArray(myArray) {
    return myArray.constructor === Array;
}

假如对象原型包含单词 “Array” 则返回 true。

constructor属性可以在JS类型转换复习

点击此处，查看例子

（3）对象由给定的构造器创建，则 instanceof 运算符返回 true

var fruits = ["Banana", "Orange", "Apple", "Mango"];
 
fruits instanceof Array     // 返回 true

点击此处，查看例子

9.数组方法

（1）toSting()方法
把数组转换为数组值（逗号分隔）的字符串。

（2）join()方法
可将所有数组元素结合为一个字符串。
它的行为类似 toString()，还可以规定分隔符。
例如：

  array.join("&");

（3）pop()方法
pop() 方法从数组中删除最后一个元素。
pop() 方法返回“被弹出”的值。

（4）push()方法
push() 方法（在数组结尾处）向数组添加一个新的元素。
push() 方法返回新数组的长度。

（5）shift()方法
shift() 方法会删除首个数组元素，并把所有其他元素“位移”到更低的索引。
shift() 方法返回被“位移出”的字符串。

（6）unshift()方法
unshift() 方法（在开头）向数组添加新元素，并“反向位移”旧元素。
unshift() 方法返回新数组的长度。

（7）delete()方法
既然 JavaScript 数组属于对象，其中的元素就可以使用JS delete 运算符来删除。

var fruits = ["Banana", "Orange", "Apple", "Mango"];
delete fruits[0];           // 把 fruits 中的首个元素改为 undefined

使用 delete 会在数组留下未定义的空洞。请使用 pop() 或 shift() 取而代之。

（8）splice()方法
splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。该方法会改变原始数组。
语法：
arrayObject.splice(index,howmany,item1,.....,itemX)

index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany ：必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, ..., itemX：可选。向数组添加的新项目。

点击此处，查看例子

（9）concat()方法
通过合并（连接）现有数组来创建一个新数组。
concat() 方法不会更改现有数组。它总是返回一个新数组。
concat() 方法可以使用任意数量的数组参数。

var arr1 = ["Cecilie", "Lone"];
var arr2 = ["Emil", "Tobias", "Linus"];
var arr3 = ["Robin", "Morgan"];
var myChildren = arr1.concat(arr2, arr3);   // 将arr1、arr2 与 arr3 连接在一起

concat() 方法也可以将值作为参数，将数组与值合并。

var arr1 = ["Cecilie", "Lone"];
var myChildren = arr1.concat(["Emil", "Tobias", "Linus"]); 

（10）slice()方法
用数组的某个片段切出新数组。

语法：

arrayObject.slice(start,end)

start：必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。

end ：可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。

10.数组排序

（1）sort()方法
以字母顺序对数组进行排序。

默认地，sort() 函数按照字符串顺序对值进行排序。
该函数很适合字符串（“Apple” 会排在 “Banana” 之前）。
不过，如果数字按照字符串来排序，则 “25” 大于 “100”，因为 “2” 大于 “1”。

正因如此，sort() 方法在对数值排序时会产生不正确的结果。
可以通过一个比值函数来修正此问题：

var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return a - b});  //b-a降序

比值函数
比较函数的目的是定义另一种排序顺序。
比较函数应该返回一个负，零或正值，这取决于参数：

function(a, b){return a-b}

当 sort() 函数比较两个值时，会将值发送到比较函数，并根据所返回的值（负、零或正值）对这些值进行排序。

（2）reverse() 方法
反转数组中的元素。
可以使用它以降序对数组进行排序：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();            // 对 fruits 中的元素进行排序
fruits.reverse();         // 反转元素顺序

（3）以随机顺序排序数组

var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return 0.5 - Math.random()}); 

（4）查找最高（或最低）的数组值
使用 Math.max()或者Math.min()方法
这俩个函数的参数只能是数值，不能是非数值，比如数组。

Math.max.apply()和Math.min.apply()方法可以查找数组的最高值和最低值。

要知道：

 Math.max.apply([1, 2, 3]) 等于 Math.max(1, 2, 3)。

所以:
Math. max/min .apply( null/Math , arr)；
null和Math都可以。

点击此处，查看例子

（5）自制Min / Max JavaScript 方法
查找 Max：

function myArrayMax(arr) {
    var len = arr.length
    var max = -Infinity;
    while (len--) {
        if (arr[len] > max) {
            max = arr[len];
        }
    }
    return max;
}

查找 Min：

function myArrayMin(arr) {
    var len = arr.length
    var min = Infinity;
    while (len--) {
        if (arr[len] < min) {
            min = arr[len];
        }
    }
    return min;
}

（6）排序对象数组、
avaScript 数组经常会包含对象：

var cars = [
{type:"Volvo", year:2016},
{type:"Saab", year:2001},
{type:"BMW", year:2010}];

即使对象拥有不同数据类型的属性，sort() 方法仍可用于对数组进行排序。
通过比较函数来对比属性值：
对于数值：

cars.sort(function(a, b){return a.year - b.year});

比较字符串属性会稍复杂：

cars.sort(function(a, b){
	  var x = a.type.toLowerCase();
	  var y = b.type.toLowerCase();
	  if (x < y) {return -1;}
	  if (x > y) {return 1;}
	  return 0;
});

11.数组迭代方法

（1）Array.forEach()
为每个数组元素调用一次函数（回调函数）。
注意: forEach() 对于空数组是不会执行回调函数的。

array.forEach(function(currentValue, index, arr), thisValue)

function(currentValue, index, arr) ：必需。 数组中每个元素需要调用的函数。
函数参数:
currentValue： 必需。当前元素
index ：可选。当前元素的索引值。
arr ：可选。当前元素所属的数组对象。

thisValue ：可选。传递给函数的值一般用"this"值。
如果这个参数为空，"undefined"会传递给 "this"值

var txt = "";
var numbers = [45, 4, 9, 16, 25];
numbers.forEach(myFunction);

function myFunction(value, index, array) {//只有value也可以
  txt = txt + value + "<br>"; 
}

（2）Array.map()
map() 方法通过对每个数组元素执行函数来创建新数组。
map() 方法不会对没有值的数组元素执行函数。
map() 方法不会更改原始数组。
它的参数和foreach()一样。

var numbers1 = [45, 4, 9, 16, 25];
var numbers2 = numbers1.map(myFunction);

function myFunction(value, index, array) {
  return value * 2;
}

（3）Array.filter()
filter() 方法创建一个包含通过测试的数组元素的新数组。
它的参数和foreach()一样。

这个例子用值大于 18 的元素创建一个新数组：

var numbers = [45, 4, 9, 16, 25];
var over18 = numbers.filter(myFunction);
    
function myFunction(value, index, array) {
  return value > 18;
}

（4）Array.reduce()
reduce() 方法在每个数组元素上运行函数，以生成（减少它）单个值。
reduce() 方法在数组中从左到右工作。
reduce() 方法不会减少原始数组。
它的三个参数和foreach()一样。
多了一个参数：total总数（初始值/先前返回的值）

这个例子确定数组中所有数字的总和：

var numbers1 = [45, 4, 9, 16, 25];
var sum = numbers1.reduce(myFunction);

function myFunction(total, value, index, array) {
  return total + value;
}

点击此处，查看例子

（5）Array.reduceRight()
reduceRight() 方法在每个数组元素上运行函数，以生成（减少它）单个值。
reduceRight() 方法在数组中从右到左工作。
reduceRight() 方法不会减少原始数组。

同reduce()方法一样，有四个参数。

（6）Array.every()
every() 方法检查所有数组值是否通过测试。返回true/false。

（7）Array.some()
some() 方法检查某些数组值是否通过了测试。返回true/false。

●filter、every、some的区别

filter()是指只要通过测试的数组元素，就创建一个数组来“包含”它们。
every()是指全部、所有、all数组元素“都”通过了测试，就返回true。
some()是指某些、某个、至少一个数组元素通过了测试，就返回true。

（8）Array.indexOf()
indexOf() 方法在数组中搜索元素值并返回其位置。

注释：第一个项目的位置是 0，第二个项目的位置是 1，以此类推。

语法：

array.indexOf(item, start)

item ：必需。要检索的项目。
start ：可选。从哪里开始搜索。负值将从结尾开始的给定位置开始，并搜索到结尾。

如果未找到项目，Array.indexOf() 返回 -1。
如果项目多次出现，则返回第一次出现的位置。

例子：

var fruits = ["Apple", "Orange", "Apple", "Mango"];

var a = fruits.indexOf("Apple");//返回0

var b = fruits.indexOf("Apple",1);//返回2

（9）Array.lastIndexOf()
Array.lastIndexOf() 与 Array.indexOf() 类似，但是从数组结尾开始搜索。
参数同上。

（10）Array.find()
find() 方法返回通过测试函数的第一个数组元素的值。
它的参数和foreach()一样。
点击此处，查看例子

（11）Array.findIndex()
findIndex() 方法返回通过测试函数的第一个数组元素的索引。
它的参数和foreach()一样。

注释：第一个项目的位置是 0，第二个项目的位置是 1，以此类推。