arr数组的方法（js小知识）

arr数组的方法

1. 检测数组Array.isArray(value)，如果是数组返回true,否则返回false

	if (Array.isArray(value)) {
		//do something...
	}

2. 转换方法 toString valueOf toLocaleString join

	var colors = ['red', 'green', 'blue'];
	// toString 返回由逗号分隔的数组项
    console.log(colors.toString()) // red,green,blue
	// valueOf 返回数组
    console.log(colors.valueOf()) // ["red", "green", "blue"]
	// toLocaleString 返回由逗号分隔的数组项
    console.log(colors.toLocaleString()) // red,green,blue
	// join 不穿参数时，返回由逗号分隔的数组项
	// 传参数时，返回有参数分隔的数组项
    console.log(colors.join()) // red,green,blue
    console.log(colors.join('||')) // red||green||blue

3. 栈方法 push pop

	// push 接受任意数量的参数，把他们逐个添加在末尾，返回修改后的数组长度。
    var colors = ['red', 'green', 'blue'];
    var pushLength = colors.push('yellow', 'green');
    console.log(pushLength); // 5
    console.log(colors); // ['red', 'green', 'blue','yellow', 'green']

    // pop 从数组末尾移除最后一项，并返回移除的值。
    var colors = ['red', 'green', 'blue'];
    var popitem = colors.pop();
    console.log(popitem); // 'bule'
    console.log(colors); // ['red', 'green']
    

4. 队列方法 shift unshift

    // shift 从数组起始移除第一项，并返回移除的值。
    var colors = ['red', 'green', 'blue'];
    var shiftitem = colors.shift(); 
    console.log(shiftitem); // 'red'
    console.log(colors); // ['green', 'blue']
    
    // unshift 从数组起始添加任意数量的项，并返回修改后数组的长度。
    var colors = ['red', 'green', 'blue'];
    var unshiftitem = colors.unshift('yellow', 'green'); 
    console.log(unshiftitem); // 5
    console.log(colors); // ['yellow', 'green', 'red', 'green', 'blue']

5. 重排序方法reverse sort

    // reverse() 将反转数组项的顺序
    var arr = [1, 2, 3, 4];
    arr.reverse();
    console.log(arr); // [4, 3, 2, 1]

    // sort() 一般配合函数compare使用，将数组项进行排序。
    var arr = [9, 11, 25, 5, 45]
    function compare(value1, value2) {
      if (value1 < value2) {
        return -1;
      } else if (value1 > value2) {
        return 1;
      } else {
        return 0;
      }
    }
    arr.sort();
    console.log(arr); // [11, 25, 45, 5, 9]
    arr.sort(compare);
    console.log(arr); // [5, 9, 11, 25, 45]

6. 操作方法concat slice splice

    // concat 不传参数的时候，会复制数组到返回新的副本
    // 在传递参数的时候，如果参数时数组的话，会将每一项都添加到数组的末尾，如果不是数组，就直接添加，最后返回一个新的数组。
    var colors1 = ['red', 'green', 'blue'];
    var colors2 = colors1.concat();
    console.log(colors2); // ["red", "green", "blue"]
    var colors3 = colors1.concat(colors2);
    console.log(colors3); // ["red", "green", "blue", "red", "green", "blue"] 
    var colors4 = colors1.concat('yellow', ['gray', 'black']);
    console.log(colors4); // ["red", "green", "blue", "yellow", "gray", "black"]

    // slice可以接受一或者两个参数，即要返回的起始和结束位置。
    // 如果是一个参数，即从当前位置，到数组末尾。
    // 如果是两个参数，即从开始位置，到结束位置，不包括结束位置。
    var colors1 = ['red', 'green', 'blue'];
    var colors2 = colors1.slice(1);
    console.log(colors2); // ['green', 'blue']
    var colors3 = colors1.slice(1,2)
    console.log(colors3) // ['green']

    // splice可以接受两个或多个参数，第一个参数是删除位置，第二个参数是删除项，后面参数是需要在被删除的位置添加的项，最后并返回被删除项组成的数组
    var colors1 = ['red', 'green', 'blue'];
    var colors2=  colors1.splice(0, 1);
    console.log(colors2); // ['red']
    console.log(colors1); // ['green', 'blue']

    var colors1 = ['red', 'green', 'blue'];
    var colors2=  colors1.splice(0, 1, 'white', 'black');
    console.log(colors2); // ['red']
    console.log(colors1); // ['white', 'black', 'green', 'blue']

7. 位置方法indexOf lastIndexOf

   	// indexOf() 和 lastIndexOf() 。这两个方法都接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。
    // indexOf() 方法从数组的开头（位置 0）开始向后查找
    // lastIndexOf() 方法则从数组的末尾开始向前查找。
    var arr =[1, 2, 3, 4, 5, 4, 3, 2, 1]
    var index = arr.indexOf(4) // 3
    console.log(index) // 3
    var index1 =arr.indexOf(4, 4) // 5
    console.log(index1) // 5
    var index2 = arr.lastIndexOf(4) // 3
    console.log(index2) // 5
    var index3 =arr.lastIndexOf(4, 4) 
    console.log(index3) // 3

8. 迭代方法every some filter map forEach

    // every 对数组中的每一项运行给定函数，如果该函数对每一项都返回 true ，则返回 true
    var arr = [1,2,3,4,5];
    var everyArrF = arr.every(function(item, index, array){
      return (item > 3);
    })
    console.log(everyArrF) // false
    var everyArrT = arr.every(function(item, index, array){
      return (item > 0);
    })
    console.log(everyArrT) // true

    // some 对数组中的每一项运行给定函数，如果该函数对任一项返回 true ，则返回 true 
    var arr = [1,2,3,4,5];
    var someArrT = arr.some(function(item, index, array){
      return (item > 3);
    })
    console.log(someArrT) // true

    // filter 对数组中的每一项运行给定函数，返回该函数会返回 true 的项组成的数组
    var arr = [1,2,3,4,5];
    var filterArr = arr.filter(function(item, index, array){
      return (item > 3);
    })
    console.log(filterArr) // [4, 5]

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

    // forEach 对数组中的每一项运行给定函数。这个方法没有返回值
    var arr = [1,2,3,4,5];
    var mapArr = arr.forEach(function(item, index, array){
      // do something...
    })

9. 归并方法reduce reduceRight

    // reduce reduceRight 这两个方法都会迭代数组的所有项，然后构建一个最终返回的值
    // 函数接收 4 个参数：前一个值、当前值、项的索引和数组对象。
    var values = [1,2,3,4,5];
    var sum = values.reduce(function(prev, cur, index, array){
      return prev + cur;
    });
    console.log(sum); //15