day0401

day0401

正则表达式

正则表达式（regular expression）

是描述字符模式的对象。

对字符串执行模式匹配

RegExp 对象

RegExp：是正则表达式（regular expression）的简写。

语法

var patt=new RegExp(pattern,modifiers);//构造函数

var patt=/pattern/modifiers;//字面量

pattern（模式）

modifiers(修饰符)

修饰符

修饰符用于执行区分大小写和全局匹配:

方括号

方括号用于查找某个范围内的字符：

群组

用处：

1.条件约束

实现手机号中间四位隐藏

var str = "18615741351";
// $1 就是第一个（）内的内容 群组内容
// $2 就是第二个（）内的内容 群组内容
// $3 就是第三个（）内的内容 群组内容
str1=str.replace(/(\d{3})(\d{4})(\d{4})/,"$1****$3")
console.log(str,str1);

replace（）方法参数为函数时：

stringObject.replace(regexp/substr,replacement)

ECMAScript v3 规定，replace() 方法的参数 replacement 可以是函数而不是字符串。在这种情况下，每个匹配都调用该函数，它返回的字符串将作为替换文本使用。该函数的第一个参数是匹配模式的字符串。接下来的参数是与模式中的子表达式匹配的字符串，可以有 0 个或多个这样的参数。接下来的参数是一个整数，声明了匹配在 stringObject 中出现的位置。最后一个参数是 stringObject 本身。

var str = "abc18615741351";
str1=str.replace(/(\d{3})(\d{4})(\d{4})/,function(a,b,c,d,e,f){
        return [a,b,c,d,e,f];
})
console.log(str);
console.log(str1);

2.重复选择

3.断言（环顾）

验证密码是否符合规范（非数字开头，由大小写字母数字特殊字符构成，无中文字符）

console.log(/^(?=\D+\d)(?=.*[a-z])(?=.*[A-Z])(?=.*\W)[\u0000-\u007F]{8,16}$/.test("A1123aA!"));

4.match
当match不使用g修饰符时，可以将（）中内容单独再找一个出来

元字符

元字符（Metacharacter）是拥有特殊含义的字符：

量词

起止符：

^起始 $结束

断言（环视/环顾）

console.log("abacadaa".match(/a(?=c)/));

叫法可能不一样

环视是指在某个位置向左/向右看，保证其左/右位置必须出现某类字符（包括单词字符\w和非单词字符\W），且环视也同上两个断言，只是做一个判断（匹配一个位置，本身不匹配任何字符，但又比上两个断言灵活）。也有人称环视为零宽断言。

字符从左向右打，从时间顺序分向前（未来）向后（过去）？

按照从左到右的扫描为前

前瞻断言：

瞻未来的字符

a在前，括号放a后面，匹配a后面的

var str1= "abacad".replace(/a(?=c)/g,"0");//肯定顺序环视（正向先行断言）
var str2= "abacad".replace(/a(?!c)/g,"0");//否定顺序环视（负向先行断言）
console.log(str1,str2);

后瞻断言：

瞻过去的字符

a在后，括号放a前面，匹配a前面的

var str3= "badaca".replace(/(?<=d)a/g,"0");//肯定逆序环视（正向后行断言）
var str4= "badaca".replace(/(?<!d)a/g,"0");//否定逆序环视（负向后行断言）
console.log(str3,str4);

环视分为四种：

肯定顺序环视（正向先行断言）positive lookahead: （?=pattern)
否定顺序环视（负向先行断言）negative lookahead: （?!pattern)
肯定逆序环视（正向后行断言）positive lookbehind: （?<=pattern)
否定逆序环视（负向后行断言）negative lookbehind: （?<=pattern)

RegExp对象属性

RegExp对象方法

compile() 方法

compile() 方法用于在脚本执行过程中编译正则表达式。

compile() 方法也可用于改变和重新编译正则表达式。

语法：

RegExpObject.compile(regexp,modifier)

exec() 方法

exec() 方法用于检索字符串中的正则表达式的匹配。

如果字符串中有匹配的值返回该匹配值，否则返回 null。

语法：

RegExpObject.exec(string)

test() 方法

test() 方法用于检测一个字符串是否匹配某个模式.

如果字符串中有匹配的值返回 true ，否则返回 false。

语法：

RegExpObject.test(string)

toString() 方法

toString() 方法返回正则表达式的字符串值。

语法：

RegExpObject.toString()

支持正则表达式的 String 对象的方法

match不可加g
replace可加g

search() 方法

search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。

如果没有找到任何匹配的子串，则返回 -1。

语法：

string.search(searchvalue)

match() 方法

match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。

语法：

string.match(regexp)

当match不使用g修饰符时，可以将（）中内容单独再找一个出来

replace() 方法

replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

语法：

string.replace(searchvalue,newvalue)

split() 方法

split() 方法用于把一个字符串分割成字符串数组。

语法：

string.split(separator,limit)

中文匹配

\u4e00到\u9fa5

ES6

历史

严格模式

<script>
        "use strict";//声明为严格模式
        
		//再书写代码内容
</script>

或者声明type为模块，自动变为严格模式

<script type="module">
	//再书写代码内容
</script>

变量必须定义后使用

不能出现相同参数名

不能使用with(比对堆中的，功耗太大）

不能对只读属性赋值
如str.lenth,get,set

Object.defineProperty(obj,"a",{writable:false,value:"a"});

不能使用八进制

不能删除不可删除的属性
如arr.length

 Object.defineProperty(obj,"a",{configurable:false,value:"a"});

不能使用eval（）效率极低
eval 可以将字符串映射为一个js对象，变量，属性，函数等等

不使用
arguments.callee
arguments.callee.caller

let

let 定义全局变量不会放在window属性中
let定义后不能重复定义，避免变量覆盖
let 定义的变量只能在块语句（花括号）中有效

const

箭头函数

箭头函数是一个匿名函数

var fn=(a,b)=>{
    var s=a+b;
    return s;
 }

箭头函数中如果参数仅有一个，可以省略()，如果没有参数或者一个以上都必须要加()

在箭头函数中，如果语句块仅有一句，并且这句话使用return返回内容，我们可以去除｛｝和return关键词

var fn=a=>a+1;

//相当于
var fn=function(a){
    return a+1;
}

箭头函数中的this将会是箭头函数外上下文环境的this指向

var obj = {
  a: 1,
  b: function () {
    console.log(this.a);
  },
  c: () => {
    console.log(this.a);
  },
};

obj.b();
obj.c();

箭头函数最大特征是改变this的执行为当前箭头函数外上下文的this

var o = {
  a: 10,
  b1: function () {
    console.log(this.a,"o对象");
    var obj = {
      a: 1,
      b: function () {
        console.log(this.a,"obj对象");
      },
      c: () => {
        console.log(this.a,"o对象");
      },
    };
    obj.b();
    obj.c();
  },
};

o.b1();

所有回调函数中this都会被重新指向为window

解构赋值

var arr=[1,2,3,4];
var [a,b,c,d]=arr;
console.log(a,b,c,d);

变量交换

var a=3;
var b=4;
[b,a]=[a,b];
//相当于
// var arr=[a,b];
// [b,a]=arr;
console.log(a,b);

数组解构按照顺序解构

var [a,b,[c,d,[e]]]=[1,2,[3,4,[5]]];
console.log(a,b,c,d,e);

对象解构是按照key解构

var obj={
    a:1,
    b:2,
    c:3
};
var {a,b,c}=obj;
console.log(a,b,c);

对象中的方法使用this，这个方法解构出来执行可能会出错，因为this指向发生了改变

对象解构中如果key名称同名，则可以使用:别名的方式另外命名

var {a,b,c:{a:a1,b:b1}}={a:1,b:2,c:{a:3,b:4}}
console.log(a,b,a1,b1);

普通函数中传参，有默认值的参数一般写在必填后
普通函数中实参的顺序必须和形参的顺序一致

参数为对象

function fn1({a,b=3,c=5,d}){
    console.log(a,b,c,d);
}
fn1({a:1,b:3});


function fn2({a,b,c,d}={a:1,b:2,c:3,d:4}){
    console.log(a,b,c,d);
}
fn2({a:10,c:20});

function fn3(a,c,b=3){
   console.log(a,b,c,);
}
fn3(3,4)