[JS] polimorfismo: passare parametro al costruttore

[SoulStorm892]

Salve a tutti,

Ho il seguente codice:

	Player = function() {}
	Player.prototype = new Sprite;
	Player.prototype.__super__ = Sprite;

La classe Player è figlia della classe Sprite.
Ho sviluppato l'ereditarietà in questo modo per ottenere questo:

Player.prototype.update = function(mod) 
{
	
	//altro codice...

	this.__super__.prototype.update.call(this,mod);
}

In questo modo mi è possibile fare un overload di un metodo e chiamare il metodo base della classe madre.

Fin qui tutto ok. Il problema è che se provo a scrivere

	var p1 = new Player("jack");

il parametro di Player NON viene passato al costruttore di Sprite.

Tutto si dovrebbe giocare nelle prime 3 di codice che ho scritto. Se per esempio sostituisco alla seconda riga questo

	Player.prototype = new Sprite("jack");

il parametro chiaramente viene passato, ma ciò che mi interessa è farlo lavorando sull'istanza di Player e non direttamente su Sprite!!

In poche parole con questo approccio ho "compromesso" l'ereditarietà... qualche idea per farla funzionare?


Grazie in anticipo per eventuali suggerimenti

[carlomarx]

Innanzitutto facciamo un po' di pulizia... Creare la proprietà Player.prototype.__super__ è del tutto inutile: hai già la proprietà Player.prototype.constructor che è settata sulla funzione Sprite. Dunque puoi farne tranquillamente a meno: quando ti serve invocarla sarà sufficiente lanciare this.constructor().
Dopodiché... da' una guardata a questo codice... dopo che avrai studiato domanda pure...:

function Sprite (sName) {
	this.nome = sName;
}

function SpriteBlank () { } // questa funzione la DEVI lasciare vuota

function Player (sName, bIsTrue) {
	Sprite.apply(this, arguments);
	this.isTrue = bIsTrue;
}

SpriteBlank.prototype = Sprite.prototype;
Player.prototype = new SpriteBlank();

// metodi del progenitore del costruttore

Sprite.prototype.generaRandom = function () {
	this.valoreRandom = Math.floor(Math.random() * 1e16).toString(36);
}

// metodi del costruttore

Player.prototype.lanciaUnAlert = function () {
	alert("Hai invocato il metodo lanciaUnAlert()!");
}

var prova = new Player("jack", false);

alert(prova.nome) // questa proprietà è assegnata da Sprite
alert(prova.isTrue) // questa proprietà è assegnata da Player
alert(prova.constructor) // Sprite: nonostante Player.prototype = new SpriteBlank()!!!
prova.generaRandom();
alert(prova.valoreRandom); // una stringa a caso
prova.lanciaUnAlert();

[SoulStorm892]

Grazie compagno Scherzi a parte grazie davvero perche' partendo dal tuo esempio ho ottenuto quello che volevo, ora l'ereditarieta` e l'overload funzionano insieme:

/* sprite class */
function SpriteBlank(){}
function Sprite (surname) {this.surname = surname;}
Sprite.prototype.getName = function (the)
{
    console.log("(caller: sprite)");

    alert(this.name + the + this.surname);
}

/* player class */
function Player (name,surname)
{
    //Sprite.apply(this, arguments);
    Sprite.call(this, surname);
    this.name = name;
}
Player.constructor.prototype = Sprite;
SpriteBlank.prototype = Sprite.prototype;
Player.prototype = new SpriteBlank();

//Player.prototype = new Sprite("jack");
Player.prototype.getName = function (the)
{
       
    console.log("(caller: player)");

    this.constructor.prototype.getName.call(this,the);
}

var prova = new Player("jack", "ripper");
prova.getName(" the ");

Nonostante il risultato non ho comunque capito queste tre righe:

Player.constructor.prototype = Sprite;
SpriteBlank.prototype = Sprite.prototype;
Player.prototype = new SpriteBlank();

perche' devo passare per forza da un una classe vuota? se scrivo Player.prototype = new Sprite() non dovrebbe essere la stessa cosa?

[carlomarx]

Originariamente inviato da SoulStorm892
Grazie compagno

Prego
Occhio però che la riga Player.constructor.prototype = Sprite; è semanticamente senza senso e devi rimuoverla. Il costruttore di Player (che è una funzione) è Function: e tale lo devi lasciare.

Originariamente inviato da SoulStorm892
perche' devo passare per forza da un una classe vuota? se scrivo Player.prototype = new Sprite() non dovrebbe essere la stessa cosa?

Lo so che è poco intuitivo. Sia che tu faccia Player.prototype = new Sprite() che se tu faccia Player.prototype = new SpriteBlank() il prototipo di Player erediterà le proprietà del prototipo di Sprite: questo perché in precedenza avevi scritto SpriteBlank.prototype = Sprite.prototype. Il motivo per cui ti conviene far così è che Sprite() richiede un argomento, se facessi Player.prototype = new Sprite([che ci metto qui dentro?]) avresti il prototipo di Player con una proprietà surname settata su undefined. Spero sia chiaro.

P.S. Se proprio non riesci a tenerti la funzione SpriteBlank, cancellala e sostituisci

SpriteBlank.prototype = Sprite.prototype;
Player.prototype = new SpriteBlank();

con

Player.prototype = Object.create(Sprite.prototype);

che è esattamente la stessa cosa. Considera però che la funzione Object.create() è una new entry in JavaScript e potrebbe non essere supportata da tutti i browsers.