JavaScript学习初阶06-数组

数组定义

var cars = ["Saab", "Volvo", "BMW"];
//或者
var cars = new Array("Saab", "Volvo", "BMW");（简洁、可读性和执行速度的考虑，请使用第一种方法）

数组类型判断

由于数组的类型时object,所有没办法通过typeof 判断出是数组还是对象，可以通过Array.isArray()函数来判断

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

访问完整数组

var x = cars; // x = "Saab,Volvo,BMW"；

toString()  
cars.toString();

数组属性

//length 属性返回数组的长度（数组元素的数目）
cars.length  //cars的长度是 4

数组得简单方法

Array.indexOf(Object obj,[Number start])，在数组中搜索元素值并返回其位置
第一个参数是所要查找得元素
第二个是查找得开始位置

Array.lastIndexOf(Object obj,[Number start])) 跟indexOf一样得功能，只不过是从右往左

遍历数组元素

//方法1，是使用 "for" 循环
for (i = 0; i < cars.length; i++) {} 
//方法2，是使用Array.foreach() 函数
cars.forEach(myFunction);
function myFunction(value,index,array) {  //函数接收三个参数，元素的值，元素的下标，还有数组的引用
text += value；
}

添加数组元素

//js的数组时动态数组，能自由的增删
方法1，push() 方法
cars.push("HONDA“);
//方法2，length 属性
cars[cars.length] = "HONDA";
//方法3，unshift() 方法（在开头）向数组添加新元素，并“反向位移”旧元素，返回新数组的长度
var x = cars.unshift("HONDA"); //x = 4 ,car = ["HONDA","Saab","Volvo","BMW"];

删除数组元素

//方法1，pop() 方法从数组中删除最后一个元素
var x = cars.pop() ;  //x = "BMW"; car = ["Saab", "Volvo"];
//方法2，shift() 方法会删除首个数组元素，并把所有其他元素“位移”到更低的索引
var x  = cars.shift(); //x = "Saab";  car = ["Volvo","BMW"];
//方法3，delete,使用 delete 会在数组留下未定义的空洞,最好使用 pop() 或 shift() 取而代之
delete cars[0];

拼接数组(插入或删除非首尾的元素)

splice(Number x,Number y, [Obj obj,…Obj obj]) 方法可用于向数组添加新项
第一个参数定义了应添加新元素的位置（拼接）。
第二个参数定义应删除多少元素
其余参数定义要添加的新元素

//拼接（增加）
cars.splice(2,0,"HONDA","Tai");
//命令解释，在第二个元素后，删掉0个元素，并插上后面两个元素，cars = ["Saab", "Volvo","HONDA","Tai",BMW]

//拼接（减少）
cars.splice(2,1);
//cars =  ["Saab", "Volvo","Tai",BMW]

合并数组

concat() 方法通过合并（连接）现有数组来创建一个新数组

//合并两个
var a = [1];
var b = [2];
var c = a.concat(b) ;
//c = [1,2];

//合并三个
var a = [1];
var b = [2];
var c = [3];
var d = a.concat(a,b);
//d = [1,2,3];

裁剪数组

slice(Number x,[Number y]) 方法用数组的某个片段切出新数组,可接受1个或者2个参数

var a = cars.slice(2);
//a = ["BMW"]；

var a = cars.slice(1,2);
//a = ["Volvo","BMW"];

数组排序

sort() 方法以字母顺序对数组进行排序,在对数值排序时会产生不正确的结果

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

reverse() 方法反转数组中的元素

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

比较函数

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

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

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

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

查找数组的最高最低值

1. 排序后选出来
2. 使用 Math.max.apply(null, arr) / Math.min.apply(null, arr)

var points = [40, 100, 1, 5, 25, 10];
var x = Math.max.apply(null, points );  // x = 100;
var x =Math.min.apply(null, points ); 	// x = 1;
//p:两个或者多个数字比较能用Math.max()方法
var x = Math.max(1,2,3) //x = 3

对象数组排序

只是比较函数的一种应用而已

var cars = [
{type:"Volvo", year:2016},
{type:"Saab", year:2001},
{type:"BMW", year:2010}];
cars.sort(function(a, b){return a.year - b.year});//根据年份的大小来排序

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

数组迭代方法

1. Array.forEach()

   上面有详细介绍

2. Array.map()

   通过对一个数组的每个元素执行定义的规则来创建一个新的函数

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

function myFunction(value, index, array) {
  return value * 2; //定义的规则
}

3. Array.filter()

   通过对一个数组的每个元素执行定义的规则，用符合条件的元素创建另一个新的数组

var numbers = [45, 4, 9, 16, 25];
var over18 = numbers.filter(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

4. Array.reduce()

   对一个数组的每个元素执行定义的规则，生成一个与所有数组元素相关的值
   这个比较函数是4个参数(total, value, index, array)，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()

   跟4是一样得规则，不过数组遍历得方向是从右往左，而4是从左往右

6. Array.every()

   every() 方法检查所有数组值是否符合所定制得规则，函数返回逻辑值

var numbers = [45, 4, 9, 16, 25];
var allOver18 = numbers.every(myFunction);
// allOver18 = false

function myFunction(value) {
  return value > 18;
}

7. Array.some()

   some() 方法检查所有数组值是否存在有元素符合所定制得规则，函数返回逻辑值

var numbers = [45, 4, 9, 16, 25];
var someOver18 = numbers.some(myFunction);
// someOver18 = true

function myFunction(value) {
  return value > 18;
}

8. Array.find()

   find() 方法返回通过测试函数的第一个数组元素的值

var numbers = [4, 9, 16, 25, 29];
var first = numbers.find(myFunction);
//first = 25

function myFunction(value, index, array) {
  return value > 18;
}

9. Array.findIndex()

   findIndex() 方法返回通过测试函数的第一个数组元素的索引

var numbers = [4, 9, 16, 25, 29];
var first = numbers.findIndex(myFunction);
//first = 3

function myFunction(value, index, array) {
  return value > 18;
}