Informatica : Internet
JavaScript: sintassi
Premessa:
Linguaggio di definizione:
Le parole in minuscolo sono parole chiave del linguaggio.
Le parole in maiuscolo vengono definite in altra parte del testo aggiungendo ":" in coda.
[contenuto] indica che "contenuto" e' opzionale.
((contenuto)) indica che contenuto puo' essere ripetuto N volte.
il simbolo "|" (pipe) indica "oppure", cioe' un grupppo di alternative tutte valide.
Es. di una semplice sintassi:
FRASE:
SOGGETTO VERBO [COMPLEMENTO_OGGETTO]
SOGGETTO:
Nome proprio
| Nome di cosa
.. etc
VERBO:
TUTTI I VERBI IN TUTTE LE DECLINAZIONI.
COMPLEMENTO_OGGETTO:
Nome proprio
| Nome di cosa
| Aggettivo
etc..
Esempi di frasi.
Mario e' bravo - Frase corretta sintatticamente
io gioco - Corretta. COMPLEMENTO_OGGETTO e' opzionale.
io gioco a carte - Frase non corretta
SINTASSI JAVASCRIPT
(( [ ((DICHIARAZIONE_DI_VARIABILE)) ]
| FLUSSO
| [ ((FUNZIONE)) ]
))
FUNZIONE:
function NOME_FUNZIONE( [PARAM1[ ((,PARAM2)) ]] )
{
[ (( DICHIARAZIONE_DI_VARIABILE)) ]
FLUSSO
[return ESPRESSIONE]
}
Se e' presente [return ESPRESSIONE]
il valore di ESPRESSIONE e' ritornato al
chiamante. (Vedere sotto CHIAMATA_DI_FUNZIONE:)
PARAM1:
PARAM2:
NOME_FUNZIONE: IDENTIFICATORE
IDENTIFICATORE:
nome definito dall'utente, puo' essere composto da:
lettere maiuscole, lettere minuscole e numeri, segno di .
sottolineatura "_"
Non puo' iniziare con un numero.
N.B. JavaScript e' case-sensitive, cioe' distingue
maiuscole e minuscole,
andrea e Andrea sono due nomi diversi !
Es.:
pippo - Valido
3pippo - Non valido
pippoDePippis - Valido
pippo!DePippis - Non valido
pippo e Pippo - SONO 2 IDENTIFICATORI DIVERSI
DICHIARAZIONE_DI_VARIABILE:
var VARIABILE;
| var VARIABILE = VALORE;
| VARIABILE = VALORE;
VARIABILE:
IDENTIFICATORE;
FLUSSO:
(( ISTRUZIONE; ))
ISTRUZIONE:
ASSEGNAZIONE
| STRUTTURA_CONDIZIONALE
| STRUTTURA_ITERATIVA
| CHIAMATA_DI_FUNZIONE;
ASSEGNAZIONE:
VARIABLE = VALORE;
| VARIABILE OPERATORE_DI_ASSEGNAZIONE VALORE;
VALORE:
ESPRESSIONE;
ESPRESSIONE:
COSTANTE
| COSTANTE OPERATORE ESPRESSIONE
| VARIABILE
| VARIABLE OPERATORE ESPRESSIONE;
COSTANTE:
COSTANTE_NUMERICA
| COSTANTE_BOOLEANA
| COSTANTE_STRINGA;
COSTANTE_NUMERICA:
numero intero (1 2 -1 etc)
numero reale (1.2 56.897 etc);
COSTANTE_BOOLEANA:
true
| false;
COSTANTE STRINGA:
"sequenza di caratteri"
| 'sequenza di caratteri';
OPERATORE_DI_ASSEGNAZIONE:
(VARIABILE OPERATORE ESPRESSIONE)
+= - Aggiunge alla VARIABILE l'ESPRESSIONE
| -= - Sottrae alla VARIABILE l'ESPRESSIONE
| *= - Moltiplica VARIABILE e ESPRESSIONE e
asssegna il risultato alla VARIABILE.
OPERATORE:
OPERATORE_NUMERICO
| OPERATORE_BOOLEANO
| OPERATORE_STRINGA
OPERATORE_NUMERICO:
+|-|*|/ - Somma/Sottrazione/Moltiplicazione/Divisione
| % - Modulo
| ++VARIABILE (incrementa la variabile di 1)
| --VARIABILE (decrementa la variabile di 1)
| -VARIABILE (cambia il segno alla variabile)
OPERATORE_BOOLEANO:
&& - AND logico
| || - OR logico
| ! - Negazione, applicato ad una espressione booleana
ne inverte il valore.
| == - confronto di uguaglianza (true se gli operandi sono uguali)
| != - confronto di NON uguaglianza (true se sono diversi)
| > - maggiore di (true se operando a sinistra e' maggiore)
| < - minore di (true se operando a sinistra e' minore)
OPERATORE_STRINGA:
+ - Concatena i due operandi (ESPRESSIONI DI TIPO STRINGA)
STRUTTURA_CONDIZIONALE:
IF_ELSE
| SWITCH
STRUTTURA_ITERATIVA:
FOR
| WHILE
| DO_WHILE
CHIAMATA_DI_FUNZIONE:
NOME_FUNZIONE( [ESPRESSIONE1 [ ((,ESPRESSIONE2)) ]] )
| VARIABILE = NOME_FUNZIONE( [ESPRESSIONE1 [ ((,ESPRESSIONE2)) ]] )
N.B.
ESPRESSIONE1 ed ESPRESSIONE2 vanno a valorizzare
i parametri, corrispondenti in posizione e tipo, nella definzione della
funzione.
Es.
function somma(add1,add2)
{
var res = 0; // si dichiara la variabile res
// e implicitamente le si assegna
// il tipo INTERO con l'assegnazione
// = 0;
res = add1 + add2;
return res;
}
La chiamata:
a = somma(2,10);
assegna ad a il valore 12.
a = somma(2,"pippo"); E' ERRATA !
IF_ELSE:
if (espressione) BLOCCO
| if (espressione) BLOCCO
else BLOCCO
BLOCCO:
ISTRUZIONE;
| { FLUSSO; }
SWITCH:
switch(espressione) {
((
case ESPRESSIONE:FLUSSO
break;
))
default:FLUSSO
break;
}
Es.:
switch (a) {
case 1:alert('Vale 1');
break;
case 2:b = a - 2;
alert('a vale 2');
break;
case 6:c= 3*1;
alert(' a vale 6');
default:alert(' Non esiste un case adatto !');
break;
}
Nel nostro caso, viene tentato il confronto
del contenuto di a con tutti i valori espressi nei "case".
Se a vale 1 viene emesso il messaggio 'Vale1'
e si esce dal blocco switch.
Se a vale 2 viene emesso il messaggio 'a Vale 2',
si assegna 0 a b e si esce dal blocco switch.
Se a vale 6 viene emesso il messaggio 'a Vale 6',
si assegna 3 a c e si esce dal blocco switch.
Per qualsiasi altro valore di "a" viene eseguito
il blocco default, quindi viene emesso il messaggio
' Non esiste un case adatto !' e si esce dal blocco switch.
FOR:
for (_inizializzazione; _espressione_controllo; _incremento) {
FLUSSO
}
_Inizializzazione e' un flusso che viene eseguito
appena viene incontrato il "for" e prima di eseguire alcunche'.
{ FLUSSO } viene eseguito in continuazione fino a
che la _espressione_controllo risulta true.
Ad ogni esecuzione, prima di rientrare nel
{ FLUSSO }, viene eseguito _incremento.
Es.:
// emette dieci alert()
for (i=0; i<10; i++) {
alert(' I vale:'+i.toString());
}
N.B.
i e' una variabile intera, ma in JavaScript le variabili sono oggetti,
con metodi associati.
nell'esempio viene richiamato il metodo toString()
associato al qualsiasi oggetto
(costante, variabile, espressione) di tipo intero.
Il metodo restituisce una espressione stringa del
numero contenuto in i, quindi puo' essere concatenata
con l'altra stringa ' I vale:', per formare il messaggio
effettivo mostrato da alert().
WHILE:
while (espressione) {
FLUSSO
}
{ FLUSSO } viene eseguito in continuazione fintanto che
espressione restituisce valore true.
Il test viene eseguito PRIMA DI ENTRARE IN { FLUSSO } LA PRIMA VOLTA e
ALLA FINE DI OGNI CICLO, se espressione ritorna true,
{ FLUSSO } viene rieseguito.
Es.:
Il for di prima eseguito con while.
i=0;
WHILE (i<10) {
alert(' I vale:'+i.toString());
i++;
}
DO_WHILE:
do {
FLUSSO
} while (espressione);
E' equivalente al WHILE, con la differenza che
{ FLUSSO } viene eseguito ALMENO 1 volta.
Ancora il for versione do-while.
i=0;
do {
alert(' I vale:'+i.toString());
i++;
} while (i<10);
