js arguments对象 作用域 模板字符串 深拷贝 数组进阶方法 函数的递归调用

arguments对象

arguments: 当我们不确定有几个参数传递时，可以用arguments来获取，arguments是一个内置对象。所有的函数都内置一个arguments对象，arguments对象中存储了传递的所有的实参

function fn() {
console.log(arguments)//里面存储了所有传递的实参
}
fn(1, 2, 3)
1.arguments展示出的结果是一个伪数组，可以进行遍历
伪数组：
(1)：具有数组的length的属性
(2): 按照索引的方式进行的存储的
(3): 它没有真正数组的一些方法 push() 等等

       function getmax() {
            var max = arguments[0];
            for (var i = 1; i < arguments.length; i++) {
                if (arguments[i] > max) {
                    max = arguments[i];
                }
            }
            return max;
        }
        var re = getmax(1, 2, 3);
        console.log(re);
    </script>

作用域

js作用域：

1.js作用域就是代码名字在某个范围所起到的作用和效果 目的：为了提高程序的可靠性更重要的是减少命名的冲突

2.js作用域（es6之前）：全局作用域 局部作用域

3.全局作用域：整个script标签 ，或者单独的js文件

4.局部作用域（函数作用域）：在函数内部就是局部作用域，这个代码的名字只能在函数内部起效果

变量作用域

变量的作用域：根据作用域的不同我们的变量分为全局变量和局部变量

1.全局变量：在全局作用域下的变量

        var num = 10//全局变量
        function fn() {
            console.log(num);
        }
        fn();

2.局部变量 ：在局部作用域的变量 后者在函数内部的变量就是局部变量，函数的形参也可以看作是局部变量

        function fn2() {
            var num1 = 10;
            num2 = 20;//如果在函数内部，没有声明直接赋值的变量也属于全局变量
        }
        fn2();
        // console.log(num1);报错
        console.log(num2);

3.从执行效率来看全局变量和局部变量

（1）：全局变量只有浏览器关闭的时候才会被销毁，比较占内存资源

（2）：局部变量当我们执行完毕就会销毁，比较节约内存资源

模板字符串

 var str = 'hello world';
        document.write('<h1><span>hello world!<span></h1>');//字符串中的内容不允许换行
        document.write('<h1><span>')
        document.write(str);//如果把变量放入字符串不能输出变量值
        document.write('</span></h1>')

        //es6:模板字符串，是允许嵌入表达式的字符串，可以使用多行字符串和字符插值功能
        //使用：以反引号结束
        //模板字符串中可以黄行
        document.write(` 
            <h1>
                <span>模板 字符串</span>
            </h1>
        `);
        //和普通字符串不同点，会保留空格，换行符 和缩进
        var str1 = `第一        行
        第二行
            第三行
        `;
        console.log(str1);
        //字符串插值操作：使用${}
        document.write(`<h2>${str1},${str}</h2>`)
        document.write(`${2 + 5 + 46 + 3}</h2>`)

模板字符串总结

1.字符串中内容可以换行

2.字符串中可以插入标签

3.字符串中可以保留空格，换行符 缩进

4.字符串中可以插值

深拷贝

//注意：基本数据类型中不存在深浅拷贝，只有值传递
        var num = 100//数值类型（基本数据类型）
        var num1 = num;//拷贝
        console.log(num1);
        num = 1000;
        console.log(num1);
        num1 = num;
        console.log(num1);

        //引用数据类型
        var obj = {
            name: '张三',
            age: 20,
            say: function () {
                console.log('hello');
            }
        }
        console.log(obj);
        //拷贝(浅拷贝：只拷贝引用地址‘指针地址’)
        //一个对象的数据改变，会影响使用另一个指针地址的对象
        var newobj = obj;
        console.dir(newobj);
        //对obj对象中的属性进行操作
        obj.sex = true;
        console.log(newobj);
        newobj.sleep = function () {
            console.log(我在睡觉);
        }
        console.log(obj);


        //深拷贝：把被拷贝的对象中的数据遍历赋值给拷贝者
        var newobj2 = {};
        for (var k in obj) {
            newobj2[k] = obj[k]
        }
        console.log(newobj2);
        delete obj.age
        delete newobj2.say
        console.log(obj);
        console.log(newobj2);

        var str = 'String';
        obj[str] = 'hello'
        obj.str = 'world';
        console.log(obj);


        //数组的深拷贝
        var arr = ['hello', 1, 2, 100, true];
        var newarr = [];
        for (var k in arr) {
            newarr[k] = arr[k]
        }
        newarr.push({ name: 'wang' })
        console.log(newarr);
        console.log(arr);

数组进阶方法

       //Array.form() 将参数转换为真正的数组
        function func() {
            console.log(arguments);//类数组
            console.log(arguments instanceof Array);//false
            var argu = Array.from(arguments);//将非数组对象转换成为真正的数组
            console.log(argu);
            console.log(argu instanceof Array); true
        }
        func(1, 2, 3, 5, 8, 9);

        var arr = [100, 3, 8, 2, 88, 2];
        //forEach()遍历，循环
        //forEach方法中defunction有三个参数（1.是遍历的数组。2.是对应的数组元素的下标。3.数组本身）
        //原理：相当于for循环遍历，数组的每一个元素都调用一次回调函数‘遍历数组数据’
        arr.forEach(function (item, index, array) {
            console.log(index + ':' + item);
        });

        //sort()数组排列，
        // 原理：是以冒泡排序，两个相邻的数据两两对比的形式。c
        // function的参数：1.相邻数的后一个数。2.相邻数的前一个数
        /*数组规则
            如果 sort(x , y) 小于 0 ，x 会被排到 y 之前。
            如果 sort(x , y) 等于 0 ，x 和 y 的顺序不变。
            如果 sort(x , y) 大于 0 ，y 会被排到 x 之前。
        */
        // 正序
        var res = arr.sort(function (x, y) {
            return x - y;
        });
        console.log(res);
        // 逆序
        var res = arr.sort(function (x, y) {
            return y - x;
        });
        console.log(res);


        // every() && 判断，数组中“每一项”都符合条件
        // 原理：让数组中的每一条数据都参与函数的运算，返回一个布尔值，只有每一个元素都满足条件结果为true，如果有一个元素结果为false则返回false并立即结束判断"后面的元素不会再参与判断"。
        var res = arr.every(function (item, index, arr) {
            return item >= 20;
        });
        console.log(res);

        // some() ||  判断，数组中“某一项”符合条件
        // 原理：数组中数据只要有一个符合函数内运算条件，返回true"后面的元素不会再参与判断"。全部为false才返回false。
        var res = arr.some(function (item, index, arr) {
            return item >= 100;
        });
        console.log(res);

        // map() "映射"，数组的深拷贝。
        // 原理：把原数组映射为新的数据。让数组中的每一条数据都参与函数的运算，返回的结果组成新的数组。
        var res = arr.map(function (item) {
            return Math.pow(item, 2);
        });
        console.log(res);
        console.log(arr);

        // filter() 过滤，筛选。
        // 原理：让数组中的每一条数据都参与函数的运算“条件过滤”，结果为true则保留，结果为false则被抛弃。
        // 注意: 不改变原数组数据，返回一个新的数组。
        var res = arr.filter(function (item) {
            return item > 10;
        });
        console.log(res);
        console.log(arr);

        // find() 用于查找数组中“第一个”符合条件的元素
        // 原理：让数组中的每一条数据都参与函数的运算，找到第一个符合条件的元素并返回“后面的元素将不会再执行”。如果条件都不满足返回undefined。
        var res = arr.find(function (item) {
            return item == 100;
        });
        console.log(res);

        // reduce() 累计运算
        // fuunction的参数4个 (1.存放上一次的结果“或初始值”。2.数组元素 3.数组下标 4.数组)
        // 原理：让数组中的每一条数据都参与函数运算，然后把每一次运算的结果都保存到第一个参数中。
        var arr = [100, 5, 30, 9, 0];
        // 注意：reduce()没有添加了第二个参数，prev参数的初始值是数组的第一个数据，item默认为第二个数据开始。
        var res = arr.reduce(function (prev, item, index, arr) {
            console.log(prev, item);
            return prev + item;
        });
        console.log(res);


        // 注意：reduce()添加了第二个参数，作为prev参数的初始值赋值，item对应的数数组中数据。
        var res = arr.reduce(function (prev, item, index, arr) {
            console.log(prev, item);
            return prev + item;
        }, 10);
        console.log(res);

try…cat…finally

//try...catch...finally
        //try 尝试 ，catch 捕获， finally最终
        //尝试着执行try语句的代码块，代码块中出错，会被catch语句捕获
        //不出错，正常执行，无法进入catch语句。(try语句不能单独使用)
        try {
            var x = 10;
            console.log(y);
            //throw抛出异常
            //throw‘我抛出了一个异常’

            //Error();错误对象，用来生成具体的错误，new是实例化Error对象生成具体的错误
            // throw new Error('自定义错误');
        } catch (error) {
            console.log('thow后的代码无法执行');
            console.log(error);
        } finally {
            //console.log('不论try语句中代码是否报错，finally总是执行的')
        }
        //try...catch应用
        //使用：一般不建议乱用，只有认为无法判断代码是否正常允许的时候才会使用try...catch让此语句帮你智能判断业务逻辑是否正常
        function calc(x, y, z) {
            try {
                //eval()会把所有数据解析为数字或者运算符后进行计算
                var res = eval(x + y + z);
            } catch (error) {
                throw error;
            }
            return res;
        }
        console.log(calc(1, "+", '2'));

        try {
            calc(1, '2', '+');
        } catch (error) {
            console.log("未知错误，计算出错，请联系XXX");
        }

函数的递归调用

 //如果一个函数内部直接调用本身，会产生死循环状态
        function enter() {
            console.log('123');
            // enter();
        }
        enter();

        //俩个函数之间如果直接相互调用，会产生死循环状态
        function f1() {
            console.log('fi执行了');
            f2();
        }
        function f1() {
            console.log('f2执行了');
            //f1();
        }
        f1();

        //方法递归：自己调用自己
        //注意：必须要有结束当前方法的条件
        function back(n) {
            console.log(n);
            if (n > 0) {
                back(n - 1)
            }
        }
        back(6)

        //使用函数打印1-10的数字
        function num(n) {
            console.log(n);
            if (n == 10) {
                return;
            }
            num(n + 1)
        }
        num(1)
        // 计算1-100的和
        function sum(n) {
            if (n == 0) {
                return 0;
            } else {
                return n + sum(n - 1);
            }
        }
        console.log(sum(100));

        function sum1(n) {
            if (n > 100) {
                return 0;
            } else {
                return n + sum1(n + 1);
            }
        }
        console.log(sum1(1));