let a0 = 96,a1 = 97, a2 = 76,a3 = 87,a4 = 87,a5 = 90, a6 = 91, a7 = 100,a8 = 78,a9 = 56;
//错误的做法
//无法对这些数据进行批量操作  比如计算这些数据的总和和平均分  for循环无从下手

let scoreArr = [96, 97, 76, 87, 87, 90, 91, 100, 78, 56];

let arr1 = []; // 创建一个空的数组

let arr2 = ["A" , "B" , "C" , "D"]; //有四项 长度为4

let arr = new Array("A" , "B" , "C" , "D");

let arr = new Array(4);

console.log(arr.length); //4
// 表示生成一个四个项的数组，每个位置都是空值。


//Array()作为构造函数，行为很不一致。
//因此，不建议使用它生成新数组，直接使用数组字面量是更好的做法。

Array.of(value1, value2, value3);

let arr = Array.of(1, 'abc', true);
console.log(arr); // 打印结果是数组：[1, "abc", true]

let arr = ["A" , "B" , "C" , "D"]; //下标分别是  0  1  2  3

let arr = ["A" , "B" , "C" , "D"];


console.log(arr[0]);
console.log(arr[1]);
console.log(arr[2]);
console.log(arr[3]);
console.log(arr);

let arr = ["A" , "B" , "C" , "D"];

console.log(arr[4]); //undefined
console.log(arr[10000]); //undefined
console.log(arr[-1]); //undefined

let arr = [2 , 0 , 2 , 0];

arr[0]++;
arr[1] = 6;
console.log(arr); // 3 6 2 0

let arr = [2 , 0 , 2 , 0];

arr[6] = 6;

console.log(arr);

let arr = ["A" , "B" , "C" , "D"];

console.log(arr.length); //4
console.log(arr[arr.length - 1]) //D

let arr = [1,2,3,4];

console.log(arr.length); //4

arr.length = 2;
console.log(arr); // [1, 2]  数组长度可改变 数组内容也发生改变

let a = ['a'];
a.length = 3;
console.log(a[2]);// undefined

let arr = ["A" , "B" , "C" , "D"];

for(let i = 0; i < arr.length; i++){
    console.log(arr[i]);
}

let arr = [1, 2, 3];


console.log( typeof arr );// "object"
console.log( Array.isArray(arr));// true

//typeof运算符只能显示数组的类型是Object
//而Array.isArray方法可以识别数组。

字符串 = 数组.toString();

字符串 = String(数组);

字符串 = 数组.join(',');  //  将数组转为字符串，每一项用 英文逗号 分隔

array = Array.from(arrayLike);

let name = 'yunmudsb';
console.log(Array.from(name)); // 打印结果是数组：["y","u","n","m","u","d","s","b"]

Array.from(btnArray);

新数组的长度 = 数组.push(元素);

let arr = [11, 22, 33, 44];
// 方法就是打点调用的函数 , 所以是数组打点调用他们
arr.push(55);
arr.push(66);
arr.push(77 , 88)
console.log(arr); // [11, 22, 33, 44, 55, 66, 77, 88]

被删除的元素 = 数组.pop();

let arr = [11, 22, 33, 44];
// 方法就是打点调用的函数 , 所以是数组打点调用他们
let del = arr.pop();

console.log(arr); //[11, 22, 33]
console.log(del); //44

let arr = [1 , 8 , 9 ,16];
let size = arr.unshift(100 , 110);
console.log(arr); //[100, 110, 1, 8, 9, 16]
console.log(size); //6

//unshift()方法可以接受多个参数，这些参数都会添加到目标数组头部。

let arr = ["tian", "夕颜", "大鱼"];

let del = arr.shift();

console.log(arr); //["夕颜", "大鱼"]

console.log(del); //tian

新数组 = 原数组.splice (删除起始索引index（从0开始）, 需要删除的个数);

新数组 = 原数组.splice(删除起始索引index（从0开始）, 需要删除的个数, 新的元素1, 新的元素2...);

//上方语法中，第三个及之后的参数，表示：删除元素之后，向原数组中添加新的元素，这些元素将会自动插入到起始位置索引的前面。也可以理解成：删除了哪些元素，就在那些元素的所在位置补充新的内容

let  arr1 = ["a" , "b" , "c" , "d"];

//只写一个参数默认从起始索引(包含)往后删除
arr1.splice(1); 

console.log(arr1);//["a"]

let arr2 = ['a', 'b', 'c', 'd', 'e', 'f'];
arr2.splice(-2); //删除最后两个元素
console.log(arr2); //["a", "b", "c", "d"]

let arr3 = ['a', 'b', 'c', 'd', 'e', 'f'];
arr3.splice(1, 3); //从索引为1的位置(包含)开始删除元素,一共删除三个元素
console.log(arr3); // ["a", "e", "f"]

let arr4 = [11, 22, 33, 44 , 55, 66];

arr4.splice(3, 0, 99, 88, 77);  //插入原来下标为3的项的前面

console.log(arr4);//[11, 22, 33, 99, 88, 77, 44, 55, 66]

let arr5 = ['a', 'b', 'c', 'd', 'e', 'f'];

//从第index为1的位置开始删除元素,一共删除三个元素。并且在 index=1 的前面追加两个元素
arr5.splice(1, 3, 'tian', '夕颜');

console.log(arr5); //["a", "tian", "夕颜", "e", "f"]

let  arr = ["a" , "b" , "c" , "d"];

let newArr = arr.splice(1 , 2); 

console.log(newArr);// ["b" , "c"]

let colors = ["red" , "green" , "blue" , "yellow"];

let newColors1 = colors.slice();// 不加参数时，则获取所有的元素。相当于数组的整体赋值
let newColors2 = colors.slice(1); // 从第一个值开始提取，直到末尾
let newColors3 = colors.slice(-2);// 提取最后两个元素 
//如果slice方法的参数中有一个负数,则用数组长度加上该数来确定相应的位置。
let newColors4 = colors.slice(2 , 4); // 提取从第二个到第四个之间的元素（不包括第四个元素）
let newColors5 = colors.slice(4, 2);   // 空
let newColors6 = colors.slice(2 , -1); 

console.log(newColors1);
console.log(newColors2);
console.log(newColors3);
console.log(newColors4);
console.log(newColors5);
console.log(newColors6);
//结果如下图

// 用一个固定值填充数组。数组里的每个元素都会被这个固定值填充
新数组 = 数组.fill(固定值);

// 从 startIndex 开始的数组元素，用固定值填充
新数组 = 数组.fill(固定值, startIndex);

// 从 startIndex 到 endIndex 之间的元素（包左不包右），用固定值填充
新数组 = 数组.fill(固定值, startIndex, endIndex);

// 创建一个长度为4的空数组，然后用 'f' 来填充这个空数组
console.log(Array(4).fill('f')); // ['f', 'f', 'f,' 'f']

// 将现有数组的每一个元素都进行填充
console.log(['a', 'b', 'c', 'd'].fill('f')); // ['f', 'f', 'f,' 'f']

 console.log(['a', 'b', 'c', 'd'].fill('f' , 1)); // ["a", "f", "f", "f"]

// 指定位置进行填充
console.log(['a', 'b', 'c', 'd'].fill('f', 1, 3)); // ["a", "f", "f", "d"]

let arr  = [11, 22, 33, 44];

let newStr = arr.join();  //等同于arr.join(",");

console.log(newStr); //11,22,33,44

//如同arr.toString();

let newStr = arr.join("");

console.log(newStr);  //11223344

let newStr = arr.join("-");

console.log(newStr); //11-22-33-44

let newStr = arr.join("❤");

console.log(newStr); //11❤22❤33❤44

let newStr = arr.join("|")
console.log(newStr); //11|22|33|44

//如果省略参数，则返回数组的唯一成员就是原字符串。
let str  = "abcdefg";

let newArr = str.split();

console.log(newArr);  //["abcdefg"]  数组只有原来字符串这一项

let str = 'yunmu, mu, shuai, bi'; // 用逗号隔开的字符串

let newArr = str.split(','); // 将字符串 str 拆分成数组，通过逗号来拆分

console.log(newArr);  // ["yunmu", " mu", " shuai", " bi"]

let str = "2020-11-11";


console.log(str.split());
// 无参数，表示：把整个字符串作为一个元素添加到数组中。

console.log(str.split(""));
// 参数为空字符串，则表示：分隔字符串中每一个字符，分别添加到数组中

console.log(str.split("-"));
// 参数为指定字符，表示：用 '-' 分隔字符串。此分隔符将不会出现在数组的任意一个元素中

console.log(str.split('0'));
// 同上

let arr1 = ["a" , "b", "c" , "d" , "e"];
let arr2 = ["f" , "g"];
let arr3 = ["h"];
let newArr = arr1.concat(arr2 , arr3 , [1 , 2 , 3]);
console.log(newArr); // ["a", "b", "c", "d", "e", "f", "g", "h", 1, 2, 3]

['hello'].concat(['world'], ['!'])
// ["hello", "world", "!"]

let arr1 = ['e', 'b', 'd', 'a', 'f', 'c'];

arr1.sort(); // 将数组 arr1 进行排序

console.log(arr1); //["a","b","c","d","e","f"]

let arr2 = [5, 2, 11, 3, 4, 1];

arr2.sort(); // 将数组 arr2 进行排序

console.log(arr2); //[1,11,2,3,4,5]

let arr = [5, 2, 11, 3, 4, 1];

// 自定义排序规则
//这个函数中的a、b分别表示数组中靠前和靠后的项
arr.sort(function (a, b) {
    if (a > b) {
        // 如果 a 大于 b，则交换 a 和 b 的位置
        return 1;
    } else if (a < b) {
        // 如果 a 小于 b，则位置不变
        return -1;
    } else {
        // 如果 a 等于 b，则位置不变
        return 0;
    }
});
console.log(arr); //[1, 2, 3, 4, 5, 11]

arr.sort(function(a , b){ return a - b; }) //会使得原数组变成升序
arr.sort(function(a , b){ return  b - a; }) //会使得原数组变成降序
console.log(arr);

arr.sort(function(a , b) { return -1 } )
console.log(arr); //使得原数组反序

arr.sort(function(a , b){  return Math.random() - 0.5;  }) 
console.log(arr);

yunmudsb 排序前的数组： [
    {"title":"品牌鞋子，高品质低价入手","publishTime":200},
    {"title":"不是很贵，但是很暖","publishTime":100},
    {"title":"无法拒绝的美食，跟我一起吃吃","publishTime":300}
]

yunmudsb 排序后的数组： [
    {"title":"不是很贵，但是很暖","publishTime":100},
    {"title":"品牌鞋子，高品质低价入手","publishTime":200},
    {"title":"无法拒绝的美食，跟我一起吃吃","publishTime":300}
]

let a = ['a', 'b', 'c'];

let b = a.reverse(); 
console.log(a);// ["c", "b", "a"]
console.log(b);// ["c", "b", "a"]

let str = "ABCDEFG";

let newArr =  str.split("");

newArr.reverse();

let newStr = newArr.join("");

console.log(newArr); //["G", "F", "E", "D", "C", "B", "A"]
 
console.log(newStr); //GFEDCBA

索引值 = 数组.indexOf(想要查询的元素);

索引值 = 数组.lastIndexOf(想要查询的元素);

let arr = ['a', 'b', 'c', 'd', 'e', 'd', 'c'];

console.log(arr.indexOf('c')); // 2  从前往后，找第一个"c"在哪个位置
console.log(arr.lastIndexOf('d')); // 5 从后往前，找第一个"d"在哪个位置

let pos = arr.indexOf(100);

console.log(pos);//-1  没有查找到为-1

[NaN].indexOf(NaN) // -1
[NaN].lastIndexOf(NaN) // -1

//这是因为这两个方法内部，使用严格相等运算符（===）进行比较，而NaN是唯一一个不等于自身的值。

索引值 = 数组.indexOf(想要查询的元素, [起始位置]);

let arr = ['q', 'i', 'a', 'n', 'g', 'u', 'y', 'i', 'h', 'a', 'o'];
let result = arr.indexOf('a', 3); // 从第三个位置开始查找 'a'这个元素 【重要】
console.log(result); // 打印结果：9

布尔值 = arr.includes(想要查找的元素, [position]);

const arr = [11, 12, 13, 14, 15];

console.log(arr.includes(12)); // 打印结果：true
console.log(name.includes(20)); // 打印结果：false

console.log(name.includes(11, 1)); // 打印结果：false

console.log([1, 2, 3].includes(2));     // true
console.log([1, 2, 3].includes(4));     // false

console.log([1, 2, 3].includes(2 , 2)); // false

console.log(NaN === NaN); //false

console.log([1,2,3,NaN].includes(NaN)); //true

let  a = ["123", true , 34];
let  b;

//方法一
b = [];
for(let i=0; i<a.length; i++){
    b.push(a[i])
}
console.log(b)

// 方法二
b  = [].concat(a);
console.log(b)

// 方法三
b = a.slice(0);
console.log(b);

// 方法四
b = a.splice(0); //会改变原数组

console.log(b);

// 求数组的总和
let arr = [ 1, 2, 3, 4, 5, 6, 7,  8, 9, 10];

// 累加器
let sum = 0;

// 遍历数组  每遍历到一个数字  就把这个数字累加到累加器之中
for(let i = 0; i < arr.length; i++){
    sum += arr[i];
}
console.log(sum);
console.log(sum / arr.length);

function reverseArr(arr) {
    for (let i = 0; i < arr.length / 2; i++) {
        let temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
    }
    return arr;
}

let arr = [1, 2, 3, 4, 5, 6];

arr.splice(0); //方式1：删除数组中所有项目
arr.length = 0; //方式2：length属性可以赋值，在其它语言中length是只读
arr = []; //方式3：推荐

let matrix = [
    [11, 22, 33], 
    [13, 26, 37], 
    [44, 47, 48],
    [34, 43, 23]
];

console.log(matrix.length); //4

// 循环输出二维数组每一项
for(let i = 0; i < 4; i++){
    for(let j = 0; j < 3; j++){
        console.log(matrix[i][j]);
    }
}

let arr = ["tian" , "黛玉" , "宝钗"];

arr.forEach(function(item , index , arr){
	console.log(item , index , arr);//一般不需要数组本身arr
})

//打印结果
tian 0 ["tian", "黛玉", "宝钗"]
黛玉 1 ["tian", "黛玉", "宝钗"]
宝钗 2 ["tian", "黛玉", "宝钗"]

let arr = [12, 23, 24, 42, 1];
let result = arr.map(function (item, index, arr) {
    return item * 10;
});
console.log(result); //[120,230,240,420,10];  原数组拷贝了一份，并进行了修改
console.log(arr);//[12,23,24,42,1]；  原数组并未发生变化

let arr1 = [
    { name: "tian", age: "18" },
    { name: "夕颜", age: "16" },
];

//将数组 arr1 中的 name 属性，存储到 数组 arr2 中
let arr2 = arr1.map(function(item){
    return item.name;
});

// 将数组 arr1 中的 name、age这两个属性，改一下“键”的名字，存储到 arr3中
let arr3 = arr1.map(function (item) {
    return {
        myName: item.name,
        myAge: item.age,
    };
});

console.log(arr2);	// ["tian", "夕颜"]
console.log(arr3);	// [{"myName":"tian","myAge":"18"},{"myName":"夕颜","myAge":"16"}]

arr.filter(function (item, index, arr) {
    return true;
});

let arr = [1 , 3 , 4, 6, 8, 28 ];

let newArr  = arr.filter(function(item){
   
    return item % 2 == 0;
    //return !(item % 2);
})

console.log(newArr);

//找出数组 arr1 中大于 4 的元素，返回一个新的数组。代码如下：
let newArr  = arr.filter(function(item){
    if (item > 4) {
        return true; // 将arr1中大于4的元素返回，组成新的数组
    }
    return false;

    //上方代码更简洁的写法如下：
     //return (item > 4);
})
console.log(newArr);

let arr = [
    { name: "许嵩", type: "一线" },
    { name: "周杰伦", type: "过气" },
    { name: "邓紫棋", type: "一线" },
];

let newArr = arr.filter((item) => item.type == "一线"); // 筛选出一线歌手

console.log(newArr);

[
    { name: '许嵩', type: '一线' },
    { name: '邓紫棋', type: '一线' },
];

let arr1 = ["千古", "宿敌", "南山忆", "素颜"];
let bool1 = arr1.every(function (element, index, array) {
    if (element.length > 2) {
        return false;
    }
    return true;
});
console.log(bool1); //输出结果：false。只要有一个元素的长度是超过两个字符的，就返回false


let arr2 = ["千古", "宿敌", "南山", "素颜"];
let bool2 = arr2.every(function (element, index, array) {
    if (element.length > 2) {
        return false;
    }
    return true;
});
console.log(bool2); //输出结果：true。因为每个元素的长度都是两个字符。

find(function(item, index, arr){
    return true;
});

let arr = [2, 3, 2, 5, 7, 6];

let result = arr.find(function(item, index,arr){
    return item > 4; //遍历数组arr，一旦发现有第一个元素大于4，就把这个元素返回
});

console.log(result); //打印结果：5

let arr = [2, 3, 2, 5, 7, 6];

let result = arr.findIndex(function(item, index,arr){
    return item > 4; //遍历数组arr，一旦发现有第一个元素大于4，就把这个元素的index返回
});
console.log(result); //打印结果：3

let students = [
    { 
        name: "tian",
        sex: "男", 
        age: 18 
    },
    {
        name: "夕颜",
        sex: "女",
        age: 16,
    },
    {
        name: "张三",
        sex: "女",
        age: 56,
    },
];

let femaleStu = students.find(function (item) {
    return item.sex === "女";
});
let femaleStuIndex = students.findIndex(function (item) {
    return item.sex === "女";
});

console.log(femaleStu); //{name: "夕颜", sex: "女", age: 16}
console.log(femaleStuIndex); //1

arr.reduce(function (previousValue, currentValue, currentIndex, arr) {},    initialValue);

//参数解释：
//previousValue：必填，上一次调用回调函数时的返回值

//currentValue：必填，当前正在处理的数组元素

//currentIndex：选填，当前正在处理的数组元素下标

//arr：选填，调用 reduce()方法的数组

//initialValue：选填，可选的初始值（作为第一次调用回调函数时传给 previousValue 的值）

let arr = ["tian", "夕颜","王二麻子"];

arr.reduce(function(prev , item , index){
    console.log(prev);
    console.log(item);
    return 88;
},0)
//0 tian
//88 夕颜
//88 王二麻子

//上面的代码中，由于return的是固定值，所以 prev 打印的也是固定值（只有初始值是 0，剩下的遍历中，都是打印 88）。

//不传递第二个参数 index是从1开始的，第一次的prev的值是数组的第一个值
let arr = ["tian", "夕颜", "王二麻子"];

arr.reduce(function (prev, item, index) {
    console.log(prev, item, index);  // tian 夕颜 1  88 "王二麻子" 2

    return 88;
});

let arr = [1, 2, 3, 4];
// 数组求和
let sum = arr.reduce(function (prev,item) {
    return prev + item;
});
console.log(sum);// 打印结果：10
//数组求乘积
let mul = arr.reduce(function (prev,item) {
    return prev * item;
});
console.log(mul); // 打印结果：24

let arr1 = [1, 2, 6, 5, 6, 1, 6];

function repeatCount(arr, value) {
    if (!arr || arr.length == 0) return 0;

    return arr.reduce((totalCount, item) => {
        totalCount += item == value ? 1 : 0;
        return totalCount;
    }, 0);
}

console.log(repeatCount(arr1, 6)); // 打印结果：3


//计算数组中每个元素出现的次数

let arr = [10, 2, 3, 4, 2, 10, 10];

let counts = arr.reduce(function (pre, item) {
    if (item in pre) {
        pre[item]++;
    } else {
        pre[item] = 1;
    }
    return pre;
}, {});

console.log(counts); //{2: 2, 3: 1, 4: 1, 10: 3}