Ancora considerazioni sull'ereditarietà in Javascript...

Ecco, io ho una classe (chiamiamola così) e creo una classe "discendente" che eredita i suoi membri.

Ora creo due istanze, una della classe madre e una della classe figlia.

<script>


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

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

}

function Aereo(passeggeri){
 this.altitudine=0;
 this.decolla=function(){
  this.altitudine=10;
 }
}

auto=new Veicolo();
jumbo=new Aereo();
alert(auto.velocita);
alert(auto.altitudine);
alert(jumbo.altitudine)

</script>

Ecco: l'istanza della classe genitrice, che non ha la proprietà altitudine, mi dà un undefined quando chiedo di mettermi a video la proprietà altitudine.
Questo non succede per l'istanza della classe figlia, che invece ha una proprietà altitudine.

Sono tutte cose lapalissiane, ma è meglio rimarcarsele!

Critica a un algoritmo per la sincope

Ho integrato l'embrione di ragionamento sulla gestione della sincope con quanto trovato a questo indirizzo.

L'algoritmo che trovo su questo documento è il seguente:

In pratica, questo algoritmo incoraggerebbe a proseguire nella ricerca di possibili cause della sincope, cardiache e non cardiache, in modo libero e lineare, riservando poi ai casi in cui non si individui una causa certa l'approfondimento cardiologico.
Non mi sembra una cosa lineare...

Per prima cosa, io escluderei l'aspetto cardiologico. Preferisco un approccio negativo, preoccupandomi prima di escludere la causa più grave. Se anche trovassi segni indicativi di una sincope di altra natura, perchè non dovrei escludere da subito una causa cardiaca? Non può coesistere una cardiopatia a cause di altro genere?

Nel contempo dell'esclusione di una cardiopatia rilevante, allora mi preoccuperei di individuare poi con calma eventuali segni di altre cause di sincope.
Mi pare più razionale e sicuro...

Approccio all'ereditarietà in Javascript

Proseguo con gli esercizi sul sito che tratta con molta chiarezza dei prototipi a livello introduttivo.

Dunque, che cosa avevo fatto prima?
Avevo imparato come si aggiungono dei metodi a una funzione, i quali possono essere esterni o interni alla funzione stessa. Per evitare eventuali conflitti può essere il caso di definirli all'interno della funzione oggetto.

Ora cerchiamo di vedere questo prototipo.

Avevo una "classe" Veicolo:

<script>


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

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

}

</script>

Ora io creo una classe Aereo:

function Aereo(passeggeri){
 this.altitudine=0;
 this.decolla=function(){
  this.altitudine=10;
 }
}

Questa classe non ha la proprietà velocita della classe Veicolo.

Ora provo a creare un oggetto Aereo

jumbo=new Aereo(3);
alert(jumbo.velocita);

E ottengo una casella di testo con scritto undefined.

---

Ora invece rendo la classe Aereo "discendente" della classe "Veicolo". Il codice è questo (in cui do alla proprietà velocita della classe Veicolo un valore diverso da zero, giusto per essere sicuro che la cosa funzioni):

<script>


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

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

}

function Aereo(passeggeri){
 this.altitudine=0;
 this.decolla=function(){
  this.altitudine=10;
 }
}

Aereo.prototype=new Veicolo();
jumbo=new Aereo(3);
alert(jumbo.velocita);

</script>

...e ottengo come risultato una casella di testo con il valore 5, in quanto essendo ora la classe Aereo "discendente" della classe Veicolo ne eredita la proprietà velocita. Ecco fatto un primo passo nell'ereditarietà in Javascript!

Un approccio non convenzionale alla sincope...

Perchè il motore funzioni, è necessario del combustibile e del comburente, mediante i quali si possa avere lo sviluppo di energia attraverso la degradazione del combustibile.
Stop.

Detto questo, dobbiamo porre l'attenzione anche al veicolo del combustibile e del comburente, e cioè alla circolazione del sangue, la quale può avere degli ostacoli.

---

Proporrei quindi una valutazione di tre elementi fondamentali:

• Combustibile (glicemia...)
• Comburente (Saturimetria, Emogasanalisi)
• Sistema di trasporto...

---

La valutazione di combustibile e comburente è fatta con molta rapidità.
Quello che è più indaginoso è invece studiare tutti i possibili "intoppi" del sistema di veicolazione di questi due componenti.

Ieri ho individuato un possibile "intoppo" in un'anamnesi di stenosi aortica, che, costituendo un'ostruzione al flusso di sangue dal cuore, può portare a un abbassamento della pressione tale da ridurre la veicolazione delle due componenti necessarie al processo energetico.

Mi sembra evidente che di fronte a un'alterazione della coscienza una delle prime indagini vadano fatte su un possibile ostacolo alla veicolazione a carico della pompa: anamnesi e indagini cardiologiche!

---

Questo sarebbe il punto di partenza fondamentale...

Costruttori, oggetti, metodi e proprietà...

Seguiamo un po' di esempi da questo sito per capire meglio questo prototype...

<script>
function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;
 if(passeggeri>0)
  this.passeggeri=passeggeri;
}
var auto=new Veicolo(1);
alert(auto.passeggeri);
</script>

Questo sarebbe il costruttore di un oggetto.
Ossia, qualcosa che assomiglia alle classi, credo...

Ha due proprietà, l'una che prende il valore del parametro e l'altra che è impostata a zero senza venir modificata inizialmente all'atto in cui si istanzia l'oggetto.
Ecco, adesso modifico la proprietà passeggeri subito e poi modifico l'altra:

<script>
function Veicolo(passeggeri){
 this.velocita=0;
 this.passeggeri=0;
 if(passeggeri>0)
  this.passeggeri=passeggeri;
}
var auto=new Veicolo(1);
var auto2=new Veicolo(1);
auto2.velocita=13;
alert("auto: velocità "+auto.velocita+" passeggeri "+auto.passeggeri);
alert("auto2: velocità "+auto2.velocita+" passeggeri "+auto2.passeggeri);
</script>

---

Aggiungiamo un metodo...

Ecco: aggiungiamo il metodo scritto all'esterno del costruttore. Provo a esercitarmi...

<script>
function carica(passeggeri){
 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);
alert("auto: velocità "+auto.velocita+" passeggeri "+auto.passeggeri);
auto.carica(4);
alert("auto: velocità "+auto.velocita+" passeggeri "+auto.passeggeri);

</script>

Funziona egregiamente!

---

Bene... finora niente di particolarmente trascendentale, e mi sono esercitato un po' sull'aggiungere metodi scritti all'esterno del costruttore stesso.

---

Ecco invece l'aggiunta di un metodo scritto all'interno del costruttore:

<script>


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

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

}
var auto=new Veicolo(1);
alert("auto: velocità "+auto.velocita+" passeggeri "+auto.passeggeri);
auto.carica(4);
alert("auto: velocità "+auto.velocita+" passeggeri "+auto.passeggeri);

</script>

Questo si chiama incorporare il metodo all'interno della funzione costruttore.
La sua utilità è evitare i conflitti nel caso si debba creare un metodo con nome analogo per un altro oggetto.

Uso di indexOf per trovare tutte le occorrenze di una sottostringa

Ed ecco un codice per individuare tutte le occorrenze di una sottostringa nell'ambito di una stringa:

<script src="funzioni.js"></script>
<script>
var stringa="Chi legge è un cretino o è un deficiente!"
var n=0;
var indice;
function inizia(){
 while(indice!=-1){
  indice=stringa.indexOf(" è ",n);
  alert(indice);
  n=indice+1;
 } 
}
 
</script>
<body onload="inizia()">

</body>

Per ora so usare questo metodo, che mi sono creato sul momento. Non so se ne esistono di migliori...

do...while e while.

Le mie peregrinazioni mentali mi portano a voler sezionare le stringhe.

Da qui vado ancora avanti con le associazioni di idee e mi trovo ai cicli Do...until.
< Una volta li praticavo, ma non mi ricordo questa sintassi, che peraltro è comune a diversi linguaggi di programmazione...

Rinfreschiamo le idee!

---

<script src="funzioni.js"></script>
<script>

function inizia(){
var n=1;
 do{
  n++;
 } while(n<10);
alert(n); 
}
 
</script>
<body onload="inizia()">

</body>

Ecco, ottengo una casella di avvertimento con il numero 10.
Il programma aumenta sempre di uno il numero n finchè resta valida la condizione n<10. Quando poi n arriva a 10 smette e prosegue con l'istruzione successiva alert(n).

---

Ora provo con il solo while.

<script src="funzioni.js"></script>
<script>

function inizia(){
var n=1;
while(n<10){
 n++;
}
alert(n); 
}
 
</script>
<body onload="inizia()">

</body>

Il risultato è analogo: 10.

Ma qual è la differenza fra le due forme?

Provo a tradurre in italiano...
Prima forma.
"Aumento n di uno. E' minore di 10? Sì. E allora continuo ad aumentare di uno. E' minore di 10? Sì. E allora continuo...". Quando n è uguale a 10: "E' minore di 10? No. E allora smetto di aumentarlo e vado avanti".

Seconda forma.
"n è minore di 10? Sì. E allora lo aumento di uno. E' minore di 10? Sì. E allora lo aumento di uno...". Quando n è uguale a 10: "E' minore di 10? No. E allora vado avanti.

Il risultato è lo stesso. La differenza è solo che nel primo caso l'istruzione viene eseguita una volta, prima di verificare se n è minore di 10, mentre nel secondo caso il processo viene bloccato in partenza.

Provo a costruirmi un codice nel quale si veda la differenza.

<script src="funzioni.js"></script>
<script>

function inizia(){
var n=10;
while(n<10){
 n++;
}
alert(n); 
}
 
</script>
<body onload="inizia()">

</body>

Ecco, partendo da un valore di n pari a 10, ottengo 10 perchè il programma ha verificato subito che n non è minore di 10 e il ciclo non è partito per niente.
Invece con questo:

<script src="funzioni.js"></script>
<script>

function inizia(){
var n=10;
do{
 n++
}while (n<10);
alert(n); 
}
 
</script>
<body onload="inizia()">

</body>

... ottengo 11, perchè la condizione non è stata verificata subito e quindi il ciclo è partito per una volta, prima di essere bloccato all'esecuzione della seconda operazione.