JavaScript高级程序设计笔记08 对象、类与面向对象编程
对象、类与面向对象编程
对象
一组属性的无序集合
属性
-
类型
- 数据属性 value、writable
- 访问器属性 getter、setter至少有一
-
定义
- .操作符：默认可配置、可枚举、可写（数据属性）
- Object.defineProperty/defineProperties：默认不可配置、不可枚举、只读
configurable：false。不可删除、不可逆。无法修改其他特性的值（除writable从true改为false）
读取特性：Object.getOwnPropertyDescriptor / Object.getOwnPropertyDescriptors(ES8)
属性名有后缀下划线：通常表示该属性不希望在对象方法的外部被访问
合并对象
Object.assign 复制源对象的可枚举且自有的属性到目标对象
- 目标只有getter 源对象无法将同名属性复制到目标对象=>报错
- 目标有setter，源对象通过执行[[Get]]获取同名属性值，给到目标对象的[[Setter]]
中途抛错=>完成部分复制
新增的定义和操作对象的语法糖
- 属性简写（变量名和属性名同名）
- 可计算属性：以字面量形式定义 计算失败=>定义失败
- 简写方法名：省略function关键字（默认匿名）
对象解构
let {name, age} = person; // 常见
let {name, job='Software Engineer'} = person; // 未获取到时的默认值
let {name: personName, age: personAge} = person; // 内部声明
({name: personName, age: personAge} = person); // 对外部声明的赋值
-
嵌套解构
嵌套的属性，属性值是对象类型或子类型
-
部分解构
过程出错，完成部分赋值
-
函数参数以解构形式
function foo(f1, {name, age}, f2) {}第二个参数存在名为name和age的属性
对象创建
封装、避免冗余
-
工厂模式
工厂函数：接收（特定）参数，拼装对象，返回对象
-
构造函数模式（声明或表达式都可）
函数：接收特定参数，拼装this，可无显式返回（默认为this指向的新对象）
构造调用：1）创建对象；2）连接对象[[prototype]]到函数的prototype对象；3）对象赋值给this；4）执行函数中的代码；5）返回指定对象或默认this。
可通过instanceof确定引用类型
问题：定义的对象如果存在类型为function的功能相同的属性，多次调用会产生多个function实例。
-
原型模式
利用函数的prototype属性（包含了它的实例可共享的属性和方法）。
原型：函数声明后会自动获取prototype属性，默认有一个键为constructor，值指回函数。
instanceof实际是查函数的prototype对象。
- xxx.isPrototypeOf(obj)：obj的原型链上是不是存在一个xxx指向的对象
- Object.getPrototypeOf(obj)：可用来获取一个对象的原型链
- Object.setPrototypeOf(obj, proObj)：重写一个对象（obj）的原型继承关系——>可能影响性能，也可能影响访问了原[[prototype]]对象的代码
Object.create：创建对象，并指定原型。
原型层级遮蔽。
查属性：
-
hasOwnProperty：自身属性
-
in和for-in：查链、可枚举
-
Object.keys()：不查链、可枚举
-
Object.getOwnPropertyNames()：不论是否可枚举，非符号键
Object.getOwnPropertySymbols()：不论是否可枚举，符号键
枚举顺序：
- for-in / Object.keys() 取决于浏览器
- getOPN、getOPS、Object.assign：升序枚举数值键、插入顺序枚举字符串和符号键
-
对象迭代
Object.values()：值数组
Object.entreis()：键/值对数组
以上两个方法符号键都会忽略。
可通过原型封装功能=>重写.prototype属性=>会丢失constructor（可以手动补）
修改原型对象的两种方式：
1）整个重写，重新定义一个对象并赋值给.prototype
2）增/改原型对象属性/值
js原生引用类型的实现基于原型模式。如需修改原生引用类型的原型对象=>更推荐的做法：创建一个类继承原生类型；直接修改可能导致命名冲突、意外重写。
原型存在的问题。共享属性中含有引用类型的数据成员（非函数）
继承
-
原型链
实例和原型对象之间构造了引用连接关系
①默认原型：Object.prototype
②原型与继承：
instanceof 实例的原型链上出现过构造函数.prototype关联的对象
isPrototypeOf 判断两个对象之间的关系
③方法覆盖（子类覆盖父类）：
子类.prototype = 父类new出来的实例
再修改单个属性（子类.prototype）
④存在的问题：子类实例化时不能给父类构造函数传参
-
盗用构造函数：伪多态，没有原型链
在子类构造函数中通过call或apply调用父类函数（非构造调用）
①解决原型链的问题：可传参给父类函数
②问题：
a. 无链，子类产生的实例无法对父类及其原型对象应用instanceof和isPrototypeOf方法
b. 必须在构造函数中定义方法（属于实例的方法），函数不能重用（与构造函数模式一样的问题）
-
组合继承：伪多态+原型
①在子类构造函数中通过call或apply调用父类函数
②重写子类原型对象（用new父类产生的实例赋值）
解决的问题：instanceof、isPrototypeOf 可用；可添加/修改原型方法
-
原型式继承：直接关联两个对象
类似直接使用Object.create
适合不需要构造函数的场合
-
寄生式继承：类似工厂
类似工厂函数，但不是用裸的Object，以某种方式取得对象（如new等返回新对象的函数），对此对象加属性或方法以增强功能，并返回对象。
function createAnother(original) { let clone = Object.create(original); clone.xx = xxx; return clone; }同样适合主要关注对象，而不在乎类型和构造函数的场景。
存在的问题：必须在构造函数中定义方法（属于实例的方法），函数不能重用（与构造函数模式一样的问题）
-
寄生式组合继承：伪多态+Object.create替代new父类（优化3）
用Object.create()替换new父类实例来重写子类的原型对象（优化3，舍去new中其他多余操作）
function inheritatePrototype(subT, superT) { let proto = Object.create(superT.prototype); proto.constructor = subT; subT.prototype = proto; }
/*
* 属性
*/
let o = {
b: 'test B'
};
// Object.defineProperty(o, "name", {
// value: 0,
// get: function() {
// return 1;
// },
// set: function(val) {
// this.name = val;
// },
// writable: true
// });
// console.log( Object.getOwnPropertyDescriptor(o, "name") );
// TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute
Object.defineProperty(o, "name", {
get: function() {
return this.b;
},
set: function(val) {
this.name = val;
}
});
console.log( Object.getOwnPropertyDescriptor(o, "name") );
// {
// get: [Function: get],
// set: [Function: set],
// enumerable: false,
// configurable: false
// }
console.log( Object.getOwnPropertyDescriptor(o, "name").value ); // undefined
console.log( Object.getOwnPropertyDescriptor(o, "b") );
// {
// value: 'test B',
// writable: true,
// enumerable: true,
// configurable: true
// }
console.log( Object.getOwnPropertyDescriptors(o) );
// {
// b: {
// value: 'test B',
// writable: true,
// enumerable: true,
// configurable: true
// },
// name: {
// get: [Function: get],
// set: [Function: set],
// enumerable: false,
// configurable: false
// }
// }
/*
* 合并对象
*/
let dest, src, result;
// 1.目标对象只有同名的set，混入源对象的同名get
// 会先执行源对象的get获取值，把值传递给目标对象的set并执行。
// 无法通过目标对象获取值（目标对象无get）
dest = {
set a(val) {
console.log( `Invoked dest setter with param ${val}` );
}
};
src = {
get a() {
console.log( 'Invoked src getter' );return 1;
}
};
Object.assign( dest, src );
console.log( dest );
// Invoked src getter
// Invoked dest setter with param undefined
// { a: [Setter] }
// 2.目标对象只有同名的get，混入源对象的同名set会报错
// Object.assign( src, dest );
// TypeError: Cannot set property a of #<Object> which has only a getter
// 3.目标对象有get和set，混入的源对象只有同名set
// 会先执行源对象的get获取值(undefined)，执行目标对象的set
src = {
get a() {
console.log( 'Invoked src getter' );
return 1;
},
set a(val) {
console.log( `Invoked src setter with param ${val}` );
}
};
Object.assign( src, dest ); // Invoked src setter with param undefined
console.log( 'src', src ); // src { a: [Getter/Setter] }
console.log( 'src.a', src.a );
// Invoked src getter
// src.a 1
// 4.目标和源都只有get
dest = {
get a() {
console.log( 'dest' );
}
};
src = {
get a() {
console.log( 'src' );
}
};
// Object.assign( dest, src ); // TypeError: Cannot set property a of #<Object> which has only a getter
// 通过setter观察覆盖的过程
dest = {
set id(x) {
console.log( x );
}
};
Object.assign(dest, { id: 1 }, { id: 2 }, { id: 3 });
// 1
// 2
// 3
dest = {};
src = {
a: 'foo',
get b() {
throw new Error();
},
c: 'bar'
};
try{
Object.assign( dest, src );
} catch(e) {}
console.log( dest ); // { a: 'foo' }
/*
* 新增的定义和操作对象的语法糖
*/
let nameKey="name";
// let o2 = {
// [nameKey]: "lily",
// [ageKey]: 12
// };
// ReferenceError: ageKey is not defined
let o2;
try{
o2 = {
[nameKey]: "lily",
[ageKey]: 12
};
} catch(e) {}
console.log( o2 ); // undefined
o2 = {
[nameKey]: "lily",
};
console.log( o2 ); // { name: 'lily' }
/*
* 对象解构
*/
let person = {
name: 'aa',
age: 27
};
let { name, age } = person;
console.log( name, age ); // aa 27
let { name: nameValue, age: ageValue } = person;
console.log( nameValue, ageValue ); // aa 27
/*
let { job } = person;
// 相当于
// let job;
// job = person.job;
console.log( job ); // undefined
*/
let { job = 'OA' } = person;
// 相当于
// let job;
// job = person.job || 'OA';
console.log( job ) ;
let gender;
// { gender } = person; // SyntaxError: Unexpected token '='
({ gender } = person);
console.log( gender ); // undefined
let personName, personAge, personBar;
try {
({name: personName, foo: {bar: personBar}, age: personAge} = person);
} catch(e) {}
console.log( personName, personBar, personAge ); // aa undefined undefined
function printPerson(foo, {name, age}, bar) {
console.log( arguments );
console.log( name, age );
}
function printPerson2(foo, {name: personName, age: personAge}, bar) {
console.log( arguments );
console.log( personName, personAge );
}
printPerson( "1st", person, '2nd' );
// [Arguments] { '0': '1st', '1': { name: 'aa', age: 27 }, '2': '2nd' }
// aa 27
printPerson2( "1st", person, '2nd' );
// [Arguments] { '0': '1st', '1': { name: 'aa', age: 27 }, '2': '2nd' }
// aa 27
/*
* 对象创建 继承
*/
function Foo() {}
Foo.prototype = {};
let f = new Foo();
console.log( f.contructor === Foo ); // false
console.log( f instanceof Foo ); // true
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = new Function("console.log(this.name)");
}
let p1 = new Person("kk", 12, "farmer");
p1.sayName(); // kk
function Student() {}
Student.prototype = {
name: 'class1',
friends: [1, 2, 3]
};
let s1 = new Student();
let s2 = new Student();
s1.friends = [2, 3, 4];
console.log( s1.friends === s2.friends ); // false
console.log( s1.friends, s2.friends ); // [ 2, 3, 4 ] [ 1, 2, 3 ]
let k1 = Symbol('k1'), k2 = Symbol('k2');
let o1 = {
1: 1,
first: 'first',
[k1]: 'k1',
second: 'second',
0: 0
};
o1[k2] = 'k2';
o1[3] = 3;
o1.third = 'third';
console.log( Object.getOwnPropertyNames( o1 ) );
// [ '0', '1', '3', 'first', 'second', 'third' ]
console.log( Object.getOwnPropertySymbols( o1 ) );
// [ Symbol(k1), Symbol(k2) ]
Object.assign( o1, { 2: 2 } );
console.log( Object.getOwnPropertyNames( o1 ) );
// [ '0', '1', '2', '3', 'first', 'second', 'third' ]
类
-
类声明与类表达式
与函数的区别：
①函数声明可提升，类定义不行
②函数受函数作用域限制，类受块作用域限制
③默认情况下，类块中的代码在严格模式下执行
④类定义体中可包含constructor、实例方法、获取函数（get）、设置函数（set）和静态类方法（static关键字）。除了静态类方法，其他都定义在原型对象上。
类表达式的名称：
①可通过类表达式赋值的变量的name属性获取
②不能在类表达式作用域外部访问这个标识符
class 的所有方法（包括静态方法和实例方法）都没有原型对象 prototype，所以也没有[[construct]]，不能使用 new 来调用。
-
constructor 类构造函数
new调用类时，默认调用constructor函数。constructor函数必须使用new操作符调用。
关于定义：
如未定义，默认为空函数体。
关于返回：
如返回null、symbol、number、string、boolean，则返回刚创建的对象
如返回{}或其他非空对象，则返回该对象。
默认返回刚创建的对象。
实例.constructor 即 类.prototype.contructor
类.constructor 即 Function.prototype.constructor（类是函数的实例）
-
实例成员、原型成员、类成员
-
实例成员
在constructor中操作this，或在其他原型函数中操作this。
-
原型成员
在class块中定义的方法为原型方法，不能添加成员数据（原始值或对象）
获取或设置访问器也支持（get、set）
-
静态类成员
适合作实例工厂
-
其他：
在类定义外部可通过修改原型对象增加成员数据，但不推荐（在共享目标（原型、类）上添加可变数据成员），如
Person.prototype.name。支持生成器函数。普通对象，包括函数原型对象也支持生成器函数。
-
-
继承
-
语法 extends关键字
可继承class或function（向后兼容）等任何拥有[[construct]]和prototype的对象
-
constructor、HomeObject和super()
内部特性[[HomeObject]]始终指向定义该方法的对象（类）
constructor：
-
不显式定义：new调用时默认会调super()，并传入传给派生类的全部参数
-
显式定义：
必须调super()或者显式返回一个对象
要使用this必须先调super()
super语法：
- 只能在派生类的constructor和方法中使用
- 不能单独引用，必须调构造函数或引用静态方法或原型方法
- 调用super()后，将返回的实例赋值给this。如需传参给父类构造函数，需手动
-
-
"伪"对象基类
- 不能直接实例化（使用new.target进行拦截）
- 子类必须定义某个方法（在父类构造函数中用this.方法名进行检测）
-
继承内置类型
如果有实例方法返回新对象实例，默认情况下，新实例与调用实例方法的实例类型一致，如需修改这个行为，可覆盖Symbol.species访问器。如：
class ... { static get [Symbol.species]() { return Array; } } -
类混入
连缀多个混入元素
如：Person-(继承)->C->B->A
方式：
-
连缀调用
-
写一个辅助函数，把嵌套调用展开
function mix(BaseClass, ...Mixins) { return Mixins.reduce((accumulator, current)=>current(accumulator), BaseClass); }
不推荐使用：
软件设计原则——复合胜过继承。在代码设计中提供极大灵活性。
-
-
/* class定义不能被提升
console.log(A);
// node - ReferenceError: Cannot access 'A' before initialization
// chrome - ReferenceError: A is not defined
class A {}
*/
/* 作用域限制不一样
{
function FunctionDeclaration() {}
class ClassDelaration {}
}
console.log( FunctionDeclaration ); // [Function: FunctionDeclaration]
console.log( ClassDelaration ); // ReferenceError: ClassDelaration is not defined
*/
/* 类表达式赋值给变量后，类表达式的名称无法在类表达式作用域外部访问
let Person = class PersonName {
identify() {
console.log( Person.name, PersonName.name );
}
}
let p = new Person();
p.identify(); // PersonName PersonName
console.log( p ); // PersonName {}
console.log( Person.name ); // PersonName
console.log( PersonName ); // ReferenceError: PersonName is not defined
*/
/*
* constructor、实例成员、原型成员、类成员
*/
class Person {
set name(newName) { // name_会添加到实例上，name是在原型对象上
this.name_ = newName;
}
get name() {
return this.name_;
}
static locate() {
console.log( 'class', this );
}
static className() {
console.log( 'Person' );
}
}
let p1 = new Person();
// p1.constructor(); // TypeError: Class constructor Person cannot be invoked without 'new'
let p2 = new p1.constructor();
console.log( p2 ); // Person {}
console.log( p2 instanceof Person ); // true
console.log( Person ); // [class Person]
console.log( typeof Person ); // function
let p3 = new Person.constructor();
console.log( p3.constructor === Person ); // false
console.log( p3 instanceof Person ); // false
console.log( p3 instanceof Person.constructor ); // true
console.log( p1.constructor === Person.constructor ); // false
console.log( p1.constructor ); // [class Person]
console.log( Person.constructor ); // [Function: Function]
console.log( p1.constructor === Person.prototype.constructor ); // true
Person.locate(); // class [class Person]
let p = new class Foo {
constructor(x) {
console.log( x );
}
}('bar');
console.log( p );
// bar
// Foo {}
/*
* 继承
*/
function Job() {}
class Engineer extends Job {}
let e = new Engineer();
console.log( e instanceof Engineer ); // true
console.log( e instanceof Job ); // true
class Vehicle {
constructor(licensePlate) {
this.licensePlate = licensePlate;
if(new.target === Vehicle) { // "伪抽象基类（不能直接实例化）"
throw new Error('Vehicle cannot be directly instantiated');
}
if(!this.foo) { // 子类必须定义某个方法
throw new Error('Inheriting class must define foo()');
}
}
identifyPrototype(id) {
console.log( id, this );
}
static identifyClass(id) {
console.log( id, this );
}
}
class Bus extends Vehicle {
// constructor() {} // ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor
// 定义的constructor函数体内必须得调用super() 或者 返回一个对象; 如果要访问this，必须先调用super();
// constructor() { return {};}
/*constructor() {
// this.name = "test"; // ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor
super();
console.log( this instanceof Vehicle );
}*/
static identifyClass(id) {
console.log( id, 'overwrite', this );
}
foo() {}
}
// let v = new Vehicle(); // Error: Vehicle cannot be directly instantiated
let b = new Bus('1337H4X'); // Error: Inheriting class must define foo()
// new Bus(); // true
b.identifyPrototype('bus'); // bus Bus { licensePlate: '1337H4X' } // bus Bus {}
// v.identifyPrototype('vehicle'); // vehicle Vehicle {}
Bus.identifyClass('bus'); // bus overwrite [class Bus extends Vehicle]
Vehicle.identifyClass('vehicle'); // vehicle [class Vehicle]
// 类混入
let FooMixin = (Superclass) => class extends Superclass {
foo() {
console.log( 'foo' );
}
};
let BarMixin = (Superclass) => class extends Superclass {
bar() {
console.log( 'bar' );
}
};
let BazMixin = (Superclass) => class extends Superclass {
baz() {
console.log( 'baz' );
}
};
function mix(BaseClass, ...Minxins) {
return Minxins.reduce((accumulator, current) => current(accumulator), BaseClass);
}
class Bus1 extends mix(Vehicle, BazMixin, BarMixin, FooMixin){};
let bb1 = new Bus1();
bb1.foo(); // foo
bb1.bar(); // bar
bb1.baz(); // baz
class TestSuper {
foo() {
console.log( 'instance super.foo' );
}
static foo() {
console.log( 'super.foo' );
}
}
class TestSub extends TestSuper{
foo() {
super.foo();
console.log( 'instance sub.foo' );
}
static foo() {
super.foo();
console.log( 'sub.foo' );
}
}
let sub = new TestSub();
sub.foo();
// instance super.foo
// instance sub.foo
TestSub.foo();
// super.foo
// sub.foo
本文来自博客园，作者：beckyye，转载请注明原文链接：https://www.cnblogs.com/beckyyyy/p/16786375.html
