JavaScript e manipolazione delle stringhe: costruire un parser per date in formato libero

by Anastasia P.
Add as preferred source on Google
SHARE
JavaScript e manipolazione delle stringhe: costruire un parser per date in formato libero
© Guida-HTML5.it

Introduzione

La manipolazione delle stringhe in JavaScript non serve solo a “tagliare” o “unire” testo: è fondamentale quando devi interpretare dati inseriti dall’utente in modi diversi dal formato atteso. Un caso molto pratico è la gestione delle date scritte in formato libero, ad esempio:

  • 12/03/2026
  • 12-03-2026
  • 12 marzo 2026
  • 12 Mar 2026

Invece di affidarti a una sola convenzione, puoi costruire un piccolo parser che normalizza queste stringhe e le converte in un oggetto Date valido. Questo approccio è utile in form, importazione dati, chatbot, CRM e applicazioni che ricevono input da fonti eterogenee.

In questo tutorial vedremo come riconoscere e trasformare varie rappresentazioni testuali di una data, usando strumenti fondamentali della manipolazione delle stringhe: trim, toLowerCase, replace, split, match ed espressioni regolari.

Codice completo

/**
 * Parser semplice per date in formato libero.
 * Accetta esempi come:
 * - "12/03/2026"
 * - "12-03-2026"
 * - "12 marzo 2026"
 * - "12 Mar 2026"
 */

function parseDateFree(input) {
  if (typeof input !== ´string´) {
    return { ok: false, error: ´L input deve essere una stringa.´ };
  }

  // 1) Normalizzazione di base: spazi e maiuscole/minuscole
  const normalized = input
    .trim()
    .toLowerCase()
    .replace(/s+/g, ´ ´); // comprime spazi multipli

  // 2) Mappa dei mesi testuali in numero
  const monthMap = {
    gennaio: 1, gen: 1,
    febbraio: 2, feb: 2,
    marzo: 3, mar: 3,
    aprile: 4, apr: 4,
    maggio: 5, mag: 5,
    giugno: 6, giu: 6,
    luglio: 7, lug: 7,
    agosto: 8, ago: 8,
    settembre: 9, set: 9, sep: 9,
    ottobre: 10, ott: 10, oct: 10,
    novembre: 11, nov: 11,
    dicembre: 12, dic: 12, dec: 12
  };

  let day, month, year;

  // 3) Formato numerico: dd/mm/yyyy o dd-mm-yyyy
  let match = normalized.match(/^(d{1,2})[/-](d{1,2})[/-](d{4})$/);
  if (match) {
    day = Number(match[1]);
    month = Number(match[2]);
    year = Number(match[3]);
  } else {
    // 4) Formato testuale: dd mese yyyy
    match = normalized.match(/^(d{1,2})s+([a-zàèéìòù]+)s+(d{4})$/i);
    if (match) {
      day = Number(match[1]);
      const monthText = match[2];
      year = Number(match[3]);

      month = monthMap[monthText];
      if (!month) {
        return { ok: false, error: ´Nome del mese non riconosciuto.´ };
      }
    } else {
      return { ok: false, error: ´Formato data non supportato.´ };
    }
  }

  // 5) Validazione dei valori estratti
  if (!isValidDateParts(day, month, year)) {
    return { ok: false, error: ´Data non valida.´ };
  }

  // 6) Creazione della data in UTC per evitare problemi di fuso orario
  const date = new Date(Date.UTC(year, month - 1, day));

  return {
    ok: true,
    day,
    month,
    year,
    iso: date.toISOString().slice(0, 10),
    date
  };
}

function isValidDateParts(day, month, year) {
  if (year < 1000 || year > 9999) return false;
  if (month < 1 || month > 12) return false;
  if (day < 1 || day > 31) return false;

  // Verifica reale del calendario
  const test = new Date(Date.UTC(year, month - 1, day));
  return (
    test.getUTCFullYear() === year &&
    test.getUTCMonth() === month - 1 &&
    test.getUTCDate() === day
  );
}

// Esempi di utilizzo
const examples = [
  ´ 12/03/2026 ´,
  ´12-03-2026´,
  ´12 marzo 2026´,
  ´12 Mar 2026´,
  ´31/02/2026´,      // non valida
  ´12/13/2026´,      // mese non valido
  ´abc´
];

for (const value of examples) {
  const result = parseDateFree(value);
  console.log(value, ´=>´, result);
}

Spiegazione

Il codice è costruito in modo progressivo: prima pulisce la stringa, poi prova a interpretarla, infine valida il risultato. Questo flusso è molto utile quando lavori con input “sporchi” o poco affidabili.

1. Normalizzazione iniziale

La prima parte usa trim() per rimuovere spazi all’inizio e alla fine, toLowerCase() per rendere uniformi i confronti, e replace(/s+/g, ´ ´) per comprimere eventuali spazi multipli in uno solo.

Questa fase è essenziale perché una stringa come " 12 Marzo 2026 " diventerebbe molto più semplice da analizzare.

2. Riconoscimento dei formati

Il parser usa due espressioni regolari:

  • /^(d{1,2})[/-](d{1,2})[/-](d{4})$/ per date numeriche con slash o trattini
  • /^(d{1,2})s+([a-zàèéìòù]+)s+(d{4})$/i per date con mese testuale

Le parentesi tonde catturano le parti utili: giorno, mese e anno. In questo modo non devi fare slicing manuale o assumere sempre la stessa lunghezza dei campi.

3. Conversione del mese testuale

Quando il mese è scritto in lettere, il codice usa un oggetto monthMap per trasformarlo nel numero corrispondente. Questo è molto più robusto rispetto a confronti ripetuti con if o switch, soprattutto se vuoi supportare abbreviazioni come gen, feb, mar.

4. Validazione reale della data

Non basta verificare che giorno e mese siano numeri plausibili. Ad esempio, 31 febbraio 2026 ha numeri “validi” ma non è una data reale. La funzione isValidDateParts() crea una data temporanea in UTC e controlla se i valori restituiti coincidono con quelli originali.

Questo passaggio evita errori comuni dovuti al comportamento automatico dell’oggetto Date, che può correggere date impossibili invece di segnalarle.

5. Uso di UTC

La costruzione della data con Date.UTC(year, month - 1, day) è una buona pratica quando vuoi evitare problemi di fuso orario. Se usassi new Date(year, month - 1, day), il risultato potrebbe cambiare leggermente a seconda del contesto locale.

Best practice

Quando scrivi parser di stringhe, la qualità del codice dipende molto dalla capacità di gestire casi limite e input inattesi. Ecco alcune regole utili:

  • Normalizza sempre l input prima di interpretarlo: spazi, maiuscole, caratteri superflui.
  • Valida dopo il parsing, non solo prima. Una stringa ben formata può comunque rappresentare una data impossibile.
  • Separa parsing e validazione: il codice diventa più leggibile e più facile da testare.
  • Preferisci mappe o dizionari per conversioni testuali, invece di catene lunghe di condizioni.
  • Evita assunzioni sul formato: se l input può cambiare, prevedi più pattern supportati.
  • Restituisci errori chiari: un messaggio come “Formato data non supportato” è molto più utile di un generico “Errore”.
  • Scrivi test con casi limite: date valide, date impossibili, stringhe vuote, tipi non stringa, spazi extra, mesi abbreviati.

Se il tuo progetto cresce, potresti anche estendere questo parser per supportare altri formati, come yyyy-mm-dd o date con separatori diversi. In quel caso, conviene organizzare il codice in moduli separati e aggiungere test automatici.

Riepilogo

In questo tutorial abbiamo visto come la manipolazione delle stringhe in JavaScript possa essere usata per costruire un parser di date in formato libero. L’idea chiave è semplice ma molto potente:

  • pulire il testo con trim e replace,
  • riconoscere il formato con match ed espressioni regolari,
  • convertire i dati estratti in valori numerici,
  • validare il risultato con la logica del calendario reale.

Questo approccio è riutilizzabile in molti contesti dove il testo va interpretato e non solo mostrato. È un ottimo esempio di come una buona gestione delle stringhe renda un’applicazione più robusta, affidabile e facile da mantenere.

Approfondisci con risorse ufficiali

  • MDN - String: documentazione completa sui metodi delle stringhe in JavaScript
  • MDN - RegExp: guida ufficiale alle espressioni regolari
  • MDN - Date: riferimento dell’oggetto Date e dei suoi metodi
  • ECMAScript Language Specification: specifica del linguaggio per dettagli avanzati sul comportamento delle stringhe

Se vuoi, nel prossimo passo posso trasformare questo parser in una versione più avanzata con supporto per più lingue, input da form HTML e test automatici con Jest.

Add as preferred source on Google
SHARE