Anruf Basisklassenkonstruktor ohne manuell liefert Argumente

Question

Stellen Sie sich vor, dass wir die folgende class haben:

class A { 
     constructor(x, y, z) { 
     } 
} 

class B extends A { 
    constructor(x, y, z) { 
     super(x, y, z); 
    } 
} 

Was passiert, wenn wir wollensuper(...) mit arguments oder Rest Argumente nennen:

super.apply(this, arguments); 
super.apply(this, args); 

Diese wird nicht funktionieren: super.* nicht vor super() erlaubt ist.

Gibt es eine Alternative manuell Argumente liefern zu vermeiden?

Answer 1

Verwenden Verbreitung Notation:

super(...args); 

ZB:

class B extends A { 
    constructor(...args) { 
     super(...args); 
    } 
} 

(. super(...arguments) würde auch)

Aber es ist erwähnenswert, dass für die A und B gezeigt, Sie don‘ t müssen einen Konstruktor für Büberhaupt bereitstellen. Der Standard constructor¹ für eine abgeleitete Klasse ist genau so, wie oben gezeigt, so:

class B extends A { 
} 

tun würde genau das gleiche.

Weitere Beispiele unten.

In einem Kommentar sagten Sie, es gibt 10 (!) Parameter für die Basisklasse und Sie brauchen nur zwei von ihnen in Ihrer Unterklasse, und mein Eindruck ist die erste zwei. Wenn ja:

class B extends A { 
    constructor(first, second, ...rest) { 
     super(first, second, ...rest); 
     // Use `first` and `second` here... 
    } 
} 

Wenn Sie zwei in der Mitte gemeint, was wir tun können, dass mit Destrukturierung auch:

class B extends A { 
    constructor(...args) { 
     super(...args); 
     let {1: second, 2: third} = args; 
     // Use `second` and `third` here... 
    } 
} 

Weitere Beispiele:

class A { 
 
    constructor(x, y, z) { 
 
    console.log(`A: ${x}, ${y}, ${z}`); 
 
    } 
 
} 
 

 
// No constructor defined; gets default 
 
class B1 extends A {} 
 

 
// Explicit version of the default constructor 
 
class B2 extends A { 
 
    constructor(...args) { 
 
    super(...args); 
 
    } 
 
} 
 

 
// Using `arguments` instead: 
 
class B3 extends A { 
 
    constructor() { 
 
    super(...arguments); 
 
    } 
 
} 
 

 
// If the subclass accepts different args 
 
class B4 extends A { 
 
    constructor(q, ...rest) { 
 
    super(...rest); 
 
    console.log(`B4: q = ${q}`); 
 
    } 
 
} 
 

 
class B5 extends A { 
 
    constructor(...args) { 
 
    super(...args); 
 
    // They don't have to be called `y` and `z`, I'm just being consistent 
 
    let { 1: y, 2: z } = args; 
 
    console.log(`B5: y = ${y}, z = ${z}`); 
 
    } 
 
} 
 

 
new B1(1, 2, 3); 
 
new B2(4, 5, 6); 
 
new B3(7, 8, 9); 
 
new B4('q', 'x', 'y', 'z'); 
 
new B5('first', 'second', 'third');

---

¹ "der Standardkonstruktor für eine Unterklasse ist genau wie oben gezeigt" Beachten Sie, dass dies anders als Sprachen wie Java oder C# ist, wo der Standardkonstruktor keine Argumente akzeptieren und super()/base() ohne Argumente aufrufen würde.

Answer 2

class A { 
 
     constructor(x, y, z) { 
 
     console.log(x,y,z); 
 
     } 
 
} 
 

 
class B extends A { 
 
    constructor(x, y, z) { 
 
     super(...arguments); 
 
    } 
 
} 
 

 
let X = new B(1,2,3);