Newsgroup: it.comp.lang.javascript
Titolo: Ereditarietà

Voi che sistema usate per implementare l'ereditarietà?
In giro si trova di tutto, non conto neanche quante modalità ci sono.
Alla fine io mi sono rifatto a questo:
http://www.cs.rit.edu/~atk/JavaScript/manuals/jsobj/
senza quindi dover usare nessuna libreria che dovrebbe rendere le cose
più chiare.
Che dite?
function Employee (name, salary) {
    this._name = name;
    this._salary = salary;
}
Employee.prototype.getName = function() {
    return this._name;
}
Employee.prototype.getSalary = function() {
    return this._salary;
}
function Manager (name, salary, department) {
    this.base = Employee;
    this.base(name, salary);
    this._department = department;
}
Manager.prototype = new Employee;
Manager.prototype.getDept = function() {
    return this._department;
}
fabio = new Employee("FABIO",100);
alert(fabio.getName() + "  " + fabio.getSalary());
paolo = new Manager("PAOLO",1000,"Sales");
alert(paolo.getName() + " " + paolo.getSalary() + " " +
paolo.getDept());

 funziona su Safari e Firefox (su Mac) e IE6 (sotto winblows). Ty.
Già buono :-)
base comunque non è una keyword ma un nome aribitrario. Purtroppo
senza fare
function Manager (name, salary, department) {
this.base = Employee;
this.base(name, salary);
non puoi creare un Manager passando i parametri al costruttore di
Employee. Quindi con quel sistema si riesce a bypassare il limite.
A me sembra sostanzialmente un buon approccio, che fa quello che serve
senza introdurre un'esagerata complessità. Ma visto che ci sono n modi
mi chiedevo quali fossero i preferiti dagli altri.
Ciao.

 metodo getName) ha avuto effetto anche per Manager ?
base non e' un object, e' il constructor di Employee, che "diventa" metodo
di Manager, in 
http://www.cs.rit.edu/~atk/JavaScript/manuals/jsobj/
 spiega
il tutto in "Specifying properties in a constructor, take 2"
'bye

 Che dite?
Che può essere una buona soluzione di ripiego, ma con gli anni mi
ha mostrato tutti i suoi difetti (o meglio, limiti). Al di là del
fatto che non è molto generalizzata, in quanto va specificato nel
costrutture l'oggetto da cui si deriva.
Qualche esempio su cui magari riflettere. Il costruttore Employee
viene chiamato due volte; se viene fatto un override di un metodo
si "perde" quello originale, mentre non sarebbe male aver un modo
un minimo elegante, per poterlo richiamare dal nuovo metodo della
"subclasse" (ovviamente uso il termine con le pinze). Inoltre, il
fatto che su alcuni browser (di sicuro, IE) non esista la keyword
"__proto__", crea non pochi limiti, se non ci si mette una pezza.
Ho cercato, come un po' tutti credo, un buon metodo per risolvere
questo tipo di problematiche, senza snaturare il linguaggio, cosa
che si rischia di fare in questi casi; basandomi su ciò che aveva
da offrire il linguaggio piuttosto che scrivere ex-novo una sorta
di "gestione delle classi" ignorando l'essenza di JS.
Pensavo di esserci riuscito tempo fa, ma quando mi sono rimesso a
riscrivere la gestione di alcuni "widget" usando un approccio del
tutto diverso, mi sono accorto che dovevo modificare ancora delle
cose. Quando avrò qualcosa di più "stabile" magari lo pubblicherò
nel NG, anche per avere qualche commento o suggerimento.
-- 
~ Se i sintomi persistono, insultare il medico.

 metodo getName) ha avuto effetto anche per Manager ?
Stai ancora dormendo, eh? :)
Dai un'occhiata alla documentazione di JS, per la precisione il link
che ho pubblicato nel reply a Faser.


 il tutto in "Specifying properties in a constructor, take 2"
Adesso forse sto dormendo io (dato la nottataccia che ho avuto, non è
da escludere, tant'è che sono davanti al PC con gli occhiali da sole)
ma non riesco a collegare la tua risposta alla sua domanda.
Si chiedeva come mai la modifica al prototype di Employee agisce pure
su Manager; questo accade per le proprietà di JS, ovvero grazie a:
	Manager.prototype = new Employee;
Che prescinde il discorso sul "base".


 costrutture l'oggetto da cui si deriva.
Mi aggrego per porre una domanda in tema.
Per un esame stò studiando javascript e nello specifico
l'ereditarietà, solo che alcuni esempi nei testi semplicemente non
funzionano, quindi per evitare di impararmi nozioni sbagliate chiedo a
voi:
Persona=function(n,a){
this.nome=n
this.anno=a
this.toString=function(){return this.nome+' è del '+this.anno}
}
Studente=function(n,a,m){
Persona.call(this,n,a)
this.matr=m
this.toString=function(){ return Studente.prototype.toString.call(this)
+' e ha matricola: '+this.matr}
}
ora la seconda toString semplicemente non funziona.
è il testo sbagliato o cosa?
l'obbiettivo, sarebbe chiamare la "super.toString " e appenderci in
coda un'altra stringa.
Da notare che questo codice non deve girare su un browser ma su rhino.
Grazie

 è il testo sbagliato o cosa?
Hai assegnato il toString() nel costruttore di Persona e quindi a
livello di istanza. Non nel prototype. Per farlo funzionare:
function Persona( n, a ){
	this.nome = n;
	this.anno = a;
	return this;
}
Persona.prototype.toString = function(){
	return this.nome+" è del "+this.anno;
}
-- 
~ L'intelligenza artificiale non può battere la stupidità naturale.
(Lemma di Sullivan)

 +' e ha matricola: '+this.matr}
Ho visto adesso, ovviamente qua ci va "Persona.prototype", non
"Studente".
-- 
~ "Tutto quello che devi fare è chiamarmi;
sarò tutto quello di cui hai bisogno" (Peter Gabriel)

 "Studente".
ovvero "return Persona.prototype.toString.call(this)" ?
Ho appena provato e il risultato non è cambiato molto.
Sembra invece funzionare se non toccando il codice si aggiunge dopo la  
definizione delle due funzioni
Studente.prototype=new Persona
Studente.prototype.constructor=Studente
però cercavo una maniera per evitare
-- 
Manny Calavera
Mail To: anforagimailpuntocom²

 Ho appena provato e il risultato non è cambiato molto.
Si, appunto perché il toString() viene impostato a livello di istanza.
Probabilmente non hai modificato il tutto correttamente.. Secondo quel
che ti ho detto di cambiare, il tuo codice dovrebbe apparire così:
		function Persona(n,a){
			this.nome = n;
			this.anno = a;
			return this;		
		}
		Persona.prototype.toString=function(){return this.nome+' è del
'+this.anno};
 
		function Studente (n,a,m) {
			Persona.call(this,n,a);
			this.matr = m;
			this.toString=function(){ return
Persona.prototype.toString.call(this)+' e ha matricola: '+this.matr}
		}
E una chiamata di questo tipo:
		var s = new Studente("Franco",2009,123);
		alert(s)
Ti stampa il messaggio che desideri.
Premesso che anche il toString() di "Studente" sarebbe da impostare al
prototype e non all'istanza. Comunque con questo approccio stai un po'
snaturando il linguaggio (che è appunto basato sui prototipi); inoltre
mi pare un po' troppo macchinoso.
-- 
~ "E' nei cambiamenti che troviamo uno scopo."
(Eraclito)

 mi pare un po' troppo macchinoso.
Ok, tutto chiaro.
Ho snaturato il linguaggio? che ti devo dire sui lucidi del corso c'è  
questo esempio.


 che ti devo dire sui lucidi del corso c'è questo esempio.
Probabilmente chi ha fatto i lucidi preferisce trasformare javascript
in un linguaggio "class-based" anche se non lo è; o non si è preso la
briga di studiarsi approfonditamente la reference. Andrebbe chiesto a
lui, suppongo. :)
-- 
~ Chi segue gli altri, non arriva mai primo.