JavaScript函数，变量的作用域，let,const，方法学习_js怎么在代码块外面获取const-CSDN博客

本文链接：https://blog.csdn.net/ypxcan/article/details/115586333

1.1 定义函数

    function abs(x) {
        if(x >= 0) {
            return x;
        }else {
            return -x;
        }
    }

一旦执行到return 代表函数结束，返回结果！

如果没有执行return,函数执行完也返回结果，结果就是undefined

定义方式二

    var abs = function (x) {
        if(x >= 0) {
            return x;
        }else {
            return -x;
        }
    }

function(x){......}这是一个匿名函数。但是可以把结果赋值给abs,通过abs就可以调用函数！

调用函数

abs(101) //101

abs(-101) //-191

参数问题：js可以传任一个参数，也可以不传递参数

参数进来是否存在的问题？

假如不存在参数，如何规避？

    var abs = function (x) {
        //手动抛出异常来判断
        if(typeof x !== 'number') {
            throw 'Not a number'
        }
        if(x >= 0) {
            return x;
        }else {
            return -x;
        }
    }

arguments

arguments是js免费赠送的关键字

var abs = function (x) {
        console.log(`x=>${x}`)
        for(var i = 0;i < arguments.length;i++) {
            console.log(arguments[i]);
        }
        if(x >= 0) {
            return x;
        }else {
            return -x;
        }
    }

rest ES6引入

获取除了已经定义的

    function f(a, b,...rest) {
        console.log(a,b);
        console.log(rest)
    }

rest参数只能写在最后面，必须用...标识

1.2 变量的作用域

在js中，var定义变量世纪是有作用域的

假设在函数体中声明，则在函数体外不可以使用

    function f() {
        var x = 1;
        x = x + 1;
    }
    x = x + 2;

如果两个函数使用了相同的函数名，只要在函数内部，就不冲突

    function f1() {
        var x = 1;
    }

    function f2() {
        var x = 2;
    }

内部函数可以访问外部函数的成员，反之则不行

    function f1() {
        var x = 1;
        function f11() {
            var y = x + 1;
        }
        var z = y + 1;
    }

假设，内部函数变量和外部函数的变量重名，

    function f1() {
        var x = 1;
        function f11() {
            var x = x + 1;
            console.log('inner' + x)
        }
        console.log('outer' + x)
    }

假设在js中函数查找变量从资深函数开始,由内向外查找。假设外部存在这个同名的函数变量，则内部函数会屏蔽外部函数的变量

提升变量的作用域

    function f3() {
        var x = 1 + y;
        console.log(x);
        var y = 1;
    }

    function f3() {
        var x = 'a' + y;
        console.log(x);
        var y = 'b';
    }

结果： aundefined

说明：js执行引擎，自动提升了y的声明，但是不会提升变量y的赋值

    function f3() {
        var y;
        var x = 'a' + y;
        console.log(x);
         y = 'b';
    }

这个是在js建立之初就存在的特性，养成规范，所有的变量定义都放在函数的头部，不要乱放，便于代码维护

全局函数

    //全局变量
    let x = 1;
    
    function f() {
        console.log(x);
    }
    f();
    console.log(x)

全局对象window

    let x = 'error'
    alert(x);
    alert(window.alert(x));

alert()这个函数本身也是一个window变量；

js实际上只有一个全局作用域，任何变量（函数也可以视为变量），假设没有在函数作用范围内找到，就会向外查找，如果在全局作用域没有找到，报错RefrenceError

规范：

由于我们所有的全局变量都会绑定到我们的window熵，如果不同的js文件，使用了相同的全局变量，冲突

如何能够减少冲突？

    //唯一全局变量
    var LuApp = {};

    //定义全局变量
    LuApp.name = 'lu';
    LuApp.add = function (a, b) {
        return a + b;
    }

把自己的代码全部放入自己定义的唯一空间名字中，降低全局命名冲突的问题

jQuery

局部作用域let

    function f() {
        for(var i = 0; i < 100; i++) {
            console.log(i);
        }
        console.log(i);
    }

ES6关键字，解决局部作用域冲突问题

    function f() {
        for(let i = 0; i < 100; i++) {
            console.log(i);
        }
        console.log(i + 2);
    }

建议使用let和const

常量const

在ES6之前，怎么定义常量：只有用全部大写字母命名的变量就是常量，建议不要修改这样的值

在ES6引入了常量关键字

    const pi = 3.14;
    console.log(pi);
    pi = 123;
    console.log(pi);

1.3 方法

方法就是把函数放在对象的里面，对象只有两个东西：属性和方法

    var lu = {
        name: 'lumou',
        birth: 1999,
        //方法
        age: function () {
            //今年-出生的年龄
            var now = new Date().getFullYear();
            return now - this.birth;
        }
    }

调用方法一定要带（）

this.代表什么？拆开上面的代码看看

    function getAge() {
        //今年-出生的年龄
        var now = new Date().getFullYear();
        return now - this.birth;
    }
    var lu = {
        name: 'lumou',
        birth: 1999,
        age: getAge
    }