-
Notifications
You must be signed in to change notification settings - Fork 0
/
ES6继承的实现原理.html
98 lines (89 loc) · 3.9 KB
/
ES6继承的实现原理.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>ES6继承的实现原理</title>
</head>
<body>
<script>
// 负责将原型的方法和静态方法定义在构造函数上的
function defineProperties(constructor, properties) {
for (let i = 0; i < properties.length; i++) {
let obj = { ...properties[i], enumerable: true, writeable: true, configurable: true }
Object.defineProperty(constructor, properties[i].key, obj);
}
}
// 对不同的属性做处理 如果是原型上的方法挂载Class.prototype 如果是静态方法放在 Class上
function createClass(constructor, protoProperty, staticProperty) {
if (protoProperty) {
defineProperties(constructor.prototype, protoProperty);
}
if (staticProperty) {
defineProperties(constructor, staticProperty);
}
}
// 类的调用检测
function checkInstance(instance, constructor) { //检查当前类 有没有new出来的，不是new出来的this属于window
if (!(instance instanceof constructor)) throw Error('without new')
}
// 父类
var Parent = function () {
function Parent() {
// 类的调用检测
this.name = 'wangliang'
checkInstance(this, Parent);
}
// 用来描述这个类的原型方法和静态方法
createClass(Parent, [ // 原型上的方法
{
key: 'getName', value: function () {
return this.name
}
}
], [ // 静态方法
{
key: 'getFuncName', value: function () {
return this.name;
}
}
])
return Parent
}()
// 继承共有方法和静态方法
function inheritPrototype(subClass, superClass) {
// 子类继承父类的公有方法
subClass.prototype = Object.create(superClass.prototype, { constructor: { value: subClass } });
// 也要让子类继承父类的静态方法
subClass.__proto__ = superClass;
// 或者
// for (let [key, value] of Object.entries(superClass)) {
// defineProperties(subClass, [{ key, value }])
// }
}
var Child = function (Parent) { // 表示儿子继承Parent类，要包多一层不然传参会传到Child上
function Child() { // 类的调用检查
// 在子类中应该调用父类的构造函数
// Parent.call(this);
if (typeof new.target === 'undefined') {
throw new SyntaxError('当前"类"不能作为一个普通函数执行')
}
let self = this;
// console.log(Object.getPrototypeOf(Child))
// Child.__proto__ = Object.getPrototypeOf(Child) 继承父类的私有方法，为了保险不用 Parent.call(this)，因为不一定继承父类
let obj = Object.getPrototypeOf(Child).call(this);
if (typeof obj === 'object') { //如果是对象把obj作为实例
self = obj;
}
return self;
}
inheritPrototype(Child, Parent); // 表示继承 儿子继承父亲
return Child
}(Parent);
let child = new Child;
// console.log(Object.getOwnPropertyNames(Child))
console.log(child.getName(), Child.getFuncName(), '\n', Object.keys(Child), '\n', Reflect.ownKeys(Child));
</script>
</body>
</html>