JavaScript è un linguaggio dinamico, multiparadigma, eseguito nel browser e in ambienti server come Node.js.

Questa guida sintetizza i fondamenti operativi necessari per essere produttivi nel quotidiano.

• Ecosistema maturo e multipiattaforma.
• Standard ECMAScript in evoluzione continua.
• Tooling moderno per sviluppo, build e test.

// Avvio rapido
console.log('Hello, JavaScript');

Conoscenze pregresse suggerite per una lettura agevole della documentazione.

• Base di HTML e CSS.
• Concetti di programmazione (variabili, funzioni, condizioni).
• Familiarità con strumenti da riga di comando.

Non sono prerequisiti assoluti, ma accelerano l’apprendimento.

<!-- Questa guida non sostituisce MDN -->

Nonostante il nome simile, i due linguaggi hanno storie e modelli di esecuzione differenti.

JavaScript è tipizzato dinamicamente e adotta un modello a oggetti basato su prototipi.

// JS dinamico
let x = 1;
x = 'test'; // valido

La somiglianza sintattica non implica compatibilità diretta.

Il primo programma aiuta a verificare ambiente e strumenti.

<script>
  document.addEventListener('DOMContentLoaded', () => {
    console.log('Hello world');
  });
</script>

Puoi eseguire lo stesso codice da console DevTools per una verifica immediata.

Le variabili si dichiarano con let o const. L’uso di var è legacy.

const PI = 3.1416;
let counter = 0;

const non rende l’oggetto immutabile: blocca il riassegnamento del binding.

La dichiarazione definisce il binding nel relativo scope.

// block scope
{
  let a = 1;
  const b = 2;
}

L’assenza di dichiarazione implicita (strict mode) previene errori difficili da tracciare.

let e const hanno scope di blocco; var ha scope di funzione e hoisting.

function f() {
  if (true) {
    let x = 1;
  }
  // x non è definita qui
}

Preferire sempre let/const per prevedibilità.

Le globali complicano il reasoning e favoriscono collisioni di nome: limitarne l’uso.

// Evitare pattern globali non necessari
window.App = window.App || {};

Moduli ES e closure offrono alternative strutturate.

const definisce un binding non riassegnabile.

const config = { debug: false };
config.debug = true; // ok (mutazione)
config = {};         // errore (riassegnazione)

Per oggetti realmente immutabili valutare Object.freeze o librerie dedicate.

Tipi primitivi: number, string, boolean, null, undefined, symbol, bigint.

• Gli oggetti sono collezioni dinamiche di proprietà.
• Gli array sono oggetti specializzati con metodi funzionali.
• Le funzioni sono oggetti di prima classe.

typeof 1n;       // 'bigint'
typeof Symbol(); // 'symbol'

Struttura di controllo condizionale per eseguire rami diversi in base a un’espressione booleana.

if (value > 0) {
  // ...
} else if (value === 0) {
  // ...
} else {
  // ...
}

Per condizioni semplici considera l’operatore ternario.

Esegue un blocco finché la condizione rimane vera.

let i = 0;
while (i < 3) {
  i++;
}

Garantire sempre condizioni di uscita per evitare loop infiniti.

Le dichiarazioni sono hoistate; le espressioni e le arrow function no (nel binding).

function sum(a, b) { return a + b; }
const mul = (a, b) => a * b;

Usare nomi descrittivi e firma coerente con il dominio.

Per approfondire concetti e API utilizzare sempre fonti primarie e aggiornate.

• MDN Web Docs
• TC39
• Node.js

// Esempio link rapido
window.open('https://developer.mozilla.org/');