day14

1、事件取消：

1、elem.on事件名=null;

2、elem.removeEventListener("事件名",当初添加时的回调函数);

2、this的指向：

单个元素绑定事件：this->这个元素 可用target代替

多个元素绑定事件：this->当前元素 可用target代替

定时器中的this->window

箭头函数中的this->外部对象

函数中出现了this->正在调用此函数的对象

3、其实不是自己的方法，也可以用，强制改变this的指向

call/apply：临时替换了函数中的this

语法：函数.call(借用的人,实参,...);

函数.apply(借用的人,arr);

借用相当于就是立刻调用

bind：永久替换了函数中的this
	语法：var 新函数=函数.bind(指定的人,永久实参);
	完成了3件事:
		1、创建了一个和原函数完全相同的新函数
		2、this被永久指定为了指定的人，其他人都借不走
		3、甚至可以永久固定一些实参
	买，是不会立刻执行的，需要自己调用

3个固定套路：
	1、数组也可以获取最大值和最小值：Math.max/min.apply(Math,arr);	===>	Math.max/min(...arr);
	2、判断x是不是数组：Object.prototype.toString.call/apply(x)=="[object Array]"
	3、类数组转为普通数组：普通数组=Array.prototype.slice.call/apply(类数组对象)	===> 普通数组=Array.from(类数组对象);

4、let、const、箭头函数

5、解构赋值：

1、类似数组的解构赋值 var [c,b,a]=[1,2,3] - return可以返回多个数据

2、类似对象的解构赋值 var {c,b=默认值,a}={a:1,b:2,c:3} - 衍生了传递实参的顺序其实无所谓了

6、模板字符串：

使用反向单引号

7、for(var v of arr){ v-值 }

缺陷：

1、没提供过下标，无法修改原数组

2、无法遍历hash数组，也无法遍历对象

8、Set和Map

[...new Set(arr)] - 使用Set数组去重，在从Set转回Array

day15

1、正则表达式：

规定了字符串的字符出现的规则

真实开发中：优先面向百度开发，学习正则的目的（1、看得懂可以改 2、笔试和面试）

何时使用：切割、替换（加g）、验证（前加^后加$）

如何使用：

1、最简单的正则就是原文本身：/原文/后缀

g：找全部 i：忽略大小写

2、备选字符集：[0-9]

3、预定义字符集：简化备选字符集

		一位数字：\d
		一位数字字母下划线：\w
		一位空白字符：\s

4、量词：

		有明确数量
			{n,m} - 前边相邻的字符集，至少n个，最多m个
			{n,} - 前边相邻的字符集，至少n个，多了不限
			{n} -  前边相邻的字符集，必须n个

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

5、选择和分组：

		(规则1|规则2)

6、指定匹配的位置

		开头：^
		结尾：$
		特殊：两者同时使用，前加^后加$，代表要求用户输入的从头到尾完全匹配 - 只要是做验证就必加

7、预判：实现密码强度

		/^(?![0-9A-Za-z]+$)[0-9A-Za-z\u4e00-\u9fa5]{4}$/

2、字符串支持正则的API：

1、切割：var arr=str.split(RegExp);

2、替换：

	基础替换法：
		str=str.replace(RegExp,"固定新内容")

	高级替换法：
		str=str.replace(RegExp,a=>{
			return 通过判断a关键字的长度的不同，返回不同的内容;
		})

	格式化：
		str=str.replace(RegExp,(a,...)=>{
			如果正则里有分组，我们就会得到更多的形参，有几个分组，就会多出几个形参！
			始终：
			第2个形参保存的是第1个分组匹配到的内容
			...
		})

3、正则对象：

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

API：
	验证：var bool=reg.test(user); - 这个bool仅仅就是给出一个正确或错误的提示

4、新学的事件：

1、每个input都有一个onfocus获取焦点事件 - 提示用户

2、每个input都有一个onblur失去焦点事件 - 验证用户

3、form有一个onsubmit提交事件 - 阻止提交return false;

4、oninput - 只要内容发生了变化都会触发

day17

1、面向对象：

三大特点：封装、继承、多态

1、封装：其实就是创建

1、直接量：

var obj={ "属性名":属性值, ... "方法名":function(){}, ... }

2、预定义构造函数

		var obj=new Object();//空对象
		obj.属性名=属性值;
		obj.方法名=function(){};

3、自定义构造函数 - 批量创建对象，创建了一个类

1、创建自定义构造函数

			function h52302(name,age,hobby){
				this.name=name;
				this.age=age;
				this.hobby=hobby;
			}

2、调用自定义构造函数，创建对象

			var obj=new h52302(实参,...);

4、使用：

		访问：obj.属性名/方法名();
		访问到不存在的：返回undefined
		遍历：for in
		如果对象的函数，想要使用对象自己的属性，要写为this.属性名;
		this的指向：
			1、单个元素绑定事件this->这个元素
			2、多个元素绑定事件this->当前元素
			3、定时器中this->window
			4、箭头函数中this->外部对象
			5、函数中的this->正在调用此函数的对象
			6、构造函数中的this->正在创建的对象

2、继承：原型对象（父对象）的东西，子对象可以直接使用

	作用：代码重用
	如何：

1、找到原型对象（父对象）：

			对象名.__proto__;
			构造函数名.prototype;

2、原型链：

            每个对象都有一个属性.__proto__，可以一层一层的找到每个人父亲，形成了一条链式结构
			作用：找属性和方法的，哪怕自己没有会悄悄的向上查找，如果最顶层也没有才会报错
			最顶层是Object的原型，甚至上面放着我们眼熟的API - toString，怪不得人人都可以使用
			

3、找到原型对象可以设置共有属性和共有方法

			原型对象.属性名=属性值;
			原型对象.方法名=function(){};
                    
                    
                    

day18

1、继承：笔试面试题：

1、判断自有和共有：

1、判断自有：

obj.hasOwnProperty("属性名"); 如果结果true，则为自有，否则有可能是共有也有可能没有

2、判断共有：

		if(obj.hasOwnProperty("属性名")==false&&"属性名" in obj){
			共有
		}else{
			没有
		}

	完整公式：
		if(obj.hasOwnProperty("属性名")){
			自有
		}else{
			if("属性名" in obj){
				共有
			}else{
				没有
			}
		}

2、修改和删除自有和共有

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

	共有：
		修改：原型.属性名=新值;
		删除：delete 原型.属性名;

3、为一类人添加API：

	构造函数名.prototype.方法名=function(){
		操作;
	}

4、判断x是不是数组：4种

	1、判断x是不是继承自Array.prototype
		Array.prototype.isPrototypeOf(x);

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

	3、ES5 - Array.isArray(x);

	4、多态：不严格的定义：同一个方法，不同的人使用，表现出来的效果，是不一样的，有多种形态
		严格的定义：子对象觉得父对象提供的成员不好用，在本地定义了同名成员进行了覆盖
		Object.prototype.toString.call/apply(x)==="[object Array]";

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

	2、批量设置：
		构造函数名.prototype=父对象;//注意时机：要在创建对象之前进行设置继承操作

2、class关键字：简化面向对象：封装、继承、多态

class 新类 extends 老类{
constructor(name,age,hobby,salary){
super(name,age,hobby)
this.salary=salary
}

哪怕我们不创造任何方法，老类有的，我们也有，但是我们如果觉得他提供的方法不好用，也可以使用多态修改

新函数(){
    操作
}
fly(){

    }
 }

3、 原型链：

每个对象都有一个.__proto__的属性，可以一层一层的找到每个人原型（父）对象，就放着

我们的共有属性和共有方法，哪怕自己没有，也会悄悄的向上查找，最顶层是Object的原型

作用：查找共有属性和共有方法

作用域链：以函数的EC的scope chain属性为起点，经过AO，逐级引用，形成的链式结构

作用：查找变量，带来了变量的使用规则

闭包：希望保护一个可以反复使用的局部变量的一种词法结构，其实还是一个函数

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

	var inner=outer();//内层函数就可以在全局反复调用

	强调：
		1、外层函数调用几次，闭包就创建了几次，受保护的变量就有了几个副本
		2、但是同一次外层函数调用返回的内部函数，都是在操作同一个受保护的变量

	缺陷：受保护的变量永远不会被释放，使用过多，会造成内存泄漏，闪退
	使用场景：变量私有化、防抖节流：四个事件需要防抖节流：
		1、elem.onmousemove
		2、input.oninput
		3、window.onresize
		4、window.onscroll