javascript new.target的学习笔记

function Foo() {
  console.log('new.target',new.target)
  console.log('new.target.prototype',new.target.prototype)
  if (!new.target) {
    throw new TypeError("calling Foo constructor without new is invalid");
  }
}

try {
  new Foo();
  Foo();
} catch (e) {
  console.log(e);
  // Expected output: TypeError: calling Foo constructor without new is invalid
}
// 输出：
/*
"new.target" function Foo() {
  console.log('new.target',new.target)
  console.log('new.target.prototype',new.target.prototype)
  if (!new.target) {
    throw new TypeError("calling Foo constructor without new is invalid");
  }
}
 "new.target.prototype" Object {  }
 */
 /*
 "new.target" undefined
 TypeError: Cannot read properties of undefined (reading 'prototype')
 */

class Animal{
    constructor() {
        console.log('Animal -> new.target.name:', new.target.name);
    }
}
class Dog extends Animal{
    constructor() {
        super();
        console.log('Dog -> new.target.name:', new.target.name);
    }
}
class toyDog extends Dog{
    constructor() {
        super();
        console.log('ToyDog -> new.target.name:', new.target.name);      
    }
}
new Dog();
// Animal -> new.target.name: Dog
// Dog -> new.target.name: Dog
console.log('----------------');
new toyDog();        
// Animal -> new.target.name: toyDog
// Dog -> new.target.name: toyDog
// ToyDog -> new.target.name: toyDog

function Foo(msg) {
    console.log(msg, '--new.target =', new.target);
}
// 通过 `new` 构造的，则 `new.target` 指向函数本身
new Foo('new Foo');
/* 输出：new Foo --new.target = ƒ Foo(msg) {
    console.log(msg, '--new.target =', new.target);
} */
// 不是通过 `new` 调用的，则 `new.target` 是 `undefined`
Foo('call Foo');  
/* 输出：call Foo --new.target = undefined */

// 函数可以被用作 `extends` 的基类，这种情况下 `new.target` 可能指向子类。
class Bar extends Foo {
    constructor() {
        super('new Bar');
    }
}
new Bar();
/* 输出：new Bar --new.target = class Bar extends Foo {
    constructor() {
        super('new Bar');
    }
}  */     

function One(name) {
    this.name = name;
    console.log('One -> new.target.name:', new.target.name);
}
const obj=Reflect.construct(One, ['aa'], Array);
console.log(obj); // 输出：Array {name: 'aa'}
console.log('obj instanceof One:', obj instanceof One); // 输出：obj instanceof One: false
console.log('obj instanceof Array:', obj instanceof Array); // 输出：obj instanceof Array: true

class A {
    constructor() {
        const arrow = () => console.log('new.target →', new.target);
        arrow();          // 箭头函数继承自构造函数作用域
    }
}
class B extends A {}
new B();
//输出：new.target → class B extends A {}

// 在全局作用域里
const arrow = () => {
    console.log(new.target); // 报错：ReferenceError
};
arrow();
//输出报错：Uncaught SyntaxError: new.target expression is not allowed here

class WithStatic {
   static {
        console.log('Static block new.target:', new.target); // undefined
    }
}
new WithStatic();
// 输出：Static block new.target: undefined