本文链接：https://blog.csdn.net/m0_66478461/article/details/123038356

一、正则表达式：

1、正则是定义字符串中字符出现规则的表达式，在切割、替换、【验证】时候使用。

语法：/正则表达式/

   1、最简单的正则：/原文/后缀gi

（后缀：g：global找全部 i：忽略大小写）

   2、备选字符集：/^[0-9]$/; 一个中括号只管一位
       默认是只要满足，就不管后续的了 - 验证：从头到尾完全匹配

   3、预定义字符集：简化备选字符集
       一位数字：\d
       一位数字、字母、下划线：\w
       一位空白字符：\s

   4、量词：

        1）有明确数量
       字符集{n,m}
       字符集{n,}
       字符集{n}

   2）无明确数量
       +：至少一个，多了不限
       ?：可有可无，最多一个
       *：可有可无，多了不限

        5、选择和分组
       (规则1|规则2)

       6、指定匹配位置
       ^：开头
       $：结尾
       特殊：同时出现，前加^后加$，验证：从头到尾完全匹配

7、预判公式：(?![0-9A-Z]+$)[0-9A-Za-z]{4};
   目的：密码强度

2、正则对象：

var reg=/正则表达式/后缀
var reg=new RegExp("正则","后缀");

API：var bool=reg.test(user);

二、String支持正则的API：

1、var arr=str.split(reg);

   2、var newStr=str.replace(reg,function(a,....){
       a//正则匹配到的内容
       //后面可能还有很多个形参，具体有多少个，看你正则有多少个分组 - （基本替换、高级替换、格式化）
   })

三、Math：提供了数学计算的API

1、属性：Math.PI

2、API：

1、取整：
           上取整：Math.ceil(num);
           下取整：Math.floor(num);
           四舍五入：Math.round(num);
           *parseInt/parseFloat/num.toFixed(d);

2、乘方和开方
       *Math.pow(底数,幂);
           Math.sqrt(num);

3、*最大值和最小值：Math.max/min(a,b,c,d,e,...)
           数组：Math.max/min.apply(Math,arr)

4、绝对值：Math.abs(num);//将负数转为正数

5、***随机整数：parseInt(Math.random()*(max-min+1)+min);

四、Date：提供了操作日期的API

1、创建：

1、当前时间：var now=new Date();
2、自定义时间：var date=new Date("yyyy/MM/dd hh:mm:ss");
var date=new Date(yyyy,MM-1,dd,hh,mm,ss);
3、复制日期：var end=new Date(start);

2、操作：

   1、两个日期可以相减，得到的毫秒差，换算出自己想要的部分
   2、API：分量：*FullYear Month Date Day Hours Minutes Seconds
       每一个分量都有一对儿get/set方法，除了Day没有set

       获取：date.getXXXX();
       设置：date.setXXXX(date.getXXXX()+/-num);
   3、格式化为本地格式字符串：date.toLocaleString(); - 具有兼容性问题

五、※Function：

1、函数的执行原理：

才有变量的使用规则，优先使用自己，没有找全局，全局没有则报错，才知道了为什么函数中的东西会自动释放

2、作用域链：

以函数的EC为起点，经过AO，逐级引用形成的链式结构，作用上面那句话

3、 ※闭包：保护一个可以反复使用的局部变量的一种词法结构

语法：

function outer(){
       受保护的变量
       return function(){
           操作受保护的变量
       }
}

缺点：用多了，会导致内存泄漏

4、重要：

外层函数调用了几次，就有几个闭包，受保护的变量就创建了几个副本

同一次外层函数调用返回的内层函数，都是在操作同一个受保护的变量

使用场景：防抖节流（mousemove、input、resize）

5、面向对象：封装：

语法：

   1、直接量：var obj={
           属性名:属性值,
           ...
           方法名:function(){
               操作
           },
           ...
       }

   2、预定义构造函数：var obj=new Object();

   3、多个对象创建：自定义构造函数
       1、创建构造函数
           function 类名(形参1,形参2){
               this.属性名=形参1;
               this.属性名=形参2;
           }

       2、使用构造函数创建对象
           var obj=new 类名(实参1,实参2);

   4、使用：
       obj.属性名;
       obj.方法名();
       遍历：for in

       在方法中想要使用对象自己的属性要写为：this.属性名;

六、※Object：

1、继承：

父对象的成员（属性和方法），子对象可以直接使用
为什么：代码重用！节约内存空间！提升网站性能！
何时继承：只要多个子对象公用的属性和【方法】，都要集中定义在父对象中

2、***如何找到父对象（原型对象）：

保存一类子对象共有属性和共有方法的父对象
1）对象名.__proto__;//必须先有一个对象
2）构造函数名.prototype;//构造函数名，几乎人人都有，除了Math

3、两链一包：作用域链、原型链、闭包

1）每个对象都有一个属性：__proto__，可以一层一层的找到每个人的父亲，形参的一条链式结构，就称之为叫做原型链，可以找到所有父对象的成员（属性和方法），最顶层是Object的原型 2）作用：找共有属性和共有方法的

4、有了原型对象，设置共有的属性和方法：

1）原型对象.属性名=属性值;//添加了一个共有属性
2）原型对象.方法名=function(){};//添加了一个共有方法

5、※继承的笔试题：

1、判断是自有还是共有：
           1、判断自有：obj.hasOwnProperty("属性名");
               如果结果为true，说明是自有属性，如果结果为false，有两种可能，共有或没有
           2、判断共有：
               if(obj.hasOwnProperty("属性名")==false && "属性名" in obj){//in 会自动在obj的原型上进行查找
                   共有
               }else{
                   没有
               }

           公式：
           if(obj.hasOwnProperty("属性名")){//false
               console.log("自有")
           }else{
               if("属性名" in obj){
                   console.log("共有")
               }else{
                   console.log("没有")
               }
           }
<body>
    <script>
        var objk = {
            "可乐": "鸡翅",
            age: 18,
            "班级": 2017,
        }
        if (objk.hasOwnProperty("alary")) {
            console.log("自有");
        } else {
            if (objk.hasOwnProperty("alary") == false && "alary" in objk) {
                console.log("共有");
            } else {
                console.log("没有");
            }
        }
    </script>
</body>

2、删除自有和共有
           自有：修改：obj.属性名=新值;
           删除：delete obj.属性名;

           共有：修改：obj.共有属性名=新值; - 非常危险的，并没有修改到爸爸，而是在本地添加了一个同名属性
           删除：delete obj.属性名; - 无效，本地本来就没有此自有属性
           找到原型，修改/删除原型

3、如何为老IE的数组添加indexOf
           原理：
           if(Array.prototype.indexOf===undefined){//老IE
               Array.prototype.indexOf=function(key,starti){
                   starti==undefined&&(starti=0);
                   for(var i=starti;i<this.length;i++){
                       if(this[i]==key){
                           return i;
                       }
                   }
                   return -1;
               }
           }
<body>
    <script>
        var arr = [1, 2, 3, 4, 5];
        if (Array.prototype.indexOf === undefined) {
            Array.prototype.indexOf = function(key, starti) {
                starti == undefined && (starti = 0);
                for (var i = starti; i < this.length; i++) {
                    if (this[i] == key) {
                        return i;
                    }
                }
                return -1;
            }
        }
        console.log(arr.indexOf(4, 5));
        console.log(arr.indexOf(3));
    </script>
</body>

4、如何判断x是不是一个正则：4种方法：千万别用typeof，只能检查原始类型，不能检查引用类型
           1、判断x是否继承自Array.prototype
               Array.prototype.isPrototypeOf(x);

           2、判断x是不是由Array这个构造函数创建
               x instanceof Array;

           3、Array.isArray(x); - ES5提供的，只是ES5+，老IE不支持，此方法只有数组

5、实现自定义继承：
           1、两个对象之间设置继承：
               子对象.__proto__=父对象

           2、多个对象之间设置继承：
               构造函数名.prototype=父对象
               时机：应该在开始创建对象之前设置好继承关系
<body>
    <script>
        function H1(name, age, hoby) {
            this.name = name;
            this.age = age;
            this.hoby = hoby;
        }
        var ty = {
            js: 100,
        }
        H1.prototype = ty;
        var ty = new H1('涛涛', '16', '学习');
        ty.__proto__.zwjs = function() {
            return "我的名字叫：" + this.name + "，今年" + this.age + "岁，喜欢" + this.hoby;
        }
        console.log(ty.zwjs());
    </script>
</body>