// 改變原數(shù)組的方法
let a = [1,2,3,4,5];

/* var b = a.pop();   // 刪除數(shù)組的最后一個并返回這一個辽旋，改變了原數(shù)組
console.log(a, b); */ // [ 1, 2, 3, 4 ] 5 

/* var b = a.push(6); // 往后面添加一個并返回耿焊，改變了原數(shù)組
console.log(a, b); // [ 1, 2, 3, 4, 5, 6 ] 6 */

/* //splice (index, length, insert1, insert2)  從index開始刪除幾個，并添加, 返回刪除后的數(shù)組
var b = a.splice(1, 0, 6, 7); 
console.log(a, b); //[ 1, 6, 7, 3, 4, 5 ] [ 2 ] */

/* var b = a.shift(); // 刪除數(shù)組的第一個距潘，并返回這一個孕暇， 同樣改變了原數(shù)組
console.log(a, b); */

/* var b = a.unshift(6); // 數(shù)組最前面插入一個仑撞， 并返回插入的這個， 改變了原數(shù)組
console.log(a, b); //[ 1, 2, 3, 4, 5 ] 5 */

// push 后添加 pop 后刪除
// shift 前刪除 unshift 前添加 
// splice 指定位置刪除和插入

// 數(shù)組反轉(zhuǎn)順序
// console.log(a.reverse());

// 數(shù)組排序 -
/* a.sort((a,b)=>{
    return b-a;
});
console.log(a);  //[ 5, 4, 3, 2, 1 ] */

/* a.length--; // 也能改變原數(shù)組
console.log(a);  //[ 1, 2, 3, 4 ] */

//----------以上都可以改變原數(shù)組--------------//


//----------下面這些不會改變原數(shù)組--------------//
// 字符串的截取妖滔，并沒有改變原數(shù)組
/* var  b = a.slice(1,3); // (start, end) 截取第start到end之間的(不包含end)
console.log(a, b); //[ 1, 2, 3, 4, 5 ] [ 2, 3 ] */

// 數(shù)組的遍歷： foreach map filter some every reduce 隧哮，

// 1 forEach 單純的循環(huán)遍歷, 不會生成新的數(shù)組
/* var b = a.forEach((value, index,arr)=>{
    return value+1; 
});
console.log(a, b); //[ 1, 2, 3, 4, 5 ] undefined */

// map 遍歷，返回一個新的數(shù)組,（不管有沒有返回值）
/* var b = a.map((value, index, arr)=>{
                    // 1 沒有return時座舍， b = [ undefined, undefined, undefined, undefined, undefined ]
    return value+1; // 2 有return時返回return的值沮翔，b= [ 2, 3, 4, 5, 6 ]

});
console.log(a , b); //[ 1, 2, 3, 4, 5 ] [ undefined, undefined, undefined, undefined, undefined ] */

// filter 遍歷， 返回符合條件的值到新數(shù)組, 如果都不符合條件為空數(shù)組[]曲秉， 也就是回掉函數(shù)結(jié)果返回true才會插入到新數(shù)組
/* 
var b = a.filter((value, index, arr)=>{
    // 1. 沒有返回值 b=[]
    
    // 2. 
    // return 1; // b = [ 1, 2, 3, 4, 5 ]
    // return 0;  //b = []

    // 3 
     return value>1; //[ 2, 3, 4, 5 ] // value>1 為true時才會插入到新數(shù)組

});
console.log(a,b); 
 */

/*  總結(jié)： 都可以遍歷采蚀， 原數(shù)組都不會發(fā)生改變
filter： 單純的遍歷數(shù)組疲牵， 沒有返回值
map： 返回新數(shù)組，將回掉函數(shù)的返回結(jié)果插入到新函數(shù)
filter 返回新數(shù)組榆鼠，回掉函數(shù)返回true時纲爸，將原數(shù)組的值插入到新數(shù)組 
*/

// 返回一個布爾值, 遍歷的回掉返回值都為true時才返回true, 否則返回false, 中途就會停止循環(huán)
/*
var b  = a.every((value, index,arr)=>{
    console.log(value);
    return value>6;
});
console.log(a, b); 
// 1
// [ 1, 2, 3, 4, 5 ] false 
*/


// 和every 相反，會一直遍歷妆够，直到有一個回掉返回true识啦，就會終止循環(huán)返回true
/*
var b = a.some((value, index,arr)=>{
    console.log(value);
    return value>2;
});
console.log(a, b);
*/
/*以上返回如下：
1
2
3
[ 1, 2, 3, 4, 5 ] true
 */ 

 // 把每一次回掉函數(shù)的返回值，作為下一次的prev,  最后返回最總結(jié)果
 // 可以理解為迭代器责静，可以用戶求和袁滥，求乘積等等
 // ps： 如果沒有默認initValue, 那么第一次的prev是數(shù)組的第一個值，從第二次開始循環(huán)灾螃，數(shù)組少循環(huán)一次
 /*
 var b = a.reduce((prev,cur, curIndex, arr)=>{
     console.log(prev, cur, curIndex, arr);
    //  return cur;
    return prev+cur;
 },0);
 console.log(a, b);
 */
 /* 以上輸出結(jié)果：
0 1 0 [ 1, 2, 3, 4, 5 ]
1 2 1 [ 1, 2, 3, 4, 5 ]
3 3 2 [ 1, 2, 3, 4, 5 ]
6 4 3 [ 1, 2, 3, 4, 5 ]
10 5 4 [ 1, 2, 3, 4, 5 ]
[ 1, 2, 3, 4, 5 ] 15
 */

 //reduce 高級用法
 //1 計算數(shù)組中每個元素出現(xiàn)的次數(shù)
 var a2 = ['daya', 'daya2','daya3', 'daya', "daya2"];
 /* var b = a2.reduce((prev, cur, curIndex,arr)=>{
    if(cur in prev){
        prev[cur]++
    }else{
        prev[cur] = 1;
    }
    return prev;
 },{});
 console.log(b); //{ daya: 2, daya2: 2, daya3: 1 } */

 // 2. 數(shù)組去重
/*  
var b = a2.reduce((prev, cur, curIndex)=>{
    if(prev.includes(cur)){
        return prev;
    }else{
        return prev.concat(cur);
    }
},[]);
console.log(a, b) //[ 1, 2, 3, 4, 5 ] [ 'daya', 'daya2', 'daya3' ]
 */
// 3.將二維數(shù)組轉(zhuǎn)化為一維
/* 
var a3 = [0,[1,2],[3,4],[5],[6,7]];
var b = a3.reduce((prev, cur, curIndex, arr)=>{
    return prev.concat(cur);
},[]);
console.log(b); //[0, 1, 2, 3, 4, 5, 6, 7 ]
 */
// 4. 多為數(shù)組轉(zhuǎn)化為一維數(shù)組
/* 
var a4  = [0,[1,2],[3,4,[31,32,[33,34]]],[5],[6,7]];
var newArr = function(arr){
  return  arr.reduce((prev, cur)=>{
    return prev.concat(Array.isArray(cur)? newArr(cur): cur);
}, [])
};
var b = newArr(a4);
console.log(b); //[ 0, 1, 2, 3, 4, 31, 32, 33, 34, 5, 6, 7 ]
 */

 // 5.對象里的屬性求和
 /* 
 var a5 = [
     {
         subject:'math',
         score: 30
     },
     {
        subject:'chinese',
        score: 90
     },
     {
        subject:'english',
        score: 60
     }
    ]
 var b = a5.reduce((prev, cur, index)=>{
     return prev + cur.score;
 },0);
 console.log(b); // 180
 */