Javascript中的数据类型与基本语法规则

基本类型（值类型）
    Undefined
    Null
    Boolean
    Number
    String

复杂类型（引用类型）
    Object
    Array
    Date
    RegExp
    Function

内置对象：
    Global
    Math

类型检测：
    typeof
    instanceof
    Object.prototype.toString.call()

值类型与引用类型在内存中的存储方式
    值类型按值存储（在栈中存储）
    引用类型按引用存储 （地址在栈中存储，对象在堆中存储）

作用域：使用范围
   全局变量：声明的变量使用var，就是全局变量，全局变量可在任何位置使用
   局部变量：在函数内部定义的变量，就是局部变量，外界无法使用
   块级作用域（一对大括号就是一个块级作用域,在这块区域中定义的变量，只能在这个区域中使用，但是js在这个块级作用域中定义的变量，外面也可以使用，说明：js没有块级作用域）
   扩展：
        隐式全局变量：声明的变量没有var，就叫隐式全局变量
        全局变量不能被删除，但是隐式全局变量可以被删除

预解析：在解析代码之前

    变量声明提前：把变量提前到当前所在的作用域的最上面
    函数声明提前：提前到当前所在的作用域的最上面
    * 注意：
    *   变量的提升只会在当前的作用域提升，提升到当前作用域的最前边
    *   函数的变量只会提升到函数的作用域中的最前边
    *   预解析会分段（多对的script标签中函数重名，预解析不会冲突）
    *   预解析的过程其实就是把函数的声明和变量的声明提前
    *   变量的声明总是在函数的声明的最上边


    //预热：
    //变量的提升
    console.log(num); //undefined
    var num = 100;

    //函数的声明被提前了
    f1();
    function f1() {
        console.log('这个函数执行了');
    }


    //函数表达式不会被提前
    f2(); //报错：f2 is not a function
    var f2 = function () {
        console.log('我是一个函数表达式')
    }



***** 案例一 *****    
    console.log(a);//猜想此处输出undefined？？？
    function a() {
        console.log('aaaaa');
        var  a=10;//变量a会被提升到作用域的最前边，所以说上边猜想输出undefined

    }
    var a=11;
    console.log(a)//输出11
    /**
    * 解析以上a的猜想结果为什么是[Function: a]，而不是a
    * 等效于如下
    *      var a;
    *      function a(){console.log('aaaaa');}
    *      console.log(a);//此处变量a与函数a同名，所以此处输出的是函数a
    *      a=11;
    *      console.log(a);
    *
    *
    */ 


***** 案例二 *****
abc();
console.log(c); //输出9
console.log(b); //输出9
console.log(a); //报错：Uncaught ReferenceError: a is not defined
function abc() {
    var a=b=c=9;
    console.log(a)  //9
    console.log(b)  //9
    console.log(c)  //9
}

/**
 * 解释如下，等同于
 *   var b;
     var c;
     function abc() {
        var a=b=c=9;
        var a;
        a=9; //局部变量

        //b,c都为隐式全局变量，变量作用域为全局
        b=9;
        c=9;

        console.log(a)  //9
        console.log(b)  //9
        console.log(c)  //9
     }
     abc();
     console.log(c); //输出9
     console.log(b); //输出9
     console.log(a); //局部变量，外部访问不到所以报错，
 *
 * */


    //函数成员
     function f1(x,y,z) {
        console.log(f1.name);//函数的名字，只读
        console.log(f1.arguments.length);//实参的个数
        console.log(f1.length);//函数定义的时候形参的个数
        console.log(f1.caller); //调用者，谁调用f1这个函数，caller就是谁

    }
    f1(10,20);//此处调用输出结果；f1； 2； 3； null；



    function f1(fn) {
        fn()
    }
    
    f1(function () {
        console.log('我是作为匿名函数调用的');
    });

    function f2() {
        console.log('我是作为命名函数调用的');
    }
    f1(f2);

    //一个函数作为另一个函数的返回值来使用

    //判断这个对象和传入的类型是不是同一个类型
    function fff(type) {
        return function (obj) {
            return Object.prototype.toString.call(obj) === type
        }
    }
    var ff = fff("[object Array]");
    var r = ff([10,20,30]);
    console.log(r);



     /**
     * 作用域：变量的使用范围
     * 局部作用域和全局作用域
     * js中没有块级作用域---（一对括号中定义的变量，这个变量可以在大括号外面使用）
     * 函数中定义的变量是局部变量
     *
     *
     * */

    /**
     * 作用域链：变量的使用，从里向外，层层搜索，找到即可使用
     * 当搜索到0级作用域的时候，还是没用找到就报错了
     * */
    var num =10;//作用域链级别：0
    function f1(){
        var num=20;//作用域链级别：1
        function f2() {
            var num = 30;//作用域链级别：2
            console.log(num);
        }
        f2()
    }
    f1();//30   



//沙箱机制优点：便于协作开发命名冲突
    //沙箱----小环境
   (function () {
       var num = 10;
       console.log(num+10);
   })();


   //沙箱----小环境
   (function () {
       var num = 20;
       console.log(num+10);
   }());




//递归介绍：函数中调用函数自己，递归一定要有结束的条件
    //递归案例：求数字相加的和：5+4+3+2+1
    function getSum(x){
       if(x == 1) return 1;
       console.log(x);
       return x+getSum(x-1);
     return   x == 1 ? 1:x+getSum(x-1);
    }
   console.log(getSum(3))
    /**
     * 执行：
     * getSum(2)------>2+1
     * 3+getSum(2) 此时的结果是3+2+1
     * 4+getSum(3) 此时的结果是4+3+2+1
     * 5+getSum(4) 此时的结果是5+4+3+2+1
     *
     * */   



    //递归案例：求一个正整数各个位数上数字的和：123---->6 = 1+2+3
   function getEverySum(x) {
       if(x < 10){
           return x
       }

       return x%10 + getEverySum(parseInt(x/10))
   }
   console.log(getEverySum(12345))



    //递归案例：求斐波那契数列
    function getFib(x) {
        if(x == 1 || x== 2){
            return 1;
        }
        return getFib(x-1) + getFib(x-2);
    }
    console.log(getFib(12))

后续继续补充中。。。