javascript基础总结1.0

	 var str = 12345
	        6789;

        console.log(str); //在控制台输出

        // alert('烦人的弹窗');
        // document.write() //网页写内容

        // innerHTML

        // var 变量名;

        // var 变量名 = 值;

        // var a = 10;
        // var a;
        // console.log(a);

        // var aa = 100;

        //1.开头得是那个英文字母_$，后面可以跟数字、字母_或$
        //2.区分大小写
        //3.不能用js中的关键字

/* 
        基本数据类型(原始数据类型/基础)
            String 字符串
            Number 数值
            Boolean 布尔型
            undefined 未定义
            null 空

            Symbol
            BigInt
        引用数据类型
            Object
            Array
            function
        */

        var str = '\n';
        str = '我\t你'; //制表符 tab
        console.log(str);
        console.log(str.length);

        /* 
        Number类型
            整数
            小数
            Infinity
            -Infinity
            NaN
                NaN == NaN

            //纯数字字符串或者空字符串
            Number('100px')  NaN

            parseInt('100px') 100
            parseFloat('100px') 100

        Boolean 布尔型
            其他类型转成布尔型得到false的情况：
                1. 空字符串
                2. 数值： 0 -0， NaN
                3. null
                4. undefined
        */
		/* 
        js的书写位置
            body的最后，js代码会阻塞DOM的解析
        引入外部js文件
            script的src属性
            async 异步加载，立即执行
            defer 异步加载，延迟执行
        变量
            ES5里面用var声明变量
            var a; //undefined
            js标识符命名规则
                只能以字母、_、$开头，后面跟数字、字母、下划线或$
                js严格区分大小写
                不能用js的关键字或保留字
            命名规范
                取名要有意义
                大驼峰、小驼峰、_
            交换2个变量的值
        数据类型
            基本数据类型
                String 字符串
                    单双引号里面
                    \ \n \t
                    String()
                    toString()
                Number 数值
                    整数
                    小数
                        浮点溢出
                    NaN
                        参与比较返回的都是false
                        参与运算结果都是NaN
                    Infinity
                    转换：
                        Number()

                        parseInt()
                        parseFloat()
                        运算符，常用的是正号+
                Boolean 布尔型
                    只有2个值，true/false
                    转换：
                        Boolean()
                        数值：0 NaN 
                        字符串：空字符串 
                        null 
                        undefined
                null
                    只有1个值，就是null
                    转换为数值的时候，是0
                undefined
                    只有1个值，就是undefined
                    转换为数值的时候，得到的是NaN

                Symbol
                BigInt
            引用数据类型
                Object 对象
                Array 数组
                Function 函数
        运算符
            算数运算符
                + - * / % ++ --
            赋值运算符
                = += -= *= /= %=
                a %= b; //a = a % b
            比较运算符
                比大小
                    > < >= <=
                比相等
                    == === != !==
                三元运算符
                    ?:
            逻辑运算符
                逻辑与 && 
                逻辑或 || 
                逻辑非 !
            逗号运算符
                var a,b,c;
                var d = (a,b,c); //返回的是最后一条语句的结果
            运算符的优先级
                ()
                一元运算符 ++ -- !
                二元： * / %
                二元： + -
                比较：
                    比大小
                    比相等
                逻辑与
                逻辑或
                三元

        */

 /* 
        变量
        数据类型
        运算符
        流程控制
            顺序结构
            分支结构
                单向分支
                    if (条件) {
                        //真区间
                    }
                双向分支
                    if (条件) {
                        //真区间
                    } else {
                        //假区间
                    }
                多向分支
                    if (条件1) {
                        //真区间1
                    } else if (条件2) {
                        //真区间2
                    } else if () {

                    } else {
                        //假区间
                    }

                    switch-case 

                        switch (表达式) {
                            case 表达式1:
                                
                            case 表达式2:
                                break;
                            default:
                                兜底的
                        }
            循环结构
                while (循环条件) {
                    //循环体
                }

                for (初始化; 循环条件; 迭代器) {
                    //循环体
                }
        */
        /* 
        顺序结构
        分支结构
            if (条件) {
                //真区间
                if () {
                    switch () {
                        case 1:
                        case 2:
                        case 3:
                    }
                }
            }

            if (条件) {
                //真区间
            } else {
                //假区间
            }

            if (条件1) {
                //真区间1
            } else if (条件2) {
                //真区间2
            } else {
                //假区间
            }

            switch (a) {
                case 1:
                    //代码段1
                    if () {

                    }
                    break;
                case 2:
                    //代码段2
                    break;
                case 3:
                    //代码段3
                    break;
                default:
                    兜底的代码
            }
        循环结构
            while (循环条件) {
                //循环体
            }
            do-while
                //初始化语句
                var i = 1;
                do {
                    //循环体
                } while (循环条件);
            for
                for (1初始化; 2循环条件; 3迭代器) {
                    //4循环体
                }
            for-in 遍历对象
                for (var 下标 in 对象) {
                    //循环体
                }

        break 和 continue
            break 终止循环
            continue 跳过本次循环，继续下一次循环

            如何指定终止指定层次的循环？
                先用js标识符给循环取个标识，然后使用‘break 标识符’
        */

		/* 
        数组
        */

        // 如何定义数组？
        var arr = new Array();
        console.log(arr);

        var arr2 = [];
        console.log(arr2);

        //定义好数字后，下标自动从0开始生成
        var arr3 = new Array(10, 20);
        console.log(arr3);

        //通过下标(索引/键/key)去访问数组里面的元素
        console.log(arr3[1]);

        var arr4 = [11,22,33,44,55];
        //遍历数组
        for (var i = 0; i < arr4.length; i++) {
            console.log(arr4[i]);
        }


        arr4[arr4.length] = 66;
        console.log(arr4);

        arr4.length = 0;
        console.log(arr4);
         /* 
        数组
            案例：
                原数组翻转
                数组去重
                冒泡排序
            方法 - 20个
                push()
                pop()
                unshift()
                shift()
                splice()
                reverse()
                sort()

                fill()
                join()
                concat()
                slice()
                valueOf() 默认是返回原数组
                toString()

                forEach() 默认返回undefined
                map() 会将return的东西组成一个新数组
                filter() 过滤：return true;的保留；return false的就不要
                some()
                every()
                reduce()

                indexOf()
        */
         /* 
        函数
            函数的定义
                function 函数名() {
                    //函数体
                }

                var fn2 = function() {}

                var fn3 = new Function();
            函数的调用
                函数名();
            函数的参数
                形参：定义函数的时候，写在()里面的变量
                实参：调用函数的时候，写在()里面的值
            函数的返回值
                return 设置函数的返回值
                默认返回undefined
                return 会终止函数体的执行
            变量作用域
                全局作用域和局部作用域
                全局变量：在任何一个地方都可以直接访问
                局部变量：只能在当前的函数作用域中使用
                作用域链：是一套查找规则
                    先在自己的作用域中找变量，找到则直接使用
                    没找到往上一级作用域找，直到全局作用域还没找到则报错
            预解析
                变量提升和函数提升
                函数提升的优先级更高
            匿名函数
                没有名字的函数
            IIFE
                匿名函数自调用
            arguments 伪数组
                所有实参的集合，会生成一个伪数组
        */
        
         /* 
        如何定义
            var obj = new Object(); //空对象
            //通过构造函数得到对象
            function Person() {}
            var obj2 = new Person();
            //通过{}字面量的方式
            var obj3 = {}
        如何访问里面的属性和方法
            . 
                点号后面只能跟合法的js标识符
                点号后面不能解析变量
            []
                中括号里面的下标一般都要加引号
                如果没有加引号，会当做变量去解析
        如何遍历对象
            for-in
        this在不同的地方代表谁？ 
            (1)在script标签(全局范围)中
                window 
            (2)在普通函数中
                window
            (3)在构造函数中
                新生成的那个对象
                要实例化的那个对象
            (4)在对象的方法中
                方法的调用者
            (5)在事件函数中
                事件源
            (6)在call和apply中
                两个方法的第一个参数
        */
	 /* 
        堆栈内存
            栈(stack)
                基本数据类型(String、Number、Boolean、null、undefined)、引用数据类型的地址、执行环境
                FILO(first in/Last Out)
            堆(heap)
                引用数据类型：(数组、函数、对象) 
        new一个构造器的时候，执行了哪些步骤？
            1. 创建一个空对象(堆)
            2. 将构造函数内部的this指向这个对象
            3. 执行函数体
            4. 返回这个对象
        JSON对象
            JSON.stringify();
            JSON.parse();
        Math对象
            round() 四舍五入
            floor()
            ceil()
            max()
            min()
            pow()
            abs() 绝对值
            PI
            random()
            sqrt()

        */