let x = 10;        // riassegnabile
const PI = 3.14;   // non riassegnabile
// niente var nel codice moderno

typeof 'ciao'    // 'string'
typeof 42        // 'number'
typeof true      // 'boolean'
typeof undefined // 'undefined'
typeof null      // 'object'  (storico)
typeof 10n       // 'bigint'

1 === '1'   // false  (no coercion)
1 ==  '1'   // true   (coercion - evitare)
NaN === NaN // false   -> usa Number.isNaN(x)

Number('42')  // 42
String(42)    // '42'
Boolean(0)    // false
parseInt('1a', 10) // 1

const nome = 'Mondo';
const msg = `Ciao, ${nome}!`;
const multilinea = `riga 1
riga 2`;

'ciao'.length            // 4
'ciao'.toUpperCase()     // 'CIAO'
'  ciao  '.trim()        // 'ciao'
'a,b,c'.split(',')       // ['a','b','c']
['a','b','c'].join('-')  // 'a-b-c'
'hello'.includes('ell')  // true
'hello'.slice(1, 4)      // 'ell'
'abc'.replace('b', 'X')  // 'aXc'

Math.max(1, 2, 3)   // 3
Math.min(...arr)
Math.round(1.6)     // 2
Math.floor(1.9)     // 1
Math.ceil(1.1)      // 2
Math.abs(-5)        // 5
(1.2345).toFixed(2) // '1.23'

const a = [1, 2, 3];
a[0]               // 1
a.length           // 3
a.push(4)          // [1,2,3,4]
a.pop()            // rimuove e ritorna l'ultimo
a.unshift(0); a.shift();

const b = [...a, 4, 5];
const copia = [...a];
const max = Math.max(...a);

[1,2,3].map((n) => n * 2)        // [2,4,6]
[1,2,3,4].filter((n) => n % 2)   // [1,3]

[1,2,3,4].reduce((acc, n) => acc + n, 0)   // 10
[1,2,3].reduce((acc, n) => Math.max(acc, n), -Infinity)

[1,2,3].find((n) => n > 1)        // 2
[1,2,3].findIndex((n) => n > 1)   // 1
[1,2,3].some((n) => n > 2)        // true
[1,2,3].every((n) => n > 0)       // true
[1,2,3].includes(2)               // true

// In-place (muta!)
[3,1,2].sort((a, b) => a - b)     // [1,2,3]
// Copia non distruttiva
[3,1,2].toSorted((a, b) => b - a) // [3,2,1]

const u = { nome: 'Alice', eta: 30 };
u.nome           // 'Alice'
u['nome']        // 'Alice'
u.email = 'x@y'; // aggiungere
delete u.eta;

const { nome, eta = 0 } = u;
const { nome: n } = u;       // rename
const [primo, ...resto] = [1,2,3];

const u2 = { ...u, eta: 31 };  // copia + override
const merged = { ...a, ...b };

Object.keys(u)        // ['nome','eta']
Object.values(u)      // ['Alice', 30]
Object.entries(u)     // [['nome','Alice'], ['eta',30]]
for (const [k, v] of Object.entries(u)) { /* ... */ }

Object.fromEntries([['a', 1], ['b', 2]])  // { a: 1, b: 2 }

function somma(a, b) { return a + b; }
const somma = (a, b) => a + b;
const saluta = (nome = 'Mondo') => `Ciao, ${nome}`;

function somma(...numeri) {
  return numeri.reduce((a, b) => a + b, 0);
}
somma(1, 2, 3);             // 6
somma(...[1, 2, 3]);        // 6

function contatore() {
  let n = 0;
  return () => ++n;
}
const c = contatore();
c(); c(); c();   // 3

const moltiplica = (k) => (n) => n * k;
const doppio = moltiplica(2);
doppio(5);   // 10

if (x > 0) {
  // ...
} else if (x === 0) {
  // ...
} else {
  // ...
}
// Ternario
const etichetta = x > 0 ? 'positivo' : 'non positivo';

switch (giorno) {
  case 'sab':
  case 'dom':
    return 'weekend';
  default:
    return 'feriale';
}

for (let i = 0; i < n; i++) { /* ... */ }
for (const v of arr) { /* valori */ }
for (const k in obj) { /* chiavi */ }
while (cond) { /* ... */ }
do { /* almeno 1 volta */ } while (cond);

for (const n of nums) {
  if (n < 0) continue;  // salta
  if (n > 100) break;   // esci
  // ...
}

try {
  const r = puoFallire();
} catch (err) {
  console.error(err.message);
} finally {
  // sempre, ok o ko
}

Promise.resolve(42);
Promise.reject(new Error('no'));
p.then((v) => console.log(v))
 .catch((err) => console.error(err));

async function carica() {
  const r = await fetch('/api/dati');
  if (!r.ok) throw new Error('HTTP ' + r.status);
  return await r.json();
}
const dati = await carica();

async function leggiSicuro() {
  try {
    return await carica();
  } catch (err) {
    return null;
  }
}

Promise.all([p1, p2, p3])         // tutte ok, prima rejection esce subito
Promise.allSettled([p1, p2, p3])  // sempre array di esiti
Promise.race([p1, p2])            // la prima che si decide

// somma.js
export function somma(a, b) { return a + b; }
export const PI = 3.14;

// app.js
import { somma, PI } from './somma.js';

// log.js
export default function log(msg) { /* ... */ }

// app.js
import log from './log.js';

export { somma as add } from './somma.js';
export * from './utils.js';