Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Apprendimento e pratica

JavaScript restituisce 23 invece di 5? Controlla il tipo dei dati

Un piccolo modulo per capire perché JavaScript concatena invece di sommare. Osserva i tipi, correggi la conversione e verifica campi vuoti e valori non validi.

CKTIS Group

Su sfondo blu scuro, due tessere separate con 2 e 3 si affiancano formando 23 nel percorso superiore. Il percorso inferiore mostra 2 + 3 = 5.

Inserisci 2 e 3 in un modulo, premi il pulsante per sommare e ottieni 23. Non compare un errore. La pagina non si blocca. Il programma ha eseguito un'istruzione: semplicemente, una diversa da quella che intendevi dargli.

È un buon caso per il primo incontro con il debugging, cioè la ricerca della causa di un errore. Non servono applicazioni complesse o strumenti a pagamento. Bastano due valori, poche istruzioni JavaScript e una domanda: che cosa contengono davvero queste variabili?

Prima prova a prevedere il risultato

Osserva queste tre operazioni. Prima di eseguirle, annota quale risultato ti aspetti:

console.log(2 + 3);
console.log("2" + "3");
console.log("2" + 3);

La prima restituisce il numero 5. La seconda e la terza restituiscono il testo "23". Le virgolette nel codice non sono decorative: distinguono il testo dai numeri. Sullo schermo, però, i due tipi di valore possono apparire molto simili. Per questo osservare soltanto il risultato può trarre in inganno.

L'operatore + ha qui due funzioni. Somma numeri, ma unisce anche testi. In questo semplice esempio, se uno dei due operandi è testo, anche l'altro viene convertito in testo e avviene una concatenazione. È come avvicinare un cartoncino con scritto «3» a uno con scritto «2», invece di calcolarne la somma. Descrizione dell'operatore su MDN.

Non conviene ricordare questo comportamento soltanto come una battuta sul «bizzarro JavaScript». È molto più utile prendere l'abitudine di controllare i dati prima di eseguire un'operazione. Lo stesso problema può presentarsi in una calcolatrice, in un contatore di prodotti o in un modulo d'ordine.

Da dove arriva il testo nel modulo

Il piccolo esempio seguente contiene un errore intenzionale. Salvalo in un file chiamato sum.html e aprilo nel browser. Il pulsante mostra il segno + e i campi sono etichettati A e B. Inserisci 2 e 3:

<!doctype html>
<meta charset="utf-8">
<title>A + B</title>
<label>A <input id="a" value="2"></label>
<label>B <input id="b" value="3"></label>
<button id="add" type="button">+</button>
<output id="result" aria-live="polite"></output>
<script>
  const first = document.querySelector("#a");
  const second = document.querySelector("#b");
  const result = document.querySelector("#result");

  document.querySelector("#add").addEventListener("click", () => {
    result.textContent = first.value + second.value;
  });
</script>

Questo esempio va eseguito in locale: non è un modulo funzionante all'interno dell'articolo. All’inizio ignoriamo l’aspetto della pagina per osservare il meccanismo. Non installi nulla e non invii i dati inseriti a un server.

La proprietà .value di un elemento input restituisce testo. L'utente vede cifre, ma il programma legge "2" e "3". Anche impostando il campo come type="number", la lettura tramite .value non inizia a restituire un numero. Il tipo del campo e il tipo del valore in JavaScript sono due aspetti diversi. Documentazione sul valore del campo.

Osservalo negli strumenti del browser

Apri gli strumenti per sviluppatori del browser e la scheda Console. Sul computer spesso puoi farlo con F12; in alternativa, passa dal menu del browser. Dopo aver premuto il nostro pulsante, controlla:

console.log(first.value, typeof first.value);
console.log(second.value, typeof second.value);

Accanto a entrambi i valori comparirà string, il tipo testuale. È un indizio concreto, non una supposizione. Quando cerchi un errore nel tuo programma, esamina nell'ordine i dati in ingresso, il punto in cui vengono trasformati e il risultato. Non cambiare caratteri a caso solo perché un frammento trovato in rete «dovrebbe aiutare».

Se, invece di digitare manualmente le istruzioni, imposti un punto di interruzione sulla riga dell'addizione, l'esecuzione si fermerà proprio lì. Potrai osservare entrambi i valori prima del calcolo. All'inizio, però, bastano console.log e typeof: non occorre imparare subito a usare l'intero pannello degli strumenti.

La correzione è breve, ma ha dei limiti

Nell'esempio del modulo, sostituisci la riga che imposta il risultato con questa:

result.textContent = Number(first.value) + Number(second.value);

Number converte esplicitamente entrambi i valori. Da "2" e "3" otteniamo numeri, quindi la somma restituisce 5. La parola importante è entrambi: Number(first.value) + second.value continuerebbe a concatenare il risultato con il testo e, con i nostri dati, mostrerebbe ancora 23.

Non tentare di correggere tutto con parseInt. Questa funzione serve a leggere un numero intero e può eliminare la parte decimale oppure accettare solo l'inizio di un testo. In questo esercizio vogliamo stabilire chiaramente quali dati accettiamo, senza troncarli in modo poco evidente.

La sola conversione non basta a convalidare il modulo. Number("") restituisce 0, non un'indicazione di «dato mancante». Invece Number("abc") restituisce NaN, un valore speciale che in questo caso indica una conversione in numero non riuscita. Un campo vuoto e uno zero inserito consapevolmente hanno significati diversi. Regole di conversione di Number.

Aggiungiamo la convalida dei dati

Sostituisci tutto il contenuto compreso tra i tag <script> e </script> con il codice seguente. Non aggiungere un secondo gestore del clic a quello precedente: vogliamo un unico modo, corretto, di gestire il pulsante.

const first = document.querySelector("#a");
const second = document.querySelector("#b");
const result = document.querySelector("#result");

function addInputs(left, right) {
  if (left.trim() === "" || right.trim() === "") {
    throw new Error("empty");
  }

  const a = Number(left);
  const b = Number(right);
  if (!Number.isFinite(a) || !Number.isFinite(b)) {
    throw new Error("invalid");
  }

  const sum = a + b;
  if (!Number.isFinite(sum)) {
    throw new Error("overflow");
  }
  return sum;
}

document.querySelector("#add").addEventListener("click", () => {
  try {
    result.textContent = addInputs(first.value, second.value);
  } catch (error) {
    result.textContent = error.message;
  }
});

Abbiamo mantenuto brevi codici di errore per concentrarci sul meccanismo: empty indica un campo vuoto, invalid un valore non valido e overflow un risultato troppo grande per essere rappresentato come numero finito. In un'applicazione normale sostituiscili con messaggi chiari nella lingua dell'utente.

Prima trim() permette di riconoscere anche un campo che contiene soltanto spazi. Solo dopo avviene la conversione. Number.isFinite verifica che il valore ottenuto sia un numero finito: rifiuta sia NaN sia l'infinito. Controlliamo separatamente la somma, perché anche il risultato dell'operazione può superare l'intervallo rappresentabile. Descrizione di Number.isFinite.

Questo modulo dimostrativo accetta le notazioni gestite da Number, fra cui il punto come separatore decimale e la notazione esponenziale. Non è una calcolatrice finanziaria pronta all'uso e non gestisce tutti i formati numerici locali. La virgola decimale richiede una decisione progettuale distinta e consapevole; non sostituiamo automaticamente ogni virgola presente in un testo qualsiasi.

Verifica qualcosa in più di 2 e 3

Dopo la correzione, esegui alcune prove:

  • A: 2, B: 3 → 5.
  • A: 0, B: 3 → 3. Zero è un valore valido.
  • A: campo vuoto, B: 3 → empty.
  • A: soltanto spazi, B: 3 → empty.
  • A: abc, B: 3 → invalid.
  • A: 2.5, B: 3 → 5.5.
  • A: 2,5, B: 3 → invalid, secondo le regole adottate.
  • A: 1e308, B: 1e308 → overflow.

Questa piccola verifica evita un'illusione frequente: «Ha funzionato con un esempio, quindi è pronto». Non devi immaginare subito tutti i dati possibili. Parti dal caso normale, dallo zero, dal campo vuoto e da dati diversi da quelli attesi.

Number.isFinite non garantisce la precisione di ogni calcolo. I numeri di JavaScript hanno una precisione limitata. Per denaro, numeri molto grandi e requisiti di precisione specifici occorre scegliere una rappresentazione adeguata e regole di arrotondamento. Correggere il risultato 23 non risolve automaticamente tutti i problemi dell'aritmetica.

Ora tocca a una tua piccola modifica

Aggiungi un terzo campo C. Prima prova a prevedere cosa succederebbe lasciandolo per sbaglio come testo. Poi modifica la funzione affinché controlli tutti e tre i campi e sommi i numeri. Verifica anche il terzo campo vuoto e il valore zero inserito al suo interno.

Se sai spiegare perché la versione precedente restituiva 23, cosa controlla ogni condizione e perché non basta il risultato corretto di una sola prova, stai esercitando la programmazione: non ti limiti a copiare una riga pronta.

Puoi esercitarti con tipi, operatori, condizioni e funzioni nel corso base di JavaScript di CKTIS. Dopo la lezione, torna a questo esperimento e verifica se riesci a ricostruire la soluzione da solo.