const obj = {  funcA: () => {    console.log('funcA')  },  funcB: function() {    console.log('funcB')  },  funcC: function namedFunc() {    console.log('funcB')  },}

//通过字面量创建的对象，其 [[Prototype]] 是 Object.prototypeconst parent = {  value: 2,  getValue() {    return this.value  },}// child 创建时指定 [[Prototype]] 为 parentconst child = {  __proto__: parent,}console.log(child.getValue()) // 2console.log(parent.getValue()) // 2, getValue 中的 this 指向 parent

const parent = {  value: 2,  getValue() {    return this.value  },}const child = {  __proto__: parent,}child.value = 4console.log(child.value) // 4console.log(child.getValue()) // 4，this 指向 childconsole.log(parent.value) // 2console.log(Object.hasOwn(child, 'value')) // true

const parent = {  value: 2,}const child = {  value: 4,  __proto__: parent,}console.log(child.value) // 4delete child.valueconsole.log(child.value) // 2，继续查找到 parent.valueconsole.log(Object.hasOwn(child, 'value')) // falseconsole.log('value' in child) // true，原型链中仍有 valueconsole.log(parent.value) // 2

const values = ['a', 'b']delete values[0]console.log(values.length) // 2console.log(0 in values) // falseconsole.log(values[0]) // undefined

function Box(value) {  this.value = value;}Box.prototype.getValue = function() {  return this.value;};const box = new Box(1);console.log(box.value); // 1console.log(box.getValue()); // 1console.log(box.constructor === Box); // true

function KeepCreatedObject() {  this.value = 1  //返回值并非对象，因此不会覆盖已创建对象  return 2}function ReplaceCreatedObject() {  this.value = 1  //返回值是对象，因此会覆盖已创建对象  return { name: 2 }}console.log(new KeepCreatedObject().value) // 1console.log(new ReplaceCreatedObject().value) // undefined

function Box(value) {  this.value = value}Box.prototype = {}const box = new Box(1)console.log(box.constructor) // Object

const object = { a: 1 }function func(value) {  return value}const array = [1, 2, 3]const regexp = /abc/console.log(object.toString()) // [object Object]console.log(func(1)) // 1console.log(array.map((value) => value * 2)) // [2, 4, 6]console.log(regexp.test('abc')) // true

function declared(value) {  return value;}const anonymous = function(value) {  return value;};const arrow = (value) => value;const dynamic = new Function("value", "return value");console.log(typeof declared); // functionconsole.log(typeof anonymous.prototype); // objectconsole.log(arrow.prototype); // undefinedconsole.log(dynamic(1)); // 1

function car() {  this.name = 'Car'}car.prototype.drive = function() {  console.log('Drive')}const carObj = new car()

const obj = {  //对象方法  method() {  },}//箭头函数const arrawFunc = () => {}console.log(obj.method.prototype) // undefinedconsole.log(arrawFunc.prototype) // undefined//匿名箭头函数console.log((() => {}).prototype) // undefined

function add(a, b) {  return a + b;}

const add = new Function("a", "b", "return a+b");

const prefix = 'prefix'function f(obj) {  // 使用上下文中的 prefix 常量  return prefix + ' ' + obj.toString()}// new Function() 定义的函数对象无法捕获上下文中的 prefix 常量const fn = new Function(  'obj',  'return prefix + obj.toString()',)console.log(f({})) // prefix [object Object]console.log(fn({})) // ReferenceError: prefix is not defined

const base = {  value: 1,};const child = Object.create(base);child.name = "child";console.log(Object.getPrototypeOf(child) === base); // trueconsole.log(base.isPrototypeOf(child)); // trueconsole.log(Object.hasOwn(child, "name")); // trueconsole.log(Object.hasOwn(child, "value")); // false

const dictionary = Object.create(null);dictionary.name = "Ada";console.log(Object.getPrototypeOf(dictionary)); // nullconsole.log(Object.hasOwn(dictionary, "name")); // trueconsole.log(dictionary.toString); // undefined

class User {  constructor(name) {    this.name = name  }  greet() {    return `Hello, ${this.name}`  }}const UserAlias = Userconst user = new UserAlias('Ada')console.log(typeof User) // functionconsole.log(UserAlias === User) // trueconsole.log(user.greet()) // Hello, Adaconsole.log(User.prototype.constructor === User)// true

console.log(User) // ReferenceError: Cannot access 'User' before initializationclass User {  constructor(name) {    this.name = name;  }  greet() {    return `Hello, ${this.name}`;  }}const obj = User() // TypeError: Class constructor User cannot be invoked without 'new'

class Counter {  //公共实例字段会成为实例的自有属性  value = 0  constructor(step = 1) {    // 构造函数中对 this 的赋值会成为实例的自有属性    this.step = step  }  //访问器存放在 ClassName.prototype 上  get doubled() {    return this.value * 2  }  //实例方法存放在 ClassName.prototype 上  add() {    this.value += this.step    return this.value  }}const counter = new Counter(2)console.log(counter.add()) // 2console.log(counter.doubled) // 4

class Counter {  static kind = "counter";  static create(step = 1) {    return new Counter(step);  }  constructor(step) {    this.step = step;  }}const counter = Counter.create(2);console.log(Counter.kind); // counterconsole.log(counter.step); // 2console.log(counter.kind); // undefined

class Counter {  static kind = 'counter'  static create(step = 1) {    return new Counter(step)  }  constructor(step) {    this.step = step  }}const counter = Counter.create(2)console.log(Counter.kind) // counterconsole.log(counter.constructor.kind) // counter

class Animal {  static category = "animal";  constructor(name) {    this.name = name;  }  speak() {    return `${this.name} makes a sound`;  }}class Dog extends Animal {  speak() {    return `${super.speak()}: wang`;  }}const dog = new Dog("Mochi");console.log(dog.speak()); // Mochi makes a sound: wangconsole.log(Dog.category); // animalconsole.log(dog instanceof Dog); // trueconsole.log(dog instanceof Animal); // true

class Counter {  #value = 0;  add() {    this.#value += 1;    return this.#value;  }}const counter = new Counter();console.log(counter.add()); // 1console.log(counter.add()); // 2

class Registry {  static #entries = [];  static {    this.#entries.push("ready");  }  static list() {    return [...this.#entries];  }}console.log(Registry.list()); // ["ready"]

class User {}const user = new User();console.log(typeof User); // functionconsole.log(typeof user); // objectconsole.log(user instanceof User); // trueconsole.log(user instanceof Object); // trueconsole.log(Array.isArray([])); // trueconsole.log(typeof null); // object

function isInstanceOf(obj, constructor) {  if (typeof obj !== 'object' || typeof constructor !== 'function')    throw new TypeError('obj must be an object and constructor must be a function')  let prototype = Object.getPrototypeOf(obj)  while (prototype !== null) {    //遍历对象的原型链，查找是否 prototype === constructor.prototype    if (prototype === constructor.prototype) {      return true    }    prototype = Object.getPrototypeOf(prototype)  }  return false}

class Counter {  //公共实例字段  value = 0  //公共静态字段  static kind = 'counter'  //构造函数  constructor(step = 1) {    //构造函数中对 this 的赋值    this.step = step  }  //公共实例方法  add() {    this.value += this.step    return this.value  }  //公共静态方法  static create(step) {    return new Counter(step)  }}

function Counter(step = 1) {  //实例字段 等价于 构造函数中对 this 的赋值  this.value = 0  this.step = step}//实例方法存储于 Counter.prototype 中Object.defineProperty(Counter.prototype, 'add', {  value: function add() {    this.value += this.step    return this.value  },  writable: true,  configurable: true,  enumerable: false,})//静态字段是类对象的自有属性Counter.kind = 'counter'//静态方法也是类对象的自有属性Object.defineProperty(Counter, 'create', {  value: function create(step) {    return new Counter(step)  },  writable: true,  configurable: true,  enumerable: false,})const counter = Counter.create(2)console.log(counter.add()) // 2

function Animal(name) {  this.name = name}//静态成员Animal.category = 'animal'Animal.logCategory = function() {  console.log(this.category)}//实例方法Animal.prototype.speak = function() {  return `${this.name} makes a sound`}//子类型function Dog(name) {  // 模拟 super，调用父类构造函数  Animal.call(this, name)}//建立实例方法的继承关系（实例字段是对象的自有属性，并不在 prototype 中）Object.setPrototypeOf(Dog.prototype, Animal.prototype)//建立静态成员的继承关系Object.setPrototypeOf(Dog, Animal)//实例方法覆写Dog.prototype.speak = function() {  //使用 prototype.method.call(this) 调用父类实例方法  return `${Animal.prototype.speak.call(this)}: wang`}//静态成员覆写Dog.category = 'dog'Dog.logCategory = function() {  console.log(`${Animal.category} -> ${Dog.category}`)}const dog = new Dog('Mochi')console.log(dog instanceof Dog) // trueconsole.log(dog instanceof Animal) // trueconsole.log(Dog.category) // dogDog.logCategory() // animal -> dog

//父类使用 class 声明class Animal {  constructor(name) {    this.name = name  }}//子类型使用 构造函数形式 无法使用 Base.call(this, ...arg)function DogFunction() {  Animal.call(this, 'Mochi') // TypeError: Class constructor Animal cannot be invoked without 'new'}//子类型使用 class 语法 可以使用 super(...arg)class DogClass extends Animal {  constructor(name) {    super(name)  }}

class Animal {  constructor(name) {    this.name = name  }}function DogFunction() {  //由子类型创建this，并传递给父类构造函数  this.detailedCategory = 'dog'  Animal.call(this, 'Mochi')}class DogClass extends Animal {  constructor(name) {    //super执行结束后，this才可访问    this.detailedCategory = 'dog' // ReferenceError: Must call super constructor before accessing 'this'    super(name)  }}

function AnimalFunction() {  console.log(new.target)}function DogFunction() {  AnimalFunction.call(this)}class AnimalClass {  constructor() {    console.log(new.target.name)  }}class DogClass extends AnimalClass {  constructor() {    super()  }}new DogFunction() // undefinednew DogClass() // Dog

function Animal() {  console.log(new.target)}Animal.call({}) // undefined

function AnimalFunction() {  return {    name: 'replacement',  }}function DogFunction() {  const result = AnimalFunction.call(this)  // result 被忽略}class AnimalClass {  constructor() {    return {      name: 'replacement',    }  }}class DogClass extends AnimalClass {  constructor() {    super()  }}console.log(new DogFunction()) // DogFunction {}console.log(new DogClass()) // { name: 'replacement' }