JavaScript03

一、正则表达式

1.最简单的正则

    关键字原文 /原文/gi
        后缀 g 找全部  i 不区分大小写
复制代码

2.备选字符集

/^[备选字符集]$/
    1.一个中括号直观一位字符
    2.默认只要满足就不管后续，希望从头到尾都满足:前加^ 后加$
    3.表示出 xxx之外的字符   [^xxx]   [^0-9] 表示出0-9之外的字符
复制代码

3.预定义字符集

\d 一位数字
\w 一位字母、数字或下划线
\s 一位空白字符（空格、\t、\n）
. 一位除了\n之外的字符
复制代码

4.量词：规定一个字符集出现的次数

1.有明确数量
    {n,m} 最少n位，最多m位
    {n,} 最少n位，最多不限
    {n} 必须n位
2.没有明确数量
    ?  前面相邻的字符集可有可无，最多一位
    *  前面相邻的字符集可有可无，最多不限
    +  前面相邻的字符集最少一位，最多不限
复制代码

5.选择分组

选择：在两个规则中选一个
    规则1 | 规则2
分组：将多个字符集淋湿组成一组子规则()
(规则1 | 规则2)
复制代码

6.指定匹配位置

^ 开头
$ 结尾
两者同时使用，前加^后加$表示从头到尾都匹配（一般在做验证的时候使用）
复制代码

7.密码强度

预判公式：
        /?![0-9]+$/ 不能全由数字组成
        /?![0-9a-z]/ 不能全由数字，小写字母和他俩组合而成
复制代码

8.搭配正则的两个字符串API

1.切割 split(reg)
2.替换 replace(reg,“新内容”)
    replace(正则表达式，function(a,b,c){
    操作 
    })
    a：匹配到的当前关键字 
    b：关键字的下标 
    c：原文
    当reg中出现分组，残水会更多，从b开始为分组，最后一个为原文
复制代码

9.正则对象

reg.test(str)
满足正则返回true，不满足返回false
复制代码

二、Math对象

1.一个常用属性

Math.PI 表示数学中的π
复制代码

2.取整

上取整：Math.ceil()
下取整：Math.floor()
四舍五入：Math.around()
以上3种方法不如ParseInt,parseFloat,toFixed()
复制代码

3.乘方开方

乘方：Math.pow(底数，幂)
开方：Math.sqrt()只能开平方
复制代码

4.最大值最小值

Math.max/min(num1,num2....)
问题：不能传数组
解决：Math.max/min.apply(Math,arr)
复制代码

5.绝对值

Math.abs（）
复制代码

三、Date对象

1.创建

1.var date = new Date()
2.自定义：
    var date = new Date(yyyy/mm/dd hh/mm/ss)
    var date = new Date("yyyy""mm""dd""hh""mm""ss")
3.复制一个日期
    var date = new Date(date1)
复制代码

2.操作

两个日期相减会得到一个毫秒差
创建的最后一个方法
    var date = new Date(毫秒数)
复制代码

3.API

获取：            设置：
getFullYear      setFullYear
getMonth         setMonth 
getDate          setDate 
getDay           setDay
getHours         setHours
getSeconds       setSeconds 
getMintues       setMintues 
getMillseconds   setMillseconds
复制代码

4.如果希望对一个日期进行+ -

date.setxxxx(date.getxxxx() +/- num)
复制代码

四、Error对象

1.浏览器自带的四种错误

语法错误： SyntaxError 多半是语法符号错了
引用错误： ReferenceError  没有创建就直接使用
类型错误： TypeError   不是它的方法却使用了
范围错误： RangeError  只有toFixed(n)当n超出0-100的范围时
复制代码

2.只要报错就会导致后续代码终止

try{可能出错的代码 } catch(err){ err 为报错信息} 
try catch的效率非常低可以使用if else代替
复制代码

3.抛出自定义报错

throw new Error()
只要是报错就会卡主后续代码
复制代码

五、Function对象

1.创建：

构造函数：var 函数名 = new Function("参数...""函数体")
何时使用：如果你的函数体是动态拼接的
复制代码

2.重载

相同函数名，传入参数不同，可以自动执行相应的操作，但是js不允许多个同名函数会被覆盖
解决：
    在函数中有一个arguments对象，可以接收传入的所有参数
    arguments是一个类数组，可以使用下标，length，遍历
arguments作用
    1.用arguments实现重载：通过函数内部判断arguments执行不同操作  
    2.以后有没有形参都无所谓
    3.正式开发中有可能将多个函数整合为一个函数
复制代码

3.匿名函数：没有名字的函数

1.函数的自调：为了节约内存
(function(){  })()
2.函数的回调：不是自调就是回调
    将函数作为实参传给另一个函数调用
    arr.sort(function(){})
    str.replace(reg,function(){})
    onclick = function(){}
复制代码

4.函数执行原理：

1.程序加载时
    创建执行环境栈（ESC），保存函数调用顺序的数组。
    首先压入全局执行环境（全局EC），全局EC引用着全局对象Window，Window中保存着全局变量
2.函数定义时
    创建函数对象：封装代码段
    在函数对象中有一个scope属性：记录着函数的作用域来自哪里
    全局函数的scope都指向window
3.调用前
    在ECS中压入新的EC（函数的EC）
    创建活动对象（AO），AO保存着本次函数调用时使用到的局部变量
    在函数的EC中有一个scope chain属性（作用域链）引用着AO
    AO有一个属性parent属性指向scope指向的对象
4.调用时：
    正因为有前面3步，才有变量的使用规则
        优先使用自己的，自己没有找全局，全局没有就报错
5.调用完
    函数的EC会出ECS栈，AO自动释放，局部变量也就自动释放了
复制代码

5.作用域链

以函数的EC的scope chain 为起点经过AO逐级引用，形成的一个连式结构
作用：查找变量，带来变量的使用规则
复制代码

6.闭包

希望保护一个可以反复使用的局部变量的一种词法结构
如何使用：
    1.两个函数嵌套
    2.外层函数创建出受保护的变量
    3.外层函数return出内层函数
    4.内层函数操作受保护的变量
强调
    1.判断是不是闭包：有没有两个函数嵌套，返回内层函数，内层函数在操作外层变量
    2.外层函数调用了几次，就创建了几个闭包，手保护的变量就有了几个副本
    3.同一次外层函数调用返回的内层函数都是在操作同一个受保护的变量
缺点：受保护的变量永远不会被释放，使用过多会造成内存泄漏，不可多用
问题：哪里需要使用闭包   （防抖节流）
    3个需要防抖节流的事件
    1.onmousemove()
    2.oninput()
    3.window.resize()
防抖节流公式：
    elem.事件 = function f1(){
        var timer = null;
        return function(){
            if(timer){
                clearTimeout(timer);
                timer = nulll;
            }
            timer = setTimeout(function(){
                操作；
            },1000)
        }
    }
    
    var 函数名 = f1();
复制代码

六、object对象

1.面向对象三大特点：封装，继承，多态
2.创建自定义对象
    1.直接量方式
        var obj = {
            属性名：属性值
            方法名：function(){}
        }
        访问对象的属性，方法
            obj.属性名   ===   obj["属性名"]
            obj.方法名   ===   obj["方法名"]
    2.预定义构造函数
        var obj = new Object();
    3.自定义构造函数：2步
        1.function 类名(a,b,c...){
            this.a = a;
            this.b = b;
            this.c = c;
            ...
        }
        不要在里面创建方法，每个方法都会创建一个方法，浪费内存
        2.调用构造函数
            var obj = new 类名（实参1...）
    面向对象：
       优点：所有的属性和方法都保存在一个对象中
            每个功能特地分开写，便于维护
            铁索连舟，一个方法触发多个方法联动
       缺点：this的指向问题
3.继承：
    父元素（原型对象）的属性和方法，子对象可以直接使用，只要多个子对象公用的属性和方法都集中定义在
    原型对象中。
4.找原型对象
    1.对象名.__proto__
    2.构造函数名.prototype
5.原型链
    每个对象都有一个__proto__属性，可以一层一层的找到每个对象的父元素，形成的一条链式结构
    作用：可以找到原型对象的所有属性和方法
    原型链的最顶层是Object的原型，再往上为null
6.判断属性是共有还是私有
    obj.hasOwnProperty("属性名")
        为true时说明为私有，为false时可能为共有或者没有
        解决：
            if(obj.hasOwnProperty("x")){
                为私有
            }else{
                if(x in obj){
                    共有
                }else{
                    没有
                }
            }
7.删除/修改私有，共有属性
    私有：修改 obj.属性名 = 新值
         删除 delete obj.属性名
    共有： 先找到原型，再修改或删除
8.判断x是否为一个（数组）
    1.判断x是否继承Array.prototype
        Array.prototype.isPrototypeOf(x)
    2.判断x是否有Array创建
        x instanceof Array
    3.Array.isArray(x) es5提供，老IE不支持，此方法只有数组有
    4.输出 对象的字符串形式