Classe derivata di paziente per mezzo di ereditarietà tramite prototipo

Creazione di una classe derivata di "paziente" per mezzo dell'ereditarietà tramite prototipo.

function prestazione(data,diagnosi){
 this.data=data;
 this.diagnosi=diagnosi;
}

function paziente(){
 this.prestazioni=new Array;
 this.aggiungiPrestazione = function(data,diagnosi){
  var prest=new prestazione(data,diagnosi);
  this.prestazioni.push(prest);
 }
}

function paziente1(){
 this.problemi=new Array;
 this.aggiungiProblema = function(problema){
  this.problemi.push(problema);
 }
}
paziente1.prototype=new paziente();

var Paziente=new paziente1();
Paziente.aggiungiProblema("diabete");
Paziente.aggiungiPrestazione("14/2/2013","ipertensione");
Paziente.aggiungiPrestazione("10/3/2013","colica renale");
for(var i=0;i<Paziente.prestazioni.length;i++)
 alert(Paziente.prestazioni[i].data+" "+Paziente.prestazioni[i].diagnosi);
for(var i=0;i<Paziente.problemi.length;i++)
 alert(Paziente.problemi[i]);

Con questa ho aggiunto anche i problemi in anamnesi.

Un oggetto di tipo "paziente" per l'archiviazione delle pregresse prestazioni.

Un codice scritto di getto senza neanche un errore...

Ecco il mio modello per elencare le prestazioni di un paziente.

function prestazione(data,diagnosi){
 this.data=data;
 this.diagnosi=diagnosi;
}

function paziente(){
 this.prestazioni=new Array;
 this.aggiungiPrestazione = function(data,diagnosi){
  var prest=new prestazione(data,diagnosi);
  this.prestazioni.push(prest);
 }
}

var Paziente=new paziente();
Paziente.aggiungiPrestazione("14/2/2013","ipertensione");
Paziente.aggiungiPrestazione("10/3/2013","colica renale");
for(var i=0;i<Paziente.prestazioni.length;i++)
 alert(Paziente.prestazioni[i].data+" "+Paziente.prestazioni[i].diagnosi);

Artifizio per salvare un file XML (da un mio vecchio studio).

Ecco come salvare un file XML modificato: ho trovato il link nel mio diario "grezzo". Questo è il codice:

   var fso=new ActiveXObject("Scripting.FileSystemObject");
   var path=document.location.pathname;
   path=path.substr(1,path.lastIndexOf("/"));
   path=path.replace(/%20/g," ");
   var f=fso.CreateTextFile(path+"data.xml",true);
   f.write(xmlDoc.xml);
   f.Close();
   fso=null;

Rianalizziamolo...

Ecco: creazione di un ActiveXObject FileSystemObject. Quindi creazione di un file di testo:

function funzione(){
 var fso=new ActiveXObject("Scripting.FileSystemObject");
 var f=fso.CreateTextFile("Ciao.txt",true);
}
funzione();

Questo è sufficiente a crearmi nella stessa locazione del file in cui viene eseguito il codice un file "Ciao.txt".

Il problema del path

Vediamo il path.

function funzione(){
 var path=document.location.pathname;
 document.write(path);
}
funzione();

Output:

/C:/Users/Antonello/Desktop/js.html

Nel codice che avevo creato in passato c'era anche una riga che ritagliava il path, ottenendo l'eliminazione del primo slash e del nome del file:

function funzione(){
 var path=document.location.pathname;
 path=path.substr(1,path.lastIndexOf("/"));
 document.write(path);
}
funzione();

Output:

C:/Users/Antonello/Desktop/

E anche una riga un po' "misteriosa"...:

path=path.replace(/%20/g," ");

Ecco, ho ripassato il metodo replace e ho decifrato che questa riga l'avevo messa per sostituire globalmente (g) tutti i simboli %20 (codice ASCII per spazio) con uno spazio reale.
Il problema si pone quando una cartella del path ha degli spazi vuoti nel nome.
Pongo il file in una cartella con spazi vuoti ed ecco cosa ottengo prima di inserire questa riga. Il codice è ancora lo stesso, ma il file è salvato in una cartella chiamata "Cartella con gli spazi".

function funzione(){
 var path=document.location.pathname;
 path=path.substr(1,path.lastIndexOf("/"));
 document.write(path);
}
funzione();

Output:

C:/Users/Antonello/Desktop/Cartella%20con%20gli%20spazi/

Ecco con l'aggiunta di quella riga:

function funzione(){
 var path=document.location.pathname;
 path=path.substr(1,path.lastIndexOf("/"));
 path=path.replace(/%20/g," ");
 document.write(path);
}
funzione();

Output:

C:/Users/Antonello/Desktop/Cartella con gli spazi/

Unendo questa stringa al nome del file da salvare, ottengo il path completo!

Alcuni metodi dell'oggetto XmlDoc

childNodes:

var mioXml = new ActiveXObject("Microsoft.XMLDOM");
mioXml.async=false;
mioXml.load("doc.xml");
var radice=mioXml.documentElement;
var figli=radice.childNodes;
document.write(figli[0].text);

Ciao, ciccio.

---

firstChild:

var mioXml = new ActiveXObject("Microsoft.XMLDOM");
mioXml.async=false;
mioXml.load("doc.xml");
var radice=mioXml.documentElement;
var primoFiglio=radice.firstChild;
document.write(primoFiglio.text);

---

hasChildNodes:

var mioXml = new ActiveXObject("Microsoft.XMLDOM");
mioXml.async=false;
mioXml.load("doc.xml");
var radice=mioXml.documentElement;
document.write(radice.hasChildNodes);

true

---

Iniziamo XMLDOM

Apriamo un semplice file XML con XMLDOM.

Usiamo IE.

Buttiamo giù il codice JavaScript.

var mioXml = new ActiveXObject("Microsoft.XMLDOM");
mioXml.async=false;

Non mi importa di dire fesserie, vado per ipotesi a valanga, suscettibili di correzioni e integrazioni successive:
Adesso carico il file:

var mioXml = new ActiveXObject("Microsoft.XMLDOM");
mioXml.async=false;
mioXml.load("doc.xml");

Adesso mi posiziono sulla radice del documento:

var mioXml = new ActiveXObject("Microsoft.XMLDOM");
mioXml.async=false;
mioXml.load("doc.xml");
var radice=mioXml.documentElement;

E adesso che mi sono posizionato, che faccio?

Provo a mettere in opera alcune istruzioni per manipolare il file XML:
nodeName che restituirebbe il nome del nodo.
Essendo posizionato sulla radice, mi dovrebbe restituire il nome del tag radice.

var mioXml = new ActiveXObject("Microsoft.XMLDOM");
mioXml.async=false;
mioXml.load("doc.xml");
var radice=mioXml.documentElement;
var nome=radice.nodeName;
alert(nome);

Ottengo messaggi di errore, finché scopro il motivo: il documento non è valido perché è così formato:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo?)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
 <paragrafo>
  Ciao, ciccio.
 </paragrafo>
 <paragrafo>
 </paragrafo>
</capitolo> 

Provando con il mitico validatore svelo l'arcano: nel DTD c'è un punto interrogativo che esprime un numero di occorrenze del tag paragrafo da 0 a 1 volta, e invece esso è rappresentato due volte!
Correggo, e ottengo il risultato giusto: una casella di avviso con scritto

capitolo

---

---

Adesso esploro tutti i metodi che mi permettono di manipolare il documento XML in Internet Explorer...

Simboli relativi alle occorrenze di un tag

Ora vediamo di capire i simboli che significano il numero di occorrenze di un tag.
Scrivo un + che dovrebbe significare una o più volte, e provo:

Con zero occorrenze del tag:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo+)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
</capitolo> 

Non valido

Con una occorrenza del tag:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo+)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
   <paragrafo>
   </paragrafo>
</capitolo> 

Valido!

con più occorrenze del tag:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo+)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
   <paragrafo>
   </paragrafo>
   <paragrafo>
   </paragrafo>
</capitolo> 

Valido!

---

Adesso con *, che dovrebbe significare "zero o più volte".

Zero occorrenze:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo*)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
</capitolo> 

Valido!

Una occorrenza:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo*)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
   <paragrafo>
   </paragrafo>
</capitolo> 

Valido!

Con più occorrenze:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo*)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
   <paragrafo>
   </paragrafo>
   <paragrafo>
   </paragrafo>
</capitolo> 

Valido!

---

Adesso metto il segno ? che dovrebbe significare zero o una occorrenza, e provo:

Zero occorrenze:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo?)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
</capitolo> 

Valido!

Una occorrenza:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo?)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
 <paragrafo>
 </paragrafo>
</capitolo> 

Valido!

Più occorrenze:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo?)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
 <paragrafo>
 </paragrafo>
 <paragrafo>
 </paragrafo>
</capitolo> 

Non valido

---

Riassumendo:
+ va da 1 a molte;
* va da 0 a molte;
? va da 0 a una.

Ancora DTD: definizione di diversi tags.

Ecco un tag capitolo che contiene un tag paragrafo, validato dal validatore:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo (paragrafo+)>
<!ELEMENT paragrafo (#PCDATA)>
]>
<capitolo>
 <paragrafo>
 </paragrafo>
</capitolo> 

Ho definito paragrafo come #PCDATA senza sapere minimamente cosa significasse.
Andiamo a vederlo:

Ah, ecco: dovrebbe significare che contiene testo. E va bene pure questa!

Reintroducendomi all'XML: il DTD.

Riprendo un po' l'XML...

Ho passato questo a questo validator:

<?xml version="1.0" encoding="UTF-8"?> 
<capitolo>
 <paragrafo>
 </paragrafo>
</capitolo> 

Non mi riconosce errori... Speriamo bene...

Invece in questo mi riconosce questo errore:

Can not find declaration of element 'capitolo'.

Evidentemente manca la dichiarazione del tag, che se ricordo bene va fatta entro il DTD.

---

Finalmente sono riuscito a ottenere un DTD valido!

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE capitolo [
<!ELEMENT capitolo EMPTY>
]>
<capitolo /> 

E' una cagatella, ma almeno è valida: questo mi serve per ripassare come si fa un DTD (argomento che ho toccato una volta sola e non molto approfonditamente).

Ereditarietà tramite prototipo in JavaScript.

Posso far ereditare ancora, soltanto tramite modifiche del prototipo?

Creo un altro costruttore, e riporto il prototipo di Aereo.

function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;
 
 this.carica=function(passeggeri){
  if(passeggeri>0) this.passeggeri+=passeggeri;
 }
 
 this.carica(passeggeri);
}

function Aereo(passeggeri){
 this.passeggeri=0;
 this.carica(passeggeri);
}

Aereo.prototype=new Veicolo();


function Missile(passeggeri){

this.carica(passeggeri);
}

Missile.prototype=new Aereo();

var Apollo=new Missile(6);

document.write(Apollo.passeggeri);

Funziona perfettamente! La classe Missile ha ereditato il prototipo di Aereo. E ne ha ereditato una funzione che questo ha ereditato tramite il prototipo dal costruttore della classe Veicolo.

Dunque a che serve modificare il costruttore di una classe derivata, se questa ereditarietà si può ottenere solo col prototipo?

Ereditarietà del prototipo in JavaScript

Si può abbreviare il codice eliminando la riga che carica i passeggeri a seconda del parametro quando l'oggetto viene istanziato, in quanto la funzione carica() fa la medesima cosa, quindi si può far partire direttamente il metodo carica() all'atto dell'istanziazione.

function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;
 
 this.carica=function(passeggeri){
  if(passeggeri>0) this.passeggeri+=passeggeri;
 }
 
 this.carica(passeggeri);
}


var Auto=new Veicolo(1);

Auto.carica(2);

document.write(Auto.passeggeri+"<br>");

...col medesimo risultato.

---

Io vado più lento del tutorial:
Creo un costruttore Aereo, al quale attribuisco una funzione che fa parte di Veicolo, e vediamo cosa succede:

function Aereo(passeggeri){
        this.passeggeri=0;
 this.carica(passeggeri);
}

var Jumbo=new Aereo(250);

document.write(Jumbo.passeggeri+"<br>");

E ottengo un errore dal web developer di FireFox:

TypeError: this.carica is not a function

E certo: il costruttore Aereo non ha la funzione carica()!

Posso inserirla nel prototipo:

function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;
 
 this.carica=function(passeggeri){
  if(passeggeri>0) this.passeggeri+=passeggeri;
 }
 
 this.carica(passeggeri);
}

function Aereo(passeggeri){
 this.passeggeri=0;
 this.carica(passeggeri);
}

Aereo.prototype.carica=function(passeggeri){
 if(passeggeri>0) this.passeggeri+=passeggeri;
}

var Jumbo=new Aereo(250);

document.write(Jumbo.passeggeri+"<br>");

...e funziona, stavolta:

250

Però il tutorial mi pone un mezzo per ereditare un altro costruttore mediante il prototipo:

function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;
 
 this.carica=function(passeggeri){
  if(passeggeri>0) this.passeggeri+=passeggeri;
 }
 
 this.carica(passeggeri);
}

function Aereo(passeggeri){
 this.passeggeri=0;
 this.carica(passeggeri);
}

Aereo.prototype=new Veicolo();

var Jumbo=new Aereo(250);

document.write(Jumbo.passeggeri+"<br>");

Che funziona!

250

Benissimo!
Dunque ho la possibilità di ereditare tramite prototipo.
Il prototipo della classe Veicolo ha proprietà e metodi del costruttore.
Riportare nel prototipo di una nuova classe il prototipo di una classe dalla quale si voglia ereditare è possibile con questa formula!

Creazione di metodi per un costruttore (sempre seguendo il tutorial)

Adesso creo un metodo per il mio costruttore Veicolo.
Ci sono due modi di creare un metodo (come nel C++): esterno al costruttore o incorporato in questo.
Mi esercito in tutti e due:

function carica(passeggeri){
 if(passeggeri>0) this.passeggeri+=passeggeri;
}

function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;

 if(passeggeri>0) this.passeggeri=passeggeri;
 this.carica=carica;
}


var Auto=new Veicolo(1);

Auto.carica(2);

document.write(Auto.passeggeri+"<br>");

3

Ecco: il metodo carica() è esterno al costruttore.
Facendo così c'è un vantaggio e uno svantaggio che dipenderanno da quello che voglio fare del programma:

• Posso usare lo stesso metodo per diversi costruttori;
• Si possono creare conflitti col nome qualora volessi creare metodi con lo stesso nome ma diversi per ciascun costruttore.

In questo secondo caso, conviene incorporare il metodo nel costruttore:

function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;

 if(passeggeri>0) this.passeggeri=passeggeri;
 this.carica=function(passeggeri){
  if(passeggeri>0) this.passeggeri+=passeggeri;
 }
}


var Auto=new Veicolo(1);

Auto.carica(2);

document.write(Auto.passeggeri+"<br>");

3

Perfetto!

Creazione di un'istanza da un costruttore (seguendo un tutorial)

Seguiamo un po' questo tutorial, perchè mi sembra ottimo.

Creiamo un costruttore Veicolo.

function Veicolo(){
 this.velocita=0;
 this.passeggeri=0;
}
var Auto=new Veicolo();

document.write(Auto.passeggeri+"<br>");

Auto.passeggeri=1;

document.write(Auto.passeggeri+"<br>");

Output:

0
1

Ho creato un'istanza di Veicolo, e poi ho modificato nell'istanza la quantità di passeggeri.
Posso modificare anche la velocità, se voglio:

function Veicolo(){
 this.velocita=0;
 this.passeggeri=0;
}
var Auto=new Veicolo();

document.write(Auto.velocita+"<br>");

Auto.velocita=3;

document.write(Auto.velocita+"<br>");

Output:

0
3

---

Bene, adesso faccio come nell'esempio, e definisco il numero di passeggeri come parametro, in modo che all'atto in cui viene creata l'istanza il numero di passeggeri viene incrementato automaticamente:

function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=passeggeri;
}
var Auto=new Veicolo(4);

document.write(Auto.passeggeri+"<br>");

4

Posso fare che il numero di passeggeri è uguale al parametro solo se il parametro supera 0, come nell'esempio: questo fa in modo che se creo l'istanza senza parametro il numero di passeggeri mi risulta comunque uguale a zero se ho inizializzato la variabile col valore di 0.

function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;

 if(passeggeri>0) this.passeggeri=passeggeri;
}
var Auto=new Veicolo();

document.write(Auto.passeggeri+"<br>");

0

...se non avessi inizializzato la proprietà, senza parametro otterrei un valore undefined:

function Veicolo(passeggeri){
 this.velocita=0;


 if(passeggeri>0) this.passeggeri=passeggeri;
}
var Auto=new Veicolo();

document.write(Auto.passeggeri+"<br>");

undefined

---

Bene: ecco dunque il costruttore!

function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;

 if(passeggeri>0) this.passeggeri=passeggeri;
}
var Auto=new Veicolo();

document.write(Auto.passeggeri+"<br>");

Funzione intercambiabile per l'oggetto window e per altri oggetti.

Creo una funzione StampaNome, che mostra this.nome

Partendo da un costruttore Oggetto, creo due istanze Uomo e Cane, il primo con un nome da uomo e il secondo con un nome da cane.
Prima chiamo la funzione StampaNome da finestra. Quindi la chiamo dalle istanze:

function StampaNome(){
 document.write(this.nome+"<br>")

}

function Oggetto(nome){
 this.nome=nome;
 this.StampaNome=StampaNome;
}

Uomo=new Oggetto("Antonello");
Cane=new Oggetto("Rex");


StampaNome();
Uomo.StampaNome();
Cane.StampaNome();

Output:

undefined
Antonello
Rex

La prima volta la funzione viene chiamata da finestra, e dà come risultato undefined perché la finestra non ha questa proprietà.
La seconda e la terza volta, viene chiamata da istanze di oggetto e dà come risultato la proprietà nome per ognuna delle due istanze.

---

Ora provo a creare una proprietà nome per la finestra, definendo una variabile globale.

var nome="FINESTRA";

function StampaNome(){
 document.write(this.nome+"<br>")

}

function Oggetto(nome){
 this.nome=nome;
 this.StampaNome=StampaNome;
}

Uomo=new Oggetto("Antonello");
Cane=new Oggetto("Rex");


StampaNome();
Uomo.StampaNome();
Cane.StampaNome();

Output:

FINESTRA
Antonello
Rex

Perfetto! Come volevasi dimostrare!

Funzione scritta esternamente al costruttore

Come nel C++, il metodo, ossia la funzione, può essere anche scritta esternamente al costruttore:

function StampaNome(){
 document.write(this.nome + " " + this.cognome);
}
function Oggetto(){
 this.nome="Antonello";
 this.cognome="Iaccarino";
 this.StampaNome=StampaNome;
}
var Istanza=new Oggetto();
Istanza.StampaNome();

e funziona lo stesso:

Antonello Iaccarino 

Un costruttore completo in JavaScript

Ed ecco un costruttore completo, con proprietà e un metodo:

function Oggetto(){
 this.nome="Antonello";
 this.cognome="Iaccarino";
 this.StampaNome=function(){
  alert(this.nome + " " + this.cognome);
 }
}
var Istanza=new Oggetto();
Istanza.StampaNome();

Funziona egregiamente!

---

Per meglio copiare e incollare i risultati, invece di alert uso document.write.

function Oggetto(){
 this.nome="Antonello";
 this.cognome="Iaccarino";
 this.StampaNome=function(){
  document.write(this.nome + " " + this.cognome);
 }
}
var Istanza=new Oggetto();
Istanza.StampaNome();

Antonello Iaccarino 

Ulteriori sviluppi delle mie comprensioni del prototipo in JavaScript

In realtà, credo che se una variabile non viene inizializzata nel costruttore, di fatto non esiste.
Perché dunque non ottengo un messaggio di errore quando la mostro nell'Istanza?
Forse è semplicemente perché di fatto la aggiungo nell'istanza, non esistendo essa nel costruttore in quanto non inizializzata.
Forse questa "filosofia" è più aderente alla realtà.

function Oggetto(){
 this.prop;
}
var Istanza = new Oggetto();
alert(Istanza.prop);
Istanza.prop="Proprieta";
alert(Istanza.prop);

Ecco, in questo caso la proprietà non esiste nel costruttore, e la sintassi di definirla senza inizializzarla è praticamente sbagliata, in quanto non esiste e viene creata nell'istanza.
Ecco la creazione della proprietà prop in due istanze dell'oggetto:

function Oggetto(){
 this.prop;
}
var Istanza = new Oggetto();
var Istanza2=new Oggetto();
alert(Istanza.prop);
Istanza.prop="Proprieta";
alert(Istanza.prop);
Istanza2.prop="Proprieta dell'Istanza2";
alert(Istanza2.prop);

Ottengo i due valori di una proprietà che è stata creata indipendentemente nelle istanze, non nel costruttore!

---

Quindi quando io cerco di "cambiare" una variabile nel prototipo, sto piuttosto cercando di aggiungere una variabile che già esiste e quindi non posso sostituirla. Posso invece aggiungerla quando non c'è. Queste proprietà aggiunte nel prototipo possono essere modificate.

function Oggetto(){
 this.prop="Prima proprieta";
}
var Istanza = new Oggetto();
Oggetto.prototype.prop2="Seconda proprieta";
alert(Istanza.prop2);
Oggetto.prototype.prop2="Seconda proprieta modificata";
alert(Istanza.prop2);

Invece non possono essere modificate le proprietà presenti già nel costruttore:

function Oggetto(){
 this.prop="Prima proprieta";
}
var Istanza = new Oggetto();
Oggetto.prototype.prop2="Seconda proprieta";
alert(Istanza.prop2);
Oggetto.prototype.prop2="Seconda proprieta modificata";
alert(Istanza.prop2);
Oggetto.prototype.prop="Prima proprieta modificata";
alert(Istanza.prop);

La prima proprietà rimane sempre uguale a quella presente nel costruttore.

Trovata la regola di costruttore e prototipo

Quindi, il prototipo può modificare come vuole il costruttore, ma non se una proprietà è stata già inizializzata nel costruttore stesso.

Forse sto cominciando a capire bene qualcosa...

Proprietà aggiunte nel prototipo e proprietà inizializzate nel costruttore: differenza.

Ecco, forse sto arrivando a capo del segreto...

Adesso inizializzo una proprietà nel costruttore e poi la modifico nel prototipo

function Oggetto(){
 this.prop="Prima proprieta";
}

var Istanza=new Oggetto();

alert(Istanza.prop);

Oggetto.prototype.prop="Prima proprieta modificata";

alert(Istanza.prop);

Ottengo: Prima proprieta e Prima proprieta.

La proprietà inizializzata nel costruttore non può più essere modificata nel prototipo.

---

Ora invece di inizializzarla nel costruttore la inizializzo nel prototipo:

function Oggetto(){

}

var Istanza=new Oggetto();

Oggetto.prototype.prop="Prima proprieta";

alert(Istanza.prop);

Oggetto.prototype.prop="Prima proprieta modificata";

alert(Istanza.prop);

E ottengo Prima proprieta e Prima proprieta modificata.
Dunque, la proprietà che non è stata inizializzata nel costruttore può essere modificata nel prototipo.

---

Per questo, se ho aggiunto una proprietà nel prototipo, posso poi modificarla.

function Oggetto(){
 this.prop="Prima proprieta";
}

var Istanza=new Oggetto();



alert(Istanza.prop2);

Oggetto.prototype.prop2="Seconda proprieta";

alert(Istanza.prop2);

Oggetto.prototype.prop2="Seconda proprieta modificata";

alert(Istanza.prop2);

ottenendo rispettivamente: Nulla, Seconda proprieta e Seconda proprieta modificata.

Non ci sto capendo più niente!!!!!

Se invece aggiungiamo una proprietà nel prototipo, tutte le istanze, anche quelle già create, assumono questa proprietà.

function Oggetto(){
 this.prop="Prima proprieta";
}

var Istanza=new Oggetto();


alert(Istanza.prop2);

Oggetto.prototype.prop2="Seconda proprieta";

alert(Istanza.prop2);

Ottengo un alert vuoto (prima che nel prototipo venga aggiunta l'altra proprietà) e poi un alert che mostra "Seconda proprieta".

Dunque, se nel prototipo la variabile non è stata inizializzata, può essere successivamente modificata, mentre se è stata inizializzata non può essere modificata.
L'istanza prende la proprietà pari pari dal costruttore, e non può essere modificata se non dalla stessa istanza.
Solo se la proprietà non è stata definita dal costruttore può essere modificata.
Ecco la regola.

Prototipi e proprietà

Dunque le istanze prendono i valori delle proprietà dal prototipo, a meno che questi valori non vengano definiti nell'istanza.
Faccio la prova.

function Oggetto(){
 this.prop;
}

var Istanza=new Oggetto();


alert(Istanza.prop);

Oggetto.prototype.prop="Proprieta definita nel prototipo";

alert(Istanza.prop);

1. Per prima cosa, creo un'Istanza.
2. Mostro il valore della proprietà.
3. Modifico il valore della proprietà nel prototipo.
4. Mostro di nuovo il valore della proprietà

La prima volta ottengo un valore nullo, la seconda volta ottengo "Proprieta definita nel prototipo".

---

Adesso do direttamente un valore nel costruttore:

function Oggetto(){
 this.prop="Prima definizione nel prototipo";
}

var Istanza=new Oggetto();


alert(Istanza.prop);

Oggetto.prototype.prop="Seconda definizione nel prototipo";

alert(Istanza.prop);

In questo caso, la proprietà è sempre uguale a "Prima definizione nel prototipo".

Perché???