一、***数据类型转换：
1、强制转换
1、转字符串：var str=x.toString();//x不能是undefined和null - undefined和null不能使用.
var str=String(x);//万能的，完全等效于隐式转换，还不如+""
不重要：页面上一切数据的数据类型都是字符串
2、*转数字：
1、*parseInt/Float(str);//专门为字符串转为数字准备的
原理：从左向右，依次读取每个字符，碰到非数字字符则停止，如果一来就不认识则为NaN
Int不认识小数点 Float认识第一个小数点
2、Number(x);//万能的，完全相当于隐式转换，还不如-0 /1 *1 %1
3、转布尔：
Boolean(x);//万能的，任何人都可以转为布尔，绝对不会手动使用，还不如：!!x
***只有6个会为false：0，""，undefined，null，NaN，false，其余都为true
在分支/循环的条件之中，自动隐式转换，以后不管代老师在条件里面写的有多奇怪，你都要知道他会悄悄的变成一个布尔值，你只需要判断是不是那6个
2、隐式转换：都是出现在运算符之中
二、****运算符和表达式
1、*算数运算符：+ - * / %
特殊：1、%：取余，判断奇偶性
2、具有隐式转换，默认转为数字，在运算
undefined->NaN
null->0
true->1
false->0
特殊：1、+运算，碰上字符串，拼接
2、-*/%：字符串也可以转为数字，但是纯数字组成的字符串才行，包含非数字字符则为NaN
NaN参与任何算术运算结果仍为NaN
2、*比较运算符：> < >= <= == != === !==
结果：布尔值
隐式转换：默认，转为数字，在比较大小
** 特殊**：1、如果参与比较的左右两边都是字符串，则是按位PK每个字符的十六进制的unicode号（十进制ascii码）
0-9<A-Z<a-z<汉字：常识：汉字的第一个字：一：unicode号：4e00 - ascii：19968
最后一个字：龥：unicode号：9fa5 - ascii：40869
2、NaN参与任何比较运算结果都为false，所以没有办法使用普通的比较运算来判断x是不是NaN
!isNaN(x);
3、undefined==null;//true
区分：undefined===null;
全等：=== - 要求数值相同，并且数据类型也要相同，不再带有隐式转换
!== - 不再带有隐式转换的不等比较
重写String方法，看出==和===的区别
function String(x){
if(x===undefined){
return "undefined";//return->返回，后面跟着的就是返回的结果
}else if(x===null){
return "null";
}else{
return x.toString();
}
}
3、*逻辑运算符：
作用：综合比较，结果也是为布尔值
隐式转换：左右两边都会悄悄转为布尔值，再综合比较结果
&&：全部满足，才满足
一个不满足，则不满足
||：全部不满足，才不满足
一个满足，则满足
!：颠倒布尔值
特殊：短路逻辑：如果前一个条件，已经可以得出最终结论了，没有必要看后续
&&短路：如果前一个条件满足，才执行后一个操作，如果前一个条件不满足，则不管后续操作
目的：简化【简单的】分支：
1、一个条件一件事，满足就做，不满足就不做：if(){}
2、【简单的】- 操作只能有一句话：多句操作导致我们以后维护项目时观看/阅读代码不方便，往往以后很多操作可能就只有一句话
** 语法：条件&&(操作);**
||短路：实现浏览器兼容性问题：二选一
e=e||window.event;
4、位运算：
左移：m<<n，读作m左移了n位，翻译：m*2的n次方
右移：m>>n，读作m右移了n位，翻译：m/2的n次方
垃圾：底数只能固定为2，虽然可以设置幂，但是不能设置底数
5、*赋值运算：+= -= *= /= %= ++ --
一句话完成两个操作，先计算，再赋值回去
i++;//递增，每次只会固定+1
i+=1;//累加，每次加几由我们程序员决定
i=i+1;//最老土的写法
*笔试/算法题：++i 和 i++的区别？
单独使用时，放前放后无所谓，效果一样
但是如果参与了别的表达式，变量中的值都会+1
前++【返回的是加了过后】的新值
后++【返回的是加了过前】的旧值
6、*三目运算：简化if...else... if...else if...else
语法：看条件满足否，满足则作操作1，不满足则作默认操作
1、条件?操作1:默认操作;
2、条件1?操作1:条件2?操作2:默认操作
特殊：
1、默认操作不能省略，省略后会报错
2、如果操作有多句话，还是推荐使用if分支，多句操作再同一行不方便以后维护
总结：
if === &&短路
if...else === 三目运算
if...else if...else === 三目运算
操作多句话使用以上三个 操作一句话使用以上3个
扩展：
1、计算机很笨，牛逼在快和记忆力好(机械硬盘-永久保存，固态硬盘-只能保存10年)：计算机带有摄入误差：解决：num.toFixed(d);//d代表保留的小数位数，会四舍五入运算
缺陷：返回的是要给字符串，建议搭配上一个parseFloat食用最好
2、获取字符串中第一个字符的ascii码：str.charCodeAt(0);
三、*****自定义函数：也叫做方法，是需要预定义好的，以后可以反复使用的代码段
1、***创建函数并且调用：2种
1、*声明方式创建函数：用一个关键字function做声明
function 函数名(形参列表){
函数体;
return 返回值;
}
2、直接量方式创建函数：函数名其实就是一个变量名
var 函数名=function(形参列表){
函数体;
return 返回值;
}
return的本意：退出函数的意思
只不过如果return后面跟着一个数据，会顺便将其返回到全局作用域中，但是只负责返回不负责保存！
所以在调用函数时：如果有return，记得拿一个变量接住结果
何时使用：如果你希望拿到函数的结果，以后还要做别的操作，就需要搭配上return
调用函数：var result=函数名(实参列表);
2、***作用域：2种
1、全局作用域：全局变量和全局函数，在任何地方都可以使用
2、函数/局部作用域：局部变量和局部函数，在【函数调用时内部可用】
*带来了变量的使用规则：优先使用局部的，局部没有找全局，全局没有就报错
特殊：
1、千万不要对着未声明的变量直接赋值：a=1;//会导致全局污染，全局本来没有的东西，突然被添加一坨内存，建议创建变量时，记得一定要写var
2、儿子不孝啊：局部的东西全局居然不能用，解决：看上面
3、哪怕没有写return，其实最后也有return值，只不过是一个return undefined，不喜欢undefined，默认return undefined
4、return一般只会出现在函数的最后，而且只能出现一个
5、往往前辈们提供的方法，底层都有一个return操作，前辈们觉得以后用这些方法的人，可能还需要拿着这个结果去做别的操作
3、***声明提前：笔试重点 （开发中不会遇到）
原理：
在程序正式执行之前，
会悄悄地将var声明的变量和function声明的函数，
集中提前到当前作用域的顶部，
变量比函数轻，
但是赋值留在原地
明说：自己写代码绝对不会碰到，只要我们遵守原则：1、先创建后使用 2、变量名和函数名尽量的不要重复
只有笔试中碰到，如果你以后碰到先使用在创建，或者经常重复变量名，很有可能就是在考你声明提前
先转为我们提前后的样子，再去判断
4、***按值传递：两个变量之间进行赋值
如果传递的是原始类型的值
修改一个变量，另一个变量是不会受到影响到，其实是复制了一个【副本】给对象
如果传递的是引用类型的对象：其实目前你已经学过了两个了，Array和Function，JS中不是原始类型就是引用类型
修改一个变量，另一个变量其实也会受到影响，因为大家操作的其实是同一个【地址值】 - 浅拷贝
函数考点： 1、*创建的方式 2、*作用域 3、*声明提前 4、*按值传递 5、重载 6、匿名函数 7、闭包
5、预定义全局函数：前辈们提前写好的，我们程序员可以直接使用的，全局（在任何地方都可以使用）
1、编码和解码：- 悄悄话玩玩，你编码发到群里，其他人来解码
问题：url中不允许出现多字节字符，如果出现会乱码
utf-8编码格式下，一个汉字，占3字节
解决：发送前，前端将多字节字符编码为单字节字符（数字、字母）
发送后，后端接住，然后将单字节字符解码为原文
如何：
编码：var code=encodeURIComponent("剑风传奇");
解码：var 原文=decodeURIComponent(code);
其实这个东西在某次浏览器更新后，当前就淘汰了！浏览器现在自带此功能
2、isFinite(num)：判断num是不是无穷大，true->有效数字，false->无穷大
哪些会为false：NaN、Infinity、分母为0，所以有多个都为false，不能用来判断是不是NaN
3、牛逼的：parseInt/Float、isNaN、eval
四、***分支结构：
switch...case...：根据条件的不同，选择一部分代码执行
语法：
switch(变量/表达式){
case 值1:
操作1;
break;
case 值2:
操作2;
break;
default:
默认操作;
}
**特殊**：1、case的比较不带隐式转换的
2、问题：默认只要一个case满足后，会将后面所有的操作全部做完
解决：break;
建议：每一个case的操作后都跟上一个break;
有的地方也可以省略break：
1、最后的一个操作default可以省略break
2、如果中间多个条件，做的操作是一样的，也可以省略掉中间的操作
3、default可以省略不写，如果条件都不满足的情况，则什么事都不会执行
** **面试题：if vs switch
1、switch：好处：执行效率相对较高
缺点：必须要知道最后的结果才能使用，case不能做范围判断
2、if 好处：可以做范围判断
缺点：执行效率相对较低
开发时：用哪个都无所谓
代码优化：尽量的将if换成switch
扩展：JS动画：
几乎和JS无关，与CSS有关（transition过度）
JS操作样式：瞬间生效的，只需要加上过度就会慢慢生效 - animate.css动画库（库：很多很多的动画）
五、***循环结构
1、var 循环变量=几;
while(循环条件){
循环体;
循环变量的变化;
}
2、var 循环变量=几;
do{
循环体;
循环变量的变化;
}while(循环条件)
**面试题**：while和do...while的区别？
除了写法上有区别，还有一个点：只看第一次
如果第一次大家都满足，两者其实没区别
如果第一次大家都不满足。while一次都不会执行，而do...while至少会执行一次
3、***for(var 循环变量=几;循环条件;循环变量的变化){
循环体;
}
建议：优先使用for循环，不确定循环次数的时候再用while补充
4、终止循环语句：break;//退出整个循环
continue;//退出本次循环，还会继续做下一次
六*****数组的基础：一个变量名可以保存多个数据
创建：2种
*1、直接量：var arr=[值1,....];
2、构造函数方式：var arr=new Array(值1,....); //缺陷：面试/鄙视中：new Array(3);这是什么意思 - 创建了一个长度为3的空数组
*访问：数组名[下标] - 某个元素
*特殊：读取元素，下标越界 - 返回undefined
添加元素，下标越界 - 在新位置添加元素，结果：不好的，下标不在连续 --- 稀疏数组，拿去遍历一手，一定会得到很多很多的undefined
*三大不限制：
1、不限制数组的长度
2、不限制数组的类型
3、不限制数组下标越界 - 不是好事
*length的三个固定套路：
1、向末尾添加元素：arr[arr.length]=新值;
2、获取倒数第n个元素：arr[arr.length-n];
3、缩容：删除倒数n个元素：arr.length-=n;
*遍历数组：
for(var i=0;i<arr.length;i++){
arr[i];//当前次元素
}
***释放一个引用类型的对象：切记一定要看清楚这个对象有几个变量关联着，每个变量都要释放后才能真正的释放
最好的方式就是封装为一个函数，因为函数中的东西，调用完毕都会自动释放
*新知识点：
索引数组：下标都是数字组成的数组 - 默认
关联（hash）数组：下标是可以自定义的数组
为什么要自定义下标：索引数组的下标无具体的意义，不便于我们查找
哈希数组
*如何创建哈希数组：2步
1、先创建一个空数组：var arr=[];
2、添加自定义下标并且赋值：arr["自定义下标"]=新值;
*访问：arr["自定义下标"];
遍历：把数组中的每一个元素取出来执行相同 或 相似的操作
问题：不能使用for循环去遍历关联数组，因为length失效了，关联数组的length永远为0，而且我们下标也不再是一个数字
*解决：for in 循环
个人不爱称呼他叫做一个循环，因为不能设置从哪里开始到哪里结束，所有的操作都是自动的
语法：for(var i in 数组名){
i;//自动得到每一个洗标
数组名[i];//当前hash数组中的元素了
}
无敌：既可以遍历hash数组，也可以遍历索引数组
个人建议：索引数组依然使用for循环
关联数组再使用for in循环
***JS中除了undefined和null不是一个对象，万物皆对象，而【一切对象的底层都是hash数组】
**面试**：*hash数组的原理：
hash算法：将字符串交给hash算法，会得到一个尽量不重复的数字，但是字符串的内容相同，那么得到的数字也一定是相同
添加元素：将自定义下标交给hash算法，得到一个数字（地址值），把要保存的数据放进去了
读取元素：将指定的自定义下标交给hash算法，得到一个和添加时完全相同的数字（地址值），通过这个地址值可以拿到当初保存的东西
七、*****数组的API：
其实就是前辈们提前定义好的一些函数，我们程序员可以直接使用，这些函数只有数组可用
1、*****数组 转为 字符串
var str=arr.join("自定义连接符");
特殊：
1、如果没有传入实参，则和toString效果一致，默认都是用，隔开
固定套路：
2、*面试笔试中：完成无缝拼接
var arr=["h","e","l","l","o"," ","w","o","r","l","d"];
console.log(arr.join(""));
3、***将数组元素拼接为页面元素（数据渲染）
//获取数据
var arr=["-请选择-","北京","南京","西京","东京","重庆","北京","南京","西京","东京"，西京","东京","重庆","北京","南京","西京","东京"];
//将数组转为了字符串，并且拼接上了标签
var str="<option>"+arr.join("</option><option>")+"</option>";
//让字符串上DOM树，innerHTML是识别标签
sel.innerHTML=str;
实现：二级联动：4个关键点
1、必须使用二维数组，细分每一个城市，并且二维数组的顺序要和之前的一维数组对应
2、select.onchange=function(){} - 状态改变事件：只有选中项发生变化时，才会触发
3、select可以直接获取当前选中项的下标，而不需要自定义下标：select.selectedIndex;
4、其实绑定事件，等号左边部分就是你的函数名
2、*拼接数组：添加元素到末尾的新方式
var newArr=arr.concat(值1,arr2....);
特殊：1、此方法不会修改原数组，必须拿一个变量去接住结果（返回的一个新数组）
2、哪怕拼接的是一个数组，悄悄的打散数组，单个添加
3、*截取子数组：可能只想拿到数组中的某一部分
var subArr=arr.slice(starti,endi+1);
特殊：
1、此方法不会修改原数组，必须拿一个变量去接住结果（返回的一个新数组）
2、含头不含尾
3、如果只传入了一个实参，则为从starti开始，到末尾
4、如果两个实参都省略，则复制了一份 - 深拷贝！两者互不影响
5、支持负数参数，-1代表倒数第一个，-n代表倒数第n个
以上的API都是不修改原数组的
以下的API都是修改原数组的
4、*删插替：
splice：
删除：var dels=arr.splice(starti,n);//从starti位置开始删除n个元素
特殊：返回的是你删除的元素组成的数组 - 有可能你删除的正好是你需要的
插入：var dels=arr.splice(starti,0,新值1,....);
特殊：1、原来starti位置的元素以及后续元素都会被向后移动
2、没有删除元素，也有返回值，返回的是一个空数组而已
替换：var dels=arr.splice(starti,n,新值1,....);var dels=arr.splice(starti,0,新值1,....);
特殊：删除的个数 和 插入的个数不必相同
5、翻转数组：arr.reverse(); -- 仅仅只能翻转
八、*****Array的API：
1、*****排序：
笔试中：手写冒泡排序：从第一个元素开始，依次比较两个相邻的元素，如果前一个>后一个，两者就要交换位置
for(var j=1;j<arr.length;j++){
for(var i=0;i<arr.length-j;i++){
if(arr[i]>arr[i+1]){
var m=arr[i];
arr[i]=arr[i+1];
arr[i+1]=m;
}
}
}
数组提供了一个排序API - 正是开发：
语法：arr.sort();
特殊：
1、默认转为字符串，按位PK每个字符的unicode（ascii）
2、希望按照数字排序 - 升序
arr.sort(function(a,b){
return a-b;
})
a是后一个数，b是前一个数
如果a>b，就会返回一个正数，说明后一个数>前一个数
如果a<b，就会返回一个负数，说明后一个数<前一个数
如果a==b，就会返回一个0，说明后一个数==前一个数
而sort的底层就能通过你返回的值来判断要不要帮你交换位置
3、希望按照数字排序 - 降序
arr.sort(function(){
return b-a;
})
*****切记：以后网页中见到任何带有排序功能的特效，说明它的底层一定是数组，因为JS中只有数组可以排序，先排序再数据渲染
2、栈和队列：作用：添加元素和删除元素的新方式
栈：一端封闭，只能从另一端进出 - 现实生活中较少，何时使用：希望使用到最新的数据的时候
队列：只能一端进入，另一端出 - 现实生活中较多，何时使用：按照先来后到的顺序
栈：
开头入：arr.unshift(新值,....)
开头出：var first=arr.shift();//一次只能删除一个，而且一定是删除的第一个元素，有可能删除的东西就是你需要的东西
个人不喜欢：开头进出，会导致每个元素的下标都会发生变化
结尾入：*arr.push(新值,...);
结尾出：var last=arr.pop();//一次只能删除一个，而且一定是删除的最后一个元素，有可能删除的东西就是你需要的东西
至少不会影响到其他人的位置
队列：以上4个API是可以混搭的
开头入：arr.unshift(新值,....)
结尾出：var last=arr.pop();
结尾入：*arr.push(新值,...);
开头出：var first=arr.shift();
2、*二维数组：数组的元素，又一次引用了一个数组
何时使用：你希望再一个数组内再次细分分类
如何使用：
var peoples=[
["吴飞华",18,"洪兴"],
["冯伟朕",19,"东英"],
["封永跃",20,"三联"]
];
访问：arr[r][c] - r代表行下标，c代表列下标
特殊：1、列下标越界，返回undefined
2、行下标越界，返回报错，因为行下标越界已经得到undefined再加[]则报错
如何遍历：
固定公式：外层循环遍历行，内层循环遍历列
for(var r=0;r<peoples.length;r++){
for(var c=0;c<peoples[r].length;c++){
console.log(peoples[r][c])
}
}
总结：ES3提供的数组：
1、数组的基础（创建、访问、添加、遍历、hash数组）
2、数组的API（10个：join、concat、slice、splice、reverse、sort、push、pop、shift、unshift）
3、二维数组
3、*****String的基础概念
什么是字符串：多个字符组成的【只读】字符【数组】！
1、【只读】：字符串所有的API都不会修改原字符串，只会返回新的字符串。
2、【数组】：跟数组有相同点：
1、字符串可以使用下标获取某个字符
2、字符串可以使用length获取字符的长度
3、字符串可以遍历得到每个字符
4、字符串可以使用数组不修改原数组的API（concat、slice）
差异：所有数组直接修改原数组的API，字符串都不可以使用！字符串自己也有一堆API等待我们下周一学习
九、***JS内置对象（引用类型）：11个
String Number Boolean -> 包装类型
Array Function Date(日期) Math(数学) RegExp(正则：验证)
Error(错误)
Object(面向对象)
Global(全局对象)：1、保存着全局变量和全局函数，只不过浏览器端/客户端/前端global被window代替了，以后我们学习Node.js后端语言的时候你会发全局真的是global
2、唯独window对象可以省略不写
包装类型：专门封装原始类型的值，将原始类型悄悄的变成了引用类型的对象（属性和方法）
为什么：前辈们觉得比如字符串经常会被我们拿来做一些操作，为了方便我们程序员，提供了包装类型，把字符串变成了一个对象，提供了我们一些操作字符串的属性和方法
本身原始类型的值，不带有任何属性和方法，意味着不能使用.去做操作的
何时使用：只要你试图使用.去操作原始类型的值的时候，包装类型就会悄悄出现
何时释放：方法一旦调用结束，包装类型就会自动释放
为什么undefined和null不能使用.，他们俩没有提供过包装类型（没有任何属性和方法）
扩展：周期性定时器：
开启：
timer=setInterval(function(){
操作;
},间隔毫秒数)
停止：
clearInterval(timer);
鼠标的移入和移出事件
onmouseover
onmouseout
十、*****String API：
1、转义字符：\
何时使用：在字符串中出现了和程序冲突的字符
1、比如：希望在""中再放入一个"，或''之中再放入一个'
"\"" '\''
2、具有特殊功能
\n 换行
\t 制表符：就是你敲tab键带来的一个大空格
3、*可以书写unicode号代表一个字
\uXXXX
汉字 的第一个字：\u4e00
汉字的最后一个字：\u9fa5
2、*英文转大小写：【统一的】将字符串转为大写或小写，再比较，忽略大小写（只要是验证码）
大写：var upper=str.toUpperCase();
小写：var lower=str.toLowerCase();
3、获取字符串中某个字符：
str.charAt(i); === str[i];
4、*获取字符串中某个字符的ascii码
var ascii=str.charCodeAt(i);
*通过ascii码转回原文：
var 原文=String.fromCharCode(ascii);
5、***检索字符串：检查索引/下标
何时：判断有没有，不重复！
var i=str/arr.indexOf("关键字",starti);
特殊：1、starti可以省略，如果省略默认从0位置开始向右查找
2、返回：如果找到了，返回关键字的第一个字符的下标
***没找到返回-1，重点：我们其实根本不关心下标为几，我们只关心下标为不为-1，为-1说明没有，如果不为-1说明存在
3、数组也可以使用：其实以前数组是没有这个方法的，某次浏览器更新后，数组才可以使用的（老IE用不到）
4、笔试题：找到所有关键字的下标
var str="no zuo no die no can no bibi";
var index=-1;
while((index=str.indexOf("no",index+1))!=-1){
console.log("找到了，下标为："+index);
}
6、拼接字符串：var newStr=str.concat(str1,str2,....); 还不如 + 运算符
7、*截取子字符串：3种
*1、var subStr=str/arr.slice(starti,endi+1);//slice不光字符串可用，数组也可以用，但是下面两个方法只能字符串能用
2、var subStr=str.substring(starti,endi+1);//几乎和slice一致，但是不如slice，因为不支持负数参数
*3、var subStr=str.substr(starti,n);//截取的个数，不必考虑含头不含尾
8、*替换字符串：
var newStr=str.replace("固定关键字"/RegExp,"新内容");
其实这个方法很吊，至少5可行，但是今天不行，目前没有学过正则表达式，所有替换暂时只能替换一个固定关键字，比较low
9、*****切割/分割字符串：功能：字符串<=>数组
var arr=str.split("自定义切割符")
特殊：
1、切割符是可以自定义的，切割后会返回一个数组，数组中不在包含切割符
2、如果传入的切割符""，每一个字符都会被切散
扩展：JS创建页面元素并且渲染上DOM树：3步
1、创建空标签：
var 新元素=document.createElement("标签名");
2、为此标签设置必要的属性和事件
新元素.属性名="属性值";
新元素.on事件名=function(){操作}
3、把新元素上DOM树
父元素.appendChild(新元素);
十一、*****正则表达式：
什么是：定义字符串中【字符出现规则】的表达式
何时使用：切割 替换 *验证*
如何使用：
1、最简单的正则：
关键字原文，但是写法和以前的字符串不同，"no" -> /卧槽/ig
i：忽略大小写
g：全部，替换的话默认只会替换第一个匹配到的关键字
2、备选字符集：
一个备选字符集：规定一位字符可能出现的情况
何时使用：只要关键字又多种情况的时候
如何使用：/[备选字符集]/
强调：1、一个中括号，只能管一个字
2、问题：正则默认只要满足后，就不再管后续操作，后续用户就可以乱来！
解决：【只要是做验证】，我们肯定希望用户完全按照我们的规则来玩，必须写为：/^[备选字符集]$/ - 前加^后加$的意思是要求用户从头到尾完全匹配
特殊：1、如果备选字符集种有部分unicode号是连续的，则可用-省略掉中间部分
比如：
一位数字：[0-9]
一位字母：[A-Za-z]
一位数字、字母、下划线：[0-9A-Za-z_]
一位汉字：[\u4e00-\u9fa5];
2、除了xxx之外，其他都可以
[^xxx] - 范围太广，不推荐
3、预定义字符集：前辈们提前定义了的一些常用的字符集
一个数字：\d === [0-9]
一位数字、字母、下划线：\w === [0-9A-Za-z_]
一位空白字符：\s === 空格、制表符、换行
一位除了换行外的任意字符：. - 范围太广，不推荐
问题：预定义字符集是固定的，不灵活
建议：开发时优先使用预定义字符集，预定义字符集满足不了，再用备选字符集补充
强调：不管是备选字符集还是预定义字符集，一个都只管一位
4、量词：规定了一个字符集出现的次数
如何使用：
1、有明确数量：
字符集{n,m}：前边相邻的字符集最少出现n次，最多出现m次
字符集{n,}：前边相邻的字符集最少出现n次，多了不限
字符集{n}：前边相邻的字符集必须出现n次
2、没有明确数量：
字符集?：前边相邻的字符集，可有可无，最多一次
字符集*：前边相邻的字符集，可有可无，多了不限
字符集+：前边相邻的字符集，至少一次，多了不限
5、指定匹配位置：
^：以xxxxx开头
$：以xxxx结尾
*特殊：如果同时使用了，前加^后加$，从头到尾完全匹配 - 只要是做验证，必须这么写
6、选择和分组：
选择：可以再多个条件中选择一个
规则1|规则2
分组：选择和分组一般来说都是需要搭配使用的 - 添加了子规则
(规则1|规则2)
7、预判：
目的：密码强度：4-6位密码，可以输入字母数字，但是必须要有一位大写和一位数字的组合
公式：比如：
1、/^(?![0-9]+$)$/ - 不能全由数字组成，可能有大写字母、小写字母、汉字、特殊符号、日文、韩文...
2、/^(?![A-Za-z]+$)$/ - 不能全由大写组成，也不能全由小写组成，也不能由大写和小写的组合组成，可能有数字、汉字、特殊符号、日文、韩文...
//4-6位密码，可以输入字母数字，但是必须要有一位大写和一位数字的组合
var reg=/^(?![0-9a-z]+$)(?![A-Za-z]+$)[0-9A-Za-z]{4,6}$/
//4-6位密码，可以输入字母数字，但是必须要是3者的组合
var reg=/^(?![0-9a-z]+$)(?![A-Za-z]+$)(?![0-9A-Z]+$)[a-zA-Z0-9]{4,6}$/;
十二*****字符串支持正则的API：
1、切割：var arr=str.split("固定切割符"/RegExp);
2、*****替换:
1、基本替换法：
str=str.replace(/正则表达式/gi,"新内容");
注意：替换时，不要前加^后加$，我们不需要完全匹配，只需要找到关键字做替换而已，想要替换所有的一定要加后缀g
问题：替换的新东西，只能是一个固定的
2、高级替换法：
str=str.replace(/[我卧握窝][去槽操曹草]+/g,function(key,i,str){//此回调函数会自动调用，找到几个关键字就会执行几次
//console.log(key);//当前次正则匹配到的关键字
//console.log(i);//当前次正则匹配到的关键字的下标
//console.log(str);//原文本身
return key.length==2?"**":"***";
});
3、格式化：如果替换时，正则中，带有分组，那么你的回调函数会得到更多的形参
var str="500103198602215933";
var reg=/\d{6}(\d{4})(\d{2})(\d{2})\d{4}/;
str=str.replace(reg,function(key,a,b,c,i,str){
//console.log(key);//正则匹配到的内容
//console.log(a);//第一个分组匹配到的内容
//console.log(b);//第二个分组匹配到的内容
//console.log(c);//第三个分组匹配到的内容
////... 你有多少个分组就会多出多少个形参，但是最后两个一定是下标和原文
//console.log(i);
//console.log(str);
return a+"年"+b+"月"+c+"日";
})
console.log(str);
十三、*****正则对象：
创建：
1、直接量方式：var reg=/正则表达式/后缀;
2、构造函数方式：var reg=new RegExp("正则表达式","后缀");
方法：验证：var bool=reg.test("用户输入的东西");
true->用户输对了 false->用户不通过
十四、Math：专门用于提供数学计算的API
强调：不能、不需要创建，浏览器自带的
属性：Math.PI - 以后不用自己在创建3.1415926
API：
1、取整：3种
上取整：只要超过，就会取下一个整数
Math.ceil(num); - 小数位数不能超过15位，超过后会失效
下取整：无论超过多少，都省略小数部分
Math.floor(num);
四舍五入取整：只看第一位小数
Math.round(num);
以上三个都是垃圾：只能取整，不能指定保留小数位数：个人推荐：num.toFixed(d);//d可以指定保留小数位数，而且也具有四舍五入的功能，唯一的缺陷：返回的是一个字符串，建议搭配上一个parseFloat使用
笔试题：封装自定义一个函数，按照任意小数位数四舍五入，返回数字类型，不允许使用toFixed
function dy(num,d){
num*=Math.pow(10,d);
num=Math.round(num);
num/=Math.pow(10,d);
return num;
}
var result=dy(Math.PI,3);
console.log(result)
2、乘方和开方：
*乘方：Math.pow(底数,幂); - 以后不用连乘
开方：Math.sqrt(num);
3、*最大值和最小值：
var max/min=Math.max/min(num1,num2,.....);
可以获取出传入的参数种最大或最小的值
问题：不支持传入数组参数，比较数组的最大值和最小值
解决：Math.max/min.apply(Math,arr);
其实apply可以悄悄的打散数组，将每个元素单独传入 - ES5带来的一个新特性
其实apply可以借用方法
笔试题：比较出数组中最大值/最小值（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、其实Math还有一些别的东西（属性和方法）- 还提供了三角函数
十五、Date：封装了一个事件对象，提供了对时间进行操作的API的对象
何时使用：只要计算时间，就必须用Date对象
如何使用：
1、创建：4种
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 月份需要修正
4、*复制一个日期对象
为什么：日期对象的API都是直接修改原日期对象的，无法获得修改之前的日期
何时使用：如果你希望同事获得修改前和修改后的两个日期，则应该先复制一份，然后再去修改其中一份
var end=new Date(start);
2、使用：
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代表星期天，外国人的眼里，星期天是一个星期的第一天
Hours：0~23
Minutes、Seconds：0~59
3、日期看上去像一个字符串一样黑色的，但是日期对象和字符串能用的API不同，而且日期对象很聪明，会自动进制
建议：对一个日期的某个分量做计算
date.setXXX(date.getXXX()+/-n);
+10分钟
date.setMinutes(date.getMinutes+10);
3、日期格式化：
date.toLocaleString();//会转为一个本地日期格式的【字符串】，虽然不能自动进制，也不能用日期的API，但是可以用字符串的API了
垃圾：具有兼容性问题，老IE输出的和主流浏览器输出的东西不一样
解决：自定义format函数
十六、*Error对象：错误对象
1、浏览器自带4种错误类型 - 帮助你们快速找到错误
SyntaxError - 语法错误：一定是符号/语法写错
ReferenceError - 引用错误：没有创建的东西，你就去使用了
*TypeError - 类型错误：不属于自己的属性和方法，你却去使用了
RangeError - 范围错误：只有一个API会遇到，num.toFixed(d);//d必须在0~100之间
2、错误处理：当程序发生错误时，保证程序不会异常中断的机制
为什么：程序默认只要碰到错误就会停止/闪退，用户体验感差
如何错误处理：
try{
可能发生错误的代码
}catch(err){
发生错误时才会执行，err形参会自动得到错误的信息，英文的
建议你自己在加上中文错误描述
}
性能垃圾：放在try中的代码，效率都会被降到最低
解决：完全可以用if...else 代替 try...catch，所有的一场都可以提前预判
需要经验的累积：一切客户端都是坏人，都要防他一手：
1、if...else...
2、!isNaN 3、【正则验证】
3、抛出自定义错误/异常：
throw new Error("自定义文字");
十七、*****Function对象：提前创建好，以后可以反复使用的代码段
js中的函数也是一个对象，函数名其实是引用函数对象的变量
考点：
1、*创建：3种
1、声明方式：function 函数名(形参列表){函数体;return 返回值;} - 完整的声明提前
2、直接量方式：var 函数名=function(形参列表){函数体;return 返回值;} - 完整的声明提前
扩展：
d1.onclick=function(){}
3、构造函数方式：
var 函数名=new Function("形参1",....,"函数体;return 返回值;");
强调：无论参数实际是什么类型，创建函数时的每一部分都必须用""包裹
何时使用：如果函数体不是固定的，而是字符串动态拼接的
2、***作用域
3、***声明提前
4、***按值传递
5、***重载（overload）：相同函数名，根据传入的实参的不同，会自动选择对应的函数执行
为什么：减轻程序员的负担！
问题：JS的语法不支持重载！JS不允许同时存在多个同名函数，如果同时存在，最后一个的函数会覆盖掉之前所有的
解决：在函数内部有一个对象：arguments
什么是arguments对象：函数中，自带的，不需要我们创建的，是一个【类数组】对象，
作用：接受住所有的实参
只有3个点是和数组相同的
1、都可以用下标访问某个元素
arguments[i] - 传入的某个实参
2、都可以用length获取到长度
arguments.length
3、可以遍历拿到每一个元素 - for循环
强调：类数组对象不是数组，所有的数组的API，类数组都不能使用
优点：何时使用：1、以后不需要形参，也可以接住所有的实参！
2、变相实现重载：在函数内部判断传入的实参（个数、类型）的不同，执行不同的分支操作
6、***匿名函数：创建的函数，没有函数名引用着
何时使用：如果函数，只会执行一次
为什么：节约内存，匿名函数没有变量引用着，用户，就会自动释放
如何使用：
1、匿名函数自调：只会执行一次，执行完毕后会自动释放，代替全局写法，节约内存空间
(function(){
console.log("我是匿名自调");
})();
2、*匿名函数回调：将函数调用时，传入的实参，又是一个匿名函数，不需要我们程序员调用，会由主函数自动执行
确实是前辈们，怎么规定，我们怎么使用，但是我们了解到，原来这个回调函数不是没有调用，只不过是前辈们提前帮我们调用好了
我们学习的主要目的：
1、你要认识哪些叫做回调函数 - 匿名函数，只要不是自调，就是回调
arr.sort(function(a,b){return a-b;})
str.replace(reg,function(){})
d1.onclick=function(){} - 就算你听懂了怎么简化为箭头函数，也暂时不要在事件上写箭头函数
2、以后搭配上ES6的箭头函数：简化了一切的回调函数
7、作用域（scope）：2种
1、全局作用域：
成员：随处可用，可以反复使用，缺陷：容易被污染
2、函数作用域
成员：不会被污染，只有函数调用时内部可用，缺点：调用结束后，就释放了，一次性的，不可反复使用
8、***函数的执行原理：
5步 - 为什么会有变量的使用规则，为什么函数中的东西会自动释放
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自动释放，局部变量也就自动释放
两链一包：
作用域链（scope chain）：以函数的EC中的scope chain属性为起点，经过AO逐级引用，形成的一条链式结构
作用：查找变量，带来了变量的使用规则：优先使用局部变量，局部没有找全局，全局没有就报错
9、*****闭包：保护一个可以【反复使用的局部变量】的一种词法结构
为什么：全局变量：缺：容易被污染
局部变量：缺：一次性
如何使用：
1、两个函数进行嵌套
2、外层函数创建受保护的局部变量，并且返回内层函数
3、内层函数在操作受保护的局部变量
强调：
1、判断闭包，有没有两个函数在嵌套，并且外层函数创建了变量，return了内层函数
2、外层函数调用几次，就创建了几个闭包，受保护的变量就有了几个副本
3、同一次外层函数调用，返回的内层函数，都哦是使用同一个受保护的变量
缺点：唯一的缺点：受保护的变量永远不会被释放，过度使用闭包，会导致内存泄漏
使用场景：**防抖节流**：减少DOM树的修改，提升性能 - 3个事件会非常的影响性能，性能差、
1、elem.onmousemove - 鼠标移动就会触发，触发次数很多很快，但是不要让他疯狂的渲染DOM
2、window.onresize - 窗口的尺寸只要发生变化就会触发，触发次数很多很快，但是不要让他疯狂的渲染DOM
3、input.oninput - input框输入的内容发生变法，就会触发
防抖节流公式：
function fdjl(){
var timer;//受保护的变量
return function(){//操作受保护的变量
if(timer){clearTimeout(timer)}
timer=setTimeout(function(){
//考虑你要做的操作是什么
},1000)
}
}
var inner=fdjl();//inner()内层函数才是写在事件中的操作
十八、*****Object：面向对象开发方式：
三大特点：封装、继承、多态
**面试题**：简单的说一下你了解的面向过程和面向对象 开发方式的区别？
面向过程：开始->经过->结束，我们从开始到现在学习写法的一直都是面向过程
一个人：出生->成长->工作->结婚->死亡
面向对象：对象（属性和方法），如果这个世界有各种属性和各种方法，但是连一个对象/生物都没有，那这些东西就没有具体的意义
我们把所有的代码全部包含在一个对象中来进行描写，才更符合现实生活
一个人：属性：身高、体重、姓名、性别
方法：吃饭、睡觉、玩耍
之前用的11个引用类型对象，都是浏览器的js解释器提供的，我们直接学习如何使用，但是我们现在可以学习如果创建属于自己的对象（可惜前辈们没有提供过轮播、选项卡、购物车...）
学习如何创建自定义对象：
1、封装/定义/创建对象：3种
1、直接量方式：
var obj={
"属性名":属性值,
...
"方法名":function(形参){函数体},
...
};
强调：
1、属性名和方法名的引号其实是可以省略的，但是不建议，因为以后我们会学习一种数据格式叫做JSON，要求属性名和方法名的【双引号】不能省略
2、如何访问对象的属性和方法
*对象名.属性名; === 对象名["属性名"]
*对象名.方法名(); === 对象名["方法名"]()
JS中万物皆对象，除了undefined和null，一切对象的底层都是hash数组
特殊：1、访问到不存在的属性，返回undefined
2、随时随地可以添加不存在的属性和方法
3、希望获取到对象之中所有的东西：遍历对象：for in循环
for(var i in obj){
obj[i];
}
4、如果你希望在对象的方法内部使用对象自己的属性，我们需要写为this.属性名;
this指向：
1、单个元素绑定事件this->这个元素
2、多个元素绑定事件this->当前元素
3、函数中this->谁在调用此函数this指向就是谁
4、定时器中this->window
5、箭头函数this->外部对象
6、自定义构造函数中出现this->你当前正在创建的对象
2、预定义构造函数方式：垃圾
var obj=new Object();//空对象
obj.属性名=属性值;
obj.方法名=function(){};
** 以上两种创建方式有一个缺点：仅仅适合创建单个对象，如果创建多个对象，代码冗余度太高**
3、专门为创建多个对象准备的
自定义构造函数方式：2步
1、创建构造函数
function 类名(name,age,hobby,...){
this.name=name;
this.age=age;
this.salary=salary;
...
}
2、调用自定义构造函数创建出对象
var obj=new 类名(实参,...);
面向对象开发方式的好处：
1、不适合初学者，逼格高！- 招聘有工作经验，你需要用5个月的时间，争取练出2年的技术
2、特地把每一块功能分开写 - 哪怕不需要注释，也便于以后维护！
3、铁索连舟 - 更符合现实生活
4、所有东西都包含在一个对象之中 - 更符合现实生活
