item *2)//[2,4]
```
注意：如果是对象，那么属性需要写对应的索引
实例方法：find()
用于找出**第一个**符合条件的数组成员，如果没有找到返回**undefined**
```js
let ary = [{
id: 1,
name: '张三'
}, {
id: 2,
name: '李四'
}];
let target = ary.find((item, index) => item.id == 2);//找数组里面符合条件的值，当数组中元素id等于2的查找出来，注意，只会匹配第一个
```
实例方法：findIndex()
用于找出**第一个**符合条件的数组成员的**位置**，如果没有找到返回\*\*-1\*\*
```js
let ary = [1, 5, 10, 15];
let index = ary.findIndex((value, index) => value > 9);
console.log(index); // 2
```
实例方法：includes()
判断某个数组**是否包含**给定的值，返回**布尔值**。
```js
[1, 2, 3].includes(2) // true
[1, 2, 3].includes(4) // false
```
### 获取对象的属性名
Object.keys(对象) 获取到当前对象中的属性名 ，返回值是一个**数组**
```js
var obj = {
id: 1,
pname: '小米',
price: 1999,
num: 2000
};
var result = Object.keys(obj)
console.log(result) //[id，pname,price,num]
```
## 字符串对象
字符串的不可变性
指的是里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间
避免大量拼接字符串！
根据字符返回索引及发现次数
```js
function lookup_element(str){
var s=prompt('输入要查找的字符');
var count=0;
var index=str.indexOf(s);
while(index !== -1){
console.log(index);
count++;
index=str.indexOf(s,index+1);
}
console.log('0出现的次数：'+count);
}
```
根据位置返回字符
```js
var str = new String('html');
console.log(str.length); // 字符长度
console.log(str.charAt(2)); // 返回指定位置的字符 参数为下标
console.log(str.charCodeAt(2)); // 返回指定字符的unicode编码 参数下标
console.log(str.concat('123456')); // 连接字符串
console.log(str.slice(1, 3)); // 根据下标 返回字符串 包含前一个下标，不包含后一个下标
console.log(str.substring(1, 3)); // 返回两个索引号之间的字符 包含前一个下标，不包含后一个下标
console.log(str.substr(1, 1)); // 从第一个参数开始截取，后一个参数为要截取的长度
console.log(str.indexOf('t')); // (从前往后)根据字符找到下标，未找到返回-1
console.log(str.lastIndexOf('r')); // (从后往前)根据字符找到下标，未找到返回-1
console.log(str.trim()); // 删除字符串两端空格
console.log(str.toUpperCase()); //转大写
console.log(str.toLowerCase()); // 转小写
console.log(str.split('t')); //分割字符串数组
console.log(str.split('t')[0]); //分割字符串数组
console.log(str.split('t')[1]); //分割字符串数组
```
### **trim**方法去除字符串两端的空格
**返回新字符串**
```js
var str = ' hello '
console.log(str.trim()) //hello 去除两端空格
var str1 = ' he l l o '
console.log(str.trim()) //he l l o 去除两端空格
```
### String的扩展方法
模板字符串
ES6新增的**创建字符串**的方式，使用反引号\`\`定义
```js
let name = `zhangsan`;
```
模板字符串中可以**解析变量**
```js
let name = '张三';
let sayHello = `hello,my name is ${name}`; // hello, my name is zhangsan
```
模板字符串中**可以换行**
```js
let result = {
name: 'zhangsan',
age: 20,
sex: '男'
}
let html = `
${result.name}
${result.age}
${result.sex}
`;
```
在模板字符串中可以**调用函数**
```js
const sayHello = function () {
return '哈哈哈哈 追不到我吧 我就是这么强大';
};
let greet = `${sayHello()} 哈哈哈哈`;
console.log(greet); // 哈哈哈哈 追不到我吧 我就是这么强大 哈哈哈哈
```
实例方法：startsWith() 和 endsWith()
* startsWith()：表示**参数字符串是否在原字符串的头部**，**返回布尔值**
* endsWith()：表示**参数字符串是否在原字符串的尾部**，**返回布尔值**
```js
let str = 'Hello world!';
str.startsWith('Hello') // true
str.endsWith('!') // true
```
实例方法：repeat()
repeat方法表示将**原字符串重复n次**，
```js
返回一个新字符串
'x'.repeat(3) // "xxx"
'hello'.repeat(2) // "hellohello"
```
## 基本包装类型
简单类型（基本数据类型，值类型）
在存储时变量中存储的是值本身，包括string，number，boolean，undefined，null(对象)
## 复杂数据类型
复杂数据类型（引用类型）
在存储时变量中存储的仅仅是地址（引用），通过new关键字创建的对象（系统对象，自定义对象），如Object，Array，Date等
## 堆栈
堆栈控件分配类别
（1）栈（操作系统）：由操作系统自动分配释放存放函数的参数值、局部变量的值等；其操作方式类似于数据结构中的栈
（2）堆（操作系统）：存储复杂类型（对象），一般由程序员分配释放，若程序员不释放，由垃圾回收机制回收
简单数据类型的存储方式
值类型变量的数据直接存放在变量（栈空间）中
复杂数据类型的存储方式
**引用类型变量**（栈空间）里**存放**的是地址，真正的**对象实例**存放在堆空间中
## 简单类型传参
函数的形参可看作一个变量，当把一个值类型变量作为参数传给函数的形参时，实际是把变量在栈空间里的值复制了一份给形参，如果在方法内部对形参做任何修改，都不会影响到外部变量
```js
function fn(a){
a++;
console.log(a);
}
var x=10;
fn(x);
console.log(x);
```
## 复杂数据类型传参
函数的形参可看作一个变量，当把引用类型变量传给形参时，其实是把变量在\*\*栈空间里保存的堆地址\*\*复制给形参，形参和实参其实保存的是同一个堆地址，即操作的是同一个对象
```js
function Person(name) {
this.name = name;
}
function f1(x) { // x = p
console.log(x.name); // 2. 这个输出什么 ?
x.name = "张学友";
console.log(x.name); // 3. 这个输出什么 ?
}
var p = new Person("刘德华");
console.log(p.name); // 1. 这个输出什么 ?
f1(p);
console.log(p.name); // 4. 这个输出什么 ?
```
## 构造函数和原型
### 静态成员和实例成员
实例成员
实例成员就是构造函数内部通过this添加的成员 如下列代码中uname age sing 就是实例成员,实例成员只能通过**实例化的对象**来访问
```js
function Star(uname, age) {
this.uname = uname;
this.age = age;
this.sing = function() {
console.log('我会唱歌');
}
}
var ldh = new Star('刘德华', 18);
console.log(ldh.uname); //实例成员只能通过实例化的对象来访问
```
静态成员
静态成员 在构造函数本身上添加的成员 如下列代码中 sex 就是静态成员,静态成员只能通过**构造函数**来访问
```js
function Star(uname, age) {
this.uname = uname;
this.age = age;
this.sing = function() {
console.log('我会唱歌');
}
}
Star.sex = '男';
var ldh = new Star('刘德华', 18);
console.log(Star.sex); //静态成员只能通过构造函数来访问
```
### 构造函数的问题
### 构造函数原型prototype
构造函数通过原型分配的函数是所有对象所**共享的**
JavaScript 规定，每一个构造函数都有一个prototype属性，指向另一个对象
注意这个prototype就是一个对象，这个对象的所有属性和方法，都会被构造函数所拥有
我们可以把那些不变的方法，直接定义在 prototype 对象上，这样所有对象的实例就可以共享这些方法
```js
function Star(uname, age) {
this.uname = uname;
this.age = age;
}
Star.prototype.sing = function() {
console.log('我会唱歌');
}
var ldh = new Star('刘德华', 18);
var zxy = new Star('张学友', 19);
ldh.sing();
zxy.sing();
```
### 对象原型
对象都会有一个属性 `__proto__` 指向构造函数的 prototype 原型对象，之所以我们对象可以使用构造函数 prototype 原型对象的属性和方法，就是因为对象有 `__proto__ `原型的存在。
`__proto__`对象原型和原型对象 prototype 是等价的
`__proto__`对象原型的意义就在于为对象的查找机制提供一个方向，或者说一条路线，但是它是一个非标准属性，因此实际开发中，不可以使用这个属性，它只是内部指向原型对象 prototype
```js
function Star(uname, age) {
this.uname = uname;
this.age = age;
}
Star.prototype.sing = function() {
console.log('我会唱歌');
}
var ldh = new Star('刘德华 ', 18);
var zxy = new Star('张学友 ', 19);
ldh.sing();
console.log(ldh);
console.log(ldh.__proto__ === Star.prototype);
```
### constructor构造函数
```js
对象原型（ __proto__）和构造函数（prototype）原型对象里面都有一个属性 constructor 属性 ，constructor 我们称为构造函数，因为它指回构造函数本身。
constructor 主要用于记录该对象引用于哪个构造函数，它可以让原型对象重新指向原来的构造函数。
一般情况下，对象的方法都在构造函数的原型对象中设置。如果有多个对象的方法，我们可以给原型对象采取对象形式赋值，但是这样就会覆盖构造函数原型对象原来的内容，这样修改后的原型对象 constructor 就不再指向当前构造函数了。此时，我们可以在修改后的原型对象中，添加一个 constructor 指向原来的构造函数。
```
如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数
```js
function Star(uname, age) {
this.uname = uname;
this.age = age;
}
//很多情况下，需要手动的利用constructor属性 指回 原来的构造函数
Star.prototype = {
//如果修改了原来的原型对象，给原型对象赋值的是一个对象，则必须手动利用constructor指回原来的构造函数
constructor: Star, //手动设置指回原来的构造函数
sing: function() {
console.log('我会唱歌');
},
movie: function() {
console.log('我会演电影');
}
}
var zxy = new Star('张学友', 19);
console.log(zxy);
```
### 构造函数实例和原型对象三角关系
1. **构造函数**的prototype属性指向了**构造函数**原型对象
2. **实例对象**是由构造函数创建的,**实例对象**的`__proto__`属性指向了构造函数的原型对象
3. 构造函数的原型对象的constructor属性指向了**构造函数**,**实例对象**的原型的constructor属性也指向了构造函数
### 原型链
每一个实例对象又有一个proto属性，指向的构造函数的原型对象，构造函数的原型对象也是一个对象，也有**proto**属性，这样一层一层往上找就形成了原型链
### 原型链和成员的查找机制
任何**对象**都有原型对象,也就是prototype属性,任何**原型对象**也是一个**对象**,该对象就有proto属性,这样一层一层往上找,就形成了一条链,我们称此为原型链
当\*\*访问一个对象的属性（包括方法）\*\*时，首先查找这个对象自身有没有该属性
如果没有就查找它的原型（也就是 \_\_proto\_\_指向的 prototype 原型对象）
如果还没有就查找原型对象的原型（Object的原型对象）
依此类推一直找到 Object 为止（null）
`__proto__`对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条路线
### 原型对象中this的指向
**构造函数中的this**和**原型对象的this**,都指向我们new出来的实例对象
```js
function Star(uname, age) {
this.uname = uname;
this.age = age;
}
var that;
Star.prototype.sing = function() {
console.log('我会唱歌');
that = this;
}
var ldh = new Star('刘德华', 18);
// 1. 在构造函数中,里面this指向的是对象实例 ldh
console.log(that === ldh); //true
// 2.原型对象函数里面的this 指向的是 实例对象 ldh
```
### 通过原型为数组扩展内置方法
```js
Array.prototype.sum = function() {
var sum = 0;
for (var i = 0; i < this.length; i++) {
sum += this[i];
}
return sum;
};
//此时数组对象中已经存在sum()方法了 可以始终 数组.sum()进行数据的求和
```
## 对象与类
对象
对象是由**属性**和**方法**组成的：是一个无序键值对的集合,指的是一个具体的事物
* 属性：事物的特征，在对象中用属性来表示（常用名词）
* 方法：事物的行为，在对象中用方法来表示（常用动词）
创建对象
```js
//字面量创建对象
var ldh = {
name: '刘德华',
age: 18
}
console.log(ldh);
//构造函数创建对象
function Star(name, age) {
this.name = name;
this.age = age;
}
var ldh = new Star('刘德华', 18) //实例化对象
console.log(ldh);
```
### 创建类
类
在 ES6 中新增加了类的概念，可以使用 class 关键字声明一个类，之后以这个类来实例化对象。
类抽象了对象的公共部分，它泛指某一大类（class）
对象特指某一个，通过类实例化一个具体的对象
创建类
**语法**
```js
//步骤1使用class关键字
class name {
//class body
}
//步骤2 使用定义的类创建实例 注意new关键字
var xx = new name();
```
constructor()方法是类的构造方法（默认），用于传递参数返回实例对象，通过new命令生成对象实例时，自动调用此方法。如果没有定义，类内部会自动创建一个constructor()
示例
```js
//1.创建类 class 创建一个 明星类
class Star {
//类的共有属性放到constructor里面
constructor(name, age) {
this.name = name;
this.age = age;
}
}
//2.利用类创建对象 new
var ldh = new Star('刘德华', 18);
console.log(ldh);
```
### 类创建添加属性和方法
```js
//1.创建类class 创建一个类
class Star {
//类的共有属性放到constructor里面 constructor是 构造器或者构造函数
constructor(uname, age) {
this.uname = uname;
this.age = age;
} //方法与方法之间不需要添加逗号
sing(song) {
console.log(this.uname + '唱' + song);
}
}
//2.利用类创建对象 new
var ldh = new Star('刘德华', '18');
console.log(ldh); //Star{uname:"刘德华",age:18}
ldh.sing('冰雨');
```
**注意:**
* 通过class 关键字创建类, 类名我们还是习惯性定义首字母大写
* 类里面有个constructor 函数,可以接受传递过来的参数,同时返回实例对象
* constructor 函数 只要 new 生成实例时,就会自动调用这个函数, 如果我们**不写这个函数**,类也会自动生成这个函数
* **多个函数方法之间不需要添加逗号分隔**
* 生成实例 new 不能省略
* 语法规范, 创建类 类名后面不要加小括号,生成实例 类名后面加小括号, 构造函数不需要加function
### 类的继承
**语法**
```js
//父类
class Father {
}
//子类继承父类
class Son extends Father {
}
```
示例
```js
class Father {
constructor(surname) {
this.surname = surname;
}
say() {
console.log('你的姓名是' + this.surname);
}
}
class Son extends Father {
//这样子类就继承了父类的属性和方法
}
var damao = new Son('刘');
damao.say();
```
子类使用super关键字访问父类的方法
```js
//定义了父类
class Father {
constructor(x, y) {
this.x = x;
this.y = y;
}
sum() {
console.log(this.x + this.y);
}
}
//子元素继承父类
class Son extends Father {
constructor(x, y) {
super(x, y); //使用super调用父类中的构造函数
}
}
var son = new Son(1, 2);
son.sum();
```
**注意:**
（1）继承中,如果**实例化子类输出一个方法**,先看子类有没有这个方法,如果有就先执行子类的
（2）继承中,如果子类里面没有,就去查找父类有没有这个方法,如果有,就执行父类的这个方法(就近原则)
（3）如果子类想要继承父类的方法,同时在自己内部扩展自己的方法,利用super 调用父类的构造函数,super 必须在子类this之前调用
```js
//父类有加法方法
class Father {
constructor(x, y) {
this.x = x;
this.y = y;
}
sum() {
console.log(this.x + this.y);
}
}
//子类继承父类的加法方法 同时扩展减法方法
class Son extends Father {
constructor(x, y) {
//利用super调用父类的构造函数super必须在子类this之前调用，放到this之后会报错
super(x, y);
this.x = x;
this.y = y;
}
subtract() {
console.log(this.x - this.y);
}
}
var son = new Son(5, 3);
son.subtract();
son.sum();
```
(4) 时刻注意this的指向问题,类里面的共有的属性和方法一定要加this使用
* constructor中的this指向的是new出来的实例对象
* 自定义的方法,一般也指向的new出来的实例对象
* 绑定事件之后this指向的就是触发事件的事件源
（5）在 ES6 中类没有变量提升，所以必须先定义类，才能通过类实例化对象
## 继承
call()
* call()可以调用函数
* call()可以修改this的指向,使用call()的时候 参数一是修改后的this指向,参数2,参数3..使用逗号隔开连接
```js
function fn(x, y) {
console.log(this);
console.log(x + y);
}
var o = {
name: 'andy'
};
fn.call(o, 1, 2); //调用了函数此时的this指向了对象o
```
子构造函数继承父构造函数的属性
1. 先定义一个父构造函数
2. 再定义一个子构造函数
3. 子构造函数继承父构造函数的属性(使用call方法)
```js
//1.父构造函数
function Father(uname, age) {
//this 指向父构造函数的对象实例
this.uname = uname;
this.age = age;
}
//2.子构造函数
function Son(uname, age, score) {
//this 指向子构造函数的对象实例
// 3. 使用call方式实现子继承父的属性
Father.call(this, uname, age);
this.score = score;
}
var son = new Son('胡梓卓', 18, 100);
console.log(son);
```
借用原型对象继承方法
1. 先定义一个父构造函数
2. 再定义一个子构造函数
3. 子构造函数继承父构造函数的属性(使用call方法)
```js
// 1. 父构造函数
function Father(uname, age) {
// this 指向父构造函数的对象实例
this.uname = uname;
this.age = age;
}
Father.prototype.money = function() {
console.log(100000);
};
// 2 .子构造函数
function Son(uname, age, score) {
// this 指向子构造函数的对象实例
Father.call(this, uname, age);
this.score = score;
}
// Son.prototype = Father.prototype; 这样直接赋值会有问题,如果修改了子原型对象,父原型对象也会跟着一起变化
Son.prototype = new Father();
// 如果利用对象的形式修改了原型对象,别忘了利用constructor 指回原来的构造函数
Son.prototype.constructor = Son;
// 这个是子构造函数专门的方法
Son.prototype.exam = function() {
console.log('孩子要考试');
}
var son = new Son('刘德华', 18, 100);
console.log(son);
```
## 严格模式
JavaScript 除了提供正常模式外，还提供了严格模式（strict mode）。
ES5 的严格模式是采用具有限制性 JavaScript变体的一种方式，即在严格的条件下运行 JS 代码。
严格模式在 IE10 以上版本的浏览器中才会被支持，旧版本浏览器中会被忽略。
严格模式对正常的 JavaScript 语义做了一些更改：
1.消除了 Javascript 语法的一些不合理、不严谨之处，减少了一些怪异行为。
2.消除代码运行的一些不安全之处，保证代码运行的安全。
3.提高编译器效率，增加运行速度。
4.禁用了在 ECMAScript 的未来版本中可能会定义的一些语法，为未来新版本的 Javascript 做好铺垫。比如一些保留字如：class,enum,export, extends, import, super 不能做变量名
### 开启严格模式
严格模式可以应用到整个脚本或个别函数中。因此在使用时，我们可以将严格模式分为为脚本开启严格模式和为函数开启严格模式两种情况。
* 情况一 :为脚本开启严格模式
有的 script 脚本是严格模式，有的 script 脚本是正常模式，这样不利于文件合并，所以可以将整个脚本文件放在一个立即执行的匿名函数之中。这样独立创建一个作用域而不影响其他 script 脚本文件。
```js
(function (){
//在当前的这个自调用函数中有开启严格模式，当前函数之外还是普通模式
"use strict";
var num = 10;
function fn() {}
})();
//或者
```
* 情况二: 为函数开启严格模式
要给某个函数开启严格模式，需要把“use strict”; (或 'use strict'; ) 声明放在函数体所有语句之前。
```js
function fn(){
"use strict";
return "123";
}
//当前fn函数开启了严格模式
```
### 严格模式中的变化
**文档参考**：
https://developer.mozilla.org/zh-CN/Web/JavaScript/Reference/Strict\_mode
```js
'use strict'
num = 10
console.log(num) //严格模式后使用未声明的变量
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
var num2 = 1;
delete num2; //严格模式不允许删除变量
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
function fn() {
console.log(this); // 严格模式下全局作用域中函数中的 this 是 undefined
}
fn();
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
function Star() {
this.sex = '男';
}
// Star();严格模式下,如果 构造函数不加new调用, this 指向的是undefined 如果给他赋值则 会报错.
var ldh = new Star();
console.log(ldh.sex);
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
setTimeout(function() {
console.log(this); //严格模式下，定时器 this 还是指向 window
}, 2000);
```
函数内的参数不能同名
函数必须声明在顶层（不允许在非函数代码块\[if，for]内声明函数）
## 高阶函数
高阶函数是对其他函数进行操作的函数，它接收函数作为参数或将函数作为返回值输出
此时fn 就是一个高阶函数
函数也是一种数据类型，同样可以作为参数，传递给另外一个参数使用。最典型的就是作为回调函数。
同理函数也可以作为返回值传递回来
## 闭包
闭包（closure）指有权访问另一个函数作用域中变量的函数。
简单理解就是 ，一个作用域可以访问另外一个函数内部的局部变量
闭包的作用
作用：**延伸变量的作用范围**
```js
function fn() {
var num = 10;
function fun() {
console.log(num);
}
return fun;
}
var f = fn();
f();
```
## 正则表达式
正则表达式（ **Regular Expression** ）是用于匹配字符串中字符组合的模式。
在JavaScript中，正则表达式也是**对象**。
正则表通常被用来检索、替换那些符合某个模式（规则）的文本，例如验证表单：用户名表单只能输入英文字母、数字或者下划线， 昵称输入框中可以输入中文(匹配reg.test())。
此外，正则表达式还常用于过滤掉页面内容中的一些敏感词(替换reg.replace(regexp,'新字符'))，或从字符串中获取我们想要的特定部分(提取match(reg))等 。
其他语言也会使用正则表达式，本阶段我们主要是利用JavaScript 正则表达式完成表单验证
正则表达式的特点
1. 灵活性、逻辑性和功能性非常的强。
2. 可以迅速地用极简单的方式达到字符串的复杂控制。
3. 对于刚接触的人来说，比较晦涩难懂。比如：^\w+(\[-+.]\w+)*@\w+(\[-.]\w+)*.\w+(\[-.]\w+)\*$
4. 实际开发,一般都是直接复制写好的正则表达式. 但是要求会使用正则表达式并且根据实际情况修改正则表达式. 比如用户名: /^\[a-z0-9\_-]{3,16}$/
### 在js中的使用
在 JavaScript 中，可以通过两种方式创建一个正则表达式。
（1）通过调用RegExp对象的构造函数创建
```js
var regexp = new RegExp(/123/);
console.log(regexp);
```
（2）利用字面量创建 正则表达式
```js
var rg = /123/;
```
测试正则表达式
test() 正则对象方法，用于**检测字符串是否符合该规则**，该对象会返回 **true** 或 false，其参数是测试字符串。
```js
var rg = /123/;
console.log(rg.test(123));//匹配字符中是否出现123 出现结果为true
console.log(rg.test('abc'));//匹配字符中是否出现123 未出现结果为false
```
#### 正则表达式中的特殊字符
正则表达式的组成
一个正则表达式可以由**简单的字符**构成，比如 /abc/，也可以是**简单和特殊字符**的组合，比如 /ab\*c/ 。其中特殊字符也被称为元字符，在正则表达式中是具有**特殊意义**的专用符号，如 ^ 、$ 、+ 等
特殊字符非常多，可以参考：
[MDN](https://developer.mozilla.org/zh-CN/Web/JavaScript/Guide/Regular_Expressions)
jQuery 手册：正则表达式部分
[正则测试工具](https://tool.oschina.net/regex)
#### 边界符
正则表达式中的边界符（位置符）用来**提示字符所处的位置**，主要有两个字符
| **边界符** | **说明** |
| ---------- | ------------------------------ |
| ^ | 表示匹配行首的文本（以谁开始） |
| $ | 表示匹配行尾的文本（以谁结束） |
如果 ^和 $ 在一起，表示必须是精确匹配。
```js
var rg = /abc/; // 正则表达式里面不需要加引号 不管是数字型还是字符串型
// /abc/ 只要包含有abc这个字符串返回的都是true
console.log(rg.test('abc'));
console.log(rg.test('abcd'));
console.log(rg.test('aabcd'));
console.log('---------------------------');
var reg = /^abc/;
console.log(reg.test('abc')); // true
console.log(reg.test('abcd')); // true
console.log(reg.test('aabcd')); // false
console.log('---------------------------');
var reg1 = /^abc$/; // 精确匹配 要求必须是 abc字符串才符合规范
console.log(reg1.test('abc')); // true
console.log(reg1.test('abcd')); // false
console.log(reg1.test('aabcd')); // false
console.log(reg1.test('abcabc')); // false
```
#### 字符类
字符类表示有一系列字符可供选择，**只要匹配其中一个**就可以了。所有可供选择的字符都放在方括号内。
\[] 方括号
表示有一系列字符可供选择，只要匹配其中一个就可以了
```js
var rg = /[abc]/; // 只要包含有a 或者 包含有b 或者包含有c 都返回为true
console.log(rg.test('andy')); //true
console.log(rg.test('baby')); //true
console.log(rg.test('color')); //true
console.log(rg.test('red')); //false
var rg1 = /^[abc]$/; // 三选一 只有是a 或者是 b 或者是c 这三个字母才返回 true
console.log(rg1.test('aa')); //false
console.log(rg1.test('a')); //true
console.log(rg1.test('b')); //true
console.log(rg1.test('c')); //true
console.log(rg1.test('abc')); //true
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
var reg = /^[a-z]$/ //26个英文字母任何一个字母返回 true - 表示的是a 到z 的范围
console.log(reg.test('a')); //true
console.log(reg.test('z')); //true
console.log(reg.test('A')); //false
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
//字符组合
var reg1 = /^[a-zA-Z0-9]$/; // 26个英文字母(大写和小写都可以)任何一个字母返回 true
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
//取反 方括号内部加上 ^ 表示取反，只要包含方括号内的字符，都返回 false 。
var reg2 = /^[^a-zA-Z0-9]$/;
console.log(reg2.test('a')); //false
console.log(reg2.test('B')); //false
console.log(reg2.test(8)); //false
console.log(reg2.test('!')); //true
```
量词符
量词符用来设定某个模式出现的次数。
| **量词** | **说明** |
| -------- | --------------- |
| \* | 重复0次或更多次 |
| + | 重复1次或更多次 |
| ? | 重复0次或1次 |
| {n} | 重复n次 |
| {n,} | 重复n次或更多次 |
| {n,m} | 重复n到m次 |
括号总结
1.大括号 量词符. 里面表示重复次数
2.中括号 字符集合。匹配方括号中的任意字符.
3.小括号表示优先级
[正则表达式在线测试](https://c.runoob.com/)
#### 预定义类
预定义类指的是**某些常见模式的简写方式**
```js
验证座机号码
var reg = /^\d{3}-\d{8}|\d{4}-\d{7}$/;
var reg = /^\d{3,4}-\d{7,8}$/;
```
### 正则表达式中的替换
replace() 方法可以实现**替换字符串操作**，用来替换的**参数**可以是**一个字符串**或是一个**正则表达式**。
```js
var str = 'andy和red';
var newStr = str.replace('andy', 'baby');
console.log(newStr)//baby和red
//等同于 此处的andy可以写在正则表达式内
var newStr2 = str.replace(/andy/, 'baby');
console.log(newStr2)//baby和red
//全部替换
var str = 'abcabc'
var nStr = str.replace(/a/,'哈哈')
console.log(nStr) //哈哈bcabc
//全部替换g
var nStr = str.replace(/a/a,'哈哈')
console.log(nStr) //哈哈bc哈哈bc
//忽略大小写i
var str = 'aAbcAba';
var newStr = str.replace(/a/gi,'哈哈')//"哈哈哈哈bc哈哈b哈哈"
```
**案例:过滤敏感词汇**
```js
```