Js基础

一由来
    网景公司：浏览器
    脚本语言：
        作用：进行本地的表单校验、
        谷歌浏览器：js解析器：
            兼容性较差
            
    统一规则：javascript
二、组成部分
    ECMAScript:核心js es5 es6
    DOM:文档(html文档)对象模型
        div
       事件：事件监听
       <button></button>
    BOM:浏览器对象模型
        alert();  //浏览器弹框

三、特点
    1、脚本语言
        本身具有逻辑能力和行为能力
    2、解释性语言
        需要js解析器解析执行
    3、弱类型语言
        var a=10;
			a="hello";
		java:
			强类型语言
			int a =10;
				a='hello';
    4、从上到下依次执行(按照解析顺序)
        优先解析函数的声明，再解析使用var操作符所声明的变量
        代码顺序：
            say();
            run();
            function say(){}
            var a=10;
            console.log(a);
            var b; 
            function run(){}
            b=20;
            function.log(b);
        解析：
            function say(){}
            function run(){}
            var a;
            vat b;
            say()
            run()
            a=10;
            console.log(a);
            b=20;
            console.log(b);
        执行：  
    5、大小写敏感
        var a=10;
        console.log(A); 

四、使用
    1、node
        js运行环境：谷歌浏览器内置js解析器

      r    repl:读取代码
      e    evel:解析
      p    print:打印
      l    loop:循环
    命令：
        ls->程序
        ls：
        node:
            /opt/node/bin

    2、浏览器
        js->>html
        内联脚本
            <script></script>
            标签
        外部引入
            创建一个外部的脚本文件.js为后缀名的文件
            <script src='外部文件地址'>     
    注意：
        外部引入脚本的script标签内部不能再写js代码，如果写了，解析器会忽略

五、基础语法
    1、变量的声明 从右向左赋值
        var 123=10;
        标识符规则：
            由字母、数字、下划线以及$组成
            不能以数字开头
            不能使用关键字和保留字
                关键字：
                    在js中具有特殊意义的
                保留字：
                    即将成为或有可能成为的特殊(int)
            建议使用驼峰式命名
                var firstnameandlastname='张三';
                从第二个单词开始，首字母大写
                var firstNameAndLastName='张三';

        声明方式
            var a; //变量的声明不进行赋值
            a=10; //从内存中获取a变量并赋值为10

            var a=10; //变量的声明并赋值

            a=30; //变量的声明并赋值

            var a=10,b=20,c=30; //同时声明多个变量
        
        let(es6)
            1、使用let声明的变量只在当前作用域块内有效
            2、不能使用let重复声明变量。不在同一作用域内，可以重复声明
            3、不会对let声明变量解析提升
        const(es6)
            1、对于使用const声明的变量，只在当前作用域内有效；一旦声明，不可修改
            2、使用const声明一个常量，一旦声明，不可修改
            3、当属性值为引用数据类型时，引用地址不变，内容可变

    2、注释
        单行注释：//注释内容
        多行注释：/*注释内用*/

        作用：
        嵌套：
    3、语句 
        每一个语句建议使用分号结尾
		jquery.js
		jquery.min.js
		var a=10
		var b=20
六、局部变量和全局变量
    作用域：
        var a=10;
    全局变量：
        js的全局作用域内都能使用的变量
    局部作用域
        js中函数内部
    
    只要声明在函数内部，并且使用了var操作符的变量即为局部变量
七、数据类型
    typeof(a) 测试a变量的数据类型
        返回值：
            undefined
            object(null/object)
            number
            boolean
            string
            function
        返回值类型：
            string 
    typeof a
    
    6种数据类型:
        5种基本数据类型（简单数据类型）
            undefined 未定义
                1. var a;
                2. var a=undefuned;
                3. 既没有声明也没有赋值的变量
            null 空引用数据类型
                var a=null;
                当前变量即将指向一个引用数据类型，但是此时未指向
            
                注意：
                undefined派生自null
                null==undefined: ture
            
            number 
                所有的数值类型均为number类型
                var a=10;
                var a=10.5;
                var a=0xa;->10
                var a=0x10;->16
                var a=010;-->8
                NaN NOT A number
                    var a="hello"/10; //NaNisNaN(a):返回a变量是不是 不是一个数
                    isNaN(10):
                        false:不，它是一个数    对于number类型
                        true:是，它不是一个数   对于非number类型
                    infinity: 无穷大
                            var a=10/0; //infinity正无穷
                            var a=-10/0; //-infinity负无穷 
                    inFinity()
                        true 不是无穷
                        false 无穷
                    is
            boolean
                true
                false

            string
                所有使用了""/''包裹的字符，都为string类型
                var a='undefined';
                var a="null";
                var a="10";   全为字符串类型

                json:json字符串
                    [{
                        "name":"lisi",
                        "age":20
                    },{
                        name:'lisi',
                        "age":30
                    }]
                '':字符串拼接
        1种引用数据类型（复杂数据类型）
            function say(){}
            object:
                function 重写了toString 
                array
                math
                date
                ...
                实例对象
                var student={
                    name:'lisi',
                    age:20
                }

                var student=new Object();
                student.name='lisi';
                student.age=20;

                自有属性/方法：
                    constructor:构造者
                    toString():
                        将当前实例对象转换为字符串
                        object:[object object]
                        function(){}:function(){}
                        [1,2,3]:[1,2,3]
                    valueOf():
                        直接输出当前实例对象的value值
值传递和引用数据传递
    var a=10;
    c=a; //从右到左进行赋值
    console.log(c);
    c=c+1;
    console.log(c); //11
    console.log(a); //10
    基本数据类型在进行值传递时，只是传递值；
    引用数据类型
    var a={
        name='lisi'
    }
    c=a;
    c.name='terry';
    console.log(a.name); //terry
    console.log(c.name); //terry

操作符
    算数运算符：
        + +=
            a+b
                1、两个变量均为number类型直接进行计算
                2、其中一个不为number，并且不为string和object，将当前变量转换为number类型之后再进行计算
                null+10
                3、如果其中一个值为string类型，那么直接进行字符串拼接
                4、如果其中一个值为object类型，另一个不为string类型，那么默认调用object中的valueOf/toString()
                a>默认调用obj的toString()
                b>如果只重写了toString,那么调用toString
                c>如果只重写了valueOf,那么只调用valueOf
                d>如果即重写了toString又重写了valueOf，调用valueOf           
            a+=b:a=a+b//a+=1->a=a+1  
        - -=
            a-b
            a-=b:a=a-b
        * *=
        / /=
        % %=
    
    比较运算符：
        返回值为boolean类型
        >:
            a>b:
                1、两个均为number，直接比较
                2、两个值中只要有一个不为number，将其转换为number类型再进行比较
                    true>0:true
                3、两个值均为字符串类型，不进行数据类型转换，比较字符串的字符编码
                "a">"A":true 
        >=
        <
        <=
        == 相等
            a==b
            1、两个均为number，直接比较
            2、两个值中只要有一个不为number，将其转换为number类型再进行比较
                    true>0:true
            3、两个值均为字符串类型，不进行数据类型转换，比较字符串的字符编码
                "a">"A":true
            4.两个值均为引用数据类型，比较引用地址
            null==undefined:true
       
        === 全等
            当两个变量的数据类型相同时，比较值是否相等
            不进行数据类型转换，如果数据类型不同，返回false。
            如果数据类型相同：
                10===11 false
                "10"==="11":比较字符编码
                null===null true
                undefined===undefined true
                null===undefined false
    逻辑运算符：
        逻辑与
            &&
            同真则真，有假则假
            a&&b:
            1、如果第一个操作数为null/undefined/0/NaN/""/false,直接返回第一个操作数
            2、如果第一个操作数是其他，返回第二个操作数
        逻辑或
            ||
            有真则真，同假才假
            1、如果第一个操作数为null/undefined/0/NaN/""/false,直接返回第二个操作数
            2、如果第一个操作数返回值为true，返回第一个操作数
        逻辑非
            !
            !a:先将变量a转换为boolean类型，然后取反
            !!a:将当前变量转换为布尔类型

        三目运算符：
            分支语句：
            if(a=1){
                console.log("hello")
            }else{
                console.log("error")
            }
        ---->
            a=1?console.log("hello"):console.log("error");
            a>b?console.log(a):console.log(b);

        一元运算符
            +:
                +a 如果a变量为number值，那么直接转换对应的number；如果a变量为其他数据类型，那么将a变量转换为number类型。
                +10->10
                +null->0
            -
                -a
                -(-a) 将变量a转换为number类型
            ++
                a++ a=a+1
                    先操作变量然后再进行自增操作
                    comsole.log(a); 
                    a=a+1;
                ++a a=a+1
                    先进行自增操作，然后再进行变量操作
                    a=a+1;
                    comsole.log(a); 
            --  同上    

        位运算
            将变量转换为二进制进行计算，执行效率更高
            原码-> 反码-> 补码

            js中number以64位储存，在进行位运算时，使用32位2进制的数值进行计算
            
            正数的原码=反码=补码
            负数
                反码=原码符号位不变，其他位取反 补码=反码+1

            -3+4

            -3: 负号为1 
            1000 0000 0000 0000 0000 0000 0000 0000 0011  --->1000 0011
            原码 1000 0011
            反码 1111 1100
            补码 1111 1101                                                               

            4
            原码 0000 0100
            反码 0000 0100
            补码 0000 0100

            sum  1111 1101
                 0000 0100
                 ---------+
                10000 0001
            只取后8位，得0000 0001。换算十进制为1 
            sum得出，符号位为1时，此时的补码需要减1得值