Como estender uma aula sem ter que usar super no ES6?

É possível estender uma classe no ES6 sem chamar o supermétodo para invocar a classe pai?

EDIT: A pergunta pode ser enganosa. É o padrão que temos que ligar super()ou estou faltando alguma coisa?

Por exemplo:

class Character {
   constructor(){
      console.log('invoke character');
   }
}

class Hero extends Character{
  constructor(){
      super(); // exception thrown here when not called
      console.log('invoke hero');
  }
}

var hero = new Hero();

Quando não estou chamando super()a classe derivada, estou tendo um problema de escopo ->this is not defined

Estou executando isso com iojs --harmony na v2.3.0

As regras para as classes ES2015 (ES6) basicamente se resumem a:

1. Em um construtor de classe filha, thisnão pode ser usado até que superseja chamado.
2. Os construtores da classe ES6 DEVEM chamar superse forem subclasses, ou devem retornar explicitamente algum objeto para substituir aquele que não foi inicializado.

Isso se resume a duas seções importantes da especificação ES2015.

A seção 8.1.1.3.4 define a lógica para decidir o que thisestá na função. A parte importante para as classes é que é possível thisestar em um "uninitialized"estado e, quando nesse estado, tentar usar thislançará uma exceção.

Seção 9.2.2 , [[Construct]]que define o comportamento das funções chamadas via newou super. Ao chamar um construtor de classe base, thisé inicializado na etapa 8 de [[Construct]], mas para todos os outros casos, thisnão é inicializado. No final da construção, GetThisBindingé chamado, portanto, se superainda não tiver sido chamado (inicializando assim this), ou um objeto de substituição explícito não for retornado, a linha final da chamada do construtor lançará uma exceção.

Houve várias respostas e comentários afirmando que super DEVE ser a primeira linha dentro constructor. Isso está simplesmente errado. A resposta @loganfsmyth tem as referências exigidas dos requisitos, mas se resume a:

O extendsconstrutor Inheriting ( ) deve chamar superantes de usar thise antes de retornar, mesmo se thisnão for usado

Veja o fragmento abaixo (funciona no Chrome ...) para ver por que pode fazer sentido ter instruções (sem usar this) antes de chamar super.

'use strict';
var id = 1;
function idgen() {
  return 'ID:' + id++;
}

class Base {
  constructor(id) {
    this.id = id;
  }

  toString() { return JSON.stringify(this); }
}

class Derived1 extends Base {
  constructor() {
    var anID = idgen() + ':Derived1';
    super(anID);
    this.derivedProp = this.baseProp * 2;
  }
}

alert(new Derived1());

A nova sintaxe da classe es6 é apenas uma outra notação para as "antigas" classes es5 "com protótipos. Portanto, você não pode instanciar uma classe específica sem definir seu protótipo (a classe base).

É como colocar queijo no sanduíche sem prepará-lo. Também não se pode colocar queijo antes de fazer o sanduíche, então ...

... usar a thispalavra-chave antes de chamar a superclasse com super()também não é permitido.

// valid: Add cheese after making the sandwich
class CheeseSandwich extend Sandwich {
    constructor() {
        super();
        this.supplement = "Cheese";
    }
}

// invalid: Add cheese before making sandwich
class CheeseSandwich extend Sandwich {
    constructor() {
        this.supplement = "Cheese";
        super();
    }
}

// invalid: Add cheese without making sandwich
class CheeseSandwich extend Sandwich {
    constructor() {
        this.supplement = "Cheese";
    }
}

Se você não especificar um construtor para uma classe base, a seguinte definição será usada:

constructor() {}

Para classes derivadas, o seguinte construtor padrão é usado:

constructor(...args) {
    super(...args);
}

EDIT: Encontrado em developer.mozilla.org:

When used in a constructor, the super keyword appears alone and must be used before the this keyword can be used.

Fonte

Só me inscrevi para postar essa solução pois as respostas aqui não me satisfazem minimamente, pois na verdade existe uma maneira simples de contornar isso. Ajuste seu padrão de criação de classe para sobrescrever sua lógica em um sub-método enquanto usa apenas o super construtor e encaminhe os argumentos do construtor para ele.

Como em, você não cria um construtor em suas subclasses per se, mas apenas faz referência a um método que é sobrescrito na respectiva subclasse.

Isso significa que você se libertou da funcionalidade do construtor imposta a você e se absteve de um método regular - que pode ser substituído e não impõe super () ao se permitir a escolha se, onde e como deseja chamar super (totalmente opcional) por exemplo:

super.ObjectConstructor(...)

class Observable {
  constructor() {
    return this.ObjectConstructor(arguments);
  }

  ObjectConstructor(defaultValue, options) {
    this.obj = { type: "Observable" };
    console.log("Observable ObjectConstructor called with arguments: ", arguments);
    console.log("obj is:", this.obj);
    return this.obj;
  }
}

class ArrayObservable extends Observable {
  ObjectConstructor(defaultValue, options, someMoreOptions) {
    this.obj = { type: "ArrayObservable" };
    console.log("ArrayObservable ObjectConstructor called with arguments: ", arguments);
    console.log("obj is:", this.obj);
    return this.obj;
  }
}

class DomainObservable extends ArrayObservable {
  ObjectConstructor(defaultValue, domainName, options, dependent1, dependent2) {
    this.obj = super.ObjectConstructor(defaultValue, options);
    console.log("DomainObservable ObjectConstructor called with arguments: ", arguments);
    console.log("obj is:", this.obj);
    return this.obj;
  }
}

var myBasicObservable = new Observable("Basic Value", "Basic Options");
var myArrayObservable = new ArrayObservable("Array Value", "Array Options", "Some More Array Options");
var myDomainObservable = new DomainObservable("Domain Value", "Domain Name", "Domain Options", "Dependency A", "Depenency B");

Felicidades!

Você pode omitir super () em sua subclasse, se omitir totalmente o construtor em sua subclasse. Um construtor padrão 'oculto' será incluído automaticamente em sua subclasse. No entanto, se você incluir o construtor em sua subclasse, super () deve ser chamado nesse construtor.

class A{
   constructor(){
      this.name = 'hello';   
   }
}
class B extends A{
   constructor(){
      // console.log(this.name); // ReferenceError
      super();
      console.log(this.name);
   }
}
class C extends B{}  // see? no super(). no constructor()

var x = new B; // hello
var y = new C; // hello

Leia isto para mais informações.

A resposta por justyourimage é a maneira mais fácil, mas seu exemplo é um pouco inchado. Aqui está a versão genérica:

class Base {
    constructor(){
        return this._constructor(...arguments);
    }

    _constructor(){
        // just use this as the constructor, no super() restrictions
    }
}

class Ext extends Base {
    _constructor(){ // _constructor is automatically called, like the real constructor
        this.is = "easy"; // no need to call super();
    }
}

Não estenda o real constructor(), apenas use o falso _constructor()para a lógica de instanciação.

Observe que esta solução torna a depuração irritante porque você precisa adotar um método extra para cada instanciação.

Experimentar:

class Character {
   constructor(){
     if(Object.getPrototypeOf(this) === Character.prototype){
       console.log('invoke character');
     }
   }
}


class Hero extends Character{
  constructor(){
      super(); // throws exception when not called
      console.log('invoke hero');
  }
}
var hero = new Hero();

console.log('now let\'s invoke Character');
var char = new Character();

Demo

Eu recomendaria usar OODK-JS se você pretende desenvolver os seguintes conceitos OOP.

OODK(function($, _){

var Character  = $.class(function ($, µ, _){

   $.public(function __initialize(){
      $.log('invoke character');
   });
});

var Hero = $.extends(Character).class(function ($, µ, _){

  $.public(function __initialize(){
      $.super.__initialize();
      $.log('invoke hero');
  });
});

var hero = $.new(Hero);
});

Solução simples: acho que não há necessidade de explicação.

class ParentClass() {
    constructor(skipConstructor = false) { // default value is false
        if(skipConstructor) return;
        // code here only gets executed when 'super()' is called with false
    }
}
class SubClass extends ParentClass {
    constructor() {
        super(true) // true for skipping ParentClass's constructor.
        // code
    }
}

@Bergi mencionou new.target.prototype, mas eu estava procurando um exemplo concreto provando que você pode acessar this(ou melhor, a referência ao objeto com o qual o código do cliente está criando new, veja abaixo) sem ter que chamar super().

Falar é barato, mostre-me o código ... Então, aqui está um exemplo:

class A { // Parent
    constructor() {
        this.a = 123;
    }

    parentMethod() {
        console.log("parentMethod()");
    }
}

class B extends A { // Child
    constructor() {
        var obj = Object.create(new.target.prototype)
        // You can interact with obj, which is effectively your `this` here, before returning
        // it to the caller.
        return obj;
    }

    childMethod(obj) {
        console.log('childMethod()');
        console.log('this === obj ?', this === obj)
        console.log('obj instanceof A ?', obj instanceof A);
        console.log('obj instanceof B ?',  obj instanceof B);
    }
}

b = new B()
b.parentMethod()
b.childMethod(b)

O que resultará em:

parentMethod()
childMethod()
this === obj ? true
obj instanceof A ? true
obj instanceof B ? true

Assim você pode ver que estamos efetivamente criando um objeto do tipo B(a classe filha), que também é um objeto do tipo A(sua classe pai) e no childMethod()da criança B, temos thisapontando para o objeto objque criamos no B de constructorcom Object.create(new.target.prototype).

E tudo isso sem se preocupar com supernada.

Isso aproveita o fato de que em JS a constructorpode retornar um objeto completamente diferente quando o código do cliente constrói uma nova instância com new.

Espero que isso ajude alguém.