【正则、内置对象、闭包】

正则表达式：切割 替换 *验证*

1.最简单的正则：/关键字原文/ig

i:忽略大小写        g：全部，替换的话只会替换掉第一个

2.备选字符集：/[备选字符列表]/

a.一个[],匹配一个字

b.正则默认满足后，不在管后续操作   解决：/^正则表达式$/，表示完全匹配，主要用于验证。

c.例如：一个数字：[0-9]        一位字母：[A-Za-z]      

             一位数字、字母、下滑线：[0-9A-Za-z_] 
             一位汉字：[\u4e00-\u9fa5] 

            除了xxx之外，其他都可以：[^xxx] - 范围太广
 

3、预定义字符集
        一位数字：\d    ===    [0-9]
        一位数字、字母、下滑线：\w === [0-9A-Za-z_]
        一位空白字符：\s === 空格、制表符、换行

        一位除了换行外的任意字符：.    -    范围太广

            问题：预定义字符集是固定的，不灵活
            建议：优先使用预定义字符集，预定义字符集满足不了，再用备选字符集自定义

    强调：不管是备选字符集还是预定义字符集，一个都只管一位字符

        

4、量词：规定一个字符集出现的次数
       1、有明确数量：
          字符集{n,m}：前边相邻的字符集，最少出现n次，最多m次
          字符集{n,}：前边相邻的字符集，最少出现n次，多了不限
          字符集{n}：前边相邻的字符集，必须出现n次

       2、没有明确数量
          字符集?：前边相邻的字符集，可有可无，最多一次
          字符集*：前边相邻的字符集，可有可无，多了不限
          字符集+：前边相邻的字符集，至少一次，多了不限

5、选择和分组：
       选择：规则1|规则2 - 可以再多个条件里满足一个也可以

       分组：添加子规则：(规则1|规则2)
    
 6、预判：密码强度：4-8位字母和数字的组合，至少一位大写字母和一位数字
         公式：比如：
            1、(?![0-9]+$) - 不能全由数字组成
            2、(?![A-Za-z]+$) - 不能全由纯小写组成，也不能由纯大写组成，也不能有大写和小写的组合组成 

String支持正则的API： 

1、切割：var arr=str.split("固定切割符"/RegExp);

    2、替换：
        1、基本替换法：
            str=str.replace("固定的关键字"/RegExp，"新内容");

        2、高级替换法：
            str=str.replace("固定的关键字"/RegExp，function(a,b,c){
                console.log(a);//正则匹配到的要替换的内容
                console.log(b);//正则匹配到的要替换的内容的下标
                console.log(c);//原文本身
                return a.length==2?"**":"***";
            });

        3、格式化：如果替换时，正则中带有分组，那么你会得到更多的形参
            str=str.replace("固定的关键字"/RegExp，function(a,b,c,....){
                console.log(a);//正则匹配到的要替换的内容
                console.log(b);//第一个分组获得的内容
                console.log(c);//第二个分组获得的内容
                ...
            });

        正则对象：

        创建：
            1、直接量方式：var reg=/正则表达式/后缀;
            2、构造函数方式：var reg=new RegExp("正则表达式","后缀");

         方法：var bool=reg.test(用户输入的文字);
                     true->用户通过    false->用户不通过

           真正的验证：
                    1、input绑定获取焦点事件onfocus - 显示提示文字
                    2、input绑定失去焦点事件onblur  - 进行正则验证 后 在进行非空验证
                    3、给form绑定提交事件 - return false阻止return

      

Math：专门用于提供数学计算的API
     强调：不用我们去创建，浏览器自带

     属性：Math.PI - 不需要程序员创建π

     方法：
        1、取整：
           1、上取整：只要超过，就会取下一个数
            Math.ceil(num);//num位数不能超过15位，此方法会失效

           2、下取整：不管超过多少，都省略小数部分
            Math.floor(num);

           3、四舍五入取整：
            Math.round(num);
            vs *toFixed(d);//d保留的小数位数，并且也具有四舍五入的功能，返回的是一个字符串，最好搭配上parseFloat使用

      自定义一个函数，按照任意小数位数四舍五入，返回的是一个数字类型，不允许使用toFixed(d)
                function round(num,d){
                    num*=Math.pow(10,d);
                    num=Math.round(num);
                    num/=Math.pow(10,d);
                    return num;
                }

        2、乘方和开方：
          *乘方：Math.pow(底数,幂)
           开方：Math.sqrt(num);//只能开平方

        3、最大值和最小值
            Math.max/min(a,b,c,d,e,f,g...);
            问题：不支持数组参数
               *解决：Math.max/min.apply(Math,arr);
                apply有两个作用：
                    1、借用不是自己的方法
                    2、将数组打散为单个元素

        4、绝对值：将负数变成正数
            Math.abs(num);

        5、随机整数：
            Math.random()：在0~1之间取随机小数
            有可能取到0，绝对不可能取到1
            在min~max之间取随机整数的公式：
                parseInt(Math.random()*(max-min+1)+min);
            如果最小值是0
                parseInt(Math.random()*(max+1));

        6、三角函数

Date：封装了一个日期对象，提供了对时间进行操作的API。
   如何使用：
    创建：5种
      1、创建一个日期对象，获取当前时间
        var now=new Date();

      2、创建一个日期对象，设置自定时间
        var birth=new Date("yyyy/MM/dd hh:mm:ss");

      3、创建一个日期对象，设置自定时间
        var birth=new Date(yyyy,MM-1,dd,hh,mm,ss);
        注意：取值范围：MM：0~11：0代表一月
                       

     4、复制一个日期：
        为什么：日期对象的API直接修改原日期对象，无法获得修改之前的日期
        何时：如果你希望同时获得修改之前的和修改之后的两个日期，则应该先复制一份，然后再去操作其中一份
        var end=new Date(now);

      5、var end=new Date(毫秒数);
        日期对象其实底层是一个毫秒数，保存的是从1970年1月1日至今的所有的毫秒数，

      
    操作：
      1、两个日期对象之间相减，得到是一个毫秒差，通过毫秒差换算出你想要的各个部分
      2、API：
        分量：时间的单位：
            年月日星期：FullYear Month Date Day
            时分秒毫秒：Hours Minutes Seconds Milliseconds
        1、每个分量都有一对儿getXXX/setXXX
           特殊：Day：没有set方法
        2、取值范围：
            FullYear：直接年份数字
            Month：0~11，计算机中的月份比现实中-1
            Date：1~31
            Day：0~6：0代表是星期天
            hh：0~23
            mm,ss：0~59

        对一个日期的某个分量进行在其基础上做加减操作：
            date.setXXXX(date.getXXXX()+/-n);

      3、格式化：date.toLocaleString(); 具有兼容性问题
        解决：自定义format函数

Error：错误对象：
   1、*浏览器自带4种错误类型：
    语法错误：SyntaxError - 多半都是哪里的符号写错了
    引用错误：ReferenceError - 根本就没有创建过，就去使用了
    类型错误：TypeError - 不是你的方法，你却使用了
    范围错误：RangeError - 只有一个API：num.toFixed(d);//d的范围只是0-100之间

       需要记忆错误类型，帮助我们快速找错。

   2、错误处理：当程序发生错误时，保证程序不会异常中断的机制
    为什么：只要报错，就会导致后续代码终止（闪退），用户体验感降低
      如何：try...catch...语句
        try{
        可能出错的代码
        }catch(err){
        console.log(err);//提示用户错误的原因是什么
        }

        后续代码都可以执行到

    不推荐：try...catch...的执行效率非常的低下，更推荐的是if...else
    想要用if...else去预判用户的错误的前提：丰富的经验（其实我一直在带你们防用户!isNaN、正则）

   3、抛出自定义错误：
    throw new Error("自定义错误信息");

Function：函数对象 - 方法
      1、声明方式
        function 函数名(形参列表){函数体;return 结果;}
        具有完整的声明提前    

      2、直接量方式
        var 函数名=function(形参列表){函数体;return 结果;}
        也有声明提前，但是赋值留在原地

      3、构造函数方式 - 函数体不是固定的
        var 函数名=new Function("形参1","形参2",...,"函数体");
        函数体是动态拼接时候，注意不能省略""部分

    调用：
      函数名();
      元素.onclick();

    考点：
      1、***创建：
      2、***作用域：全局（成员哪里都可以使用）、函数（成员只能在函数调用时内部可用）
             变量的使用规则：优先使用局部的，局部没有找全局，全局没有就报错
      3、***声明提前：在程序正式执行之前，会将var声明的变量和function声明的函数集中提前到当前作用域的顶部，但是赋值留在原地，变量比函数轻
      4、***按值传递：如果传递的是原始类型，互不影响。如果传递的是引用类型，相互影响。
        
      5、***重载：相同的函数，根据传入的实参的不同，会自动选择对应的函数执行
        为什么：减少程序员的负担
        问题：JS不支持重载，JS不允许同时存在多个同名函数，如果存在，最后的一个会覆盖之前的所有函数
        解决：arguments对象 - 只能在函数内部可用，是一个类数组对象：
            作用：接住所有的实参，【以后甚至不用形参都可以了】
            只有3点相同：
                1、支持下标
                2、支持length
                3、支持遍历
        变相实现重载：通过判断arguments的不同，执行不同的操作

      6、匿名函数：理解概念
        没有名字的函数，没有变量名/函数名引用着，调用完毕后会立马释放 - 一次性函数
        2种：
        1、匿名函数自调：代替全局作用域
            (function(){
                函数体; - 好处：调用完毕会【立刻释放】
            })()

        2、匿名函数回调：某个函数调用时，传入的实参又是一个函数，而且不需要我们调用自动执行
              arr.sort(function(a,b){return a-b})
              str.replace(reg,function(){})
                匿名函数，不是自调，就一定是回调 - 以后会学习箭头函数：简化一切的回调函数
   *****闭包：
    作用域：‘’
      1、全局作用域：成员 随处可用，可以反复使用，容易被污染

      2、函数作用域：成员 只有当前函数调用时内部可用，调用完了，就会释放了，一次性

    ***函数的执行原理：
       1、程序加载时：
        创建执行环境栈（ECS）：保存函数调用顺序的数组
        首先压入全局执行环境（全局EC）
        全局EC中引用着全局对象window
        window中保存着全局变量

       2、定义函数时：
        创建函数对象：封装函数的定义
        在函数对象中创建scope属性，记录着自己来自的作用域
        全局函数的scope都是window

       3、调用函数前
        在执行环境栈ECS压入新的函数的EC
        创建活动对象AO：保存着本次函数调用时用到的局部变量
        在EC中添加scope chain属性引用AO
        设置AO的parent属性为函数的scope引用的对象

       4、调用时：
        变量的使用规则：优先使用局部的，局部没有才找全局，全局没有才报错

       5、调用完：
        函数的EC会出栈，AO会自动释放，局部变量也就自动释放了

    *****闭包：目的：保护一个可以【反复使用的局部变量】的一种词法结构
            结合了全局和局部的优点
        唯一的缺点：受保护的变量永远不能释放，用多了会导致内存泄漏
        尽量的少用：只有一个点会用到防抖节流
            如何：3步
          1、创建一个外层函数
          2、在其中创建一个受保护的局部变量
          3、外层函数调用要返回内层函数，此内层函数在操作受保护的变量

        固定语法：
          function 外层函数(){
            受保护的变量;
            return function(){
                不断的操作受保护的变量
                return 结果;
            }
          }    

          var 内层函数=外层函数();

        正式开发：防抖节流：减少DOM树的渲染，DOM数据渲染的次数越频繁页面的效率越底下
          3个事件需要去做防抖节流：
            1、elem.onmousemove - 鼠标移动事件，每次移动就会触发
            2、input.oninput - input每次修改内容就会触发
            3、window.onresize - 屏幕每次改变大小就会触发

            固定公式：
            function fdjl(){
                var timer=null;//3
                return function(){
                    //判断有没有定时器，如果有定时器就清除定时器
                    if(timer){clearTimeout(timer)}
                    timer=setTimeout(function(){
                        //你要做的操作
                    },毫秒数)
                    console.log(timer);//定时器的序号
                }
            }
        
            var animate=fdjl();

2、*****Object：面向对象开发方式 - 三大特点（封装、继承、多态）
   什么是面向对象：在程序中都使用对象来描述现实中的一个事物
               现实中事物的属性，代码中就成为了对象的属性
           现实中事物的方法，代码中就成为了对象的函数
           现实中所有数据都必须包含在一个事物中才有具体的意义

    之前我们学的10个引用类型都是对象 - 浏览器内置对象

    1、封装/创建/定义/声明/实例化：自定义创建对象：3种
        1、*直接量方式：
            var obj={
                "属性名":属性值,
                ...
                "方法名":function(){},
                ...
            }
            强调：1、其实属性名和方法名的""可以省略，但是不推荐，以后JSON必须加""
                  2、如何访问对象属性和方法
                    obj.属性名 === obj["属性名"]
                    obj.方法名(); === obj["方法名"]();
                 强烈建议：使用.去访问
                  3、访问到不存在的属性：返回undefined
                  4、也可以在后续随时随提的添加自己想要的东西

            特殊：this在当前对象的方法内，指向的当前调用方法对象
                1、单个元素绑定事件 this->单个元素
                2、多个元素绑定事件 this->当前触发的元素
                3、函数中也可以使用 this->当前调用函数的对象
                4、构造函数中如果出现了this this->当前正在创建的对象
                  只要以后对象的方法想要使用对象自己的属性，那么就写为this.属性名

        2、预定义构造函数：var obj=new Object();//空对象
                 obj.属性名=属性值;
                 ...
                 obj.方法名=function(){}
                 ...

        以上两个方法仅适合创建单个对象，如果想要创建多个对象则太繁琐
        3、*自定义构造函数：2步
            1、创建一个构造函数
                function 类名(形参,...){
                    this.属性名=形参1;
                    this.属性名=形参2;
                    ...
                }

            2、反复调用构造函数创建出多个对象
                var xxx=new 类名(实参,...)