JavaScript è stato creato da Netscape di Brendan Eich nel 1995. È stato originariamente pensato come un semplice linguaggio di scripting per i siti web, complementare all'uso di java per applicazioni più complesse ma la sua stretta integrazione con le pagine Web e il supporto integrato con esse ha causato il suo divenire più comune di Java per i frontend web.
Tuttavia JavaScript non è semplicemente limitato ai web browser: Node.js è un progetto che fornisce una runtime standalone dell'engine JavaScript V8 per Google Chrome, sta diventando sempre più popolare.
JavaScript ha una sintassi C-like, quindi se usate linguaggi come C o Java, molta della sintassi di base sarà già familiare. A dispetto di questo, e a dispetto del nome similare, il modello a oggetti di JavaScript è significativamente diverso da quello di Java.
```js
// I commenti a singola linea iniziano con due slash.
/* I commenti multilinea cominciano con uno slash e un asterisco,
e terminano con un asterisco e uno slash */
// Le istruzioni possono essere terminate con ;
doStuff();
// ... ma non devono esserci per forza, i punti e virgola vengono automaticamente inseriti
// dove c'è un newline, ad eccezione di alcuni casi.
doStuff()
// Poiché questi casi possono causare risultati inaspettati, noi continueremo ad usare
// i punti e virgola in questa guida.
///////////////////////////////////
// 1. Numeri, Stringe e Operatori
// JavaScript ha un tipo numero (che è a 64-bit IEEE 754 double).
// Double ha una mantissa di 52-bit che è abbastanza per memorizzare interi
// fino a 9x10¹⁵ per essere precisi.
3; // = 3
1.5; // = 1.5
// Alcuni lavori aritmetici di base come ci si può aspettare.
1 + 1; // = 2
0.1 + 0.2; // = 0.30000000000000004
8 - 1; // = 7
10 * 2; // = 20
35 / 5; // = 7
// inclusa la divisione con la virgola.
5 / 2; // = 2.5
// E il modulo.
10 % 2; // = 0
30 % 4; // = 2
18.5 % 7; // = 4.5
// Anche le operazioni binarie funzionano; quando effettuate una operazione binaria il vostro numero decimale
// è convertito in un intero con segno *fino a* 32 bit..
1 <<2;//=4
// Le precedenza è subordinata dalle parentesi.
(1 + 3) * 2; // = 8
// Ci sono tre valori speciali che non sono numeri reali:
Infinity; // ad esempio il risultato di 1/0
-Infinity; // ad esempio il risultato di -1/0
NaN; // ad esempio il risultato di 0/0, sta per 'Not a Number'
// Ci sono anche i tipi booleani.
true;
false;
// Le stringe sono create con ' oppure ".
'abc';
"Hello, world";
// La negazione usa il ! simbolo
!true; // = false
!false; // = true
// L'uguaglianza è ===
1 === 1; // = true
2 === 1; // = false
// L'inuguaglianza è !==
1 !== 1; // = false
2 !== 1; // = true
// Altre comparazioni
1 <10;//=true
1 > 10; // = false
2 <= 2; // = true
2 >= 2; // = true
// Le stringhe si concatenano con il +
"Hello " + "world!"; // = "Hello world!"
// ... che funziona con qualcosa in più delle semplici stringhe
"1, 2, " + 3; // = "1, 2, 3"
"Hello " + ["world", "!"]; // = "Hello world,!"
// e sono comparate con <e>
"a" < "b"; // = true
// La comparazione con conversione implicita si fa con il doppio uguale...
"5" == 5; // = true
null == undefined; // = true
// ...ammenoché non si usi ===
"5" === 5; // = false
null === undefined; // = false
// ...che può provocare strani comportamenti...
13 + !0; // 14
"13" + !0; // '13true'
// Si può accedere ai caratteri di una stringa con `charAt`
"This is a string".charAt(0); // = 'T'
// ...o usando le `substring` per ottenere una parte.
"Hello world".substring(0, 5); // = "Hello"
// `length` è una proprietà, quindi non usate le ().
"Hello".length; // = 5
// Ci sono anche `null` e `undefined`.
null; // usato per indicato deliberatamente un non-valore
undefined; // usato per indicare un valore che attualmente non è presente (sebbene
// `undefined` sia un valore a sua stessa volta)
// false, null, undefined, NaN, 0 e "" sono falsi; tutto il resto è vero.
// Notare che 0 è falso e "0" è vero, nonostante 0 == "0".
///////////////////////////////////
// 2. Variabili, Array e Oggetti
// Le variabili sono dichiarate con la parola chiave `var`. JavaScript è tipato
// dinamicamente, quindi non serve specificare il tipo. L'assegnamento usa un carattere `=`
// singolo.
var someVar = 5;
// Se si toglie la parola chiave var non si otterrà un errore...
someOtherVar = 10;
// ...ma la tua variabile sarà creata con visibilità globale e non
// nel blocco dove la si è definita.
// Le variabili dichiarate senza essere definite vengono impostate come undefined.
var someThirdVar; // = undefined
// Se si vuole dichiarare una coppia di variabili, lo si può fare usando una virgola
// come separatore
var someFourthVar = 2, someFifthVar = 4;
// C'è una scorciatoia per effettuare operazioni matematiche sulle variabili:
someVar += 5; // equivalente di someVar = someVar + 5; someVar vale 10 ora
someVar *= 10; // ora someVar è 100
// e un ulteriore scorciatoia per aggiungere o sottrarre 1
someVar++; // ora someVar è 101
someVar--; // di nuovo 100
// Gli array sono liste ordinati di valori, di qualsiasi tipo.
var myArray = ["Hello", 45, true];
// Si può accedere ai loro membri usando la sintassi sottoscritta con le parentesi quadra.
// Gli indici degli array iniziano a zero.
myArray[1]; // = 45
// Gli Array sono mutabili e di dimensione variabile.
myArray.push("World");
myArray.length; // = 4
// Aggiungere/Modificare in un indice preciso
myArray[3] = "Hello";
// Aggiungere e rimovere un elemento dall'inizio o dalla fine di un array
myArray.unshift(3); // Aggiungere come primo elemento
someVar = myArray.shift(); // Rimuovere il primo elemento e restituirlo
myArray.push(3); // Aggiungere come ultimo elemento
someVar = myArray.pop(); // Rimuovere l'ultimo elemento e restituirlo
// Unire tutti gli elementi di un array con un punto e virgola
var myArray0 = [32,false,"js",12,56,90];
myArray0.join(";") // = "32;false;js;12;56;90"
// Ottenere un subarray di elementi dall'indice 1 (incluso) al 4 (escluso)
myArray0.slice(1,4); // = [false,"js",12]
// Rimuovere 4 elementi partendo dall'indice 2 e inserirci delle stringhe
// "hi","wr" e "ld"; restituiscono i subarray rimossi
Il [Mozilla Developer Networ][1] fornisce una documentazione eccellente su come JavaScript è utilizzato nei browsers. In più è un wiki, quindi si può imparare di più aiutando gli altri condividendo la propria conoscenza.
MDN's [A re-introduction to JavaScript][2] copre molti dei concetti qui trattati in maggiore dettaglio. Questa guida ha deliberatamente coperto solamente il linguaggio JavaScript; se volete sapere di più su come usare JavaScript in una pagina web, iniziate leggendo il [Document Object Model][3].
[JavaScript: The Right Way][10] è una guida dedicata all'introduzione dei nuovi sviluppatori a JavaScript e come aiuto agli sviluppatori esperti per imparare di più sulle best practice.
[javascript.info][11] è un moderno tutorial su JavaScript che copre le basi (linguaggio principale e lavorazione con un browser) come anche argomenti avanzati con spiegazioni concise.
In aggiunta ai contributori di questo articolo, alcuni contenuti sono adattati dal Louie Dinh's Python tutorial su questo sito, e da [JS Tutorial][7] sul Mozilla Developer Network.
