[JavaScript] Ereditarietà tra oggetti bizzarra

[AlexKidd]

Sto imparando il JavaScript su un libro (learning Javascript di Shelley Powers) che, purtroppo, ogni tanto tratta in modo troppo superficiale alcuni argomenti.... fornendo una soluzione veloce senza analizzare le motivazioni che stanno dietro ad un certo stile di programmazione

Conosco abbastanza bene la programmazione ad oggetti (quella con classi esplicite) è ho ben compreso l'uso di prototype e la precedenza che hanno i metodi privilegiati dei suo confronti

però mi sfugge la motivazione di un modo, di ereditare le funzionalità di un altro oggetto, che era presentato come il più naturale:

function tune(title,type) {
   this.title = title;
   this.type = type;
   this.getTitle=function() {
     return "Song: " + this.title + " Type: " + this.type;
   }
}

function artist_tune(title,type,artist) {
   this.artist = artist;
   this.toString("Artist is " + artist);
   tune.apply(this,arguments);
   this.toString = function () {
     return "Artist: " + this.artist + " " + this.getTitle();
   }
}

artist_tune.prototype = new tune();

Questo comprende sia la chiamata del costruttore della superclasse (attraverso l'uso di apply() o call()) che l'assegnamento di una istanza della superclasse all'oggetto prototype della sottoclasse

ma questa cosa non ha senso, ovvero secondo me è inutile inizializziare prototype in questo caso, l'assegnamento che avvenga o meno non fa alcuna differenza

ho preparato un piccolo esempio dove analizzo tutti i casi possibili con le evidenti differenze

B, C e D sono tutti oggetti che specializzano A ma lo fanno in modi diversi, nonostante ciò appaiono esternamente con le medesime capacità di accesso ai membri pubblici della superclasse

function A(){
    var x="valore di default"; 
    this.set=function(v){
                    x=v
                    }; 
    this.get=function(){
                    return x;
                    }
    } 
function B(){} 
function C(){A.apply(this);}
function D(){A.apply(this);} 

B.prototype=new A; 
D.prototype=new A; 



a1=new A(); 
a1.set("sono a1"); 
alert(a1.get()); // "sono a1" 
a2=new A(); 
alert(a2.get()) // "valore di default" 


b1=new B();
b1.set("sono b1"); 
alert(b1.get()); // "sono b1" 
b2=new B(); 
alert(b2.get()) // "sono b1" 

c1=new C(); 
c1.set("sono c1"); 
alert(c1.get()); // "sono c1" 
c2=new C(); 
alert(c2.get()) // "valore di default" 

d1=new D(); 
d1.set("sono d1"); 
alert(d1.get()); // "sono d1" 
d2=new D(); 
alert(d2.get()) // "valore di default"

Nel primo caso l'oggetto B si limita a inizializzare prototype, questo comporta la "condivisione" delle variabili private della superclasse tra due istanze diverse di B; è un comportamento di cui non colgo l'uso pratico, se sapete perchè e che senso ha illuminatemi

Nel secondo caso (oggetto C) la modalità è quella classica, si usa un costruttore e il comportamento ottenuto è tipico di qualsiasi linguaggio OOP che io conosco

Nel terzo caso (oggetto D) avviene la stessa cosa dell'esempio che ha suscitato la mia curiosità, una combinazione di costruttore e inizializzazione di prototype e non ne capisco il motivo, il comportamento sembra sia identico a quello dell'oggetto C

L'unica cosa che cambia è la possibilità di accede attraverso prototype ai metodi della superclasse ma è inutile, ogni cambiamento viene ignorato perchè javascript cerca i metodi prima tra quelli privilegiati (definiti all'interno della funzione "madre")

Che senso ha tutto ciò? Quando utilizzare una delle seguenti combinazioni al posto di altre? C e D possono considerarsi equivalenti?

Un grazie a chi avrà la pazienza di legger tutto quello che ho scritto e mi aiuterà a capire

[binarysun]

Non capisco cosa non comprendi.
Perchè usa il new?

[AlexKidd]

non capivo che senso avesse definire metodi "privilegiati" (cioè non definiti in prototype) e poi assegnare un'istanza dell'oggetto ereditato al prototipo del nuovo oggetto

È un minestrone di diversi modi di utilizzare l'ereditarietà della programmazione ad oggetti in Javascript

Ma mi sono reso conto che il libro che stavo leggendo è stato un pessimo acquisto, questa non è certo la prima cretinata che trovo in quel testo ma è la classica goccia che fa traboccare il vaso

Mi rivedrò da capo l'argomento con un testo più chiaro ed esaustivo

[binarysun]

Premeto che conosco poco js, ma conosco l'OOP.

Effettivamente ho provato ora l'esempio
b1=new B();
b1.set("sono b1");
alert(b1.get()); // "sono b1"
b2=new B();
alert(b2.get()) // "sono b1"

E non ha senso, probabilmente perchè JS non è a "veri" oggetti.
La classe B non estende la classe A, ma viene creato un oggetto prototype che estende L'ISTANZA di A (buffo).

Probabilmente per questo bisogna fare
B.prototype=new A;

[AlexKidd]

da quel che ho capito esistono due modi per creare una "classe"

definendo dei metodi privilegiati (interni alla funzione che si considera il tipo dell'oggetto)
oppure assegnando tutti i metodi all'oggetto prototype

mischiando le due cose avvengono cose prive di senso come questa

[binarysun]

Be, metodi ereditabili e non esistono in ogni linguaggio.
La cosa strana è che si eredita l'istanza.

Per il resto non vedo cose strane, ma ho guardato velocente questa paginetta
http://sviluppare-in-rete.blogspot.c...totype-ed.html

Riguardo al problema dell'istanza c'è una parte che spiega il problema


una singola istanza di un oggetto Veicolo sarà condivisa (tramite prototype) da tutti gli oggetti creati da Aereo.

Per risolvere il problema bisogna modificare il costruttore Aereo in questo modo

function Aereo(passeggeri) {
Veicolo.call(this,passeggeri);
this.carica(passeggeri);
/* il resto invariato */
}

[AlexKidd]

si, lo sapevo, avevo letto quell'articolo ma l'idea proposta è una soluzione empirica

quella soluzione comunque è l'oggetto di tipo D definito nel primo esempio, non era quello il punto

lasciamo morire questa discussione nata per cercare di trovare un senso alle incomprensibili affermazioni dell'autrice del libro (che brucerò)

[binarysun]

Avevo capito che il tuo problema fosse sul passaggio del riferiemento dell'ereditarietà.
Altro non so dirti.
Perchè eistono molti modi per fare ereditarietà? Perchè non è una vera ereditarietà.

Altrimenti non ho capito :/

[AlexKidd]

probabilmente è come dici tu, anche se una affermazione del genere fa imbestialire chi con javascript ci lavora da anni

comunque prima mi documento per bene con testi più seri poi se, eventualmente, scoprirò che avevamo torto entrambi, riprenderò questa discussione per chiuderla con quello che avrò capito (perchè quando m'impunto, m'impunto!)