第一天:
1、正则表达式:
(1)最简单的正则:/关键字原文/后缀 (后缀:g:找全部 i:忽略大小写)
(2)备选字符集:/^[备选字符集]$/
[]中括号只管一个字符,正则表达式默认只要满足就不管后续,因此从头到尾完全匹配需加前加^ 后加$
(3)预定义字符集:
一位数字:\d === [0-9]
一位字母、数字、下划线:\w === [0-9A-Za-z_]
一位数字:\s === 空格、制表符、换行
(4)量词:
①有明确的数量:
{n,m} 前边相邻的字符集,至少n个,最多m个
字符集:{n,} 前边相邻的字符集,至少n个,多了不限制
字符集:{n} 前边相邻的字符集,必须有n个
②没有明确的数量:
?:前面相邻的字符集,可有可无,最多1个
*:前面相邻的字符集,可有可无,多了不限
+:前面相邻的字符集:至少1个,多了不限
(5)选择和分组
①选择:在两个规则中选一个
规则1|规则2
②分组:
(规则1|规则2)
(6)密码强度:4位密码,数字和字母的组合,至少出现1位数字或1位字母
/^[0-9A-Za-z]$/
预判公式:/(?![0-9a-z]+$)(?![A-Za-z]+$)[0-9A-Za-z]{4}/
2、支持正则表达式字符串的API
(1)切割:var arr = str.split(reg);
(2)替换:
①基本替换法:var newStr = str.replace(/正则表达式/后缀,"新内容");
②高级替换法:var newStr = str.replace(/正则表达式/后缀 ,function{
//a:代表正则匹配到的当前的关键字
return a.length = = 2 ? "**" : "***" ;
});
③格式化:var id= "500112199909093798" ;
var reg = /\d{6}\d{4}\d{2}\d{2}\d{4}/ ;
id = ( reg,function(a , b ,c){
replace的时候正则出现了分组,会得到更多的形参,在形参a的后面会出现那个形参,看有多少个分组,第一个分组获得的内容将会保存在第二个形参中,第二个分组获得的参数内容会保存到第三个形参中。。。。。。
return b+"年"+c+"月"+d+"日";
})
3、正则对象:
创建:
①直接量方法:var reg = /正则表达式/后缀;
②构造函数方式: var reg = new RegExp("正则表达式","后缀");
API: var bool = reg.test(用户输入的内容);
true->验证成功
false ->验证失败
第二天:
1、Math对象
属性:Math.PI === 3.1415926
API:
(1)取整:3种
① 上取整:超过一点点就取下一个整数
var num = Math.ceil (num); //小数位数不能超过15位
②下取整:无论超过多少,都会省略掉小数部分
var num = Math.floor(num);
③四舍五入取整:
var num = Math.round(num);
取整的方法还有parseInt(str可去掉单位)、num.toFixed(d) //d:小数位数
num.toFixed(d):
优点:可四舍五入保留指定小数位数
缺点:结果是一个字符串,搭配parseInt使用
(2)乘方和开方
①乘方:Math.pow(底数,幂);
②开方:Math.sqrt(num); 只能开平方
(3)最大值和最小值:
var 最大的/最小的 = Math.max/min(a,b,c...);
问题:本身不支持数组参数
解决:固定用法
var 最大的/最小的 = Math.max/min.apply(Math.arr);
apply的作用:可以将数组打散成单个元素
(4)绝对值:var num = Math.abs(num);
(5)随机数:Math.random();
parseInt(Math.random()*(max-min+1)+min);
2、Date日期对象
创建:4种方法
(1)创建一个当前日期:
var new = 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);
(4)复制一个日期:(日期所有的API都是直接修改原日期的,无法获取到修改之前的日期)
var star = new Date();
var end = new Date(star);
操作:
1、两个日期对象之间可以相减,得到一个毫秒差,换算出自己想要的某一部分 - 日期的本质其实就是保存的一个毫秒数
创建的最后一个方式:var date=new Date(毫秒数);
2、API:
分量:时间的单位 年日月星期:FullYear Month Date Day
时分秒毫秒:Hours Minutes Seconds Milliseconds
每一个分量都有一堆getXXX/setXXX
特殊:
①取值范围:
FullYear:当前年份的数字
*Month:0~11
Date:1~31
*Day:0~6
Hours:0~23
Minutes,Seconds:0~59
②Day,没有set方法
3、如果希望对某个分量进行加减计算 :date.setXXX(date.getXXX()+/-n)
4、格式化日期为字符串:
date.toLocaleString();//本地日期格式
第三天:
1、Error对象 - 错误
(1)浏览器自带4种错误类型:可以快速找到自己的错误
语法错误:SyntaxError - 语法符号写错
引用错误:ReferenceError - 没有创建就直接使用了
类型错误:TypeError - 使用了不是自身的方法
范围错误:RangeError - 只有一个API会碰到:num.toFixed(d);//d取值范围的
(2)只要发生错误,就会报错,会导致后续代码终止,
错误处理:就算发生错误,我们也不希望报错,而是给一个错误的提示,后续代码可以继续执行
语法:
try{
只放入你可能出错的代码
}catch(err){
发生错误后才会执行
console.log(err);//err就是我们的错误提示,英文
console.log("中文错误提示");
}
可以用一个技术代替:if...else...
(3)抛出自定义错误
throw new Error("自定义错误信息") - 只要是报错都会卡主后续代码
2、Function对象:
(1)创建:3种
①声明:function 函数名(形参,...){函数体;return 返回值;}
②直接量:var 函数名=function(形参,...){函数体;return 返回值;}
③构造函数:var 函数名=new Function("形参1","形参2",...,"函数体;return 返回值;");
(2)调用时,如果有return,记得接住 var result=函数名(实参,...)
(3)考点:
①重载:相同的函数名,传入不同的实参,可以自动选择对应的函数执行操作
问题:js的语法不支持重载! js不允许多个同名函数同时存在,如果同时存在,最后的会覆盖之前的所有
解决:在【函数中】有一个对象 - arguments对象:只能在函数中使用,自动创建,是一个类数组对象(类似数组)
作用:可以接收所有传入的实参
(4)匿名函数:没有名字的函数
①匿名函数自调:
语法:(function(){
//以后可以代替全局代码写法,尽量不要再外部再去书写JS(不用担心事件会被释放掉)
})();
②匿名函数回调:将函数作为实参,传递给其他函数调用
学习回调的目的:知道哪些叫做回调:只要不是自调,就是回调
arr.sort(function(){}) str.replace(reg,function(){}) btn.οnclick=function(){}
第四天:
1、Function
作用域:2种
1、全局:随处可用,可以反复使用,缺点:容易被污染
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自动释放,局部变量也就自动释放了
两链一包:
作用域链:以函数的EC的scope chain属性为起点,经过AO,逐级引用,形成的一个链式结构
作用:查找变量,带来变量的使用规则
1、闭包:希望保护一个可以【反复使用的局部变量】的一种词法结构 - 其实还是一个函数,写法和以前不同
何时使用:希望保护一个可以【反复使用的局部变量】的时候
如何使用:
1、两个函数进行嵌套
2、外层函数创建出受保护的变量
3、外层函数return出内层函数
4、内层函数要去操作受保护的变量
强调:
1、判断是不是闭包,有没有两个函数嵌套,返回内层函数,内层函数在操作受保护的变量
2、外层函数调用了几次,就创建了几个闭包,受保护的变量就有了几个副本
3、同一次外层函数调用,返回的内层函数,都是在操作同一个受保护的变量
缺点:受保护的变量,永远都不会被释放,使用过多,内存泄漏 - 不可多用
问题:应该在哪里用呢?
1、三个事件需要防抖节流
1、elem.onmousemove - 鼠标移动事件
2、input.oninput - 每次输入/改变就会触发
3、window.onresize - 每次窗口的大小发生变化就会触发
防抖节流公式:
elem.on需要防抖节流的事件=function(){
fdjl();//内层函数只要一旦移动就会触发
}
function f1(){
var timer=null;//3
return function(){//
if(timer){clearTimeout(timer);timer=null;}
timer=setTimeout(function(){
//操作
},1000)
}
}
var fdjl=f1();
------------------------------------------------------------------------------------------------------------------------------
2、Object:对象 - Array/String/RegExp...对象具有属性和方法,都是预定义好的,现在我们可以学习自定义对象
面向对象:三大特点:封装、继承、多态
1、开发方式:面向对象 和 面向过程?
面向过程:经过 - 开始->结束,我们一直的开发方式都是面向过程,先干什么在干什么最后干什么
面向对象:对象(属性和方法),js有一句话万物皆对象,假设一个人是一个对象的话:
2、封装:创建自定义对象:3种方法
1、直接量方式:var obj={
"属性名":属性值,
...
"方法名":function(){},
...
}
强调:1、其实属性名和方法名的""可以不加 - 暂时建议你加上
2、访问对象的属性和方法
*obj.属性名 === obj["属性名"]
*obj.方法名() === obj["方法名"]();
建议使用.去访问属性和方法,更简单
***JS中一切都是对象,一切对象的底层都是hash数组
3、访问到不存在的属性,返回undefined
4、可以随时随地的添加新属性和新方法
5、如果我希望遍历出对象所有的东西,使用for in,obj[i]才能拿到,不要用.会出问题
6、***如果你希望在对象的方法里使用对象自己的属性:写为this.属性名
*****难点:this的指向:
1、单个元素绑定事件:this->单个元素
2、多个元素绑定事件:this->当前触发的元素
3、函数中使用this,this->谁在调用此方法,this指的就是谁
4、定时器中this->window
2、预定义构造函数方式:var obj=new Object();//空对象
//需要自己后续慢慢追加属性和方法
obj.属性名=属性值
obj.方法名=function(){}
以上两个方法都有一个缺陷:一次只能创建一个对象,适合创建单个对象的时候(第一种方法),第二种方法永远不远
3、自定义构造函数方法:2步
1、创建自定义构造函数
function 类名(name,age,salary){
this.name=name;
this.age=age;
this.salary=salary;
}
//千万不要在里面创建方法,每个对象都会创建一个方法,浪费内存 - 明天,继承将统一的方法放到原型上
2、调用构造函数创建出对象
var obj=new 类名(实参1,...)
第五天:
1、*****Object:
1、*****继承:父对象的成员(属性和方法),子对象可以直接使用
为什么:代码重用!节约内存空间!提升网站性能!
何时继承:只要多个子对象公用的属性和【方法】,都要集中定义在父对象中
2、***如何找到父对象(原型对象):保存一类子对象共有属性和共有方法的父对象
1、对象名.__proto__;//必须先有一个对象
2、构造函数名.prototype;//构造函数名,几乎人人都有,除了Math
3、*面试题:两链一包:作用域链、原型链、闭包
每个对象都有一个属性:__proto__,可以一层一层的找到每个人的父亲,形参的一条链式结构,就称之为叫做原型链
可以找到所有父对象的成员(属性和方法),作用:找共有属性和共有方法的
最顶层是Object的原型,上面放着我们一个眼熟的toString,怪不得人人都可以用到toString();
JS万物皆对象
4、有了原型对象,设置共有的属性和方法:
1、原型对象.属性名=属性值;//添加了一个共有属性
2、原型对象.方法名=function(){};//添加了一个共有方法
***继承具有非常多的鄙视题:
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("没有")
}
}
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;
}
}
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不支持,此方法只有数组
4、输出【对象的字符串】形式
在Object的原型上保存着最原始的toString方法
原始的toString输出形式:[object 构造函数名]
***多态:子对象觉得父对象的成员不好,在本地定义了同名成员,覆盖了父对象的成员
固定套路:借用:Object.prototype.toString.apply(x);
if(Object.prototype.toString.apply(arr)=="[object Array]"){
console.log("是数组")
}else{
console.log("不是数组")
}
5、实现自定义继承:
1、两个对象之间设置继承:
子对象.__proto__=父对象
2、多个对象之间设置继承:
构造函数名.prototype=父对象
时机:应该在开始创建对象之前设置好继承关系