Use ES6 new Target to simulate abstract classes

lately , We found that symbol Is the only value , but symbol Cannot be new operation , Can only be used as a function , function new Type error occurs when

new Symbol()

// error
Uncaught TypeError: Symbol is not a constructor
    at new Symbol (<anonymous>)
    at <anonymous>:1:1

If the underlying implementation is not considered , Is it possible to implement a function that can only be called but cannot be called at the code level ？ After thinking , Write the following code :

function disConstructor() {
  if (this !== window) {
    throw new TypeError(' disConstructor is not a constructor')
  }
  console.log('gogo go')
}

//  The test results are as follows 
disConstructor() // gogo go

new disConstructor()

// error
Uncaught TypeError:  disConstructor is not a constructor
    at new disConstructor (<anonymous>:3:15)
    at <anonymous>:1:1

Use nodejs when ,window You can switch to global, The execution result of the code remains unchanged . This is because there is no applicable scenario for individuals . therefore , Although no further research , But lately , reread es 6 Found out new.target.

new.target attribute

Introduce ( quote mdn file )

new.target Property allows you to detect whether a function or constructor passes through new Operator is called . Through new Operator is initialized in a function or constructor ,new.target Returns a reference to a constructor or function . In normal function calls ,new.target The value of is undefined.

In this case Our code can be changed to ：

function disConstructor() {
  //  In ordinary function calls ,new.target  The value of is undefined.
  if (new.target) {
    throw new TypeError(' disConstructor is not a constructor')
  }
  console.log('gogo go')
}

Get the same answer as the above code .

thorough

Don't es6 Is the specially added function only used to check our function calling methods ？ In the process of consulting, it is found that most of the schemes use new.target Write classes that can only be inherited . Similar to implementation java The abstract class of .

class Animal {
  constructor(name, age) {
    if (new.target === Animal) {
      throw new Error('Animal class can`t instantiate');
    }
    this.name = name
    this.age = age
  }
  //  Other code 
  ...
}

class Dog extends Animal{
  constructor(name, age, sex) {
    super(name, age)
    this.sex = sex
  }
}

new Animal()
// error
Uncaught Error: Animal class can`t instantiate
    at new Animal (<anonymous>:4:13)
    at <anonymous>:1:1

new Dog('mimi', 12, ' Male ')
// Dog {name: "mimi", age: 12, sex: " Male "}

however java Abstract classes and abstract methods need to be overridden , There is no plan for this . So in the process of testing and using , However, I accidentally found that the superclass can access the prototype of the derived class during construction , Use it .

class Animal {
  constructor(name, age) {
    console.log(new.target.prototype)
  }
  //  Other code 
  ...
}

The previous run-time call to the method that needs to be rewritten reported an error as follows .

class Animal {
  constructor(name, age) {
    this.name = name
    this.age = age
  }

  getName () {
    throw new Error('please overwrite getName method')
  }
}

class Dog extends Animal{
  constructor(name, age, sex) {
    super(name, age)
    this.sex = sex
  }
}

const pite = new Dog('pite', 2, ' Male ')
a.getName()
// error
Uncaught Error: please overwrite getName method
    at Dog.getName (<anonymous>:8:11)
    at <anonymous>:1:3

However, at this time new.target , I can use Tectonic period An error is reported when operating on a subclass .

class Animal {
  constructor(name, age) {
    //  If  target  No   Base class   And   No,  getName  Report errors 
    if (new.target !== Animal && !new.target.prototype.hasOwnProperty('getName')) {
      throw new Error('please overwrite getName method')
    }
    this.name = name
    this.age = age
  }
}

class Dog extends Animal{
  constructor(name, age, sex) {
    super(name, age)
    this.sex = sex
  }
}

const pite = new Dog('pite', 2, ' Male ')
// error
Uncaught Error: please overwrite getName method
    at new Animal (<anonymous>:5:13)
    at new Dog (<anonymous>:14:5)
    at <anonymous>:1:1

At this point, you can advance the errors that occur when running the method to the construction time , Although they are all in operation , But the error trigger mechanism should be early and harmful . Instead, it is a kind of protection for the code .

Yes, of course , Using superclasses to access the prototypes of derived classes during construction is far from simple , It must be very powerful , You can talk about understanding and role in combination with business scenarios .