ES5,ES6,js, 数组，数组对象，字符串，排序 ,常用方法

        变异：push()和pop()，shift() 和 unshift()，sort()，splice()
        非变异：join()，concat()，slice()，indexOf()和 lastIndexOf() （ES5新增），forEach() （ES5新增），some() （ES5新增）,fliter() (ES5新增)，map() （ES5新增），every() （ES5新增），reduce()和 reduceRight() （ES5新增）
        变异方法意味着会改变原数组，而非变异方法则只会返回一个新数组，不会修改原始数组
   
     
        
  

let arrayobject1 = [{
            name: '张三',
            age: 20
        }, {
            name: '李四',
            age: 30
        }, {
            name: '王五',
            age: 25
        }];
        let strings = 'hello 嗨，你是谁？my name is 张三';
        let array = ['张三', '李四', '王五'];


//forEach()  对数组的每一项运行给定函数，该方法没有返回值
        arrayobject1.forEach((item, index, arr) => {

        })

//some（）： 对数组中的每一项运行给定函数，如果该函数对任一项返回true，则返回true
       let some=arrayobject1.some((value,index,arr)=>{
           return value.age>20
       })
      console.log('some 对任一项返回true，则返回true',some);


//every()  对数组中的每一项运行都给定函数，如果该函数对每一项都返回true，则返回true
let every=arrayobject1.every((value,index,array)=>{
    return value.age>20
})
console.log('every 每一项都返回true则返回true',every);


        //查看数组或字符串是否包含某个值,返回一个新的数组
        //map（） ：对数组的每一项运行给定函数，返回每次函数调用结果所组成的数组
        //return什么值,返回值就push什么值,如果不写return,就push(undefined)
        let map = arrayobject1.map((item, index, arr) => {
            item.age *= 2
            return item
        })
        console.log('map-arrayobject1', map,arrayobject1);


        for (let i in arrayobject1) {
            // console.log('for...in',i); // i 0 序号
        }

        for (let i of arrayobject1) {
            // console.log('for...of',i);  //i=object
        }
        
        //filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
        let filters = arrayobject1.filter((item, index, arr) => {
            return item.age > 40
        })
        console.log('filter 符合条件的所有元素-', filters,arrayobject1);
        
        
        let finds = arrayobject1.find((item, index, obj) => {
            return item.age > 40
        })
        console.log(' es6 find 符合条件的1', finds,arrayobject1);
        
        
        let findindexs = arrayobject1.findIndex(item => item.age > 20)
        console.log('findIndex 符合条件的1元素索引', findindexs,arrayobject1);
        
        console.log('---------------------------------------');
        
        let splics = strings.split('？')
        //将字符串分隔成数组  字符串.split（"以什么分隔"）[分隔出来的第几项]
        console.log('split 字符串分隔成数组-strings', splics,strings);
        
        console.log('---------------------------------------');

        let push=array.push('张三', '罗老') //添加到数组末尾
     console.log('push-array',push,array);
     
        //pop()：数组末尾移除最后一项
        let pops = array.pop()
        console.log('pop 数组末尾移除最后一项-array', pops,array);

//数组去重
        let set1 = Array.from(new Set(array))
        console.log('Array.from(new Set()) 数组去重-array', set1,array);


        

        //接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的开头（位置 0）开始向后查找。
        //lastIndexOf 从数组的末尾开始向前查找。
        let indexofs = array.indexOf('张三')
        console.log('indexOf-array ', indexofs,array);

        let includesb = array.includes('张三')
        console.log('includes 包含-array', includesb,array);

        


        let join = array.join()
        //把数组中所有元素拼接成字符串 数组名.join()  //括号中可指定分隔符，不写则默认为逗号
        console.log('join拼接成字符串-array', join,array);

        let slice = array.slice(1, 3)
        //返回从原数组中指定开始下标到结束下标之间的项组成的新数组。但不包括结束位置的项。0
        console.log('开始下标到结束下标,不包括结束 array.slice(1,3)-array', slice,array);


        let splice = array.splice(1, 1, '纸张')
        //可以实现删除、插入和替换。 返回 从原始数组中删除的项
        //splice(0,2)会删除数组中的前两项
        //splice(2,0,4,6)会从当前数组的位置 2 开始插入4和6。
        // 替换 splice (2,1,4,6)会删除当前数组位置 2 的项，然后再从位置 2 开始插入4和6。
        console.log('splice 实现删除、插入和替换(返回 从原始数组中删除的项)-array-', splice,array);


        let reverse = array.reverse() //数组反转 数组名.reverse()
        console.log('reverse 数组反转-array', reverse,array);


        //shift()：删除原数组第一项
        let shift = array.shift()
        console.log('shift 删除原数组第一项-array', shift,array);

        let unshift = array.unshift('丽丽')
        //向数组的开头添加一个或更多元素,并返回新的长度  数组名.unshift(要添加的内容)
        console.log('unshift 开头添加-array', unshift,array);

        let concat = array.concat('KK', ['露露', ['发发']])
        //将参数添加到原数组中。 oncat方法只能将传入数组中的每一项添加到数组中，
        //如果传入数组中有些项是数组，那么也会把这一数组项当作一项添加到原数组中
        //返回新构建的数组
        console.log('concat 将参数添加到原数组中。-array', concat,array);


//JSON.parse()深拷贝
        //JSON.parse(JSON.stringify(要拷贝的数组名或对象名))
        let parse = JSON.parse(JSON.stringify(array))
        console.log('JSON.parse()深拷贝---array', parse,array);
        
        


        let Mathrandom = Math.random() //生成随机数
        console.log('Math.random 生成随机数', Mathrandom);

        let mathround = Math.round(4.256)
        console.log('math.round 四舍五入', mathround);

        


        /* setTimeout() 定时器
        名字= settimeout(()=>{
            //数据处理
        },倒计时的事件(单位是毫秒)) */
        let settimeout2 = setTimeout(() => {
            console.log('定时器 2秒 ');
        }, 2000)

        // clearTimeout(定时器的名字) 清除定时器


        //delete() 对象名.delete(属性名)  //  delete 对象名.属性名


        console.log('y.repeat(5)', 'y'.repeat(5));

        /**
         * 数组对象排序
         * @param {Array} arr  需要排序的对象数组
         * @param {string} key 排序的关键字
         * @param {boolean} flag 如果是true, 则正序，否则倒序
         * */
        function arrObjCompare(arr, key, flag) {
            arr = Object.assign([], arr); // 如果带这一行，则不改变原数组排序，不带则改变原数组排序
            return arr.sort((a, b) => {
                return flag ? a[key] - b[key] : b[key] - a[key]

            })
        }

        let arrObjCompares = arrObjCompare(arrayobject1, 'age', false)
        console.log('数组对象排序', arrObjCompares);
        //排序 顺序
        function compare(value1, value2) {
            return value1.age - value2.age
        }
        let sort = arrayobject1.sort(compare)
        console.log('按升序排列', sort);

参考 js前端数组常用方法_暴走的山交的博客-CSDN博客_前端数组方法