cómo llamar al constructor padre?

Question

Digamos que tengo el siguiente fragmento de código.

function test(id) { alert(id); } 

testChild.prototype = new test(); 

function testChild(){} 

var instance = new testChild('hi'); 

¿Es posible obtener alert('hi')? Obtengo undefined ahora.

Answer 1

Así es como se hace esto en CoffeeScript:

class Test 
    constructor: (id) -> alert(id) 

class TestChild extends Test 

instance = new TestChild('hi') 

No, No estoy empezando una guerra santa. En cambio, estoy sugiriendo que echar un vistazo al código JavaScript resultante para ver cómo se podría implementar subclases:

// Function that does subclassing 
var __extends = function(child, parent) { 
    for (var key in parent) { 
    if (Object.prototype.hasOwnProperty.call(parent, key)) { 
     child[key] = parent[key]; 
    } 
    } 
    function ctor() { this.constructor = child; } 
    ctor.prototype = parent.prototype; 
    child.prototype = new ctor; 
    child.__super__ = parent.prototype; 
    return child; 
}; 

// Our code 
var Test, TestChild, instance; 

Test = function(id) { alert(id); }; 

TestChild = function() { 
    TestChild.__super__.constructor.apply(this, arguments); 
}; __extends(TestChild, Test); 

instance = new TestChild('hi'); 

// And we get an alert 

verlo en acción en http://jsfiddle.net/NGLMW/3/.

Para mantenerse correcto, el código se modifica ligeramente y se comenta para que sea más legible, en comparación con la salida de CoffeeScript.

Answer 2

Debe declarar el function testChild() antes de configurar su prototipo. Luego debe llamar al testChild.test para llamar al método. Creo que quiere establecer testChild.prototype.test = test, luego puede llamar al testChild.test('hi') y debería resolverse correctamente.

Answer 3

Al aprovechar variable arguments y el método apply(), puede hacerlo de esta manera. Aquí hay un fiddle para este ejemplo.

function test(id) { alert(id); } 
function testChild() { 
    testChild.prototype.apply(this, arguments); 
    alert('also doing my own stuff'); 
} 
testChild.prototype = test; 
var instance = new testChild('hi', 'unused', 'optional', 'args'); 

Answer 4

JS programación orientada a objetos ...

// parent class 
var Test = function(id) { 
    console.log(id); 
}; 

// child class 
var TestChild = function(id) { 
    Test.call(this, id); // call parent constructor 
}; 

// extend from parent class prototype 
TestChild.prototype = Object.create(Test.prototype); // keeps the proto clean 
TestChild.prototype.constructor = TestChild; // repair the inherited constructor 

// end-use 
var instance = new TestChild('foo'); 

Answer 5

usted ya tiene muchas respuestas, pero voy a tirar de la manera ES6, que en mi humilde opinión es la nueva forma estándar de hacer esto.

class Parent { 
    constructor() { alert('hi'); } 
} 
class Child extends Parent { 
    // Optionally include a constructor definition here. Leaving it 
    // out means the parent constructor is automatically invoked. 
    constructor() { 
    // imagine doing some custom stuff for this derived class 
    super(); // explicitly call parent constructor. 
    } 
} 

// Instantiate one: 
var foo = new Child(); // alert: hi