函数进阶-arguments关键字/自执行函数/回调函数/有名回调和匿名回调的优劣

01-函数进阶 -arguments 关键字

    <script>
        // arguments关键字：函数内部使用

        // 1. 应该先定义函数
        function test() {
            // 2. 在函数内部打印arguments
            console.log(arguments)
            // 长得像数组：但又不是数组：伪数组
            // 作用：存储用户传入的实参

            // 按照传入的顺序保存在“数组”中

            // 伪数组访问：当数组一样访问（有下标）
            // console.log(arguments[1])

            // 访问全部：可以for循环遍历
            for (let i = 0; i < arguments.length; i++) {
                console.log(arguments[i])
            }
        }

        // 3. 调用函数：不同参数传值
        test(1, 'a')

        // arguments的作用：接收所有的参数，解决不确定实参数量的行为
        let res = Math.max(1, 2, 5, 7, 8, 9, 10)
        console.log(res)

        function max() {
            // 求最大值：擂台思想

            let m = -Infinity

            // 用户输入的数据肯定在arguments中
            // 遍历，取出所有元素进行对比
            for (let i = 0; i < arguments.length; i++) {
                // arguments[i]代表元素
                if (m < arguments[i]) {
                    m = arguments[i]
                }
            }

            // 返回最大值
            return m
        }

        let newRes = max(1)
        console.log(newRes)

        // arguments解决：参数数量不确定的方式（这种场景极少：最大值，最小值，求和）
    </script>

注意：
1.arguments关键字：函数内部使用,先定义函数,在函数内部打印arguments
2.是伪数组，当不确定有多少数组数据的时候。作用：存储用户传入的实参，按照传入的顺序保存在“数组”中
3.伪数组访问：当数组一样访问（有下标）
4.可以for循环遍历
5.arguments的作用：接收所有的参数，解决不确定实参数量的行为（这种场景极少：最大值，最小值，求和）

02-函数进阶-自执行函数

    <script>

        // 变量：全局变量（随时可以被修改的变量），存的数据一点都不安全

        function test() {
            // 变量定义在函数内部：安全（外面不能修改）
            let lives = 10
            console.log(lives)
        }

        test();     // 分号必加（如果后面跟一个自执行函数）

        // 保证数据安全：将数据保存在函数里面

        // 自执行函数：函数的数据与任何数据都不相关（同名也没关系）

        // 语法：( function(){} )()
        (function suibian() {
            let a = 1
            console.log(a)
        })()
        // 自执行函数内部的任何东西：外面都用不了

        let a = 2
        // 自执行函数：内部的数据与外部不冲突（安全：沙箱）
        // 自执行函数：永远只能执行1次

        // !function () { }()
    </script>

注意：
1.变量定义在函数内部：安全（外面不能修改）
2.自执行函数：函数的数据与任何数据都不相关（同名也没关系）
3.语法为：( function(){} )()
4.自执行函数：内部的数据与外部不冲突（安全：沙箱）
5.自执行函数：永远只能执行1次

03-回调函数基本语法

    <script>
        // 函数内部可以调用其他函数
        function a() {
            console.log('我是a函数')
        }

        function b() {
            console.log('我是b函数')

            // 调用a函数
            a()
        }

        b()
    </script>

注意：

1.这里结果是“我是b函数 我是a函数”
2.输出b() 按照执行顺序先返回console.log('我是b函数')的结果，在执行下面调用a()的结果

04-回调函数的有名，匿名等用法

    <script>
        // 回调函数
        let a = function () {
            console.log('我是a函数')
        }

        let b = function () {
            console.log('我是b函数')
        }

        // 函数可以当做实参传递给形参
        function c(f) {
            console.log('我是c函数')

            // 调用a函数
            // a()

            // 调用b函数
            // b()

            // 想要调用a或者b函数
            // 当一个内容不确定的时候（不写死）：传参
            console.log(f)
            f()
        }

        c(a)        // 将a函数传递给f形参
        c(b)

        // 有名函数
        function d() {
            console.log('我是有名d函数')
        }

        c(d)

        // 直接匿名
        c(function () {
            console.log('我是六神无主的函数')
        })
    </script>

05-函数进阶-回调函数-有名回调和匿名回调的区别

    <script>

        function a() {
            console.log('我是a函数')
        }

        // fn是一个回调函数
        function b(fn) {
            console.log('我是b函数')

            fn()
        }

        b(a)
        b(a)
        b(a)
        // 有名回调：有名函数可以重复使用（名字就够）
        // 缺点：长期占用内存（直到脚本运行结束）


        // 匿名回调
        b(function () {
            console.log('我是匿名回调函数')
        })

        // 不是重复使用：而是新代码
        b(function () {
            console.log('我是匿名回调函数')
        })
        // 匿名回调：不能重复使用
        // 优点：用后即焚（用完立马释放内存）：不占内存

        // 回调函数中：很少使用有名回调，一般都是匿名回调（除非某个函数需要多次使用）

    </script>

注意：
1.// 有名回调：有名函数可以重复使用（名字就够）
// 缺点：长期占用内存（直到脚本运行结束）
2. // 匿名回调：不能重复使用
// 优点：用后即焚（用完立马释放内存）：不占内存
3.调函数中：很少使用有名回调，一般都是匿名回调（除非某个函数需要多次使用）