js数组经常使用的一些方法

(1) arr.length => 返回一个数组中的元素个数（数组属性）

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

(2) arr.indexOf(searchElement[, fromIndex = 0]) => 返回给定元素在数组中的第一个索引值，不然返回-1

var array = [2, 5, 9];
array.indexOf(5);     // 1
array.indexOf(9, 2);  // 2
array.indexOf(2, -3); // 0

(3) arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1]) => 返回指定元素在数组中最后出现位置的索引值,从 fromIndex 位置向前开始查找，若是不存在，则返回 -1

var arr = [2, 5, 9, 2];
arr.lastIndexOf(2);     // 3
arr.lastIndexOf(7);     // -1
arr.lastIndexOf(2, 3);  // 3
arr.lastIndexOf(2, 2);  // 0
arr.lastIndexOf(2, -2); //0

(4) arr.push(element1, ..., elementN) => 在数组的末尾添加一个或多个元素，并返回数组新的 length 值

var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");

console.log(sports); // ["soccer", "baseball", "football", "swimming"]
console.log(total);  // 4

(5) arr. unshift(element1, ..., elementN) => 在数组的开头添加一个或者多个元素，并返回数组新的 length 值

var sports = ["soccer", "baseball"];
var total = sports.unshift("football", "swimming");

console.log(sports); // ["football", "swimming", "soccer", "baseball"]
console.log(total);  // 4

(6) arr.pop() => 删除数组中的最后的一个元素，而且返回这个元素

var myFish = ["angel", "clown", "mandarin", "surgeon"];
var popped = myFish.pop();

console.log(myFish); // ["angel", "clown", "mandarin"]
console.log(popped); // "surgeon"

(7) arr.shift() => 删除数组中的第一个元素，而且返回这个元素

var myFish = ["angel", "clown", "mandarin", "surgeon"];
var shifted = myFish.shift();

console.log(myFish); // ["clown", "mandarin", "surgeon"]
console.log(shifted); // "angel"

(8) arr.concat(value1, value2, ..., valueN) => 将传入的数组或值与原数组合并,组成一个新的数组并返回

var alpha = ["a", "b", "c"];
var numeric = [1, 2, 3];
var alphaNumeric = alpha.concat(numeric);        // 组成新数组 ["a", "b", "c", 1, 2, 3]; 原数组 alpha 和 numeric 未被修改
var alphaNumeric2 = alpha.concat(1,[2,3,[4,5]]); // 组成新数组 ["a", "b", "c", 1, 2, 3, [4,5]]

(9) arr.reverse() => 颠倒数组中元素的位置，并返回该数组的引用

var myArray = ['one', 'two', 'three'];
myArray.reverse(); 
console.log(myArray); // ['three', 'two', 'one']

(10) array.splice(start, deleteCount[, item1[, item2[, ...]]]) => 用新元素替换旧元素，修改数组的内容；返回由被删除的元素组成的数组

// start 从数组对哪一位开始修改内容
// deleteCount 整数，表示要移除的数组元素的个数
// itemN 要添加进数组的元素
var myFish = ["angel", "clown", "mandarin", "surgeon"];
myFish.splice(2, 0, "drum"); // []  '增'
console.log(myFish); // ["angel", "clown", "drum", "mandarin", "surgeon"]

myFish.splice(1,2); // ["clown", "drum"]   '删'
console.log(myFish); // ["angel", "mandarin", "surgeon"]

myFish.splice(0, 2, "parrot", "anemone", "blue"); // ["angel", "mandarin"]   '改'
console.log(myFish); // ["parrot", "anemone", "blue", "surgeon"]

(11) arr.slice([begin[, end]]) => 把数组中的一部分浅拷贝，存入到一个新的数组中，并返回这个新数组

// 原数组的元素按照下述规则拷贝：
// 1.若是该元素是个对象引用（不是实际的对象），slice会拷贝这个对象引用到新的数组
//   里。两个对象都引用了同一个对象。若是被引用的对象发生改变，则改变将反应到新的和
//   原来的数组中；
// 2.对于字符串和数字来讲（不是String和Number对象），slice会拷贝字符串和数字到
//   新的数组里。在一个数组里修改这些字符串或数字，不会影响另外一个数组。
// 若是向两个数组任一中添加了新元素，则另外一个不会受到影响

var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
fruits.slice(1,3); // ["Orange", "Lemon"]
console.log(fruits); // ["Banana", "Orange", "Lemon", "Apple", "Mango"]

// slice 方法能够用来将一个类数组（Array-like）对象/集合转换成一个数组
function list() {
  return Array.prototype.slice.call(arguments);
  // 或者 return [].prototype.slice.call(arguments);
}
var list1 = list(1, 2, 3); // [1, 2, 3]

(12) arr.join([separator = ',']) => 将数组中的全部元素链接成一个字符串

var a = ['Wind', 'Rain', 'Fire'];
var myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"
var myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"
var myVar3 = a.join(' + '); // myVar3的值变为"Wind + Rain + Fire"
var myVar4 = a.join('');    // myVar4的值变为"WindRainFire"

(13) arr.sort([compareFunction]) => 对数组的元素排序，并返回这个数组；默认按照字符串的Unicode码位点（code point）排序

var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort(); // ['apples', 'bananas', 'cherries']

var scores = [1, 10, 2, 21]; 
scores.sort(); // [1, 10, 2, 21]

//对数字进行升序排序
function compareNumbers(a, b) {
  return a - b;
}
var numbers = [4, 20, 5, 12, 3];
numbers.sort(compareNumbers); // [3, 4, 5, 12, 20]

(14) array.forEach(callback[, thisArg]) => 让数组的每一项都执行一次 callback 函数；thisArg 是可选参数，用来看成callback 函数内this值的对象。注：没有办法停止或者跳出forEach循环，除了抛出一个异常

//callback 函数传三个参数：数组当前项的值、数组当前项的索引、数组对象自己
function logArrayElements(item, index, array) {
    console.log("a[" + index + "] = " + item);
}
[2, 5, 9].forEach(logArrayElements);
// a[0] = 2
// a[1] = 5
// a[2] = 9

(15) array.map(callback[, thisArg]) => 返回一个由原数组中的每一个元素调用一个指定方法后的返回值组成的新数组

var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
console.log(numbers); // [1, 4, 9]
console.log(roots); // [1, 2, 3]

(16) arr.reduce(callback,[initialValue]) => 接收一个callback函数做为累加器（accumulator），数组中的每一个值（从左到右）开始合并，最终为一个值

// callback 函数传四个参数：
//   @param previousValue 上一次调用回调返回的值，或者是提供的初始值（initialValue）
//   @param currentValue 数组中当前被处理的元素
//   @param index 当前元素在数组中的索引
//   @param array 调用 reduce 的数组

function accAdd(previousValue, currentValue, index, array){
  return previousValue + currentValue;
};
[0,1,2,3,4].reduce(accAdd); // 10 第一次调用时，previousValue = 0，currentValue = 1
[0,1,2,3,4].reduce(accAdd,10); // 20 第一次调用时，previousValue = 10，currentValue = 0

//eg.将数组全部项相加
var total = [0, 1, 2, 3].reduce(function(a, b) {
    return a + b;
});
console.log(total); // 6

//eg.数组扁平化
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
    return a.concat(b);
});
console.log(flattened); // [0, 1, 2, 3, 4, 5]

(17) arr.every(callback[, thisArg]) => 测试数组的全部元素是否都经过了指定函数的测试

// callback 被调用时传入三个参数：元素的值，元素的索引，被遍历的数组
function isBigEnough(element, index, array) {
  return (element >= 10);
}
[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true

(18) arr.some(callback[, thisArg]) => 测试数组中的某些元素是否经过了指定函数的测试

// callback 被调用时传入三个参数：元素的值，元素的索引，被遍历的数组
function isBigEnough(element, index, array) {
  return (element >= 10);
}
[2, 5, 8, 5, 4].some(isBigEnough);   // false
[2, 3, 4, 5, 11].some(isBigEnough); // true

(19) arr.filter(callback[, thisArg]) => 使用指定的函数测试全部元素，并建立一个包含全部经过测试的元素的新数组

function isBigEnough(element, index, array) {
  return element >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]