SOURCE

//1·数组添加元素
//push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度
let arr01 = [1, 2, 3];
arr01.push(4, 5, 6);
arr01.push(true ? 6 : null);
console.log('末尾添加', arr01);

//unshift() 方法可向数组的开头添加一个或多个元素，并返回新的长度
arr01.unshift(0, 0.01);
console.log('开头添加', arr01);

//2·数组删除元素
//pop() 方法用于删除并返回数组的最后一个元素
arr01.pop();
console.log('删除最后一个元素', arr01);

//shift() 方法用于删除并返回数组的第一个元素
arr01.shift();
console.log('删除第一个元素', arr01);

//splice()方法从数组中添加/删除元素，然后返回被删除的元素,参数：(index, deleteNum, addElement...)
//只有一个参数，删除从该参数起至数组末尾全部元素
arr01.splice(5)
console.log('删除当前位到末尾元素', arr01);
//两个参数
arr01.splice(1, 2)
console.log('删除m到n的元素', arr01);
//N个参数
arr01.splice(1, 2, 21, 22, 23);
console.log('删除m到n的元素,并添加', arr01);

//3·数组截取元素
//slice()方法从数组中返回选定的元素,参数：(start, end)
//没有end参数， 返回从start开始到数组末尾全部数组
//不改变原数组
//start，end都可以为负数，从数组末尾开始选取元素
//start，end无论正负，start要小于end，否则返回空数组
let arr02 = arr01.slice(1, 4);
console.log('返回选定的元素', arr02);

//4·数组转字符串
//join()方法把数组中到所有元素放入一个字符串
//如果不带参数，将使用逗号作为分隔符， 等价于Array.prototype.toString()。
//如果是二维及多维数组，仍然可以将所有元素转化为字符串。
let arr03 = arr02.join('-');
console.log('读取为字符串', arr03);
//重复字符串
let arr04 = new Array(15).join('a');
console.log('重复字符串', arr04);

//5·数组颠倒顺序
//reverse()方法用于颠倒数组中元素的顺序,改变原数组,只能颠倒一维数组
arr02.reverse();
console.log('颠倒顺序', arr02);

//6·sort()方法用于对数组的元素进行排序，改变原数组
let nums = [1, 20, 4, 31, 100];
//默认数字会先被转换为字符串，在按照Unicode顺序
console.log('数组排序', nums.sort());
let newNums = nums.sort((a, b) => (a - b));
console.log('按大小排序', newNums);

//7·对象排序
let oArr01 = [{ id: 8 }, { id: 23 }, { id: 21 }];
//对数组中的对象排序
let oArr02 = oArr01.sort((a, b) => (a.id - b.id))
console.log('对象排序', JSON.stringify(oArr02));

//8·数组合并,不改变原数组
let arr05 = [11, 22];
let arr06 = arr05.concat(1, [1, 2, 3], [4, 5, 6])
console.log('数组合并', arr06);

//数组对象合并，es6扩展运算符...
let oArr03 = [{ a: 1 }, { a: 1 }, { a: 2 }];
let oArr04 = [{ b: 1 }, { b: 1 }, { b: 2 }];
let oArr05 = [...oArr03, ...oArr04];
console.log('数组对象合并', JSON.stringify(oArr05));

//9`数组循环forEach()方法对数组的每个元素执行一次提供的函数
let arr07 = ['a', 'b', 'c'];
arr07.forEach((item, index, array) => {
    console.log(item, index, array, this)
})

//map()方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。简称映射。
let arrmap = arr07.map((value, index, array) => {
    console.log(value, index, array, this)
    return value + ''
});
console.log('map()', arrmap)

//filter()方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。简称过滤
let arr08 = [1, 2, 3];
let arr09 = arr08.filter((value, index, array) => {
    console.log(value, index, array)
    return value > 1
})
console.log('arr09:', arr09)

//every()方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。返回一个布尔值
let arr10 = [1, 2, 3];
let arr11 = arr10.every((item, index, arr) => {
    console.log(item, index, arr)
    return item > 2
})
console.log('arr11:', arr11)

//some()方法测试是否至少有一个元素可以通过被提供的函数方法。返回一个布尔值
let arr12 = arr10.some((item, index, arr) => {
    console.log(item, index, arr)
    return item > 2
})
console.log('arr12:', arr12)

//reduce() 方法对数组中的每个元素执行一个reducer函数(升序执行)，将其结果汇总为单个返回值。
//arr.reduce(func(accumulator, currentValue, index, array), initialValue)
let sum = [0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, index, array){
  return accumulator + currentValue;
},100);
console.log('升序求和',sum);
let sum1 = [{x: 1}, {x:2}, {x:3}].reduce(function (accumulator, currentValue) {
    return accumulator + currentValue.x;
},5);
console.log('对象升序求和',sum1);
//reduceRight() 方法和reduce()方法功能一样，不同的是执行顺序从右到左，即从数组的末尾向前。


//indexOf()方法返回数组中可以找到给定的元素的第一个索引，如果不存在则返回-1。
//arr.indexOf(searchElement,index);
let arr13 = [1, 2, 3,4,5];
console.log(arr13.indexOf(2));
console.log(arr13.indexOf(4, 2));
//lastIndexOf() 和indexOf()方法一致，不同的是从查找顺序从后往前查找。

function repeat4(str, num, time) {
            var flag = 0;
            function st() {
                setTimeout(function () {

                    if (flag > num-1) {
                        return
                    } else {
                        console.log(str);
                        st();
                        flag++;
                    }
                }, time)
            }
            st()
        }
        repeat4("helloworld", 4, 3000);