啦啦啦啦啦啦啦啦绿绿绿绿绿绿
1 1.JavaScript： 2 前段三大语言：HTML CSS js 3 HTML：专门编写网页内容的语言 4 CSS：专门编写网页样式的语言 5 js：专门编写网页交互行为的语言 6 原生js：不需要下载任何第三方文件就可以直接使用的js 7 ECMAScript(ES)：ECMA制定的JavaScript语言国际标准规定js语言的核心语法 8 JavaScript：NetScape遵照ES标准实现的自己的js语言 9 JScript：Microsoft遵照ES…… 10 DOM：专门操作网页内容的程序标准 11 BOM：专门操作浏览器窗口的程序 12 js语言四大特点： 13 1.运行在脚本解释引擎中：脚本解释引擎：专门解析js语言并执行的小软件 14 1.浏览器自带脚本解释引擎：内容排版引擎和脚本解释引擎 15 2.独立安装的脚本解释引擎：Node.js 16 2.边解释边执行，后解释的相同内容会覆盖先解释的 17 3.弱类型： 18 声明变量时，不必提前规定变量的数据类型，一个变量先后可保存不同类型的数据 19 4.基于对象：core
1.使用
1 1. 页面中的script标签里: 2 一旦进入script标签内，就要使用js的语法 3 问题: 不符合内容与行为分离的原则——不便于维护和共用 4 2. 独立的js文件中: 5 引入: <script src="js文件的url"></script> 6 强调: script标签不同同时引入外部js和包含内部js。结果: 内部js自动失效
2.变量
1 var 变量1,变量2,...;; 2 强调: 一切变量都用var声明，不必提前规定数据类型。 3 默认值: 变量的默认值为undefined 4 命名规则: 5 1. 字母，数字或下划线组成，不能以数字开头 6 2. 不能使用保留字: js语言已经提前占用的有特殊意义的名字 7 3. 见名知义 8 4. 驼峰命名: 首字母小写，之后每个单词首字母大写 9 10 强调: 变量赋值前，必须先声明 11 特殊: 给为声明过的变量赋值 12 特殊: 试图从未声明过的变量中取值，会报错！ 13 声明: const 常量名=值; 14 强调: 声明常量时，必须初始化其值常量名通常全大写 15 赋值: 常量不允许赋值 16 普通模式: 强行赋值，不报错，但也无法修改 17 ——静默失败 18 ES5 严格模式: 将所有静默失败升级为错误！
3.***数据变量：
1 1. 原始类型: 值直接保存在变量本地的数据类型 2 number string boolean null undefined 3 2. 引用类型: 值无法直接保存在变量本地的复杂数据类型 4 功能: typeof x 返回变量x中存储的数据的类型名 5 number类型：其类型的数字在内存中采用二进制存储 1字节=8位二进制 6 功能：n.toString(2) 将n的数值转为内存中的二进制形式（整数4字节 浮点数8字节） 7 特殊：舍入误差（底层二进制计算导致）->四舍五入n.toFixed(2)n按2位小数四舍五入 8 string类型：c.charCodeAt();查看C中的Unicode号 9 boolean类型:只有两个值的类型: true/false 10 undefined: 空 由程序自动使用，给变量赋初值。 11 null: 空 让程序员主动清空一个变量的值
4. ***数据类型转换:
1 弱类型: 2 1. 声明变量时，不用提前指定变量的数据类型 3 2. 同一个变量先后可保存不同类型的数据 4 3. js会根据自己的需要，动态转变数据的类型 5 1. 隐式转化: 由程序自动完成，不需要程序员手动干预的类型转化 6 只要所给的数据类型，不是程序想要的，程序自动将给定的数据转化为自己想要的类型 7 2. 强制转换: 由程序员主动调用功能，执行的类型转换 8 1. 强制转数字: 9 1. Number(x): 可将任意类型的数据，转化为number类型。 10 问题: 只能转纯数字组成的字符串和bool 11 2. parseFloat(str): 将str转化为数字，保留小数。 12 特殊功能: 可去掉数字*结尾*非数字字符。 13 parseInt(str): 将str转化为数字，去掉小数部分，下取整。 14 强调: parseFloat/Int的参数，要求是字符串。 15 如果给定的不是字符串，则首先隐式转为字符串，再转为数字。 16 比如: Number(true) -> 1 parseInt(true) -> NaN "true"->NaN 17 总结: 只要转字符串，都用parseFloat 18 除非去掉小数，才用parseInt 19 Number(x)，几乎不会主动使用 20 因为隐式转换使用的其实就是Number 21 如果转不了: 都返回NaN（NaN: Not a Number） 22 代表一切不是数字的值NaN参与任何算数计算，结果依然是NaN 23 补: 转二进制: n.toString(2) 10->2 24 parseInt(str,2) 2->10 25 2. 转字符串: 2种: 26 x.toString() 将任意内容，转为字符串除null和undefined之外 27 String(x) 将任意内容，转为字符串——万能 28 总结: 今后，凡是转字符串，首选String(x) 29 3. 转bool: Boolean(x); 30 规律: 只有5个值会转为false: 0 "" null undefined NaN 31 其余都转为true！
5. ***运算符:
1 1.算数运算: + - * / % 2 m%n:模运算-->1.判断能否整除 2.用来取余数 3 隐式转换: 4 默认: 一切都转为number，再计算 5 特殊: +运算中，如果碰到字符串，则一切都转字符串，+计算变为字符串拼接 6 2.关系运算: 做比较，做判断（ 6种: > < >= <= == !=） 7 隐式转换: 8 默认: 一切都转数字，再比较 9 特殊: 10 1. 如果两个字符串比较: 不再转数字，而是依次比较每个字符的unicode号大小 11 2. null和undefined: 12 如何鉴别: null vs undefined 13 ===: 全等: 首先要求类型必须相同 ，其次值再相等 14 !==: 其实就是全等的反义,可代替!= 15 强调: 只要比较undefined必须用===，其实===就是不带隐式转换的== 16 建议: 用===代替== 17 3. NaN不大于，不小于，不等于任何值 18 isNaN(num) 19 num不是数字或无法转为数字，则返回true 20 num是数字或可隐式转为数字，则返回false 21 3.逻辑运算: 将多个关系运算综合得出最终结论 22 短路逻辑: 如果前一个条件已经可以得出最终结论，则后续条件不再执行 23 &&: 如果前一个条件为true,则后续条件继续执行 24 如果前一个条件为false,则后续条件不再执行，直接返回false！ 25 ||: 如果前一个条件为true,则后续条件不再执行, 直接返回true 26 如果前一个条件为false,则后续条件继续执行 27 4.位运算: 了解 28 1.左移右移 29 m<<n :等效于: m*Math.pow(2,n) ， 30 m>>n : 等效于m/Math.pow(2,n) 31 2.下取整: 32 m^0 33 m|0 34 等效于Math.floor(m) 35 3. 交换两变量的值: 3种: 36 1. var t=a; a=b; b=t; 通常鄙视不让用！(不允许声明第三个变量) 37 2. a+=b; b=a-b; a-=b; 38 3. a^=b; b^=a; a^=b; 最简单 39 5.扩展赋值运算: 对计算+赋值的一种简写 40 a=a+b; 可简化为 a+=b 称为累加 41 a=a-b; 可简化为 a-=b 42 a=a*b; 可简化为 a*=b 43 a=a/b; 可简化为 a/=b 44 a=a%b; 可简化为 a%=b
6.***数组API:
1 API: 应用程序编程接口（数组: 连续存储多个数据的存储空间——存储 2 并提供了操作数据的API——功能） 3 1.转字符串: 2种: 4 String(arr): 将每个元素转为字符串，并用逗号连接 5 何时: 只关心内容，不关心格式——拍照，对比 6 arr.join(“自定义连接符”): 将每个元素转为字符串，但是，可自定义连接符 7 何时: 如果要求带格式的转化 8 比如: 将单词拼接为句子: words.join("") 9 将字母拼接为单词: 错误: chars.join() =>String(chars) 10 正确: chars.join("") 11 将数组内容动态生成页面元素 12 判断数组是空数组: 13 错误: arr.length==0 因为还有new Array(n)这种仅规定个数的空数组 14 正确: arr.join("")===”” 15 16 2.拼接和选取: 17 *拼接: 将其它元素或其它数组，和当前数组拼接为一个新数组 18 如何: var newArr=arr.concat(值1,值2,...,arr2,…) 19 强调: 20 1.concat无法修改原数组，只能返回新数组。 21 要想获得拼接后的新值，必须用变量接住新数组 22 2.会自动打散数组参数为单个元素，再拼接 23 *选取: 复制出数组中指定开始到结束位置之间的元素，组成新数组 24 如何: var subArr=arr.slice(starti,endi+1); 25 复制出arr中starti位置到endi为止的所有元素，组成新数组。 26 强调: 1. 如果两个参数都是下标，则含头不含尾,结束为止总要+1 27 2. 不修改原数组，仅复制出原数组的元素，组成新数组返回。 28 简写: 29 1.省略第二个参数: arr.slice(starti)表示一直选取到结尾 30 2.支持负数下标: 表示倒数第n个元素 31 原本: arr.length-n可简写为: -n ,其实,是slice自动用length-n 32 3.省略第一个参数: arr.slice() 复制整个数组 33 34 3.修改数组: 删除，插入，替换 —— splice 35 *删除: arr.splice(starti,n) 删除arr中，starti位置开始的n个元素。 36 其实, splice有返回值: 返回被删除的元素，组成的临时子数组 37 因为，程序中删除的东西，可能还有别的用途 38 如何: var deletes=arr.splice(starti,n); 39 强调: 1. 直接修改原数组 40 2. 不用考虑含头部含尾 41 简写: 1. 省略第二个参数，表示到结尾 42 2. 支持负数参数 43 *插入: arr.splice(starti,0,值1,值2,…) 44 在starti位置，插入值1,值2,…,原starti位置的被向后顺移 45 强调: 不支持打散数组类型参数 46 vs concat() 不同: 47 1.Concat不修改原数组，返回新数组 48 Splice 直接修改原数组 49 2.Concat可打散数组参数为单个元素 50 Splice 不支持打散数组参数,而是住套间 51 3.Concat只能在结尾添加 52 Splice 可在任意位置插入 53 *替换: arr.splice(starti,n,值1,值2,….)其实就是先删除，再插入 54 强调: 1. 删除的个数和插入的个数不必一致，因为，数组不限制元素个数。 55 56 *翻转: arr.reverse();
7.***排序：
1 鄙视: 3大排序算法: 冒泡，插入，快速 2 冒泡: 3 数组排序API: arr.sort(); 4 原理: 将每个元素都转为字符串，按字符串比较大小 5 问题: 只能按字符串排序。无法按数字排序。 6 解决: 自定义比较器函数: 7 专门比较任意两数大小的函数 8 要求: 2个参数: a,b 9 返回值: 如果a>b，就返回正数 10 a<b,就返回负数 11 a==b,就返回0 12 函数体: return a-b 13 何时: 只要希望按数字排序时，必须自定义比较器函数 14 如何定义: function cmp(a,b){return a-b} 15 如何使用: 将比较器函数作为参数传给sort函数 16 arr.sort(cmp) 17 强调: cmp后不要加()，因为不是立刻执行，而是传入sort函数内，被sort函数反复调用。 18 降序排列: 19 只要颠倒比较器函数的返回值的正负即可 20 比如: function cmp(a,b){return b-a}
8.***栈和队列:
1 Js中没有专门的栈和队列类型。都是用数组模拟的。 2 只不过，控制了使用数组元素的顺序。 3 何时: 只要希望按照特定的顺序使用数组元素时 4 5 栈(stack): 一端封闭，只能从另一端进出的数组 6 特点: FILO 7 如何: 8 结尾出入栈: 9 入栈: arr.push(值) 已入栈的元素下标不改变 10 出栈: var last=arr.pop() 11 开头出入栈: 12 入栈: arr.unshift(值) 已入栈元素的位置 往后顺延 13 强调: 开头入栈的结果和结尾入栈的结果是首尾颠倒的 14 出栈: var first=arr.shift(); 15 16 队列(queue): 只能从一端进入，从另一端出的数组 17 特点: FIFO 18 何时: 只要按照先来后到的顺序使用数组元素时 19 如何: 结尾入: arr.push() 20 开头出:var first= arr.shift()
9.*** 二维数组:
1 什么是: 数组中的元素，又引用另一个子数组 2 何时: 2种: 3 要保存的数据，就是横行竖列的二维数据 4 要对数组中保存的内容，进行更细致的分类时（保存上下级关系的数据） 5 如何: 6 创建: 2种: 7 先创建空数组，再添加子数组 8 创建数组同时，初始化子数组 9 访问: 数组[r][c] 10 二维数组中每个元素的用法和一维数组中每个元素的用法，以及单个变量的用法完全相同。 11 强调: 二维数组中行下标r不能越界列下标c 可以 12 遍历: 外层循环控制行，内层循环控制列 13 for(var r=0;r<arr.length;r++){ 14 for(var c=0;c<arr[r].length;c++){ 15 arr[r][c] //当前元素 16 } 17 } 18 arr.index(值):在arr中找“值”的位置，如果找到返回下标i，否则返回-1 19 ******* 20 1.Length属性： 21 数组是对象：分装了一组数据，并提供了对数据操作方法 22 .length属性：获得数组中的元素个数！=实际中的元素个数 23 何时使用： 24 arr[arr.length-1]: 任意长度数组中的最后一个元素 25 arr[arr.length]：向数组末尾追加一个新元素 26 改小length的值，可删除末尾元素 27 2.关联数组：可以自己定义下标名称的数组 28 如何创建关联数组： 29 Var fbb=[]; 30 Key value—>对儿 31 fbb[“sname”]=”范冰冰”; 32 fbb[“shx”]=91; 33 如何访问关联数组：fbb[“sname”] 34 关联数组中的length属性失效！ 35 关联(hash)数组：下标是不能重复 36 优势：利用hash算法，精确定位某个下标的位置，不用遍历 37 索应数组：下标自动分配，无意义，要按内容查找只能从头开始遍历 38 遍历关联数组： 39 For(var key in arr){ 40 Key，仅得到当前元素的下标 41 arr[key],得到当前元素的值！ 42 } 43 44 3.数组API 45 1.arr to String: 46 var str=arr.toString()?自动，逗号分离 47 var str=arr.join(“连接符”)—>自定义连接符 48 固定套路：1.将字符拼接为单词：arr.join(“”) 49 2.将单词拼接为句子：arr.join(“ “) 50 *优化： 51 问题：频繁字符窜拼接造成内存浪费* 52 解决：先将要拼接的字符串放入数组 最后，arr.join(“”) 53 过程：Var arr=[“a”]; 54 arr[arr.length]=”b”; arr[arr.length]=”c”; 55 1个arr 2个str 1个arr 3个str 56 [“a”,”b”,”c”] arr.join(“”); 57 Var str=“a”; a 58 str+=”b”;//3个 ab b 59 str+=”c”;//5个 abc c 60 2. 拼接和截取：原对象保持不变 61 Var newArr=arr.concat(新值1，另一个数组，新值2…) 62 Var subArr=arr.slice(starti[,endi+1]); 63 第二个参数可省略，若省略表示从start一直取到结尾 64 两个参数都可以取负值，就近使用下标 含头不含尾 65 3.arr.splice():删除 插入 替换 66 4.arr.reverse(); 67 5.专门比较两数字的大小 68 Function compareNum(a,b){return a-b;} 69 专门比较两字符串的大小 70 Function compareStr(a,b){ 71 if(a>b) { return 1; } 72 else if(a=b){return 0;} 73 else if(a<b){return -1} 74 } 75 Function compareStr(a,b){return a>b?1:a<b?-1:0;} 76 Bubble(nums,compareNum);console.log(nums); 77 Bubble(emps,compareStr); console.log(emps);
1 ***函数对象作为参数 2 Js中函数本质是一个对象 3 函数名本质是指向函数对象的变量 4 自定义sort方法的排序 arr.sort（比较器函数） 5 ***String：字符串：多个字符组成的一个只读的集合(数组) 6 凡是数组对象中，不修改原对象的API，字符串都能用！ 7 比如：slice indexof 8 反例：push sort splice 9 内置对象（javacsript）ES标准中已经定义好的，由浏览器厂商已经实现的对象 10 11个：String Number Boolean 11 /Array Date Math RegExp 12 /Error 13 /Function Object 14 /Globel(全局Window) 15 16 ***包装类型：临时封装原始类型数据，提供对原始类型数据的操作方法 17 3种：String Number Boolean(不能new) 18 函数调用完，包装类型自动释放 19 原理: 20 1. 尝试对原始类型的值调用功能时, 引擎会判断值的类型， 21 然后创建对应类型的包装类型对象。 22 2. 包装类型对象中封装要操作的值，并提供各种API 23 3. 用值调用功能其实是调用包装类型的功能 24 4. 功能执行完，包装类型对象自动释放 25 比如: var n=345.678; n.toFixed(2) 26 //new Number(n).toFixed(2) 27 var char=”张”; char.charCodeAt() 28 //new String(char).charCodeAt()
10.****String API:
1 1.大小写转换: 将字符串中的字母统一转为大写或小写 2 何时: 不区分大小写时 3 比如: 用户名，验证码，邮箱地址 4 如何: str.toUpperCase() 转大写 5 str.toLowerCase() 转小写 6 2.获得指定位置的字符: 3种 7 2.str.charAt(i) => str[i] 8 1. str[i] 倒数第二个：str[str.length-2] 9 3.获得指定位置的字符的unicode号: str.charCodeAt(i) 10 4.将unicode号再转回原文: String.fromCharCode(unicode) 11 3.查找关键字的位置：2种： 12 1.Var i=str.indexOf(“kword”[,starti]); 13 2.Var i=str.lastIndexOf(“kword”[,starti]);查找starti左侧第一次出现关键字位置 14 Starti默认等于0 15 16 ***截取子字符串: 17 1.str.slice(starti,endi+1) eg: pid.slice(6,-5+1); 18 2.str.substring(starti,endi+1) 同slice， 19 仅不支持负数参数eg: pid.substring(6,pid.length-5+1); 20 如果知道个数: str.substr(starti,n) 21 22 ***检索关键词: 23 1. 检索一个固定的关键词出现的位置: 24 var i=str.indexOf(“关键词”,fromi) 25 查找str中fromi位置之后的下一个关键词的位置 26 fromi: 指开始查找的位置 27 如果省略，默认从头开始找 28 返回值: 如果找到，返回关键词第一个字的下标位置 29 如果找不到了，返回-1 30 问题: 每次只找一个关键词的位置 31 无法自动找下一个 32 解决: 循环调用indexOf 33 每次都要显式指定开始查找位置为本次找到位置的下一个 34 直到返回-1就退出循环 35 36 查找最后一个关键词的位置: 37 var i=str.lastIndexOf(“关键词”); 38 查找str中最后一个“关键词”的位置 39 问题: 只能查找一个固定的关键词 40 关键词稍微变化，就找不到 41 解决: 正则表达式 42 2.判断是否包含符合规则的关键词——支持正则 43 var i=str.search(/正则/) 44 查找str中第一个符合正则要求的关键词的位置 45 如果找不到，返回-1 46 问题1: 所有正则默认区分大小写 47 解决: 只要在第二个/后加i，表示ignore 48 问题2: 没有第二个参数, 永远只能找第一个 49 问题3: 只能返回位置，无法返回关键词的内容 50 解决: match 51 3.查找所有关键词的内容或个数: 52 var kwords=str.match(/正则/ig); 53 在str中查找所有符合正则要求的关键词 54 返回值: 所有关键词组成的数组 55 如果没找到，返回null！ 56 问题: 所有正则默认只匹配第一个符合条件的关键词 57 解决: 在第二个/后加g, 表示global 58 问题: 只能返回内容，无法返回位置！ 59 4.即查找每个关键词的内容，又查找每个关键词的位置: ? 60 61 替换: 将字符串中找到的所有关键词，替换为指定的新内容 62 包含2种: 63 简单替换: 将所有关键词替换为统一的新值 64 str=str.replace(/正则/ig,”新值”) 65 强调: 字符串是只读数组，所有，所有API都无权直接修改原字符串，只能返回新字符串 66 高级替换: 根据本次找到的关键词不同，动态选择不同的替换值. 67 str=str.replace(/正则/ig,function(kword){ 68 kword //可自动获得本次找到的关键词 69 return 根据kword的不同，动态选择不同替换值 70 }) 71 删除: 将关键词替换为”” 72 73 切割: 将字符串按指定切割符，切成多段子字符串 74 简单切割: 切割符时固定的 75 var substrs=str.split(“切割符”) 76 复杂切割: 切割符不固定 77 var substrs=str.split(/正则/) 78 固定套路: 将字符串打散为字符数组: str.split(“”)
11.***正则表达式：
1 验证字符串格式 2 使用规则模糊查找多种关键词 3 如何: 4 1.最简单的正则表达式，就是关键词本身 5 2.字符集: 6 什么是: 规定一位字符备选字符列表的集合 7 何时: 只要一位字符上有多种备选字时 8 如何:[备选字符列表] 9 强调: 1. []不能随便加逗号和空格 10 2. 一个[]字符集只能限定一位字符的备选范围 11 简写: 当备选字符中部分字符是连续的，可用-省略中间字符: 12 比如: 一位数字[0-9] 13 一位小写字母[a-z] 14 一位大写字母[A-Z] 15 一位字母[A-Za-z] 16 一位汉字[\u4e00-\u9fa5] 17 反选: 选择除了xxx都行: [^xxx] 18 3.预定义字符集: 19 什么是: 对常用字符集的最简化写法 20 包括: 4个: 21 \d 一位数字, 代替[0-9] 22 \w 一位字母,数字或_, 代替[A-Za-z0-9_] 23 \s 一位空字符: 空格，Tab，… … 24 . 一位任意字符（除了换行）——通配符 25 \D,\W,\s-?除了\d,\w或\s--?了解 26 强调: 必须规则和预定义字符集的规则完全匹配时，才能使用预定义字符集。 27 问题: 字符集只能规定一位字符的备选内容无法灵活规定出现次数 28 解决: 量词: 29 4.量词: {min,max}灵活定义一位字符集出现次数的规则 30 何时: 只要规定字符集出现次数 31 如何: 2大类: 32 1.有明确数量边界的:3个 33 字符集{m,n} 至少m次，最多n次 34 字符集{m,} 至少m次，多了不限 35 字符集{m} 必须m次 36 2.没有明确数量边界:3个 37 字符集? 可有可无，最多一次{0.1} 38 字符集* 可有可无，多了不限{0,} 39 字符集+ 至少一次，多了不限{1,} 40 强调: 默认一个量词仅修饰相邻的前一个字符集 41 5.选择和分组: 42 分组: 将多个子规则用()包裹为一组 43 为什么: 默认一个量词只能修饰一个字符集 44 何时: 只要希望一个量词同时修饰多个字符集时 45 选择: “规则1|规则2” |读作或 46 类似于程序中的或者 47 只要匹配任意一个规则即可 48 例：身份证: 1,2,3代 15位数字 2位数字 49 最后一个可能是数字或Xx后三位整体可有可无，最多1次 50 \d{15} (\d{2} [0-9Xx])? 51 例：手机号: +86或0086 整体可有可无，最多一次 52 (\+86|0086)? 53 空字符 可有可无，多了不限 54 \s* 55 1 56 3,4,5,7,8中挑一个 57 [34578] 58 9位数字 59 \d{9} 60 (\+86|0086)? \s*1[34578] \d{9} 61 6.指定匹配位置: 3个位置 62 ^开始位置, 第一个字符之前 63 $结束位置, 最后一个字符之后 64 何时: 只要仅匹配特定位置的值时 65 比如: 匹配空字符: 66 ^\s+ 字符串开头的空字符 67 \s+$ 字符串结尾的空字符 68 ^\s+|\s+$匹配开头或结尾的空字符 69 \b 专指单词边界: 70 ^ $ 空格 标点符号 71 专门选择一个单词之用
12.**RegExp
1 什么是: 封装一条正则表达式，并提供使用正则表达式执行验证和查找的API 2 何时: 2种: 3 1.验证格式 4 2.实现最高级的查找 5 如何: 6 创建: 2种: 7 1.使用直接量: var reg=/正则/ig; 8 何时: 如果正则表达式是固定，无需动态拼接生成 9 因为//之中不支持js表达式 10 字符冲突: //之间出现特殊符号: + /等等，都要转义为\+ \/ 11 2.用new: var reg=new RegExp(“\n \t正则”,”ig”); 12 何时: 如果正则表达式需要动态拼接生成（所有\都要改为\\） 13 字符冲突: \\ 或 “ 都要转义为\\ \” 14 正则API: 2个: 15 1.验证格式: var bool=reg.test(str) 16 验证：str是否符合reg的正则规则（要求从头到尾必须完全匹配） 17 符合返回true，不符合返回false 18 问题:（test方法默认只要找到部分匹配，就算验证通过。 19 解决: 凡是验证必须前加^后加$ 20 ^表示开头位置的xxxx,$表示结尾位置的xxxx 21 ^和$联用表示从头到尾必须完整匹配 22 23 密码强度要求：6-8位，只能是字母、数字的组合 24 至少包含一位大写字母至少包含一位数字 25 预判(?)：1.不全由小写字母或数字组成，可能包含大写或符号 26 （?! [a-z0-9]*$） 27 2. 不全由大写或小写字母组成，可能包含数字或符号 28 (?![a-zA-Z]*$) 29 正式规则：只能是字母数字的组合—>屏蔽了符号 30 [a-zA-Z0-9]{6} 31 补齐第四种查找关键词的方式:（即查找内容，又查找位置:） 32 var arr=reg.exec(str) 33 在str中查找下一个符合reg规则的关键词的内容和位置. 34 强调: 每次只找一个 35 返回值: 36 如果找到:arr:[0: 关键词内容, index: 关键词位置] 37 没找到: 返回null 38 如何查找所有: 39 仅循环调用即可！直到返回null为止 40 不用指定开始查找位置，就可自动找下一个 41 42 总结：查找关键字： 43 1.var i=str.search(reg)?判断有没有 44 缺点：不能指定开始位置 45 2.var arr=str.match(reg)?获得所有关键字内容，个数 46 缺点：不能返回位置 47 3.var i=str.indexOf(“kword”[,starti])?从指定位置开始，查找下一个关键字的位置 48 缺点：不支持正则 49 4.var arr=reg.exec(str)?即获得内容，又获得位置 50 缺点：复杂 51 52 正则：贪婪模式与懒惰模式 53 默认贪婪模式：默认总是匹配最长的符合条件的字符串 54 原因：.*或.+等引起 55 懒惰模式：仅匹配最短的符合条件的字符串 56 贪婪-->懒惰：(.*?) 57 从正则表达式中获得子内容：2步 58 1.正则表达式：用（）包括要获取子内容的部分 59 2.程序中，本次查找后：RegExp.$n-->n：第几个圆括号 60 取本次匹配结果中第N个()匹配的子内容，正则中n从1开始
1 ***String中的模式匹配API：4个 2 2个查找：str.search(reg);str.match(reg); 3 1个替换：str.replace(reg); 4 1个切割： 5 1. ***String中的正则API： 6 1.替换：str.replace(reg,"替换值") 7 固定套路：利用replace格式化数据 8 “替换值中，也可用$n,和RegExp.$n的用法完全相同 9 2.切割：var arr=str.split(reg); 10 11 2.*Math 专门执行数学计算的对象 12 封装了数学计算中常用的常量 13 1.取整：3种：上取整 下取整 四舍五入取整 14 Math.ceil(n) Math.floor(n) Math.round(n) 15 对比： round VS toFixed 16 Math对象 Number对象 17 只能取整 按任意小数位数（参数0~20之间） 18 返回数字 返回字符串 19 2.乘方、开平方： 20 乘方：Math.pow(n,m):计算n的m次方 21 开平方：Math.sqrt(n)：计算n的平方根 22 3.获取最大值最小值： 23 getMax（a,b） 24 Math.max(a,b,c...) Math.min(a,b,c...) 25 ***固定套路：变相实现获取数组中最大值 26 Math.max.apply(Math,arr)；--》Math.max(arr[0],...) 27 4.随机数：Math.random();0<=n<1 28 任意min到max之间去一个随机整数 29 parseInt(Math.random()*(max-min+1)+min) 30 31 3.*Date：封装了一个时间点，提供对时间日期的操作API 32 创建Date对象： 33 1.var now=new Date()；//创建一个新日期对象同时，保存了*客户端*当前时间点的毫秒数。--获得当前时间 34 2.var time=new Date（"xxxx/xx/xx [xx:xx:xx]"） 35 3.var time new Date（年，月-1，日[，时，分，秒]） 36 date.getTime()：获得日期对象中的毫秒数 37 38 Date API 39 1.每个分量都有一对儿get set方法 40 getDay（）获得星期，没有setDay 41 2.命名：年月日星期，不加s，时分秒毫秒，加s 42 3.返回值：月中的日取值范围从1开始到31结束 43 其余都是从0开始到减1结束 44 星期：日 一 二 六 45 0 1 2 6 46 月份：1月 2月 11月 12月 47 0 1 10 11 48 Date计算：2中 49 1.两日期对象可直接相减，结果毫秒差 50 2.对任意分量做加减：先get出来-》计算-》再set回去*直接修改原日期对象* 51 date.set(date.getXXX()+-n) 52 53 补：创建日期对象第四种：复制日期对象 54 var date1=new Date(); 55 var date2=new Date(date1.getTime()); 56 //new Date(毫秒数) 57 date2.setXXX(date2.getXXX()+-n)
1.*错误/异常处理
1 what：导致程序无法继续执行的异常状态 2 js中一旦发生错误，就会自动创建一个error类型对象 3 6种： 4 SyntaxError：语法错误 5 ReferenceError：引用错误，找不到变量或对象 6 TypeError：类型错误，错误的使用了对象中的方法时 7 RangeErroe:范围错误，参数超范围 8 EVA了Error：调用eval函数出错 9 URLError：URL错误 10 错误处理：在程序发生错误时，保证程序不退出或正常退出 11 如何错误处理 12 语法：tryCatch: 13 try{ 14 可能出错的代码段 15 }catch(err){//仅在发生错误时才执行 16 //一旦发生错err中就会自动存入Error对象 17 1.记录/显示错误的信息 18 2.继续向调用者抛出异常 19 }[finally{ 20 无论对错一定都会执行的代码段 21 释放资源 22 }] 23 建议：尽量优先使用if…else语句代替tryCatch块，已知的 24 try catch：解决浏览器兼容问题
2.***Function 对象
1 js中一切都是对象 2 连函数也是对象 3 函数名其实是引用函数定义 4 5 ************************************************************************** 6 7 1.*arguments对象： 8 重载：程序中可定义多个相同函数名，不同参数列表的函数调用者不必区分每个函数的参数，执行时，程序根据传入的参数个数，自动判断选择哪个函数执行。 9 10 js语法不支持重载！但可用arguments对象模拟重载效果 11 arguments对象：函数对象内，自动创建的专门接收所有参数值的类数组对象。 12 arguments[i]:获得传入的下标为i的参数值 13 arguments.length:获得传入的参数个数 14 15 即使定义了参数变量，arguments对象同样会收到所有参数值 16 17 2.****函数对象本质： 18 1.创建函数对象：3种： 19 1.声明方式：function 函数名（参数）{ 20 函数体； 21 return 返回值} 22 函数名和函数定义都被提前 23 在调用前后位置定义都行 24 2.函数直接量：var 函数名=function（参数）{ 25 函数体； 26 return 返回值} 27 仅函数名变量声明会提前，函数定义留在本地 28 必须定义在调用前! 29 3.使用new创建函数类型对象： 30 var 函数名=new function（"a","b",...,"函数体"）； 31 2.***内存中的函数对象*** 32 创建函数对象时：同时创建2个对象： 33 函数对象：函数的定义 34 作用域链对象：保存了函数对象可用的变量位置 35 默认第一项指向window对象 36 调用函数时：又会创建一个新对象： 37 活动对象：专门保存局部变量的对象 38 在作用域链对象中追加指向活动对象的引用 39 调用后：默认仅释放活动对象 40 作用域链对象中活动对象的引用出栈 41 3.***匿名函数：定义时，不能指定函数名的函数 42 何时使用：2大用途： 43 1.匿名函数自调时：定义完，立刻执行 执行完立刻释放 44 何时使用：只有确定函数只执行一次时！ 45 如何自调：（function（参数）{ 46 函数体 47 }）（参数值）； 48 2.匿名函数回调：先将函数作为对象传递给另一个函数， 49 由另一个函数自主决定在需要时调用 50 何时使用：只要将一个函数对象传递给其他方法调用时 51 如何回调：直接将匿名函数的声明传入另一函数中 52 4.****闭包： 53 问题：局部变量的全局变量的缺陷 54 全局变量：容易全局污染 55 局部变量：无法共享不能长久保存 56 57 既可以共享，长久保存，又不会全局污染---闭包 58 解决：3步：闭包3特点： 59 1.定义外层函数：封装被保存的局部变量 60 2.定义内层函数，执行对外层函数局部变量的操作 61 3.外层函数返回内层函数的对象 62 并且外层函数被调用，结果被保存在全局变量中 63 64 何时使用：既反复使用局部变量，又避免全部污染--->闭包（保护局部变量，占内存） 65 判断闭包3特点： 66 1.嵌套函数 67 2.内层函数操作了外层函数的局部变量 68 3.外层函数将内层函数返回到外部，被全局变量保存住 69 70 判断闭包执行结果： 71 1.外层函数被调用几次，就有几个受保护的局部变量的副本 72 2.反复调用来自一个闭包的函数，受保护的局部变量就变化几次
1 1.面向对象： 2 在程序中都是用一个对象来描述现实中的一个具体的东西。 3 对象：封装多个数据的存储空间 4 自定义对象：封装现实中一个东西的属性和功能的存储空间。 5 现实中东西的属性会成为对象中的属性变量 6 现实中东西的功能，会成为对象中的方法（函数） 7 1.创建自定义对象 8 3种： 9 1.var obj={'属性名1':值1，'属性名2':值2，'功能名':function(){...}} 10 js中一切都是对象！所有对象的底层都是hash数组 11 12 属性：2种：obj.属性名 obj["属性名"] 13 访问对象中不存在的属性 14 （访问数组中不存在的下标）：不会出错，返回undefined强行给不存在的属性赋值，不报错！js会自动创建同名属性 15 16 如何判断某个对象是否包含指定成员：3种 17 1.obj.hasOwnProperty("成员名") 18 如果找到，返回true，否则返回false！ 19 20 方法：如何在方法中，访问当前对象自己： 21 ****this关键字：运行时，指代正在*调用*方法的对象 22 （.前的对象） 23 this本质是window下唯一的指针，指向当前正在调用方法的对象
1 2.****继承 2 面向对象三大特点：封装 继承 多态 3 封装：将描述同一个东西的属性和方法，定义在一个对象中 4 继承：父对象中的属性和方法，子对象可以直接使用 5 多态：同一个对象，在不同情况下，呈现不同的状态 6 重载：同一方法名，传入参数不同，执行不同的操作 7 重写：子对象觉得父对象的成员不好用，可自己定义一个，覆盖子对象 8 创建对象：3中： 9 1.var obj={"属性名":值， 10 ……， 11 "方法名":function(){…this.属性…} 12 } 13 2.var obj=new Object();//创建一个空对象 14 obj.属性名=值； 15 obj.方法名=function(){…this.属性名…} 16 17 3.利用构造函数*反复*批量*创建相同结构的对象 18 构造函数：描述一类对象结构的特殊函数 19 2步： 20 1.定义构造函数 21 function 构造函数|类型名（属性参数1，……）{ 22 this.属性名=属性参数1； 23 ... 24 this.方法名=function(){...this.属性名...} 25 } 26 2.利用构造函数创建对象 27 var obj=new 构造函数|类型名（属性值1，...）; 28 new:1.创建一个空对象：new obj={ }； 29 2.用空对象，调用构造函数 30 构造函数在空对象中添加属性和方法 31 3.设置新对象的_proto_指向构造函数的prototype 32 4.返回新对象的地址 33 34 继承：js中一切继承都是用原型对象实现的！ 35 原型对象（prototype）：每个函数对象都有一个原型对象 36 构造函数的原型对象负责保存所有子对象共享的成员！ 37 ---避免重复定义方法对象，浪费内存。 38 说明：其实所有内置类型的API都是定义在类型.prototype 39 40 41 扩展对象：2种： 42 1.扩展共有属性：通过构造函数.prototype添加的属性 43 2.扩展自有属性：通过某一个具体子对象添加的属性 44 判断自有属性或共有属性： 45 1.自有属性：obj.hasOwnProperty("属性名") 46 2.共有属性："属性名"in obj&&!obj.hasOwnProperty("属性名") 47 在原关系中包含 且 子对象没有 48 49 删除属性：delete对象.属性名 50 *仅能删除当前对象自己的属性，无法删除共有属性 51 全局变量：3种： 52 var n=1; | window.n=1 | window["n"]=1 53 不能delete 不能delete 可被delete 54 55 原型链：由各级对象的_proto_逐级继承形成的关系 56 获得任意对象的父级原型对象： 57 Object.getPropertyOf(子对象) 58 ==>子对象._proto_ 59 60 61 检查对象的父对象：父对象.isPrototypeOf(子对象)
1 3.原形，原型链，继承： 2 原型：保存所有子对象共有属性和方法的对象！ 3 所有函数都有prototype，指向自己的原型对象 4 所有对象都有_proto_，指向自己父级原型对象 5 所有原型对象都有constructor，指回原型对应的构造函数 6 7 原型链：所有父子级对象间由_proto_形成的多级引用关系-->*多级*继承 8 9 原型相关API： 10 1.判断自有属性和共有属性： 11 1.自有：obj.hasOwnProperty("属性名")； 12 2.判断原型链上的属性：2种： 13 判断不包含：if(!("属性"in obj)) 14 if(obj.属性名==undefined) 15 if(!obj.属性名) 16 3.仅判断共有：必须满足两个条件 17 ！obj.hasOwnProperty("属性名") 18 && 19 obj.属性名 20 2.获得任意对象的原型： 21 obj._proto_ X 22 onject.getPropertyOf(obj) 23 3.判断父对象是否在子对象的原型链上 24 父对象.isPrototypeOf(子对象)
1 ***检测一个对象是不是数组类型：4种 2 1.Array.prototype.isPrototypeOf(obj); 3 2.obj instanceof Array 4 对象 是不是 构造函数 的实例 5 3.obj.constructor==Array仅判断直接父级 6 4.利用当前对象，强行调用原始的toString方法 7 Object.prototype.toString.call(obj)=="[object Array]" 8 .apply(obj) 9 10 继承：代码重用！ 11 1.直接继承对象：想法设法修改对象的_proto_ 12 3种： 13 1.仅修改一个对象的_proto_ 14 Object.setPrototypeOf(子对象，父对象) 15 2.通过修改构造函数的原型对象，实现批量修改后续子对象的继承关系。 16 构造函数.prototype=父对象 17 强调：仅影响之后创建的对象的继承关系 18 3.var obj=Object.create(父对象[,{属性列表}]) 19 创建一个空对象 20 继承父对象中的属性 21 继承同时可再扩展属性和方法 22 2.仅继承结构 23 function 父类型构造函数（属性参数1，属性参数2）{ 24 this.属性1=属性参数1； 25 this.属性2=属性参数2； 26 } 27 function 子类型构造函数（属性参数1，属性参数2，属性参数3）{ 28 父类型构造函数.call(this,属性参数1，属性参数2)； 29 this.属性3=属性参数3； 30 } 31 var obj=new 子类型构造函数（值1，值2，值3）{ 32 33 }