一、正则表达式

定义在字符串中字符出现的表达式

1、何时使用

切割、替换、验证

2、语法

/正则表达式/ 默认只要满足就不管后续

3、最简单的正则

/关键字/ig
i:忽略大小写，g：找全部

4、备选字符集

/^[备选字符集]$/

一个中括号只管一位字符
^开头满足条件，￥结束满足条件，同时加上指从头到尾都满足条件
若备选字符集中的ASCII码连续，中间可以省略用-代替，如数字[0-9]
除什么之外[^0-9],除数字之外

5、预定义字符集

已经提前定义好的一些字符集，我们可以直接使用

数字：\d==[0-9]
数字字母下划线：\w==[0-9A-Za-z_]
空白字符：\s包含：空格、制表符、换行
除了换行以外的任意字符：.

6、量词

规定一个字符集出现的次数

1）、有明确数量

字符集{n,m}：前边相邻的字符集，至少n个，最对m个
字符集{n,}：前边相邻的字符集，至少n个，多了不限
字符集{n}：前面相邻的字符集，只能为n个

2）、无明确数量

？：前面相邻的字符集，可有可无，最多一个
* ：前面相邻的字符集，可有可无，多了不限
+：前面相邻的字符集，至少一个，多了不限

7、选择和分组

（规则1|规则2）

8、密码强度

1)预判公式语法

（？！[字符集]+$）：不能由[字符集]中组成

二、支持正则表达式的字符串API

1、切割

var arr =str.split(reg)

2、替换

1）、基本替换法

var newStr=str.replace(/正则表达式/后缀，“新内容”)

2）、高级替换法

var newStr=str.replace(/正则表达式/后缀，function(a){
            //a代表正则匹配大当前的关键字
            return a.属性？“新内容”；
})

```mermaid
sequenceDiagram
Alice->>John: Hello John, how are you?
John-->>Alice: Great!
Alice-)John: See you later!

### 3）、格式化
在replace的时候，正则出现了分组，我们就会的大更多的形参，在形参a的后面就会出现n个形参，就有几个分组，第一个分组获得的内容就保存在第二个形参中

var id="012345678912345678" var reg=/\d{6}(\d{4})(\d{2})(\d{2})\d{4}/ id=id.replace(reg.function(a,b,c,d){ return b+"年"+c+"月"+d+"日" } console.log(id);

## 2、正则对象
### 1）、创建方式
1. 直接量方式：var reg=/正则表达式/后缀
2. 构造函数方式：var reg=new RegExp("正则表达式"，"后缀")
### 2）、API
 `reg.text("用户输入内容")`
结果为布尔值
## 3、input绑定事件
1. 获取焦点事件：`input.onfocus=function（）{}`
2. 失去焦点事件：`input.onblur=function（）{}`
3. 修改内容时获取内容事件：`input.onfocus=function（）{}`
# 三、Math 对象
特殊：不需要创建Math对象，可以直接使用
## 1、Math API
### 1）、上取整
超过一点就取下一个整数，但是小数点不操过15位
`var num=Math.ceil（num）`
### 2）、下取整
无论多少都会省略小数点部分
`var num=Math.floor（num）`
### 3）、四舍五入取整
- `var num=Math.round（num）`只能取整数
- `parseInt()`去单位取整，也只能取整数
- `num.to Fixed(d)`:可以指定小数位数d，但结果为字符串，若想转为num，则在前面加上`parseFloat()`
## 2、乘方和开方
- `Math.pow(底数，幂);`乘方
- `Math.sqrt(num);`开方
## 3、最大值和最小值
- `var 最大/小=Math.max/min(......)`
- 但是本身不支持数租
- 解决：`var 最大/小=Math.max/min.apply(Math,arr);`
## 4、绝对值
`Math.abs(num);`把负数转为正数
## 5、随机数
- `Math.random();`在0-1之间取出一个随机小数，可以取到0，但是不能取到1
- `parseInt(Math.random()*(max-min+1)+min;`随机整数
# 四、Date 日期
## 1、创建
###  1）、创建一个当前的时间
`var now=new Date()`
###  2）、创建一个自定义时间
- `var bir=new Date(Y/M/D h:n:s);`
- `var bir=new Date("Y,M,D,h,n,s");`
### 3）、复制一个时间
var end=new Date(start);
### 4）、特殊
两个时间相减会得打一个毫秒差
## 2、API
Date 所有的啊API都会修改原日期
### 1）、分量
- 年、月、日、星期：FullYear、Month、Date、Day;
- 时、分、秒、毫秒：Hours、Minutes、Seconds、Millisenconds;
- getxxx：获取某一个分量的值；
- setxxx：设置某一个分量的值；
### 2）、特殊
- FullYear取值：当前年份的数字;
- Month取值：0~11;
- Date取值：1~31;
- Day取值：0~6;
- Hours取值：0~23;
- Minutes取值：0~59;
- Day没有set方法。
## 3、对某个分量进行加减计算
`date.setxxx(date.getxxx()+1-n)`
# 五、Error 对象
目的：快速找错，防止用户恶意驶入
## 1、浏览器自带4种错误类型
### 1）、语法错误
SytaxError----多半是语法符号错误
###  2）、引用错误
ReferenceError----没有创建就直接使用了
### 3）、类型错误
TypeError----不是自己的方法却使用了
###  4）、范围错误
RangeError----只有num.toFixed（d）会发生,d的取值（0~100）
## 2、解决报错
###  1）、语法

try{ 只放可能出现的错误的代码 }catch（err）{ 发生错我后执行的代码； console.log(err)//提示错误 }

但是try...catch..的性能很低，几乎里面的代码效率会讲到最低，可以用if...else...代替
##  3、抛出自定义错误
`throw new Error("自定义错误信息")`，但是会卡住后续代码
# 六、function 对象
## 1、创建
###  1）、声明
`function 函数名（形参...）{函数体；return 返回值；}；`
###  2）、直接量
`var 函数名= function（形参...）{函数体；return 返回值；}；`
###  3）、构造函数
`var 函数名= new function{"形参...函数体；return 返回值；"}；`
##  2、调用
如有return需接住：var result=函数名（实参...）
## 3、重载
相同的函数名，传入不同的实参，可以自动选择对应的函数执行操作，但JS不允许多个同名的函数同时存在，后面的额会覆盖前面的。
###  1）、解决
函数中有个arguments对象，会制动创建，是一个类数组对象
###  2）、arguments
- 作用：可以接住所有传入的实参
- 是类数组：有3个点和数组相同
1. 使用下标
2. 使用length
3. 遍历
####  （1）、arguments可以做的事
1. 实现重载，通多函数内部判断arguments执行不同的操作
2. 以后有无形参无所谓
3. 正式开发中，有可能讲多个函数整合为一个函数---代码优化
## 4、匿名函数
没有名字的函数
###  1）、匿名函数自调
节约内存,因为匿名函数没有变量引用着，用完就会自动释放变量
####  （1）、匿名函数语法

（function（）{ //js代码 }（））

###  2）、匿名函数回调
1. 目的：只要不是回调函数就是自调函数
2. 后面ES6技术：箭头函数：简化一切回调函数
#  七、Function
##  1、作用域
###  1）、全局作用域
随处可用，可以反复适应但是容易全局污染
###  2）、函数作用域
只能在函数内部使用，不会被污染，但是是一次性的，用完会自动释放
## 2、函数的执行原理
###  1）、程序加载时
创建执行环境栈（ECS）：保存函数调用顺序的数组，首先压入全局执行环境（全局EC），全局EC引用着全局对象window，window中保存着全局变量
###  2）、定义函数时
创建函数对象：封装函数代码段，在函数对象中有一个scope（作用域）属性，记录着函数来自哪里，全局函数的scope都是window
### 3）、调用函数时
在执行环境栈（ECS）上压入新的EC（函数的EC），创建活动对象（AO），保存着本次函数调用时用到的局部变量，在函数的EC中有一个scope chain（作用域链）属性引用AO，AO有一个parent属性是函数的scope引用着的对象
###  4）、调用时
正是因为前面三部，才有了变量的使用规则：优先使用自己的，自己没有找全局，全局，没有就报错
###  5）、调用完
函数的EC会出栈，AO自动释放，局部变量也就自动释放了
###  6）、作用域链
- 以函数EC的scope chain属性为起点，经过AO，逐级引用，形成的一个链式结构
- 作用：查找变量，带来变量的使用规则
# 八、闭包
希望保护一个**可以反复使用的局部变量**的一种词法结构，其实还是一个函数，至少写法不同
## 1、如何使用
1. 两个函数进行嵌套
2. 外层函数创建出受保护的变量
3. 外层函数return出内层函数
4. 内层函数要去操作受保护的变量
## 2、强调
1. 判断是不是闭包，有没有两个函数嵌套，返回内层函数，内层函数在操作受保护的对象
2. 外层函数调用了几次，就会创建几个闭包，受保护的变量就有了几个副本
3. 同一次外层函数调用，返回的内层函数都是在操作同一个受保护的变量
##  3、缺点
受保护的变量，永远不会被释放，使用过多，内存泄漏----不可多用
##  4、三个事假需要防抖节流
1. elem.onmousemove;鼠标移动就会触发
2. input.oninput;每次改变就会触发
3. window.onresize;每次窗口的大小就会触发
###  1）、防抖节流公式

elem.on需要防抖节流的事件=function(){ fdjl();//内层函数只要一旦移动就会触发 }

graph TD
Start --> Stop

function f1(){
	var timer=null;//3
	return function(){//
	if(timer){clearTimeout(timer);timer=null;}
		timer=setTimeout(function(){
			//操作
			},1000)
		}
	} 
		var fdjl=f1();

# 九、Object 对象
面向对象三大特点：封住、继承、多态
##  1、开发方式
###  1）、面向对象
对象.属性/对象.方法（），js中万物皆对象，一切对象的底层都是hash数组
####  （1）、面向对象优点
1. 所有的属性和方法都保存在一个对象中，更符合现实意义
2. 每个功能特地分开写，便于后期维护
3. 铁索连舟，一个方法触发多个方法联动
#### （2）、面向对象去缺点
this的指向很难确定
####  （3）、原因
现实中的数据都必须包含在一个事物中才有意义
##  2、封装
###  1）、创建自定义对象
####  （1）、直接量

var obj ={ "属性名"：属性值，... "方法名"：function（）{ }，...

graph TD
Start --> Stop

}

####  （2）、强调
- 其实属性名和方法名的的""可以不加
- 访问对象和方法
1. `obj.属性名==obj["属性名"]`
2. `obj.方法名==obj["方法名"]`
3. 访问到不存在的属性，返回undefined
4. 可以随时随地的添加新属性和方法
5. 如果我们希望遍历出对象的所有东西，必须用`for...in..obj[j]`才能拿到
6. 如果希望在对象的方法里使用对象自己的属性：`this.属性名；`
#### （3）、this的指向
1. 单个元素绑定事件：this----当前元素
2. 多个元素绑定事件：this----当前触发的元素
3. 函数中使用this：谁在使用次方法，this指的就是谁
4. 定时器中：this----window
## 3、预定义构造函数方式
- `var obj=mew Object（）//空对象，垃圾，基本没用`
- 以上两种方法都有个缺陷：一次只能创建一喝对象，适合创建单个对象的时候，用第一种方法，第二种方法垃圾
##  4、自定义构造函数方法
### 1）、创建

function 类名（name，age，salary）{ this.name=name； this.age=age; this.salary=salary; }

不要用此方法创建方法，这样会导致每个对象都会有一个方法，浪费内存
###  2）、调用
var obj=new 类名（实参，...）

```mermaid
graph TD
Start --> Stop

十、Object继承

sequenceDiagram
Alice->>John: Hello John, how are you?
John-->>Alice: Great!
Alice-)John: See you later!

父对象的成员（属性和方法），子对象可以直接使用

1、目的

代码重用！节约内存空间！提升网站性能！

2、何时继承

只要多个子对象公用的属性和方法，都要集中定义在父对象中

classDiagram
Animal <|-- Duck
Animal <|-- Fish
Animal <|-- Zebra
Animal : +int age
Animal : +String gender
Animal: +isMammal()
Animal: +mate()
class Duck{
+String beakColor
+swim()
+quack()
}
class Fish{
-int sizeInFeet
-canEat()
}
class Zebra{
+bool is_wild
+run()
}

3、如何找到父对象（原型对象）

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

4、原型链

每个对象都有一个属性：__proto__，可以一层一层的找到每个人的父亲，形参的一条链式结构，就称之为叫做原型链可以找到所有父对象的成员（属性和方法），作用：找共有属性和共有方法的,最顶层是Object的原型，上面放着我们一个眼熟的toString，因此人人都可以用toString();

5、设置共有的属性和方法

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

JavaScript入门学习第三周