数组扩大运算符

寄义：
扩大运算符是三个点(…);比如rest参数的逆运算，将一个数组转为用逗号支解的参数序列。

console.log(...[1,2,3]);
//1,2,3
console.log(1,...[2,3,4],5);
//1,2,3,4,5
[...document.querySelectorAll('div')]
//[<div>,<div>]

该运算符重要用于函数挪用。

function pushs(array,...items){
  array.push(...items);
  return array;
}
console.log(pushs([1,2],...[4,5,6]));
//[1, 2, 4, 5, 6]

function add(x,y){
    return x+y;
}
const numbers = [4,38];
var b = add(...numbers);
//b=42

扩大运算符与一般的函数能够连系运用,异常天真。

function f(v,w,x,y,z){}
const args = [0,1];
f(-1,...args,2,...[3]);

扩大运算符背面还能够安排表达式

const arr =[
    ...(x>0?['a']:[]),
    'b',
]

假如扩大运算符背面是一个空数组，则不发生任何结果。

[...[],1]

注重：扩大运算符假如放在括号中，JavaScript引擎就会认为是函数挪用，不然就会报错。

(...[1,2]);
console.log((...[1,2]))

上面两种状况都邑报错，由于扩大运算符地点的括号不是函数挪用，而console.log(…[1,2])就不会报错，由于这时刻是函数的挪用。

• 替换函数的apply要领

//ES5的写法
function f(x,y,z){
    //...
}
var args = [0,1,2];
f.apply(null,args);
//ES6的写法
function f(x,y,z){
    //...
}
let args = [0,1,2];
f(...args);

下面是扩大运算符庖代apply要领的一个现实的例子，运用Math.max要领，简化求出一个数组最大元素的写法。

// ES5 的写法
Math.max.apply(null, [14, 3, 77])

// ES6 的写法
Math.max(...[14, 3, 77])

// 等同于
Math.max(14, 3, 77);

另一个例子是经由过程push函数，将一个数组增加到另一个数组的尾部。

//ES5的写法
var arr1 = [0,1,2];
var arr2 = [3,4,5];
Array.prototype.push.apply(arr1,arr2);
//ES6的写法
let arr1 = [0,1,2];
let arr2 = [3,4,5];
arr1.push(...arr2);

下面是另一个例子。

//ES5
new (Date.bind.apply(Date,[null,2015,1,1]));
//ES6
new Date(...[2015,1,1])

• 扩大运算符的运用

（1）复制数组

const a1 = [1,2];
//写法一
const a2 = [...a1];
//写法二
const [...a2] = a1;
//上面的两种写法，a2都是a1的克隆，转变相互不影响。

（2）兼并数组

const a1 = [{ foo: 1 }];
const a2 = [{ bar: 2 }];

const a3 = a1.concat(a2);
const a4 = [...a1, ...a2];

a3[0] === a1[0] // true
a4[0] === a1[0] // true
//上面代码中，a3和a4是用两种差别要领兼并而成的新数组，然则它们的成员都是对原数组成员的援用，这就是浅拷贝。假如修正了原数组的成员，会同步反应到新数组。
（3）与解构赋值连系
扩大运算符能够与解构赋值连系起来，用于天生数组。

//ES5
a=list[0],rest=list.slice(1);
//ES6
[a,…rest] = list

const [first, ...rest] = [1, 2, 3, 4, 5];
first // 1
rest  // [2, 3, 4, 5]

const [first, ...rest] = [];
first // undefined
rest  // []

const [first, ...rest] = ["foo"];
first  // "foo"
rest   // []

假如将扩大运算符用于数组赋值，只能放在参数的末了一名，不然会报错。

const [...butLast, last] = [1, 2, 3, 4, 5];
// 报错

const [first, ...middle, last] = [1, 2, 3, 4, 5];
// 报错

怎样从数组中按递次取每5个元素为一组放到新数组中，末了不够5个也存为一个数组

//1.
var SplitArray = function(cont,arr){
    var newArr =[];
    var f;
    for(f=0;f<arr.length;) newArr.push(arr.slice(f,f+=cont))
    return newArr;
};
var arr = [1,2,3,4,545,6,57,67,87,8,98,98,090,0,32,43,45,45,6,7,67,8,78,8];
console.log(SplitArray(5,arr))
//2.
var data = [
    {name:'li'},
    {name:'si'},
    {name:'zi'},
    {name:'ai'},
    {name:'wi'},
    {name:'hi'},
    {name:'ei'},
    {name:'ti'},
    {name:'yi'},
    {name:'ui'},
    {name:'ii'},
]
var result =[];
for(var i=0;i<data.length;i+=3){
    result.push(data.slice(i,i+3));
}
console.log(result);

斐波那契数列

//1.运用generator函数和for...of完成
function*fibonaci(){
    let[prev,curr] = [0,1];
    for(;;){
        yield curr;
        [prev,curr] = [curr,prev+curr];
    }
}
for(let n of fibonaci()){
    if(n>1000)break;
    console.log(n);
}
//2.递归要领基本长举行尾挪用优化：
function fb(n,res1=1,res2=1){
  if(n<=2){
    return res2;
  }else{
    return fb(n-1,res2,res1+res2);
  }
}
var a = fb(10);

//3.迭代
function fb(n){
  var res1=1;
  var res2=1;
  var sum = res2;
  for(var i=2;i<n;i++){
    sum = res1+res2;
    res1 = res2;
    res2 = sum;
  }
  return sum;
}
var a = fb(10);
console.log(a)

var temp;
var res1 =1;
var res2 =1;
for(var i=2;i<=10;i++){
  //先把res2赋值给一个变量保留下来。
  temp = res2;
  //res2从新赋值即是res1+res2;
  res2 = res1+res2;
  //再把保留的temp赋值给res1，保证下次轮回的时刻res1即是上次轮回res2未转变时的值
  res1 = temp;
}

slice()和splice()区分

slice(start,end)
start:必须。划定从那边最先拔取。假如是负数，那末它划定从数组尾部最先算起的位置。也就是说，-1指末了一个元素，-2指倒数第二个元素，以此类推。
end：可选。划定从那边完毕拔取。该参数是数组片断完毕处的数组下标。假如没有指定该参数，那末切分的数组包含从start到数组完毕的一切元素。假如这个参数是负数，那末它划定的是从数组尾部最先算起的元素。
返回一个新的数组，包含从start到end（不包含该元素）的arrayObject中的元素。
注重：该要领并不会修正数组，而是返回一个子数组。假如想删除数组中的一段元素，应当运用要领Array.splice().

var a =[1,2,3,4,5,6]
//假如不传入参数二，那末将从参数一的索引位置最先截取，一直到数组尾
console.log(a.slice(0,3))//1,2,3
console.log(a.slice(2))//3,4,5,6
//假如两个参数中的任何一个是负数，array.length会和它们相加，试图让它们成为非负数，举例说明：
//当只传入一个参数，且是负数时，length会与参数相加，然后再截取
//当只传入一个参数，是负数时,而且参数的绝对值大于数组length时，会截取全部数组
console.log(a.slice(-1))//6
console.log(a.slice(-2))//5,6
console.log(a.slice(-3))//4,5,6
//当传入两个参数一正一负时，length也会先于负数相加后，再截取
console.log(a.slice(-3,6))//4,5,6
console.log(a.slice(-3,5))//4,5
console.log(a)//1,2,3,4,5,6
//当传入一个参数，大于length时，将返回一个空数组

splice()要领向/从数组中增加/删除项目，然后返回被删除的项目。
该要领会转变原始数组。
arrayObject.splice(index,howmany,item1,…,itemX)
index：必须，整数，划定增加/删除项目的位置，运用负数可从数组结尾处划定位置。
howmany：必须。要删除的项目数目。假如设置为0，则不会删除项目。
item1,…,itemX:可选。向数组增加的新项目。
返回值：包含被删除项目的新数组，假如有的话。

var arr = ['a','b','c','d','e'];
// console.log(arr.splice(1,2));//[b,c]
// console.log(arr);//[a,d,e]
// console.log(arr.splice(1,2,'bb','cc'));//[b,c]
// console.log(arr)//[a,bb,cc,d,e]
console.log(arr.splice(1,2,'bb','cc','dd','ee'));//[b,c]
console.log(arr)//["a", "bb", "cc", "dd", "ee", "d", "e"]

split与join

split()要领用于把一个字符串支解成字符串数组。stringObject.split(separator,howmany)。
separator:必须。字符串或正则表达式，从该参数指定的处所支解stringObject。
howmany:可选。该参数可指定返回的数组的最大长度。假如设置了参数，返回的子串不会多于这个参数指定的数组。假如没有设置该参数，全部字符串都邑被支解，不斟酌它的长度。
返回值：一个字符串数组。该数组是经由过程在separator指定的边境处将字符串stringObject支解成子串建立的。返回的数组中的字串不包含separator本身。
然则，假如separator是包含子表达式的正则表达式，那末返回的数组中包含与这些子表达式婚配的字串（但不包含与全部正则表达式婚配的文本）
join()要领用于把数组中的一切元素放入一个字符串。元素是经由过程指定的分开符举行分开的。
arrayObject.join(separator)。
separator：可选。指定要运用的分开符。假如省略该参数，则运用逗号作为分开符。
返回值：返回一个字符串。该字符串是经由过程把arrayObject的每一个元素转换为字符串，然后把这些字符串链接起来，在两个元素之间插进去separator字符串而天生的。

map遍历

array.map(callback,[thisObject]);
map要领的作用不难理解，映照，也就是原数组被映照成对应新数组。下面这个例子是数值项求平方：

var data = [1,2,3,4];
var arrayOfSquares = data.map(function(item){return item*item});
alert(arrayOfSquares)//1,4,9,16

callback须要有return值，假如没有，就像下面如许：

var data = [1,2,3,4];
var arrayOfSquares = data.map(function(){});
arrayOfSquares.forEach(console.log());

concat()

Array.concat(),建立并返回一个新数组。

var a = [1,2,3];
var b = a.concat(4,5);
var c = a.concat([4,5]);
console.log(a);//[1,2,3];
console.log(b);//[1,2,3,4,5];
console.log(c);//[1,2,3,4,5];

这个要领还能够用来复制数组。

var a = [1,2,3];
var b = a.concat();
console.log(a)//[1,2,3];
console.log(b)//[1,2,3];

push()要领与pop()要领

push()要领在数组的尾部增加一个或多个元素，并返回数组的新长度。注重的是，转变的是原数组的值，返回的是新数组的长度。
pop()要领删除数组的末了一个元素，并返回它的删除值。也是转变原数组，返回的是删除的值。

unshift()要领与shift()要领

unshift()要领类似于push()差别的是，它是在数组的头部增加，别的都一样。
shift()要领则类比pop()要领。

toString()和toLocaleString()

toString()要领将每一个元素转化为字符串，类似于不传参数的join()要领。
toLocaleString()要领是toString()的本地化版本。

forEach()要领，自始至终遍历数组，为每一个元素挪用指定的函数

var a =[1,2,3,4,5];
var sum = 0;
a.forEach(function(value){
    sum+=value;
})
console.log(sum);//sum = 15;

filter()要领，返回的是挪用数组的一个子集

var a = [1,2,3,4,5];
var b = a.filter(function(value){
    return value > 3;
})
console.log(b)//返回[4,5];
注重：假如运用map()要领，返回的是[false,false,false,true,true]
filter()会跳过悉数数组中缺乏的元素，它的返回数组老是浓密的。所以能够用以下要领来紧缩希罕数组的空白。
var a = [1,2,,,5];
var b = a.filter(function(value){
    return true;
})
console.log(b)//返回[1,2,5]

every()和some()

every()要领是只需数组中一切元素都满足某个前提才会返回true；some()要领是只需有满足前提的值，就返回true。

var a = [1,2,3,4,5];
a.every(function(value){
    return value <10;
})//true
a.every(function (value){
    return value%2 ===0;
})//false

indexOf()和lastIndexOf()

这两个要领都是用来搜刮全部数组中具有给定值的元素，返回找到的第一个元素的索引，假如没找到，则返回-1.区分在于indexOf()自始至终搜刮，而后者则是反向搜刮。