数组要领ES5

——ES5——-

1. push() –从数组末端增加参数，返回修改后数组的长度；(可传多个参数)

       栈要领（后进先出）

   var animals = ['cat','dog','pig'];
   var all = animals.push('bird');  //末端推入一项
   console.log(all);  // 4

2. pop() –从数组末端删除参数，返回值为删除元素（只删除一个）；
   栈要领（后进先出）

   var animals = ['cat','dog','pig','bird'];
   var all = animals.pop(); //获得末了一项  
   console.log(all);  // bird

3. unshift() –从数组肇端增加参数，返回修改后数组的长度；(可传多个参数)

      行列要领（先进先出）

   var animals = ['cat','dog','pig'];
   var all = animals.unshift('bird');  //肇端推入一项
   console.log(all);  // 4

4. shift() –从数组肇端删除参数，返回值为删除元素（只删除一个）

      行列要领（先进先出）

   var animals = ['cat','dog','pig','bird'];
   var all = animals.unshift();  //获得肇端一项
   console.log(all);  // cat

5. splice()—
   删除：删除恣意数目的项，指定两个参数，要删除的第一项的位置和要删除得项数；

   var animals = ['cat','dog','pig','bird'];
   var all = animals.splice(0,2);  //删除前两项
   console.log(all);  // ["cat"]

   插进去：向指定位置增加恣意数目的项，需供应三个参数：肇端位置、0（要删除的项数）和要插进去的项；

   var animals = ['cat','dog','pig','bird'];
   var all = animals.splice(2,0,'a','b','c');  //从第二项后插进去
   console.log(all);  // [] 
   console.log(animals);  // ["cat", "dog", "a", "b", "c", "pig", "bird"]

   替代：向指定位置增加恣意数目的项，且同时删除恣意数目的项，需供应三个参数：肇端位置、要删除的项数和要插进去的项；

   var animals = ['cat','dog','pig','bird'];
   var all = animals.splice(1,3,'a','b','c');  //从第一项后插进去，删除后三项
   console.log(all);  // ["dog", "pig", "bird"] 返回删除得项
   console.log(animals);  // ["cat", "a", "b", "c"]

6. slice(start,end)–切去肇端位置到完毕位置的数组（不包括end），返回值为切出的数组；

   var animals = ['cat','dog','pig','bird','tiger'];
   var frag = animals.slice(1,2);  
   var frag2 = animals.slice(1);
   console.log(frag);    //["dog"]
   console.log(frag2);  // ["dog", "pig", "bird",'tiger']
   //假如slice()要领的参数中有一个负数，则用数组长度加上该数来肯定响应的位
   //置。比方，在一个包括5 项的数组上挪用slice(-2,-1)与挪用slice(3,4)获得的
   //效果雷同。假如完毕位置小于肇端位置，则返回空数组。
   var frag3 = animals.slice(-3); //等同于 animals.slice(2)
   var frag4 = animals.slice(-3,-1); //等同于 animals.slice(2,4)

7. concat()–衔接两个数组返回新数组

   var colors = ["red", "green", "blue"];
   var colors2 = colors.concat("yellow", ["black", "brown"]);
   alert(colors); //red,green,blue
   alert(colors2); //red,green,blue,yellow,black,brown

Javascript高等程序设计（第3版）

1. sort()–按升序分列数组项，即最小的值位于最前面，最大的值排在末了面（默许是依据最左侧的数字举行排序，不是依据数字大小排序的）,返回值是排好的数组；

   var values = [0, 1, 5, 10, 15];
   values.sort();
   console.log(values); //0,1,10,15,5
   values.sort(function(a,b){
       return a - b;   //由小到大排序，b-a由大到小排序
   })

2. reverse()–反转数组项的递次（默许是依据最左侧的数字举行排序，不是依据数字大小排序的）,返回值是反转后的数组;

   var values = [1, 22, 3, 43, 5];
   values.reverse();
   console.log(values); //5,43,3,22,1

3. indexOf()–查找某个元素的索引值，如有反复的，则返回第一个查到的索引值若不存在，则返回-1

   var numbers = [1,2,3,4,5,4,3,2,1];
   alert(numbers.indexOf(4)); //3

4. lastIndexOf()–查找某个元素的索引值(从后往前)，如有反复的，则返回第一个查到的索引值若不存在，则返回-1；

   var numbers = [1,2,3,4,5,4,3,2,1];
   alert(numbers.lastIndexOf(4)); //5

5. forEach(callback)–遍历数组。这个要领没有返回值;

   var numbers = [1,2,3,4,5,4,3,2,1];
   numbers.forEach(function(item,index,array){
       console.log(`value:${value}  index:${index}  array:${array}`)
   })

6. every(callback)–依据前提推断，悉数满足，则返回true，不然false；

   var numbers = [1,2,3,4,5,4,3,2,1];
   var everyResult = numbers.every((v,i) => v < 3);
   alert(everyResult); //false

7. filter(callback)–对数组举行过滤，返回满足前提的数组;

   var numbers = [1,2,3,4,5,4,3,2,1];
   var filterResult = numbers.filter((item, index, array) => item >2);
   alert(filterResult); //[3,4,5,4,3]

8. map(callback)–映照数组(遍历数组),有return 返回一个新数组;

   var numbers = [1,2,3,4,5,4,3,2,1];
   var mapResult = numbers.map((item, index, array) => item * 2);
   alert(mapResult); //[2,4,6,8,10,8,6,4,2]

9. some(callback)–依据前提推断，有一个满足前提，则返回true；

   var numbers = [1,2,3,4,5,4,3,2,1];
   var someResult = numbers.map((item, index, array) => item > 2);
   alert(someResult); //true

10. reduce()–要领吸收一个函数 callback 作为累加器（[accumulator]()），数组中的每一个值（从左到右）最先兼并，终究为一个值。
    吸收四个参数：
    preValue: 上一次挪用回调返回的值，或者是供应的初始值（initialValue）前一个值
    curValue: 数组中当前被处置惩罚的数组项（当前值）
    index: 当前数组项在数组中的索引值（项的索引）
    array: 挪用 reduce()要领的数组

    说这么多照样看代码就清晰了

    var values = [1,2,3,4,5];
    var sum = values.reduce(function(prev, cur, index, array){
        return prev + cur;
    });
    alert(sum); //15

`第一次实行回调函数，prev 是1，cur 是2。第二次，prev 是3（1 加2 的效果），cur 是3（数组
的第三项）。这个历程会延续到把数组中的每一项都接见一遍，末了返回效果。`

1. reduceRight()–功用和 reduce() 功用是一样的，差别的是 reduceRight() 从数组的末端向前将数组中的数组项做累加;

   var values = [1,2,3,4,5];
   var sum = values.reduce(function(prev, cur, index, array){
       return prev + cur;
   });
   alert(sum); //15

`第一次实行回调函数，prev 是5，cur 是4。固然，终究效果雷同，由于实行的都
是简朴相加的操纵。
运用reduce()照样reduceRight()，重要取决于要从哪头最先遍历数组。除此之外，它们完整
雷同。`