写给不耐烦程序员的 JavaScript 指南（四）

const myObject = { // object literal
 myProperty: 1,
 myMethod() {
 return 2;
 }, // comma!
 get myAccessor() {
 return this.myProperty;
 }, // comma!
 set myAccessor(value) {
 this.myProperty = value;
 }, // last comma is optional
};
assert.equal(
 myObject.myProperty, 1
);
assert.equal(
 myObject.myMethod(), 2
);
assert.equal(
 myObject.myAccessor, 1
);
myObject.myAccessor = 3;
assert.equal(
 myObject.myProperty, 3
);

const original = {
 a: 1,
 b: {
 c: 3,
 },
};
// Spreading (...) copies one object “into” another one:
const modifiedCopy = {
 ...original, // spreading
 d: 4,
};
assert.deepEqual(
 modifiedCopy,
 {
 a: 1,
 b: {
 c: 3,
 },
 d: 4,
 }
);
// Caveat: spreading copies shallowly (property values are shared)
modifiedCopy.a = 5; // does not affect `original`
modifiedCopy.b.c = 6; // affects `original`
assert.deepEqual(
 original,
 {
 a: 1, // unchanged
 b: {
 c: 6, // changed
 },
 },
);

const exactCopy = {...obj};

// `obj1` has no prototype (its prototype is `null`)
const obj1 = Object.create(null); // (A)
assert.equal(
 Object.getPrototypeOf(obj1), null // (B)
);
// `obj2` has the prototype `proto`
const proto = {
 protoProp: 'protoProp',
};
const obj2 = {
 __proto__: proto, // (C)
 objProp: 'objProp',
}
assert.equal(
 Object.getPrototypeOf(obj2), proto
);

// `obj2` inherits .protoProp from `proto`
assert.equal(
 obj2.protoProp, 'protoProp'
);
assert.deepEqual(
 Reflect.ownKeys(obj2),
 ['objProp'] // own properties of `obj2`
);

const fixedLayoutObject = {
 product: 'carrot',
 quantity: 4,
};

const dictionaryObject = {
 ['one']: 1,
 ['two']: 2,
};

const jane = {
 first: 'Jane',
 last: 'Doe', // optional trailing comma
};

const obj = {
 if: true,
 const: true,
};

> Object.keys({a:1, b:2})
[ 'a', 'b' ]

function createPoint(x, y) {
 return {x, y}; // Same as: {x: x, y: y}
}
assert.deepEqual(
 createPoint(9, 2),
 { x: 9, y: 2 }
);

const jane = {
 first: 'Jane',
 last: 'Doe',
};
// Get property .first
assert.equal(jane.first, 'Jane'); // (A)

assert.equal(jane.unknownProperty, undefined);

const obj = {
 prop: 1,
};
assert.equal(obj.prop, 1);
obj.prop = 2; // (A)
assert.equal(obj.prop, 2);

const obj = {}; // empty object
assert.deepEqual(
 Object.keys(obj), []);
obj.unknownProperty = 'abc';
assert.deepEqual(
 Object.keys(obj), ['unknownProperty']);

const jane = {
 first: 'Jane', // value property
 says(text) {   // method
 return `${this.first} says “${text}”`; // (A)
 }, // comma as separator (optional at end)
};
assert.equal(jane.says('hello'), 'Jane says “hello”');

const jane = {
 first: 'Jane',
 last: 'Doe',
 get full() {
 return `${this.first}  ${this.last}`;
 },
};
assert.equal(jane.full, 'Jane Doe');
jane.first = 'John';
assert.equal(jane.full, 'John Doe');

const jane = {
 first: 'Jane',
 last: 'Doe',
 set full(fullName) {
 const parts = fullName.split(' ');
 this.first = parts[0];
 this.last = parts[1];
 },
};
jane.full = 'Richard Roe';
assert.equal(jane.first, 'Richard');
assert.equal(jane.last, 'Roe');

> const obj = {one: 1, two: 2};
> {...obj, three: 3}
{ one: 1, two: 2, three: 3 }

const obj1 = {one: 1, two: 2};
const obj2 = {three: 3};
assert.deepEqual(
 {...obj1, ...obj2, four: 4},
 {one: 1, two: 2, three: 3,  four: 4}
);

> const obj = {one: 1, two: 2, three: 3};
> {...obj, one: true}
{ one: true, two: 2, three: 3 }
> {one: true, ...obj}
{ one: 1, two: 2, three: 3 }

> {...undefined}
{}
> {...null}
{}
> {...123}
{}
> {...'abc'}
{ '0': 'a', '1': 'b', '2': 'c' }
> {...['a', 'b']}
{ '0': 'a', '1': 'b' }

const symbolKey = Symbol('symbolKey');
const obj = {
 stringKey: 1,
 [symbolKey]: 2,
};
assert.deepEqual(
 {...obj, anotherStringKey: 3},
 {
 stringKey: 1,
 [symbolKey]: 2,
 anotherStringKey: 3,
 }
);

const copy = {...original};

const original = { a: 1, b: {prop: true} };
const copy = {...original};

copy.a = 2;
assert.deepEqual(
 original, { a: 1, b: {prop: true} }); // no change

copy.b.prop = false;
assert.deepEqual(
 original, { a: 1, b: {prop: false} });

const DEFAULTS = {alpha: 'a', beta: 'b'};
const providedData = {alpha: 1};
const allData = {...DEFAULTS, ...providedData};
assert.deepEqual(allData, {alpha: 1, beta: 'b'});

const providedData = {alpha: 1};
const allData = {alpha: 'a', beta: 'b', ...providedData};
assert.deepEqual(allData, {alpha: 1, beta: 'b'});

const obj = {alpha: 'a', beta: 'b'};
obj.alpha = 1; // (A)
assert.deepEqual(obj, {alpha: 1, beta: 'b'});

const obj = {alpha: 'a', beta: 'b'};
const updatedObj = {...obj, alpha: 1};
assert.deepEqual(updatedObj, {alpha: 1, beta: 'b'});

Object.assign(target, source_1, source_2, ···)

const target = { a: 1 };
const result = Object.assign(
 target,
 {b: 2},
 {c: 3, b: true});
assert.deepEqual(
 result, { a: 1, b: true, c: 3 });
// target was modified and returned:
assert.equal(result, target);

const jane = {
 first: 'Jane',
 says(text) {
 return `${this.first} says “${text}”`;
 },
};

assert.equal(typeof jane.says, 'function');

const jane = {
 first: 'Jane',
 says: function (text) {
 return `${this.first} says “${text}”`;
 },
};

const obj = {
 someMethod(x, y) {
 assert.equal(this, obj); // (A)
 assert.equal(x, 'a');
 assert.equal(y, 'b');
 }
};
obj.someMethod('a', 'b'); // (B)

obj.someMethod('a', 'b')

obj.someMethod.call(obj, 'a', 'b');

const func = obj.someMethod;
func.call(obj, 'a', 'b');

const jane = {
 first: 'Jane',
 says(text) {
 return `${this.first} says “${text}”`; // (A)
 },
};
const func = jane.says.bind(jane, 'hello');
assert.equal(func(), 'Jane says “hello”');

const jane = {
 first: 'Jane',
 says(text) {
 return `${this.first} says “${text}”`;
 },
};
const func = jane.says; // extract the method
assert.throws(
 () => func('hello'), // (A)
 {
 name: 'TypeError',
 message: "Cannot read properties of undefined (reading 'first')",
 });

assert.throws(
 () => jane.says.call(undefined, 'hello'), // `this` is undefined!
 {
 name: 'TypeError',
 message: "Cannot read properties of undefined (reading 'first')",
 }
);

const func2 = jane.says.bind(jane);
assert.equal(func2('hello'), 'Jane says “hello”');

const func3 = text => jane.says(text);
assert.equal(func3('hello'), 'Jane says “hello”');

class ClickHandler {
 constructor(id, elem) {
 this.id = id;
 elem.addEventListener('click', this.handleClick); // (A)
 }
 handleClick(event) {
 alert('Clicked ' + this.id);
 }
}

const listener = this.handleClick.bind(this);
elem.addEventListener('click', listener);
// Later, possibly:
elem.removeEventListener('click', listener);

const prefixer = {
 prefix: '==> ',
 prefixStringArray(stringArray) {
 return stringArray.map(
 function (x) {
 return this.prefix + x; // (A)
 });
 },
};
assert.throws(
 () => prefixer.prefixStringArray(['a', 'b']),
 {
 name: 'TypeError',
 message: "Cannot read properties of undefined (reading 'prefix')",
 }
);

const prefixer = {
 prefix: '==> ',
 prefixStringArray(stringArray) {
 return stringArray.map(
 (x) => {
 return this.prefix + x;
 });
 },
};
assert.deepEqual(
 prefixer.prefixStringArray(['a', 'b']),
 ['==> a', '==> b']);

prefixStringArray(stringArray) {
 const that = this; // (A)
 return stringArray.map(
 function (x) {
 return that.prefix + x;
 });
},

prefixStringArray(stringArray) {
 return stringArray.map(
 function (x) {
 return this.prefix + x;
 }.bind(this)); // (A)
},

prefixStringArray(stringArray) {
 return stringArray.map(
 function (x) {
 return this.prefix + x;
 },
 this); // (A)
},

obj?.prop     // optional fixed property getting
obj?.[«expr»] // optional dynamic property getting
func?.(«arg0», «arg1») // optional function or method call

> null?.prop
undefined
> {prop: 1}?.prop
1
> null?.(123)
undefined
> String?.(123)
'123'

const persons = [
 {
 surname: 'Zoe',
 address: {
 street: {
 name: 'Sesame Street',
 number: '123',
 },
 },
 },
 {
 surname: 'Mariner',
 },
 {
 surname: 'Carmen',
 address: {
 },
 },
];

const streetNames = persons.map(
 p => p.address?.street?.name);
assert.deepEqual(
 streetNames, ['Sesame Street', undefined, undefined]
);

const streetNames = persons.map(
 p => p.address?.street?.name ?? '(no name)');
assert.deepEqual(
 streetNames, ['Sesame Street', '(no name)', '(no name)']
);

o?.prop
(o !== undefined && o !== null) ? o.prop : undefined

assert.equal(undefined?.prop, undefined);
assert.equal(null?.prop,      undefined);
assert.equal({prop:1}?.prop,  1);

o?.[«expr»]
(o !== undefined && o !== null) ? o[«expr»] : undefined

const key = 'prop';
assert.equal(undefined?.[key], undefined);
assert.equal(null?.[key], undefined);
assert.equal({prop:1}?.[key], 1);

f?.(arg0, arg1)
(f !== undefined && f !== null) ? f(arg0, arg1) : undefined

assert.equal(undefined?.(123), undefined);
assert.equal(null?.(123), undefined);
assert.equal(String?.(123), '123');

assert.throws(
 () => true?.(123),
 TypeError);

function invokeM(value) {
 return value?.a.b.m(); // (A)
}
const obj = {
 a: {
 b: {
 m() { return 'result' }
 }
 }
};
assert.equal(
 invokeM(obj), 'result'
);
assert.equal(
 invokeM(undefined), undefined // (B)
);

obj?.[«expr»]          // better: obj?[«expr»]
func?.(«arg0», «arg1») // better: func?(«arg0», «arg1»)

obj?['a', 'b', 'c'].map(x => x+x)
obj ? ['a', 'b', 'c'].map(x => x+x) : []

const obj = {
 mustBeAnIdentifier: 123,
};
// Get property
assert.equal(obj.mustBeAnIdentifier, 123);
// Set property
obj.mustBeAnIdentifier = 'abc';
assert.equal(obj.mustBeAnIdentifier, 'abc');

const obj = {
 'Can be any string!': 123,
};

// Get property
assert.equal(obj['Can be any string!'], 123);
// Set property
obj['Can be any string!'] = 'abc';
assert.equal(obj['Can be any string!'], 'abc');

const obj = {
 'A nice method'() {
 return 'Yes!';
 },
};
assert.equal(obj['A nice method'](), 'Yes!');

const obj = {
 ['Hello world!']: true,
 ['p'+'r'+'o'+'p']: 123,
 [Symbol.toStringTag]: 'Goodbye', // (A)
};
assert.equal(obj['Hello world!'], true);
assert.equal(obj.prop, 123);
assert.equal(obj[Symbol.toStringTag], 'Goodbye');

assert.equal(obj['p'+'r'+'o'+'p'], 123);
assert.equal(obj['==> prop'.slice(4)], 123);

const methodKey = Symbol();
const obj = {
 [methodKey]() {
 return 'Yes!';
 },
};
assert.equal(obj[methodKey](), 'Yes!');

const obj = {
 alpha: 'abc',
 beta: false,
};
assert.equal('alpha' in obj, true);
assert.equal('beta' in obj, true);
assert.equal('unknownKey' in obj, false);

assert.equal(
 obj.alpha ? 'exists' : 'does not exist',
 'exists');
assert.equal(
 obj.unknownKey ? 'exists' : 'does not exist',
 'does not exist');

assert.equal(
 obj.beta ? 'exists' : 'does not exist',
 'does not exist'); // should be: 'exists'

const obj = {
 myProp: 123,
};
assert.deepEqual(Object.keys(obj), ['myProp']);
delete obj.myProp;
assert.deepEqual(Object.keys(obj), []);

const enumerableSymbolKey = Symbol('enumerableSymbolKey');
const nonEnumSymbolKey = Symbol('nonEnumSymbolKey');
// We create enumerable properties via an object literal
const obj = {
 enumerableStringKey: 1,
 [enumerableSymbolKey]: 2,
}
// For non-enumerable properties, we need a more powerful tool
Object.defineProperties(obj, {
 nonEnumStringKey: {
 value: 3,
 enumerable: false,
 },
 [nonEnumSymbolKey]: {
 value: 4,
 enumerable: false,
 },
});
// Non-enumerable properties are ignored by spreading:
assert.deepEqual(
 {...obj},
 {
 enumerableStringKey: 1,
 [enumerableSymbolKey]: 2,
 }
);

const enumerableSymbolKey = Symbol('enumerableSymbolKey');
const nonEnumSymbolKey = Symbol('nonEnumSymbolKey');
const obj = {
 enumerableStringKey: 1,
 [enumerableSymbolKey]: 2,
}
Object.defineProperties(obj, {
 nonEnumStringKey: {
 value: 3,
 enumerable: false,
 },
 [nonEnumSymbolKey]: {
 value: 4,
 enumerable: false,
 },
});
assert.deepEqual(
 Object.keys(obj),
 ['enumerableStringKey']
);
assert.deepEqual(
 Object.getOwnPropertyNames(obj),
 ['enumerableStringKey', 'nonEnumStringKey']
);
assert.deepEqual(
 Object.getOwnPropertySymbols(obj),
 [enumerableSymbolKey, nonEnumSymbolKey]
);
assert.deepEqual(
 Reflect.ownKeys(obj),
 [
 'enumerableStringKey', 'nonEnumStringKey',
 enumerableSymbolKey, nonEnumSymbolKey,
 ]
);

const firstName = Symbol('firstName');
const obj = {
 [firstName]: 'Jane',
 lastName: 'Doe',
};
assert.deepEqual(
 Object.values(obj),
 ['Doe']);

const firstName = Symbol('firstName');
const obj = {
 [firstName]: 'Jane',
 lastName: 'Doe',
};
assert.deepEqual(
 Object.entries(obj),
 [
 ['lastName', 'Doe'],
 ]);

function entries(obj) {
 return Object.keys(obj)
 .map(key => [key, obj[key]]);
}

> Object.keys({b:0,a:0, 10:0,2:0})
[ '2', '10', 'b', 'a' ]

const symbolKey = Symbol('symbolKey');
assert.deepEqual(
 Object.fromEntries(
 [
 ['stringKey', 1],
 [symbolKey, 2],
 ]
 ),
 {
 stringKey: 1,
 [symbolKey]: 2,
 }
);

pick(object, ...keys)

const address = {
 street: 'Evergreen Terrace',
 number: '742',
 city: 'Springfield',
 state: 'NT',
 zip: '49007',
};
assert.deepEqual(
 pick(address, 'street', 'number'),
 {
 street: 'Evergreen Terrace',
 number: '742',
 }
);

function pick(object, ...keys) {
 const filteredEntries = Object.entries(object)
 .filter(([key, _value]) => keys.includes(key));
 return Object.fromEntries(filteredEntries);
}

invert(object)

assert.deepEqual(
 invert({a: 1, b: 2, c: 3}),
 {1: 'a', 2: 'b', 3: 'c'}
);

function invert(object) {
 const reversedEntries = Object.entries(object)
 .map(([key, value]) => [value, key]);
 return Object.fromEntries(reversedEntries);
}

function fromEntries(iterable) {
 const result = {};
 for (const [key, value] of iterable) {
 let coercedKey;
 if (typeof key === 'string' || typeof key === 'symbol') {
 coercedKey = key;
 } else {
 coercedKey = String(key);
 }
 result[coercedKey] = value;
 }
 return result;
}

const dict = {};
assert.equal('toString' in dict, true);

const dict = {};
dict['__proto__'] = 123;
// No property was added to dict:
assert.deepEqual(Object.keys(dict), []);

const dict = Object.create(null); // prototype is `null`
assert.equal('toString' in dict, false); // (A)
dict['__proto__'] = 123;
assert.deepEqual(Object.keys(dict), ['__proto__']);

const obj = { myProp: 123 };
assert.deepEqual(
 Object.getOwnPropertyDescriptor(obj, 'myProp'),
 {
 value: 123,
 writable: true,
 enumerable: true,
 configurable: true,
 });

assert.deepEqual(Object.keys(obj), ['myProp']);
// Hide property `myProp` from Object.keys()
// by making it non-enumerable
Object.defineProperty(obj, 'myProp', {
 enumerable: false,
});
assert.deepEqual(Object.keys(obj), []);

const frozen = Object.freeze({ x: 2, y: 5 });
assert.throws(
 () => { frozen.x = 7 },
 {
 name: 'TypeError',
 message: /^Cannot assign to read only property 'x'/,
 });

const proto = {
 protoProp: 'a',
};
const obj = {
 __proto__: proto,
 objProp: 'b',
};
// obj inherits .protoProp:
assert.equal(obj.protoProp, 'a');
assert.equal('protoProp' in obj, true);

> const obj = { one: 1 };
> typeof obj.one // own
'number'
> typeof obj.toString // inherited
'function'

> Object.keys(obj)
[ 'one' ]

const proto = {
 protoProp: 'a',
};
const obj = {
 __proto__: proto,
 objProp: 'b',
};

// In the beginning, obj has one own property
assert.deepEqual(Object.keys(obj), ['objProp']);
obj.protoProp = 'x'; // (A)
// We created a new own property:
assert.deepEqual(Object.keys(obj), ['objProp', 'protoProp']);
// The inherited property itself is unchanged:
assert.equal(proto.protoProp, 'a');
// The own property overrides the inherited property:
assert.equal(obj.protoProp, 'x');

Object.getPrototypeOf(obj: Object) : Object

Object.create(proto: Object) : Object

const proto1 = {};
const proto2a = {};
const proto2b = {};
const obj1 = {
 __proto__: proto1,
 a: 1,
 b: 2,
};
assert.equal(Object.getPrototypeOf(obj1), proto1);
const obj2 = Object.create(
 proto2a,
 {
 a: {
 value: 1,
 writable: true,
 enumerable: true,
 configurable: true,
 },
 b: {
 value: 2,
 writable: true,
 enumerable: true,
 configurable: true,
 }, 
 }
);
assert.equal(Object.getPrototypeOf(obj2), proto2a);
Object.setPrototypeOf(obj2, proto2b);
assert.equal(Object.getPrototypeOf(obj2), proto2b);

const a = {};
const b = {__proto__: a};
const c = {__proto__: b};
assert.equal(a.isPrototypeOf(b), true);
assert.equal(a.isPrototypeOf(c), true);
assert.equal(c.isPrototypeOf(a), false);
assert.equal(a.isPrototypeOf(a), false);

const proto = {
 protoProp: 'protoProp',
};
const obj = {
 __proto__: proto,
 objProp: 'objProp',
}
assert.equal('protoProp' in obj, true); // (A)
assert.equal(Object.hasOwn(obj, 'protoProp'), false); // (B)
assert.equal(Object.hasOwn(proto, 'protoProp'), true); // (C)

const jane = {
 firstName: 'Jane',
 describe() {
 return 'Person named '+this.firstName;
 },
};
const tarzan = {
 firstName: 'Tarzan',
 describe() {
 return 'Person named '+this.firstName;
 },
};
assert.equal(jane.describe(), 'Person named Jane');
assert.equal(tarzan.describe(), 'Person named Tarzan');

const PersonProto = {
 describe() {
 return 'Person named ' + this.firstName;
 },
};
const jane = {
 __proto__: PersonProto,
 firstName: 'Jane',
};
const tarzan = {
 __proto__: PersonProto,
 firstName: 'Tarzan',
};

assert.equal(jane.describe(), 'Person named Jane');
assert.equal(tarzan.describe(), 'Person named Tarzan');

class Person {
 #firstName; // (A)
 constructor(firstName) {
 this.#firstName = firstName; // (B)
 }
 describe() {
 return `Person named ${this.#firstName}`;
 }
 static extractNames(persons) {
 return persons.map(person => person.#firstName);
 }
}
const tarzan = new Person('Tarzan');
assert.equal(
 tarzan.describe(),
 'Person named Tarzan'
);
assert.deepEqual(
 Person.extractNames([tarzan, new Person('Cheeta')]),
 ['Tarzan', 'Cheeta']
);

class Employee extends Person {
 constructor(firstName, title) {
 super(firstName);
 this.title = title; // (C)
 }
 describe() {
 return super.describe() +
 ` (${this.title})`;
 }
}
const jane = new Employee('Jane', 'CTO');
assert.equal(
 jane.title,
 'CTO'
);
assert.equal(
 jane.describe(),
 'Person named Jane (CTO)'
);

class Person {
 #firstName; // (A)
 constructor(firstName) {
 this.#firstName = firstName; // (B)
 }
 describe() {
 return `Person named ${this.#firstName}`;
 }
 static extractNames(persons) {
 return persons.map(person => person.#firstName);
 }
}

const jane = new Person('Jane');
const tarzan = new Person('Tarzan');

assert.deepEqual(
 Reflect.ownKeys(jane),
 []
);

assert.equal(
 jane.describe(), 'Person named Jane'
);
assert.equal(
 tarzan.describe(), 'Person named Tarzan'
);

assert.deepEqual(
 Person.extractNames([jane, tarzan]),
 ['Jane', 'Tarzan']
);

class Container {
 constructor(value) {
 this.value = value;
 }
}
const abcContainer = new Container('abc');
assert.equal(
 abcContainer.value, 'abc'
);

// Anonymous class expression
const Person = class { ··· };
// Named class expression
const Person = class MyClass { ··· };

> new Person('Jane') instanceof Person
true
> {} instanceof Person
false
> {} instanceof Object
true
> [] instanceof Array
true

class MyClass {
 #instancePrivateField = 1;
 instanceProperty = 2;
 getInstanceValues() {
 return [
 this.#instancePrivateField,
 this.instanceProperty,
 ];
 }
}
const inst = new MyClass();
assert.deepEqual(
 inst.getInstanceValues(), [1, 2]
);

assert.deepEqual(
 Reflect.ownKeys(inst),
 ['instanceProperty']
);

class SuperClass {
 #superProp = 'superProp';
}
class SubClass extends SuperClass {
 getSuperProp() {
 return this.#superProp;
 }
}
// SyntaxError: Private field '#superProp'
// must be declared in an enclosing class

class MyClass {
 #instancePrivateField = 1;
 instanceProperty = 2;
 getInstanceValues() {
 return [
 this.#instancePrivateField,
 this.instanceProperty,
 ];
 }
}

let MyClass;
{ // Scope of the body of the class
 const instancePrivateFieldKey = Symbol();
 MyClass = class {
 // Very loose approximation of how this
 // works in the language specification
 __PrivateElements__ = new Map([
 [instancePrivateFieldKey, 1],
 ]);
 instanceProperty = 2;
 getInstanceValues() {
 return [
 this.__PrivateElements__.get(instancePrivateFieldKey),
 this.instanceProperty,
 ];
 }
 }
}

class Color {
 #name; // (A)
 constructor(name) {
 this.#name = name; // (B)
 }
 static getName(obj) {
 return obj.#name;
 }
}
class Person {
 #name; // (C)
 constructor(name) {
 this.#name = name;
 }
}
assert.equal(
 Color.getName(new Color('green')), 'green'
);
// We can’t access the private slot #name of a Person in line B:
assert.throws(
 () => Color.getName(new Person('Jane')),
 {
 name: 'TypeError',
 message: 'Cannot read private member #name from'
 + ' an object whose class did not declare it',
 }
);

class SuperClass {
 #privateField = 'super';
 getSuperPrivateField() {
 return this.#privateField;
 }
}
class SubClass extends SuperClass {
 #privateField = 'sub';
 getSubPrivateField() {
 return this.#privateField;
 }
}
const inst = new SubClass();
assert.equal(
 inst.getSuperPrivateField(), 'super'
);
assert.equal(
 inst.getSubPrivateField(), 'sub'
);

class Color {
 #name;
 constructor(name) {
 this.#name = name;
 }
 static check(obj) {
 return #name in obj; // (A)
 }
}

class C1 {
 #priv() {}
 static check(obj) {
 return #priv in obj;
 }
}
assert.equal(C1.check(new C1()), true);

class C2 {
 static #priv = 1;
 static check(obj) {
 return #priv in obj;
 }
}
assert.equal(C2.check(C2), true);
assert.equal(C2.check(new C2()), false);

class C3 {
 static #priv() {}
 static check(obj) {
 return #priv in obj;
 }
}
assert.equal(C3.check(C3), true);

class Color {
 #name;
 constructor(name) {
 this.#name = name;
 }
 static check(obj) {
 return #name in obj;
 }
}
class Person {
 #name;
 constructor(name) {
 this.#name = name;
 }
 static check(obj) {
 return #name in obj;
 }
}
// Detecting Color’s #name
assert.equal(
 Color.check(new Color()), true
);
assert.equal(
 Color.check(new Person()), false
);
// Detecting Person’s #name
assert.equal(
 Person.check(new Person()), true
);
assert.equal(
 Person.check(new Color()), false
);

class Person {
 #firstName;
 constructor(firstName) {
 this.#firstName = firstName;
 }
 describe() {
 return `Person named ${this.#firstName}`;
 }
 static extractNames(persons) {
 return persons.map(person => person.#firstName);
 }
}

assert.deepEqual(
 Reflect.ownKeys(Person),
 ['length', 'name', 'prototype', 'extractNames']
);
// The number of parameters of the constructor
assert.equal(
 Person.length, 1
);
// The name of the class
assert.equal(
 Person.name, 'Person'
);

assert.deepEqual(
 Reflect.ownKeys(Person.prototype),
 ['constructor', 'describe']
);

const jane = new Person('Jane');
assert.equal(
 Object.getPrototypeOf(jane), Person.prototype
);
const tarzan = new Person('Tarzan');
assert.equal(
 Object.getPrototypeOf(tarzan), Person.prototype
);

> Person.prototype.constructor === Person
true

const jane = new Person('Jane');
const cheeta = new jane.constructor('Cheeta');
// cheeta is also an instance of Person
assert.equal(cheeta instanceof Person, true);

const tarzan = new Person('Tarzan');
assert.equal(tarzan.constructor.name, 'Person');

class Person {
 #firstName;
 constructor(firstName) {
 this.#firstName = firstName;
 }
 describe() {
 return 'Person named '+this.#firstName;
 }
}
const jane = new Person('Jane');

jane.describe()

const func = jane.describe;

func.call(jane);

Person.prototype.describe.call(jane)

const obj = Object.create(null);
// `obj` is not an instance of Object and doesn’t inherit
// its prototype method .toString()
assert.throws(
 () => obj.toString(),
 /^TypeError: obj.toString is not a function$/
);
assert.equal(
 Object.prototype.toString.call(obj),
 '[object Object]'
);

function StringBuilderConstr(initialString) {
 this.string = initialString;
}
StringBuilderConstr.prototype.add = function (str) {
 this.string += str;
 return this;
};
const sb = new StringBuilderConstr('¡');
sb.add('Hola').add('!');
assert.equal(
 sb.string, '¡Hola!'
);

class StringBuilderClass {
 constructor(initialString) {
 this.string = initialString;
 }
 add(str) {
 this.string += str;
 return this;
 }
}
const sb = new StringBuilderClass('¡');
sb.add('Hola').add('!');
assert.equal(
 sb.string, '¡Hola!'
);

function SuperConstructor() {}
class SubClass extends SuperConstructor {}
assert.equal(
 new SubClass() instanceof SuperConstructor, true
);

> StringBuilderClass.prototype.constructor === StringBuilderClass
true
> typeof StringBuilderClass
'function'

class PublicProtoClass {
 constructor(args) {
 // (Do something with `args` here.)
 }
 publicProtoMethod() {
 return 'publicProtoMethod';
 }
 get publicProtoAccessor() {
 return 'publicProtoGetter';
 }
 set publicProtoAccessor(value) {
 assert.equal(value, 'publicProtoSetter');
 }
}
assert.deepEqual(
 Reflect.ownKeys(PublicProtoClass.prototype),
 ['constructor', 'publicProtoMethod', 'publicProtoAccessor']
);
const inst = new PublicProtoClass('arg1', 'arg2');
assert.equal(
 inst.publicProtoMethod(), 'publicProtoMethod'
);
assert.equal(
 inst.publicProtoAccessor, 'publicProtoGetter'
);
inst.publicProtoAccessor = 'publicProtoSetter';

const accessorKey = Symbol('accessorKey');
const syncMethodKey = Symbol('syncMethodKey');
const syncGenMethodKey = Symbol('syncGenMethodKey');
const asyncMethodKey = Symbol('asyncMethodKey');
const asyncGenMethodKey = Symbol('asyncGenMethodKey');
class PublicProtoClass2 {
 // Identifier keys
 get accessor() {}
 set accessor(value) {}
 syncMethod() {}
 * syncGeneratorMethod() {}
 async asyncMethod() {}
 async * asyncGeneratorMethod() {}
 // Quoted keys
 get 'an accessor'() {}
 set 'an accessor'(value) {}
 'sync method'() {}
 * 'sync generator method'() {}
 async 'async method'() {}
 async * 'async generator method'() {}
 // Computed keys
 get [accessorKey]() {}
 set accessorKey {}
 [syncMethodKey]() {}
 * [syncGenMethodKey]() {}
 async [asyncMethodKey]() {}
 async * [asyncGenMethodKey]() {}
}
// Quoted and computed keys are accessed via square brackets:
const inst = new PublicProtoClass2();
inst['sync method']();
inst[syncMethodKey]();

class MyClass {
 #privateMethod() {}
 static check() {
 const inst = new MyClass();
 assert.equal(
 #privateMethod in inst, true // (A)
 );
 assert.equal(
 #privateMethod in MyClass.prototype, false
 );
 assert.equal(
 #privateMethod in MyClass, false
 );
 }
}
MyClass.check();

class MyClass {
 #privateMethod() {}
 static check() {
 const inst1 = new MyClass();
 const inst2 = new MyClass();
 assert.equal(
 inst1.#privateMethod,
 inst2.#privateMethod
 );
 }
}

class PrivateMethodClass {
 #privateMethod() {
 return 'privateMethod';
 }
 get #privateAccessor() {
 return 'privateGetter';
 }
 set #privateAccessor(value) {
 assert.equal(value, 'privateSetter');
 }
 callPrivateMembers() {
 assert.equal(this.#privateMethod(), 'privateMethod');
 assert.equal(this.#privateAccessor, 'privateGetter');
 this.#privateAccessor = 'privateSetter';
 }
}
assert.deepEqual(
 Reflect.ownKeys(new PrivateMethodClass()), []
);

class PrivateMethodClass2 {
 get #accessor() {}
 set #accessor(value) {}
 #syncMethod() {}
 * #syncGeneratorMethod() {}
 async #asyncMethod() {}
 async * #asyncGeneratorMethod() {}
}

class InstPublicClass {
 // Instance public field
 instancePublicField = 0; // (A)
 constructor(value) {
 // We don’t need to mention .property elsewhere!
 this.property = value; // (B)
 }
}
const inst = new InstPublicClass('constrArg');
assert.deepEqual(
 Reflect.ownKeys(inst),
 ['instancePublicField', 'property']
);
assert.equal(
 inst.instancePublicField, 0
);
assert.equal(
 inst.property, 'constrArg'
);

const computedFieldKey = Symbol('computedFieldKey');
class InstPublicClass2 {
 'quoted field key' = 1;
 [computedFieldKey] = 2;
}
const inst = new InstPublicClass2();
assert.equal(inst['quoted field key'], 1);
assert.equal(inst[computedFieldKey], 2);

class MyClass {
 instancePublicField = this;
}
const inst = new MyClass();
assert.equal(
 inst.instancePublicField, inst
);

class SuperClass {
 superProp = console.log('superProp');
 constructor() {
 console.log('super-constructor');
 }
}
class SubClass extends SuperClass {
 subProp = console.log('subProp');
 constructor() {
 console.log('BEFORE super()');
 super();
 console.log('AFTER super()');
 }
}
new SubClass();
// Output:
// 'BEFORE super()'
// 'superProp'
// 'super-constructor'
// 'subProp'
// 'AFTER super()'

class InstPrivateClass {
 #privateField1 = 'private field 1'; // (A)
 #privateField2; // (B) required!
 constructor(value) {
 this.#privateField2 = value; // (C)
 }
 /**
 * Private fields are not accessible outside the class body.
 */
 checkPrivateValues() {
 assert.equal(
 this.#privateField1, 'private field 1'
 );
 assert.equal(
 this.#privateField2, 'constructor argument'
 );
 }
}
const inst = new InstPrivateClass('constructor argument');
 inst.checkPrivateValues();
// No instance properties were created
assert.deepEqual(
 Reflect.ownKeys(inst),
 []
);

class Countdown {
 constructor(counter, action) {
 this._counter = counter;
 this._action = action;
 }
 dec() {
 this._counter--;
 if (this._counter === 0) {
 this._action();
 }
 }
}
// The two properties aren’t really private:
assert.deepEqual(
 Object.keys(new Countdown()),
 ['_counter', '_action']);

const _counter = new WeakMap();
const _action = new WeakMap();
class Countdown {
 constructor(counter, action) {
 _counter.set(this, counter);
 _action.set(this, action);
 }
 dec() {
 let counter = _counter.get(this);
 counter--;
 _counter.set(this, counter);
 if (counter === 0) {
 _action.get(this)();
 }
 }
}
// The two pseudo-properties are truly private:
assert.deepEqual(
 Object.keys(new Countdown()),
 []);

let Countdown;
{ // class scope
 const _counter = new WeakMap();
 const _action = new WeakMap();
 Countdown = class {
 // ···
 }
}