递归函数 高阶函数 回调函数 数组的高阶方法 闭包函数

1.递归函数

<script>

        //递归函数,就是在函数的内部继续调用自己，注意：递归函数一定要有结束条件，否则就是死循环

        function fun() {

            console.log("你好！");

            let jx = prompt("继续执行吗（y/n）")

            //这个判断就是控制递归函数的结束条件

            if (jx == "y") {

                fun()

            }

        }

        fun()

    </script>

2.高阶函数

<script>

        //高阶函数：当前函数的参数是函数或函数的返回值是函数，满足其中一个就是高阶函数

        //1。函数的参数是函数

        function fun1() {

            console.log("我是方法一");

        }

        //方法二是高阶函数，因为它的参数是函数

        function fun2(fun) {

            fun()

            console.log("我是方法二");

        }

        fun2(fun1)

        //2.函数的返回值是函数

        function fun3() {

            return function () {

                console.log("我是方法三");

            }

        }

        let fun4 = fun3()

        fun4()

    </script>

3.回调函数

 <script>

        //函数的参数是一个函数。这个函数我们也称为回调函数

        let arr = [11, 22, 33, 44, 55, 66, 77, 88, 111, 222, 333, 444]

        //返回数组中所有的偶数，并保存到一个新的数组中

        let os = []

        for (let i = 0; i < arr.length; i++) {

            if (arr[i] % 2 == 0) {

                os.push(arr[i])

            }

        }

        console.log(os);

        let sws = []

        for (let i = 0; i < arr.length; i++) {

            if (arr[i] % 2 == 0 && arr[i] < 1000) {

                sws.push(arr[i])

            }

        }

        console.log(sws);

        //返回数组中所有能被3整除

        function myFilter(arr, callBack) {

            let newArr = [] //定义一个新数组

            for (let i = 0; i < arr.length; i++) {

                //if的条件返回true，表示找到了满足条件的数，但是条件会变化

                if (callBack(arr[i])) {

                    newArr.push(arr[i])

                }

            }

            return newArr

        }

        //判断函数是否是偶数

        function osFun(num) {

            return num % 2 == 0

        }

        let a1 = myFilter(arr, osFun)

        console.log(a1);

        let ret2 = myFilter(arr, function (num) { return num % 2 != 0 })

        console.log(ret2);

        let ret3 = myFilter(arr, num => num % 2 != 0)

        console.log(ret3);

    </script>

4.数组的高阶方法

<script>

        let arr = [11, 22, 33, 44, 55, 66, 77, 88, 111, 222, 333, 444]

        //forEach方法，用于遍历数组，方法需要传一个函数参数，函数的第一个参数是数组的每一项元素，第二个参数是每一项元素的索引

        arr.forEach(function (item, index) {

            console.log(item + " " + index);

        })

        console.log("-------------------------------------");

        //filter方法，用于过滤数组，从数组中返回满足条件的数

        let ret1 = arr.filter(function (item) {

            return item % 2

        })

        console.log(ret1);

        let ret2 = arr.filter(item => item % 3 == 0)

        console.log(ret2);

        console.log("-------------------------------------");

        //map方法，用于根据原数组隐射出满足条件的新数组

        //要求 ：返回数组每个数+100后的数组

        let ret3 = arr.map(item => item + 100)

        console.log(ret3);

        //返回数组中，每个数%3后的余数

        let ret4 = arr.map(item => item % 3)

        console.log(ret4);

        console.log("-------------------------------------");

        //some方法用于检查数组中是否有满足条件的数据，有返回true，没有返回falase

        let ret5 = arr.some(item => item == 66) //条件满足等于66

        console.log(ret5);

        let ret6 = arr.some(item => item > 100) //条件满足大于100

        console.log(ret6);

        console.log("-------------------------------------");

        //every方法，用于检查数组中所有满足条件

        let ret8 = arr.every(item => item % 2 == 0) //检查数组中所有的数是否都是偶数

        console.log(ret8);

        let ret9 = arr.every(item => item > 10) //检查数组中的数是否大于0

        console.log(ret9);

        console.log("-------------------------------------");

        let arr10 = [55, 99, 11, 33, 66]

        //sort方法，默认就是升序，可以传一个回调函数，回调函数有两个参数

        //参数1-参数2是升序，参数2-参数1是降序

        arr10.sort()

        console.log(arr10); //默认值 不传参数 是升序

        arr10.sort((a, b) => a - b)

        console.log(arr10);  //升序

        arr10.sort((a, b) => b - a)

        console.log(arr10); //降序

        console.log("-------------------------------------");

        //find方法用于在数组中查找满足条件的第一个数 ，如果没有返回undefined

        let ret10 = arr.find(item => item % 4 == 0) //查找数组中第一个能被4整除的数

        console.log(ret10);

        let ret11 = arr.find(item => item > 10000)

        console.log(ret11);

        console.log("-------------------------------------");

        //findIndex 方法，用于数组中查找满足条件的数组第一个数索引位置，如果没有返回-1

        let ret12 = arr.findIndex(item => item > 10000)

        console.log(ret12);

5.闭包函数

 <script>

        let momey = 10000

        function pay() {

            if (momey >= 7000) {

                money -= 7000

                console.log(`买了一部ipone15，花了7000，存款还剩下${money}`);

            } else {

                console.log("对不起，余额不足");

            }

        }

        console.log('调用pay方法才会触发花钱机制，不调用就不会触发，或者可以先不调用....');

        momey -= 10000  //成员变量是公开的，很容易被篡改

        //定义一个变量只是暂时先不用，很有可能被其他程序修改,所以成员变量不能保证数据的安全性

        pay()

        console.log("-----------------------------------");

        //如何解决成员变量不安全的问题，使用闭包函数去保护

        //闭包函数，也是一个高阶函数，因为它要在函数内部返回出去一个函数

        function myCk() {

            //闭包函数就是在外层函数中定义函数，在内层函数中使用函数

            let money = 10000

            return function () {

                if (momey >= 7000) {

                    money -= 7000

                    console.log(`买了一部ipone15，花了7000，存款还剩下${money}`);

                } else {

                    console.log("对不起，余额不足");

                }

            }

        }

        //调用myCk函数，此时在函数中会初始化一个money，值是10000

        //myCk函数会返回一个函数，这里我们用一个变量去接受

        let my = myCk()

        console.log("此时我赞了一笔存款不想花。。。。。");

        console.log("当我想花的时候调用方法");

        my()

    </script>