RegExp、JSON、创建对象、构造函数、原型对象、原型链、原型继承、class、class继承
RegExp 正则表达式
| 语句 | 含义 | 例子 |
|---|---|---|
| \d | 一个数字 | |
| \w | 一个字母或者数字 | |
| . | 任意字符 | |
| * | 任意个字符 | |
| + | 至少一个字符 | |
| ? | 0个或1个字符 | |
| {n} | n个字符 | |
| {n,m} | n-m个字符 | |
| \s | 一个空格 | |
| ^ | 开头 | ^\d 以数字开头 |
| $ | 结尾 | ^\w 以字母结尾 |
| [] | 范围 | [0-9a-zA-Z_] 匹配一个数字、字母或是下划线 |
| \s | 一个空格 |
使用场景：匹配字符串、切分字符串、分组、贪婪匹配等
JSON
JSON是js的子集，它是一种数据交换格式，所有前端的同学你懂的。可以将任意的js对象序列化成一个JSON格式的字符串，这样就可以在网络中传递数据，当然，当接受到了一个JOSN字符串，反序列化后可以生成一个js对象。
JSON的几种数据类型：
| 语句 | 含义 |
|---|---|
| number | 和JavaScript的number完全一致 |
| boolean | 就是JavaScript的true或false |
| string | 就是JavaScript的string |
| null | 就是JavaScript的null |
| array | 就是JavaScript的Array表示方式——[] |
| object | 就是JavaScript的{ ... }表示方式 |
JSON还定死了字符集必须是UTF-8，字符串规定必须用双引号""，Object的键也必须用双引号""。
js对象的序列化和反序列化函数：
JSON.stringify()
JSON.parse()
1. 序列化
var wangdaji = {
name: 'wangdaji',
school: 'xibei heihei',
skills: ['c', 'c++', 'objc', 'swift', 'js'],
address: {
city: 'shanghai',
detail: '上海...'
}
};
var s = JSON.stringify(wangdaji);
console.log(s);
将wangdaji对象序列化后：
{"name":"wangdaji","school":"xibei heihei","skills":["c","c++","objc","swift","js"],"address":{"city":"shanghai","detail":"上海..."}}
stringify方法有三个参数：(对象，需要序列化的键值，空白字符串-用于美化输出)。
第二个参数可以传入一个数组或函数，分别来筛选需要序列化的key value或对key value进行特殊处理。
var s = JSON.stringify(wangdaji, null, ' ');
美化输出后得到JSON：
{
"name": "wangdaji",
"school": "xibei heihei",
"skills": [
"c",
"c++",
"objc",
"swift",
"js"
],
"address": {
"city": "shanghai",
"detail": "上海..."
}
}
2. 反序列化
var JSONStr = '{"name":"wangdaji","school":"xibei heihei","skills":["c","c++","objc","swift","js"],"address":{"city":"shanghai","detail":"上海..."}}';
var wangdaji1 = JSON.parse(JSONStr);
console.log(wangdaji1);
创建对象、构造函数
创建对象：（1）使用{...}；（2）使用构造函数
使用构造函数，创建对象：
// 构造方法
function Person(name) {
this.name = name,
this.say = function () {
return 'Hello, ' + this.name + '!';
}
}
// 创建一个对象
var wangdaji = new Person('wdj');
console.log(wangdaji.say());
构造函数为了和普通函数区别，在使用时需要加上new；构造函数会自动return this，不需要手动加return；this指向的是新创建的对象。
原型对象、原型链
首先要记住：
（1）prototype：“原型”的意思, constructor：“构造器”的意思
（2）js会对每个对象设置一个原型对象，并指向它。
（3）对象的属性查找流程：js首先会在当前对象上查找属性，如果当前对象没有，就找到它的原型对象，在原型对象上找该属性，如果原型对象上也没有，就一直上溯到Object.prototype对象，如果Object.prototype对象上也没有这个属性，那就返回undefined，这样就形成了一条原型链。
所以js对象的原型链：
js对象 -> 原型对象 -> ... -> Object.prototype -> undefined
创建一个数组对象arr，其原型链：
var arr = ['wangdaji', 'xiaoming', 'rock'];
arr -> Array.prototype -> Object.prototype -> null
访问length属性：首先会在arr对象上找该属性，如果没有，就会在Array.prototype对象上找。由于length是Array.prototype的属性，那访问到这里就返回了。
定义一个函数，其原型链：
var fn = function () {
console.log('hello world !');
}
// 或者
function fn() {
console.log('hello world !');
}
fn -> Function.prototype -> Object.prototype -> null
调用call()方法：由于call()是Function.prototype定义的，在上溯到Function.prototype对象时就会返回了。也说明了所有的函数都具有call()方法。
（4）定义一个构造函数Person，创建了wangdaji对象，wangdaji对象的原型指向函数Person的原型属性：
// Person构造函数
function Person(name) {
this.name = name;
this.say = function () {
console.log(this.name + 'hello world !');
}
}
// 创建了两个对象
var wangdaji = new Person('wangdaji');
var rock = new Person('rock');
wangdaji原型 === Person.prototype
rock原型 === Person.prototype
rock和wangdaji的原型是一样的，都是Person.prototype，所以say函数可以直接定义在他们原型上，那创建出的所有对象都具有say函数，这样还可以节省很多的内存哦。
所以可以将代码修改成：
// Person构造函数
function Person(name) {
this.name = name || '匿名'; // 默认值为'匿名'
}
// 添加对象的共享函数
Person.prototype.say = function () {
console.log(this.name + ' hello world !');
}
// 创建了两个对象
var wangdaji = new Person('wangdaji');
var rock = new Person('rock');
wangdaji.say();
rock.say();
同时创建的对象和原型对象也自动拥有一个属性constructor，他们指向Person。
console.log(Person.prototype.constructor);
console.log(wangdaji.constructor);
console.log(Person.prototype.constructor === wangdaji.constructor);
console.log(Person.prototype.constructor === rock.constructor);
// ture
// ture
原型链：(参考廖雪峰的js教程)
原型继承
js中的继承是通过原型继承来实现的，其流程：
（1）创建一个新的构造函数，在内部使用call()方法于要继承的构造函数。 （2）采用中间变量将原型串起来。
（3）给新的构造函数添加新的函数。
这样的编码方式确实难受了，在es6后，有一个更加便捷的继承方式，那就是class继承。
class继承
构造函数 --> class关键字，使用两者来写构造函数是一样的效果。
使用构造函数：
function Person(name, age) {
this.name = name || '匿名'; // 默认值为'匿名'
this.age = age || 18; // 默认值为18
}
// 添加对象的共享函数
Person.prototype.say = function (message) {
console.log(this.name + message);
}
使用class关键字：
class Person {
constructor (name, age) {
this.name = name || '';
this.age = age || 18;
}
say (message) {
console.log(this.age + '岁的' + this.name + message);
}
}
var wangdaji = new Person('wangdaji', 20);
wangdaji.say(' 生日快乐');
js的class继承有点像java，使用extends关键字来实现的。
class Person {
constructor (name, age) {
this.name = name || '';
this.age = age || 18;
}
say (message) {
return this.age + '岁的' + this.name + message;
}
}
class Man extends Person {
constructor (name, age, address, phone) {
super(name, age);
this.address = address;
this.phone = age;
}
showUser (message) {
return this.say(message) + this.address;
}
}
var wangdaji = new Man('wangdaji', 20, '上海市', 1777);
console.log(wangdaji.showUser(' 的地址是：'));