数组基本操作 迭代查找归并操作及数组length属性

数组的基本操作

1.pop

删除最后一项,并返回删除元素的值；如果数组为空则返回undefine

var a = [1,2];
b = a.pop();//a:[1]; b= 2
b = a.pop();//a:[]; b = 1
b = a.pop();//a:[]; b = undefine

---

2.shift

删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefine

var a = [1,2];
b = a.shift();//a:[2]; b= 1
b = a.shift();//a:[]; b = 2
b = a.shift();//a:[]; b = undefine

---

3.push

将一个或多个新元素添加到数组结尾，并返回数组新长度

var a = [1,2,3,4,5]; 
a.push(6);//[1, 2, 3, 4, 5, 6] //返回长度6
aa.push('xx','yy');//[1, 2, 3, 4, 5, 6, "xx", "yy"] //返回长度8

---

4.unshift

将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度

var a = [1,2,3,4,5]; 
a.unshift(0);//[0,1, 2, 3, 4, 5] //返回长度6
a.unshift("cc","aaa");//["aaa", "cc", 0, 1, 2, 3, 4, 5] //返回长度8

---

5.reverse

将原数组翻转，并返回翻转后的原数组

var a = [1,2,3,4,5]; 
a.reverse()//a：[5, 4, 3, 2, 1] 返回[5, 4, 3, 2, 1]

---

6.join

原数组不变，返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开（不加默认是以逗号隔开）

var a = [1,2,3,4,5]; 
var b=a.join('||');//b:"1||2||3||4||5" a:[1,2,3,4,5] 
var b=a.join(');//b:"[1,2,3,4,5]" a:[1,2,3,4,5] 

---

7.slice

原数组不变，返回从原数组中指定开始索引(包含)到结束索引(不包含)之间的项组成的新数组。索引从0开始

var a = ['a','b','c','d','e']; 
a.slice(1,3);//["b", "c"] a:['a','b','c','d','e']
a.slice(0,4);//["a", "b", "c", "d"]

---

8.splice

原数组变化，删除从指定位置开始的指定数量的元素，返回被删除部分的数组形式，索引从0开始

也可以向数组内删除位置添加元素

var a = ['a','b','c','d','e']; 
b = a.slice(1,3);//b = ["b", "c"]; a:['a','b','c','d','e']
b = a.slice(0,4);//b= ["a", "b", "c", "d"]; a:[]

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,1,"Lemon","Kiwi"); fruit: Banana,Orange,Lemon,Kiwi,Mango

---

9.indexOf

原数组不变，返回指定数值的数组下标

var a = ['a','b','c','d','e']; 
a.indexOf('a');//0
a.indexOf(a);//-1
a.indexOf('f');//-1
a.indexOf('e');//4

---

10.concat

原数组不变，返回合并后的新数组

var a = ['a','b','c','d','e']; 
b = a.concat(['f','g']); //b = ["a", "b", "c", "d", "e", 'f', 'g'] a:["a", "b", "c", "d", "e"]
var b= ['f','g']
b = a.concat(b); //b = ["a", "b", "c", "d", "e", 'f', 'g'] a:["a", "b", "c", "d", "e"]

---

11.sort

原数组变化，sort()方法用于对数组的元素进行排序。
注意：当数字是按字母顺序排列时"40"将排在"5"前面。
使用数字排序，你必须通过一个函数作为参数来调用,函数指定数字是按照升序还是降序排列。函数内的两个参数前面一个参数应该在后面一个参数前面返回负数

//数组排序：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
//fruits 输出结果：
Apple,Banana,Mango,Orange

//降序函数  
var desc = function(x,y) {    
        if (x > y)      
        return -1;  //返回一个小于0 的数即可  
        else        
        return 1;  //返回一个大于0 的数即可  
}    

//也可以这样写
//function sortNumber(a,b){
//	return a - b
//}

//升序函数  
var asc = function(x,y) {    
        if (x > y)      
        return 1;  //返回一个大于0 的数即可  
        else            
        return -1;  //返回一个小于0 的数即可  
}  
var arr2 = [4,6,4,2,7,9,0,1];    
arr2.sort(desc); //降序排序  9,7,6,4,4,2,1,0
arr2.sort(asc); //升序排序  0,1,2,4,4,6,7,9

---

数组的迭代操作

不会对空数组进行检查，函数也不会执行。都不会改变原函数

1.forEach

没有返回值
forEach()方法用于调用数组的每个元素，并将元素传递给回调函数。

  var arr = [1, 2, 3, 2, 5];
  arr.forEach(function(a, index, array) { // 循环遍历,对每一项运行给定函数,这个方法没有返回值
	  console.log(a, index, array === arr); // 参数分别为：遍历的数组内容,内容对应的数组索引,数组本身
	    // 1 0 true
	    // 2 1 true
	    // 3 2 true
	    // 2 3 true
	    // 5 4 true
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.forEach(function(a) { // forEach方法没有返回值
    return a * 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // undefined

---

2.map

返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
map() 方法按照原始数组元素顺序依次处理元素。

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.map(function(a) { // 对每一项运行给定函数，返回每次函数调用的结果组成的数组
  	return a * 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // (5) [2, 4, 6, 4, 10]

---

3.filter

返回一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.filter(function(a) { // 返回满足过滤条件组成的数组
    return a > 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // (2) [3, 5]

---

4.every

用于检测数组所有元素是否都符合指定条件（通过函数提供）
如果数组中检测到有一个元素不满足，则整个表达式返回 false，且剩余的元素不会再进行检测。所有元素都满足条件，才返回true。

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.every(function(a) { // 判断数组中每一项都是否满足条件，所有项都满足条件才会返回true
    return a > 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // false

---

5.some

用于检测数组是否有元素符合指定条件（通过函数提供）
如果数组中检测到有一个元素满足，则整个表达式返回 true，且剩余的元素不会再进行检测。所有元素都不满足条件，才返回false。

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.some(function(a) { // 判断数组中是否有一项满足条件，有满足条件才会返回true
    return a > 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // true

---

数组的查找操作

1.find

返回传入数组的第一个符合测试条件（函数）的元素。
数组中的每个元素都调用一次函数执行，当测试条件时返回true 时,返回符合条件的元素，之后的值不会再调用执行函数，如果没有符合条件的元素返回 -1

  function big(element) {
    return element > 2;
  }
  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.find(big); // 返回数组中满足提供的测试函数的第一个元素的值
  console.log(arr1); // 3 
  console.log(arr); // (5) [1, 2, 3, 2, 5]

---

2.includes

用来判断一个数组是否包含一个指定的值，返回 true或 false

  var arr = [1, 2, 3, 2, 5];
  console.log(arr.includes(2)); // true
  console.log(arr.includes(6)); // false

---

数组的归并操作

1.reduce

原数组不变，迭代数组的所有项，然后构建一个最终返回的值，从数组的第一项开始，逐个遍历到最后

  var arr = [1, 2, 3, 2, 5];
  // reduce方法有两个参数：在每一项上调用的函数和（可选的）作为归并基础的初始值
  // reduce方法的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象
  // 这个函数返回的任何值都会作为第一个参数自动传给下一项，作为下一次调用函数的前一个值
  // 第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数是数组的第二项
  var sum = arr.reduce(function(pre, cur, index, array) { 
    return pre + cur;
  }, 10)
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(sum); // 23

---

2.reduceRight

原数组不变，迭代数组的所有项，从数组的最后一项开始，向前遍历到第一项
与reduce类似

---

数组的其他操作

1.fill

原数组改变，元素填充

// arr.fill(value, start, end)
  var arr = [1, 2, 3, 2, 5];
  arr.fill(1,2,4); // 用1填充数组中从起始索引到终止索引内的全部元素
  console.log(arr); // (5) [1, 2, 1, 1, 5]

---

2.valueOf

返回Array对象的原始值。
valueOf()方法通常由 JavaScript 在后台自动调用，并不显式地出现在代码中。

//valueOf() 是数组对象的默认方法。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var v=fruits.valueOf();
// fruits.valueOf()与 fruits返回值一样。
//v输出结果为：
Banana,Orange,Apple,Mango

---

3.toString

把数组转换为字符串，并返回。数组中的元素之间用逗号分隔

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.toString();
//fruits将输出：
Banana,Orange,Apple,Mango

---

3.valueOf,toString,toLocalString三者区别

valueOf()：返回最适合该对象类型的原始值；
toString(): 将该对象的原始值以字符串形式返回。
这两个方法一般是交由JS去隐式调用，以满足不同的运算情况。
在数值运算里，会优先调用valueOf()，如a + b;
在字符串运算里，会优先调用toString()，如alert©;。

  var arr = [12421,22232,3333];
  console.log(arr.valueOf()); // (3) [12421, 22232, 3333] 返回数组本身
  console.log(arr.toString()); // '12421,22232,3333' 把数组转换为字符串，并返回结果，每一项以逗号分割
  console.log(arr.toLocaleString()); // '12,421,22,232,3,333' 会根据你机器的本地环境来返回字符串

---

数组的length属性

Length属性表示数组的长度，即其中元素的个数。因为数组的索引总是由0开始，所以一个数组的上下限分别是：0和length-1。和其他大多数语言不同的是，JavaScript数组的length属性是可变的，这一点需要特别注意。当length属性被设置得更大时，整个数组的状态事实上不会发生变化，仅仅是length属性变大；当length属性被设置得比原来小时，则原先数组中索引大于或等于length的元素的值全部被丢失。

var arr=[12,23,5,3,25,98,76,54,56,76];
//定义了一个包含10个数字的数组
alert(arr.length); //显示数组的长度10
arr.length=12; //增大数组的长度
alert(arr.length); //显示数组的长度已经变为12
alert(arr[8]); //显示第9个元素的值，为56
arr.length=5; //将数组的长度减少到5，索引等于或超过5的元素被丢弃
alert(arr[8]); //显示第9个元素已经变为"undefined"
arr.length=10; //将数组长度恢复为10
alert(arr[8]); //虽然长度被恢复为10，但第9个元素却无法收回，显示"undefined"

*注：
会改变原数组的方法
pop、push、shift、unshift、fill、sort、reverse、splice