1.Indicazioni per eseguire gli script
JavaScript è un linguaggio di programmazione utilizzato per aggiungere interattività alle pagine web. Se si vuole solo controllare lo script e provare l'esecuzione del codice, si può usare questa forma ridotta e scrivere il codice JavaScript all'interno dei tag<script>...</script> come nell'esempio che segue, e
salvarlo in un file con l'estenzione.php, tipo prova.php e mandarlo in esecuzione sul Browser.
<html>
<body>
<script>
document.write("Ciao Mondo"); <!--Scrivi "Ciao Mondo" -->
</script>
</body>
</html>
Per inserire il codice JavaScript, vengono utilizzati i tag
<script type=" text/javascript "> ... ... ... </script>Possiamo inserire gli script nella sezione Head, nel Body, ed in file esterni.
Script nell'head
Vengono caricati insieme alla pagina ma non eseguiti. Possiamo inserire ad esempio delle funzioni che non vengono sempre eseguite, ma solo come risposta a degli eventi.
<html> <head> <script type=" text/javascript "> ... istruzioni ... </script> </head> <body> ... </body> </html>Script nel body
Vegnono eseguiti quando la pagina viene caricata.
<html> <head> </head> <body> <script type=" text/javascript "> ... istruzioni ... </script> </body> </html>
JavaScript esterni
Si può creare un file esterno contente il codice e salvarlo con estensione.js per poi richiamarlo nelle pagine in cui serve; questo può essere comodo quando si vuole utilizzare uno script in più documenti.
Per farlo creiamo un documento JavaScript, e lo nominiamo ad esempio:
"script_esterno.js",
e nel documento in cui vogliamo utilizzarlo inseriremo il tag <script> con l'attributo src
che punta al file contenente il codice javascript come segue:
<html> <head> <script src="script_esterno.js"></script> </head> <body> ... </body> </html>
PRIMA PARTE
2.Regole Sintattiche
I programmi JavaScript vengono scritti usando il set di caratteri Unicode, che supportano praticamente ogni lingua scritta attualmente.
distinzione tra maiuscole e minuscole
JavaScript è un linguaggio che fa distinzione tra maiuscole e minuscole: di conseguenza, le parole chiave del linguaggio, le
variabili, i nomi delle funzioni e altri
identificatori devono sempre essere scritti nello stesso modo, con un uso coerente delle maiuscole e delle minuscole.
Javascript non bada agli SPAZI BIANCHI, tranne che per quelli che si trovano nelle stringhe, per cui si possono omettere o anche aumentare. Il loro uso, tuttavia, con l'identazione aumenta la leggibilità del programma per cui sono consigliati.
Importanti sono gli APICI, sia singoli (' ') che doppi, VIRGOLETTE (" "). I doppi apici si adoperano per racchiudere parti di codice Javascript, e, insieme a quelli singoli, a racchiudere anche le stringhe.
Se si desidera che in una stringa appaiano con apici doppi o singoli come parte integrante della stringa stessa, si fanno precedere da una barra rovesciata(\).
Convenzione per i nomi
La regola di scrittura utilizzata per la denominazione degli elementi di un programma, anche se non è una regola standardizzata, gli oggetti si dovrebbero scrivere usando la notazione
UpperCamelCase
in cui l’identificatore, se formato da più parole, deve essere scritto tutto unito e ogni parola deve iniziare con la lettera
maiuscola
(per esempio MioOggettoDichiarato);
le variabili e i metodi si dovrebbero invece scrivere utilizzando la notazione definita
lowerCamelCase
in cui, se l’identificatore è formato da più parole, deve essere scritto tutto unito, e la prima parola deve iniziare con la minuscola mentre le altre con la maiuscola
(per esempio mioMetodo, miaVariabile).
Commenti
JavaScript supporta due stili per i commenti. Il testo tra // e la fine di una riga è considerato come un commento e viene
ignorato da JavaScript. Il testo tra i caratteri /* e */ è anchesso gestito come un commento; la differenza è che questi
commenti possono occupare più righe, anche senza essere annidati. Le righe di codice di seguito corrispondono tutte a commenti
JavaScript validi:
/* Anche questo è un commento
organizzato su più righe. */
Identificatori e parole riservate
Un identificatore non è altro che un nome.
In JavaScript, gli identificatori sono usati per assegnare nomi a variabili e funzioni e per fornire etichette ad alcuni cicli nel codice.
Un identificatore JavaScript deve iniziare con una lettera, un carattere di sottolineatura ( _ ) o un simbolo di
dollaro ( $ ). I caratteri successivi possono essere lettere, cifre, caratteri di sottolineatura o simboli del dollaro.
JavaScript riserva diversi identificatori all'uso come parole chiave del linguaggio stesso.
Queste parole NON POSSONO essere usate come identificatori nei programmi:
- abstract,
- boolean,
- break,
- byte,
- case,
- catch,
- char,
- class,
- const,
- continue,
- default,
- do,
- double,
- else,
- extends,
- false,
- final,
- finally,
- float,
- for,
- function,
- goto,
- if,
- implements,
- import,
- in,
- instanceof,
- int,
- interface,
- long,
- native,
- new,
- null,
- package,
- private,
- protected,
- public,
- return,
- short,
- static,
- super,
- switch,
- synchronized,
- this,
- throw,
- throws,
- transient,
- true,
- try,
- var,
- void,
- while,
- with.
Punti e virgola di fine istruzione
JavaScript usa il punto e virgola ( ; ) per separare le istruzioni.
Questa scelta è molto importante per chiarire il significato del codice: senza un separatore, la fine di
un'istruzione potrebbe sembrare l'inizio della successiva, o viceversa.
Anche se non é obbligatorio é consigliabile metterlo sempre.
a = 3; //non obbligatorio
b = 4;
a = 3; b = 4; //il primo punto e virgola è obbligatorio
var nomeVariabile = valore/espressioneLe variabili sono dei nomi simbolici che servono ad inviduare delle locazioni di memoria in cui possono essere posti dei valori.
Prima di utilizzare una variabile, è opportuno dichiararla utilizzando il costrutto
varLa parte "valore\espressione" è opzionale.
Questo comando non ha altro scopo che dichiarare la creazione di una nuova variabile e se necessario, di darle come valore una stringa, un numero o una espressione.
Le variabili dichiarate al di fuori della funzione sono variabili GLOBALI e sono accessibili all' intera applicazione.
Le variabili inserite all'interno delle funzioni sono variabili LOCALI e saranno visibili solo all' interno della funzione nella quale sono state immesse.
I due differenti tipi sono generati da esigenze diverse in quanto le variabili locali hanno una vita brevissima ed esistono finché opera la funzione, e alla chiusura della parentesi finale della funzione vengono distrutte liberando memoria,
mentre
le variabili globali sono dei contenitori che durano per tutta la durata della pagina e servono a veicolare dei valori tra le funzioni e tra gli script, ma anche tra le varie pagine o al server.
Javascript utilizza un controllo di tipo NON RISTRETTO(lasco, blando) per cui non esiste una sezione di dichiarazione di variabili e non c'è bisogno di farlo, ma automaticamente viene assegnato il tipo in base alla dichiarazione.
3.Tipi di Dato
I programmi informatici manipolano valori, per esempio il numero "6,28" o il testo "Ciao Mondo".
I generi di valori che possono essere manipolati in un linguaggio di programmazione sono definiti tipi.
1.NUMERI: interi e decimali
2.STRINGHE (o sequenza di caratteri)
3.BOOLEANI o logici: che possono assumere soltanto due stati (true o false)
4.OGGETTI
5.VALORE NULLO
6.CARATTERI SPECIALI (es.: \f per l'avanzamento pagina)
1.NUMERI Non c'è distinzione tra interi e reali. Sono costanti numeriche tutte le espressioni che rappresentano un numero valido, con e senza virgola.
Le funzioni
parseInt e parseFloat possono essere usate per convertire stringhe in numeri.
2.STRINGHE Le stringhe possono essere create implicitamente, attraverso una costante di tipo stringa.
Sono costanti di tipo stringa i valori racchiusi tra virgolette (singole o doppie).
Tutti i tipi di dato vengono automaticamente convertiti in stringa quando si trovano in un contesto che richieda la presenza di una stringa (ad esempio, quando vengono concatenati a un'altra stringa).
3.BOOLEANI Le costanti boooeane sono true e false. Tutti gli altri tipi di dato possono venire convertiti, se necessario, in valori booleani in base alle regole che seguono:
Se l'espressione ha un valore numerico diverso da zero è true.
Se l'espressione ha un valore stringa non vuoto è true.
Se l'espressione ha un valore oggetto è true.
In tutti gli altri casi (numerico zero, stringa vuota, valore undefined o null) l'espressione è false.
4.OGGETTI Le variabili di tipo oggetto contengono in effetti dei riferimenti ad oggetti. Più variabili possono quindi fare riferimento allo stesso oggetto.
Inoltre non bisogna pensare agli oggetti Javascript come veri oggetti, ma piuttosto come "contenitori di informazioni e funzioni" con un comportamento simile a quello dei veri oggetti.
5.NULL Il tipo nullo ha un unico valore, null.
| Sequenza | Significato |
|---|---|
\n
|
Nuova Linea |
\t
|
Tab Orizzontale |
\v
|
Tab Verticale |
\b
|
Backspace (spazio) |
\r
|
Carriage Return (Ritorno Carrello) |
\'
|
Apice |
\\
|
Backslash |
\"
|
Virgolette |
\f
|
Avanzamento pagina |
\uXXXX
|
Carattere Unicode con 4 cifre in esadecimale |
\xXX
|
Carattere Latin-1 con 2 cifre in esadecimale |
Costanti
Le costanti servono a memorizzare dei valori che non cambiano durante l'esecuzione dello script.
Javascript non le supporta come ci aspettiamo, è infatti possibile modificarne il valore, anche perchè vengono dichiarate e gestite come le variabili.
Conversione tra tipi di dato
Quando utilizziamo delle espressioni che contengono variabili con valori di differente tipo, il linguaggio
JavaScript attua automaticamente, delle conversioni tra i tipi secondo un ben preciso set di regole che possiamo sintetizzare in modo schematico
nella Tabella.
Questa si legge considerando il valore della colonna
Valore
e come lo stesso
verrebbe convertito nel tipi espressi nelle colonne
String,
Number,
Boolean
e Object.
Per i casi più consueti, possiamo dire che:
- se usiamo, in un’operazione aritmetica, una stringa che contiene un numero la stessa verrà convertita in numero e tutta l’espressione sarà valutata come espressione numerica;
- se usiamo l’operatore più (
+) tra una stringa e un numero allora tale operatore, a causa della sua ambiguità, verrà impiegato per svolgere un’operazione di concatenamento e non di addizione, e dunque il numero verrà convertito in stringa e tutta l’espressione sarà valutata come espressione di tipo stringa; - vi sono alcuni valori che sono considerati come valori di “verità” e sono automaticamente
convertiti nel valore
true, e alcuni valori che sono considerati come valori di “falsità” e sono automaticamente convertiti nel valorefalse. Esempi di questi ultimi sono i valori:undefined,null,0,-0,NaNe""(una stringa vuota). Gli altri valori che includono gli oggetti e gli array sono valutati invece cometrue.
| Valore | String | Number | Boolean |
|---|---|---|---|
undefined |
"undefined" |
NaN |
false |
null |
"null" |
0 |
false |
true |
"true" |
1 |
new Boolean(true) |
false |
"false" |
0 |
new Boolean(false) |
"" |
0 |
false |
new String("") |
"9" |
9 |
true |
new String("9") |
"nove" |
NaN |
true |
new String("nove") |
0 |
"0" |
false |
new Number(0) |
1 |
"1" |
true |
new Number(1) |
-0 |
"0" |
false |
new Number(-0) |
NaN |
"NaN" |
false |
new Number(Nan) |
Infinity |
"Infinity" |
true |
new Number(Infinity) |
-Infinity |
"-Infinity" |
true |
new Number(-Infinity) |
var t = "1"; var u = 4; var j = t + u; // qui j vale "14" e non 5 document.write("j = " + j + " ed è di tipo " + typeof j); var x = "2"; var m = 10; var y = x * m; // qui y vale 20 document.write("y = " + y + " ed è di tipo " + typeof y);
j = 14 ed è di tipo stringy = 20 ed è di tipo number
ANALISI
La variabile u, ancorché di tipo numerico, è convertita in un tipo stringa
e il suo valore viene concatenato con il valore della variabile t
e posto nella variabile j, che diviene anch’essa di tipo stringa.
La variabile m, invece, rimane di tipo numerico, ma la variabile
x viene convertita da stringa in numero perché così è possibile eseguire la relativa
operazione di moltiplicazione il cui risultato viene posto nella variabile y che diviene di tipo
numerico.
Notiamo infine l’uso dell’operatore unario typeof, che posto prima del
suo singolo operando ne ritorna un valore di tipo stringa che contiene la descrizione del suo tipo di dato.
NOTA: È possibile usare un modo veloce per convertire una stringa contenente un numero in un tipo numerico
semplicemente moltiplicandola per 1 (per esempio, typeof ("1" * 3) ritornerà il
valore number). Allo stesso modo è possibile convertire un numero in una stringa usando
l’operatore + con una stringa vuota (per esempio, typeof (3 +
"") ritornerà il valore string).
Conversioni esplicite
Spesso potremmo voler effettuare esplicitamente delle conversioni tra i tipi e non lasciare al linguaggio
tale automatismo. A tal fine possiamo utilizzare le funzioni Boolean, Number, String e Object – invocandole
senza l’operatore new –, le quali restituiscono l’argomento passato convertito nel tipo
che rappresentano.
Possiamo anche usare il metodo toString per convertire il suo oggetto di
invocazione in una stringa passando, opzionalmente, per i tipi numerici, un argomento che rappresenta la base o la radice in
cui deve convertire il numero, il metodo parseInt per convertire il suo argomento in un tipo
numerico intero e il metodo parseFloat per convertire il suo argomento in un tipo numerico in
virgola mobile. Lo Snippet 3.8 mostra degli esempi.
Esempi di conversioni esplicite
var a = Number("5"); // 5
var b = String(null); // "null"
var c = Boolean(""); // false
var d = 10;
var e = d.toString(2); // 1010 convertito in binario
var f = d.toString(16); // a convertito in esadecimale
var g = parseInt(" 12"); // 12 salta lo spazio bianco iniziale
var h = parseFloat("12.55 avb"); // 12.55 non considera le lettere avb
var i = parseFloat("@12.66"); // NaN un numero non può iniziare con un carattere non numerico
4.OPERATORI
Un operatore è definibile come una sorta di istruzione che agisce su dei dati, detti operandi, e permette di ottenere un risultato eseguendo un’operazione. Ogni operatore è rappresentato da simboli che determinano su quali operandi agisce. Quando in un’espressione si incontrano diversi operatori, l’ordine di esecuzione viene scelto in base alla precedenza (che indica se un operatore ha priorità maggiore di un altro) e all’associatività (se più operatori hanno la stessa precedenza allora viene eseguito, nel caso dell’associatività da sinistra a destra, prima quello che si trova più a sinistra e poi a seguire gli altri sempre da sinistra; nel caso dell’associatività da destra a sinistra, viene eseguito prima quello che si trova più a destra e poi sempre da destra a seguire gli altri).
In ogni caso, l’ordine di precedenza prestabilito può essere variato con l’utilizzo dell’operatore
parentesi tonde (), che ha la precedenza più alta in assoluto; se vi sono varie coppie di
parentesi annidate, la priorità sarà dalla più interna verso quella più esterna, mentre se ve ne sono varie sullo stesso
livello, l’associatività sarà da sinistra a destra.
Gli operatori servono a fare operazioni sui valori.
Si distinguono in:
ARITMETICI DI ASSEGNAZIONE DI CONFRONTO LOGICI OPERATORI SPECIALI
OPERATORI ARITMETICI
Servono ad lavorare con i numeri, tramite gli operatori aritmetici è infatti possibile eseguire le comuni operazioni di somma, sottrazione,
e le altrte operazioni aritmetiche base. Per funzioni matemetiche più complesse quali calcoli esponenziali,
trigonometrici o altro, esiste un oggetto "math" che vedremo in seguito
Vediamo nel dettaglio la lista degli operatori aritmetici supportati da JavaScript
Operatore Descrizione
+ Addizione
- Sottrazione
* Moltiplicazione
/ Divisione
% Modulo
++ Incremento
-- Decremento
SPIEGAZIONI ED ESEMPI:
Nel comporre le espressioni è necessario tenere conto della precedenza delle operazioni (prima
vengono valutate moltiplicazioni e divisioni, poi addizioni e sottrazioni).
Nel comporre le espressioni possono risultare utili le parentesi;
in questo caso è possibile usare solo parentesi tonde
(JavaScript non supporta l'uso di parentesi quadre e graffe nelle espressioni).
3 + 4 /2 //restituisce 5
(3+ 4) / 2 //restituisce 3.5
(3+ (2+ 6) * 2) /2 //restituisce 9.5
Esistono poi due operatori chiamati unari in quanto lavorano su un solo dato numerico. Sono:++ incrementa di uno il valore della variabile
-- decrementa di uno il valore della variabile
Questo operatore può essere usato da solo oppure all'interno di un'espressione:
var1++ //corrisponde a var1 = var1 + 1
var1-- //corrisponde a var1 = var1 - 1
var2 = var1++ - 15 //corrisponde a var2 = var1 -15; var1 = var1 +1
Operazioni con le stringhe
L'operazione più utilizzata quando si lavora con le stringhe è la concatenazione, che consiste nell'unire due stringhe accostandole una di seguito all'altra. L'operatore di concatenazioni in JavaScript è
+Vediamo alcuni esempi:
alert("Io sono Mario" + " Rossi");
var nome = "Mario";
alert("Io mi chiamo " + nome);
USCITA:
L'uscita di questo breve listato sono due finestre alert contenti il testo:
Io sono un Mario RossiIo mi chiamo MarioSi noti lo spazio prima delle virgolette.
OPERATORI DI ASSEGNAZIONE
Servono ad asegnare un valore ad una veriabile, esiste un operatore semplice di assegnazione e degli operatori "composti"
che permettono di avere un codice più compatto.
Operatore Esempio Equivalente a:
= x=y x=y
+ x+=y x=x+y
-= x-=y x=x-y
*= x*=y x=x*y
/= x/=y x=x/y
%/ x%=y x=x%y
OPERATORI DI CONFRONTO
Sono utilizzati nelle espressioni condizionale che vderemo in seguito per effettuare dei confronti tra valori
Operatore Descrizione
== Uguale a
!= Diverso da
> Maggiore di
< Minore di
>= Maggiore o uguale
<= Minore o uguale
Il loro uso è strettamente legato ai dati numerici ed è intuitivo.
Ad esempio:
3 < 4 //restituisce true
4 == 5 //restituisce false
È possibile inoltre comparare le stringhe.
Ad esempio:
"mioValore" == "mioValore" //restituisce true
"mioValore" == "non_mioValore" //restituisce false
"MioValore" == "mioValore" //restituisce false (distingue maiuscole e minuscole)
OPERATORI LOGICI
Sono i classici and or not che consentono di concatenare istruzioni di confronto, vengono utilizzati anch'essi nelle istruzioni condizionali.
Operatore Descrizione
&& and
|| or
! not
È possibile inoltre comporre le espressioni di confronto (o booleane) usando gli operatori della logica, che lavorano con valori booleani e restituiscono a loro volta un valore booleano.
In questo caso è possibile comporre le espressioni con le parentesi
(a > 0) && (a < 100)
valuta se
a è compreso tra 0 e 100 esclusi.Se JavaScript si aspetta un dato booleano e riceve un altro tipo di dato, converte in
false le stringhe vuote e il numero 0
in true il resto.
OPERATORI SPECIALI
Vediamo infine altri operatori che non trovano una collocazione in quelli visti
? selettore condizionale.
Sintassi: condizione ? espressionePerVero : espressionePerFalso
Se la condizione è valutata per true ritorna espressionePerVero,
altrimenti restituisce espressionePerFalso
Esempio:
document.write ("Il pollo è " + (zampe==2 ? "bipede" : "non bipede"))
, (virgola)
Serve a separare diverse espressioni l’una dall’altra in una posizione
che prevede una singola espressione. Tutte le espressioni vengono valutate,
ma il valore che viene preso in considerazione è quello dell’ultima espressione.
Esempio:
for (a=3, i=1; i<100; i++) ............
.(punto)
Serve a richiamare una proprietà o un metodo associato ad un oggetto
Esempio:
document.write("Chiamo il metodo write dell'oggetto document")
delete
elimina un oggetto, una proprietà definita dall’utente, un elemento di
un array o una variabile dichiarata implicitamente (senza l’uso dell’istruzione var).
Sintassi:
delete nomeoggetto | oggetto.proprietà | array[ind]
new
crea una nuova istanza di un oggetto predefinito o definito dall’utente.
Sintassi:
nomeoggetto=new tipooggetto(par1[, par2 ....parx])
this
riferisce le operazioni all’oggetto corrente.
Esempio:
alfa= this.voto anziché alfa=studente.voto
L’oggetto deve essere quello che correntemente viene in uso, altrimenti si
riferirà all’oggetto di più alta gerarchia.
typeof(...) (controllo tipo)
Restituisce una stringa contenente il nome del tipo del suo argomento.
Utile per capire che tipo ha dedotto Javascript per una certa espressione,
o per verificare che un argomento sia del tipo giusto.
void(...) (statement nullo)
Esegue il codice passato come argomento, ma non restituisce l'eventuale valore di ritorno.
Usato solo in casi molto particolari
Precedenza tra gli operatori Dalla priorità più alta alla più bassa:
1) Funzione o indice di matrice () []
2) Negazione (!, ~, -), incremento (++), decremento (--)
3) Moltiplicazione, divisione e modulo (*, /, %)
4) Addizione e sottrazione (+, -)
5) Operatore bit (>>, <<, >>>)
6) Confronto (<, >, <=, >=)
7) Uguaglianza e disuguaglianza (==, !=)
8) Operatore relativo ai bit AND (&)
9) Operatore relativo ai bit XOR (^)
10) Operatore relativo ai bit OR (|)
11) Operatore logico AND (&&)
12) Operatore logico OR (||)
13) Operatori condizionali (?, :)
14) Operatori di assegnazione (=)
15) Virgola (,)
5.VARIABILI, ESPRESSIONI
La sintassi per dichiarare una VARIABILE:
var nomeVariabile = valore/espressione
Le variabili sono dei nomi simbolici che servono ad inviduare delle locazioni di memoria in cui
possono essere posti dei valori.
La parte "valore\espressione" è opzionale.
Questo comando non ha altro scopo che dichiarare la creazione di una nuova variabile e
se necessario, di darle come valore una stringa, un numero o una espressione.
JavaScript usa gli ambiti lessicali:
Le variabili dichiarate al di fuori della funzione
sono variabili GLOBALI e sono accessibili all' intera applicazione.
Le variabili inserite all'interno delle funzioni
sono variabili LOCALI e saranno visibili solo all' interno della funzione
nella quale sono state immesse.
I due differenti tipi sono generati da esigenze diverse in quanto
le variabili locali hanno una vita brevissima ed esistono finché opera la funzione,
e alla chiusura della parentesi finale della funzione vengono distrutte liberando memoria, mentre
le variabili globali sono dei contenitori che durano per tutta la durata della pagina e servono
a veicolare dei valori tra le funzioni e tra gli script, ma anche tra le varie pagine o al server.
Le variabili di JavaScript sono non tipizzate: è possibile assegnare un valore di qualunque tipo a una variabile e successivamente assegnarle un valore di tipo diverso.
Le variabili vengono dichiarate con la parola chiave var.
Nomi delle variabili
Le variabili JavaScript sono caratterizzate da un identificatore,da un ambito e da un tipo specifico di dati.
Poiché il linguaggio non è strettamente tipizzato, tutto il resto può cambiare dinamicamente.
Le variabili JavaScript vengono utilizzate per memorizzare dei valori in modo da poterli poi referenziare simbolicamente in altre parti del codice.
Ogni variabile ha un identificatore, unico all’interno dell’ambito in cui la variabile risulta definita,
costituito da una qualsiasi combinazione di lettere, numeri, caratteri di sottolineatura (_) e caratteri dollaro ($)
L’unico altro requisito per i nomi delle variabili è che devono iniziare con una lettera, un $ o un carattere _
Tutti i seguenti nomi, per esempio, sono validi in JavaScript
_identificatoreDiVariabile
identificatoreDiVariabile
$identificatore_di_variabile
ESPRESSIONI
Un'espressione è una frase di JavaScript che un interprete JavaScript può valutare per produrre un valore.
Una costante incorporata letteralmente nel programma è un tipo molto semplice di espressione;
anche un nome di variabile è unespressione semplice che restituisce il valore assegnato alla variabile.
Le espressioni complesse vengono create a partire dalle espressioni più semplici.
Il modo più comune per creare una espressione complessa partendo da espressioni semplici richiede l'uso di un operatore
che combina il valore dei suoi operandi (in genere due) e restituisce un nuovo valore.
Per esempio:
l'espressione "x * y" restituisce il prodotto dei valori delle espressioni "x" e "y".
Le espressioni più semplici, dette espressioni primarie, sono quelle indipendenti,
cioè che non contengono espressioni più semplici.
Le espressioni primarie in JavaScript sono le costanti o i valori letterali,
alcune parole chiave del linguaggio e i riferimenti alle variabili.
I valori letterali sono valori costanti incorporati direttamente nel programma. Ecco un esempio:
1.23 // Un valore letterale numerico"hello" // Un valore letterale stringaLe parole riservate come
true , false , null e this sono espressioni primarie.Infine, il terzo tipo di espressione primaria è il riferimento semplice alla variabile:
i // Restituisce il valore della variabile i.