js常用数组方法==简单模拟实现

总结：

 1.forEach循环==专门遍历数组；不需要return，在内部对数组的元素直接进行处理即可

 2.map==数组映射，返回一个新数组；

  内部创建全新数组，收集每次return的值，遍历结束，返回这个全新的数组；不同于原来的数组！

3.filter == 数组筛选，返回一个新数组

注意点：filter方法会遍历整个数组，只有某个元素符合筛选条件，返回值为true的时候，该元素才会被添加进返回的新数组中；

4.findIndex===查找索引，找不到返回-1

5.reduce 方法==累加求和

注意：一定要有return，下次函数体执行，sum初始值是上一次return的结果！

6.some方法===查找是否有'符合'条件的元素，有返回true，停止循环

7.every方法===查找是否有‘不符合条件的元素’，有就返回false，停止循环

  <script>

        // 1.forEach循环==专门遍历数组
        Array.prototype.forEach = function (fn) {
            // this指的是函数的调用者，arr
            for (let i = 0; i < this.length; i++) {
                fn(this[i], i, this)
            }
        }

        const arr = [1, 3, 4, 5]
        arr.forEach((value, index, arr) => {
            console.log(value, index);
        })


        // 2.map==数组映射，返回一个新数组
        Array.prototype.map = function (fn) {
            const newArr = []
            for (let i = 0; i < this.length; i++) {
                const res = fn(this[i], i, this)
                //原理：把每次遍历return的结果添加到一个新数组，然后返回这个新数组
                newArr.push(res)
            }
            return newArr
        }

        const arr1 = [1, 3, 4, 5]
        const res = arr1.map((value, index, arr) => {
            return value * 2
        })
        console.log(res);


        // 3.filter == 数组筛选，返回一个新数组
        Array.prototype.filter = function (fn) {
            const newArr = []
            // this指的是函数的调用者，arr2
            for (let i = 0; i < this.length; i++) {
           // 每遍历一个元素，返回一个Boolean值，表示是否符合条件
                const res = fn(this[i], i, this)  
            //原理：如果遍历的元素为true，添加到新数组，返回新数组
                if (res) {
                    newArr.push(this[i])
                }
            }
            return newArr
        }


        const arr2 = [1, 3, 4, 5]
        const res2 = arr2.filter((value, index, arr) => {
            return value > 2
        })
        console.log(res2);


        // 4.findIndex===查找索引，找不到返回-1
        Array.prototype.findIndex = function (fn) {
            let ind = -1
            // this指的是函数的调用者，arr3
            for (let i = 0; i < this.length; i++) {
                const res = fn(this[i], i, this)  // 返回Boolean，true表示符合条件
                // 原理：只有为true时，进入循环，返回索引；否则返回-1
                if (res) {
                    ind = i
                }
            }
            return ind
        }

        const arr3 = [1, 3, 4, 5]
        const res3 = arr.findIndex((value, index, arr) => {
            return value === 0
        })
        console.log(res3);


        // 5.reduce 方法====累计求和
        Array.prototype.reduce = function (fn, num) {
            let newsum = num  // 初始值
            // this指的是函数的调用者，arr4
            for (let i = 0; i < this.length; i++) {
                // 下一次调用时，把上一次的结果传进去，继续累加
                newsum = fn(newsum, this[i], i, this)
            }
            return newsum
        }



        const arr4 = [1, 3, 4, 5]
        const res4 = arr2.reduce((sum, value, index, arr) => {
            return sum += value
        }, 0)
        console.log(res4);


        // 6.some方法===查找是否有'符合'条件的元素，有返回true，停止循环
        Array.prototype.some = function (fn) {
            // this指的是函数的调用者，arr5
            for (let i = 0; i < this.length; i++) {
                const boolean = fn(this[i], i, this)
                //   原理：有符合条件的元素，就返回true；否则返回false
                if (boolean) {
                    return true
                }
            }
            return false
        }
        const arr5 = [1, 3, 4, 5]
        const res5 = arr5.some((value, index, arr) => {
            // 查找是否有大于2的元素
            return value > 2
        })
        console.log(res5);


        // 7.every方法===查找是否有‘不符合条件的元素’，有就返回false，停止循环
        Array.prototype.every = function (fn) {
            // this指的是函数的调用者，arr6
            for (let i = 0; i < this.length; i++) {
                const boolean = fn(this[i], i, this)
                console.log(boolean);
                //   原理：有不符合条件的元素，就返回false；
                if (!boolean) {
                    return false
                }
            }
            return true
        }
        const arr6 = [1, 3, 4, 5]
        const res6 = arr6.every((value, index, arr) => {
            //判断是否所有元素大于2
            return value > 2
        })
        console.log(res6);
    </script>