ereditarietà: new o __proto__

[mandp]

Ho un piccolo problema di comprensione, nonchè di conseguente utilizzo, su quella che è la logica di prototype
Dopo avere letto centinaia di opinioni su quale sia il metodo migliore pr implementare l'ereditarietà (per es. sottoclasse.prototype.__proto__=superclasse.protot ype oppure sottoclasse.prototype = new superclasse() ??) ero finalmente giunto ad una conclusione del tutto personale. Se mi serve che il costruttore della superclasse venga avviato, userò il codice che prevede "new", altrimenti utilizzo il prototype.__proto__
Con il secondo metodo in pratica la sottoclasse eredita tutto dal prototipo della superclasse. Una vera e propria catena di ereditarietà.
Ora, siccome con il codice sottoclasse.prototype.__proto__=superclasse.protot ype stabilisco uan catena di ereditarietà, mi aspettavo che inserendo nel codice del costruttore della sottoclasse un richiamo al costruttore delal superclasse, usando super(), il coastruttore della sueprclasse venisse istanziato. Ed invece no. Per spiegarmi, ecco un codice di esempio:
superclasse = function() {
trace("costruttore superclasse")
}
superclasse.prototype.variabile=10;
sottoclasse = function() {
super();
trace("costruttore sottoclasse")
}
sottoclasse.prototype.__proto=superclasse.prototyp e;
esempio= new sottoclasse();
trace(esempio.variabile);

L'output è il seguente:
costruttore sottoclasse
10
In pratica la variabile è presente nelal sottoclasse perchè il codice sottoclasse.prototype.__proto=superclasse.prototyp e ha stabilito l'ereditarietà, il costruttore della sotoclasse viene ovviamente chiamato ma prima non viene istanziato il costruttore della superclasse. Cosa che invece dovrebbe avvenire.
Ora, secondo il manauel macromedia, il codice funziona se, invece di scrivere "sottoclasse.prototype.__proto=superclasse.prototy pe;" io scrivo "sottoclasse.prototype=new superclasse();"
Così facendo, però, secondo qualcuno si ha una creazioen inutile di una istanza delal superclasse in un momento in cui in effetti non mi serve e di conseguenza, per progetti gorssi, si potrebbe richiedere inutilmente uno sforzo alla CPU nel creare queste istanze della sueprclasse.
Inoltre, seguendo il codice macromedia, ottengo un output quando non lo vorrei (mentre sto creando la catena di ereditarietà ma ancora non ho creato nessuna istanza della sottoclasse) ed in più, siccome uso super() nel costruttore della sottoclasse, mi ritrovo a richiamare due volte il costruttore delal superclasse. Cosa che non voglio. Unica soluzione è utilizzare il codice "new superclasse()" elimiando "super()". Però, così facendo, resta il problema della creazione di una istanza di superclasse quando a me ancora non serve (non esiste ancora una istanza delal sottoclasse e quindi non mi serve che vanga avviato il costruttore si quelal da cui essa eredita).
qualcuno sa come mai il codice che ho indicato all'inizio non funziona? Dov'è l'errore? In linea teorica, una volta creata una catena di ereditarietà, super(9 dovrebbe puntare senza problemi al costruttore della classe superiore, ma così non è. Ed ho il dubbio, che snoo sicuro qualcunio mi confermerà, che quesot dipenda dal fatto che Actionscript non è - in realtà - un vero linguaggio ad oggetti ma solo "orientato agli oggetti".
Chi sa dirmi come sta veramente la questione????

mandp

[negatyve]

Ereditarietà con il __proto__ e che ripristina l'utilizzo del super(), di Brandon Hall:

Function.prototype.inheritFrom = function(obj)
{
	if (majorVersion == null) {
		var version = getVersion();
		var i = version.indexOf(" ");
		_global.majorVersion = version.substr(i + 1, 1);
	}
	if (majorVersion == 6) {
		this.prototype.__constructor__ = obj;
		this.prototype.__proto__ = obj.prototype;
	} else {
		var backup = this.prototype;
		this.prototype = new obj();
		for (var i in backup) {
			this.prototype[i] = backup[i];
		}
	}
};
B.inheritFrom(A);

[mandp]

grazie

[Trinità76]

La cosa interessa anche a me ma state parlando turco 0_0'

[negatyve]

in inglese: http://www.debreuil.com/docs/

[mandp]

un'ultima, piccola, insignificante domandina. ma che differenza c'è tra constructor e __constructor__ ?
__constructor__ non l'ho trovato segnalato da nessuna parte, intendo nelle mie varie peregrinazioni e ricerche sul web, mentre constructor sì, e pure su flashwiki.
Ora, parlando proprio di debreuil che tu hai citato come testo sulla programmazione OO (in effetti è fatto benissimo ed è chiarissimo), gli esempi che lui fa prevedono l'utilizzo di constructor.
Ho provato a mettere __construtor__ al posto di constructor negli esempi di debreuil e tutto fila liscio, non così accade se metto constructor al posto di __constructor__ nel codice di fix per super().
ora, il pezzo di debreuil fa riferimento a flash 5, questo vuol dire che in flash mx __constructor__ fa ciò che fa constructor ma anche qualcosa di più per cui non li posso usare indifferentemente?
Il concetto di constructor mi era chiaro ed avevo anche io provato ad usarlo per venire a capo della questione di super(), però di __constructor__ non ne avevo mai trovaot traccia...
Dove trovo qualche riga di spiegazione su __constructor__??

byebye e grazie!
mandp

[negatyve]

__constructor__

è proprio il "link" al super.
Ti posso consigliare due testi:

http://www.amazon.com/exec/obidos/tg...books&n=507846

http://www.amazon.com/exec/obidos/tg...glance&s=books

[negatyve]

Anzi, tre: http://www.amazon.com/exec/obidos/tg...glance&s=books

[mandp]

thanks! )

[negatyve]

E di che.. :)