一 。类（构造函数/构造方法）
1. 定义：具有相同属性和方法的集合
2.通过function关键字定义 类名首字母大写
3.属性写在构造函数里 方法写在原型下
4.类下有个prototype属性（原型） 原型下所有的属性和方法都会被实例化对象所共享
function Person(name, age) {
this.name = name;
this.age = age;
}
//定义类下方法
Person.prototype.sleep = function() {
console.log(this.name + ' is sleeping ....');
}
//实例化对象
let p1 = new Person('xm', 20)
let p2 = new Person('zs', 18)
二。类的继承
ES5中实现继承的方式：
1.子类的构造函数中 通过父类.call() 继承父类的属性
2.子类的prototype = 父类的实例化对象 来继承父类的方法
3.子类的constructor指向子类
如： function Student(name, age, grade) {
Person.call(this,name, age)
this.grade = grade
}
Student.prototype = new Person();
Student.prototype.constructor = Student;
Student.prototype.code = function() {
console.log(this.name + ' is codeing....');
}
2.ES6中通过class来定义类
1.构造函数里定义属性
2.构造函数外定义方法
3.static 关键字定义的方法是静态方法 只能通过 类名.方法 来调用 实例化对象不能直接调用
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
eat() {
console.log(this.name + ' is eating....')
}
sleep() {
console.log(this.name + ' is sleeping...')
}
static fun() {
console.log(123);
}//调用的话 Person.fun();
}
3. es6 里 通过 extends 来实现的继承
class Student extends Person {
constructor(...params) {
// 通过super()来继承父类的构造函数
// params 是个数组
super(...params)
this.grade = params[2] //赋值
}
code() {
console.log(this.name + ' is coding...')
}
}
三。 generator 函数：
在function 和 函数名 之间加一个 *
yield 执行之后暂停
function * fun1 (){
console.log('hello');
let res = yield request1(); // res 的值是next方法调用的时候传递的参数
console.log(res);
console.log('world');
}
// 方法返回的是一个指针对象 需要调用next()执行
let fn1 = fun1();
function request1() {
setTimeout(() => {
let obj = {
name: 'zs',
age: 18
}
console.log('请求成功')
console.log(fn1.next(obj)); //{value: undefined, done: true}
}, 1000)
return 'requset函数'
}
四。async函数
async函数await会自动等待后面的函数 执行完 在执行下一条语句
此时的promise对象就像是一个容器
执行 嵌套的异步操作
async function fun() {
console.log('准备发送请求1');
await request();
console.log('准备发送请求2')
await request2();
console.log('结束');
}
function request() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('请求1成功');
resolve();
}, 1500)
})
}
function request2() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('请求2成功');
resolve();
}, 800)
})
}
fun();
五.proxy
1.定义：Proxy 用于修改某些操作的默认行为，等同于在语言层面做出修改
在目标对象之前架设一层“拦截”，外界对该对象的访问，都必须先通过这层拦截，
可以对外界的访问进行过滤和改写。
2.操作
var proxy=newProxy(target,handler);
不同的只是handler参数的写法。其中，new Proxy()表示生成一个Proxy实例，target参数表示所要拦截的目标对象，handler参数也是一个对象，用来定制拦截行为。
要使得Proxy起作用，必须针对Proxy实例（上例是proxy对象）进行操作，而不是针对目标对象（上例是空对象）进行操作。
如果handler没有设置任何拦截，那就等同于直接通向原对象。
3.Proxy 类型
get(target, propKey, receiver)：拦截对象属性的读取，比如proxy.foo和proxy['foo']。
set(target, propKey, value, receiver)：拦截对象属性的设置，比如proxy.foo = v或proxy['foo'] = v，返回一个布尔值。
let obj = {
a: 1,
b: 2,
}
const p = new Proxy(obj, {
get(target, key, value) {
if (key === 'c') {
return '我是自定义的一个结果';
} else {
return target[key];
}
},
set(target, key, value) {
if (value === 4) {
target[key] = '我是自定义的一个结果';
} else {
target[key] = value;
}
}
})
console.log(obj.a) // 1
console.log(obj.c) // undefined
console.log(p.a) // 1
console.log(p.c) // 我是自定义的一个结果
obj.name = '李白';
console.log(obj.name); // 李白
obj.age = 4;
console.log(obj.age); // 4
p.name = '李白';
console.log(p.name); // 李白
p.age = 4;
console.log(p.age); // 我是自定义的一个结果
