PHP e gestione delle stringhe: lavorare con la codifica UTF-8 in modo corretto

by theArchitect
Add as preferred source on Google
SHARE
PHP e gestione delle stringhe: lavorare con la codifica UTF-8 in modo corretto
© Guida-HTML5.it

Introduzione

Quando si parla di gestione delle stringhe in PHP, un aspetto spesso sottovalutato è la codifica dei caratteri. Molti problemi apparentemente “strani” — testi tagliati male, lunghezze sbagliate, caratteri accentati corrotti, confronti inattesi — dipendono proprio dal fatto che una stringa non viene trattata con la codifica giusta.

In ambienti moderni, la scelta più comune è UTF-8, perché supporta praticamente tutte le lingue e i simboli più usati sul web. Tuttavia, in PHP non basta “usare UTF-8”: bisogna anche sapere come leggere, validare, convertire e manipolare correttamente le stringhe multibyte.

In questo tutorial vedremo un sotto-argomento molto pratico e utile: gestire le stringhe UTF-8 in PHP in modo sicuro, con attenzione alle funzioni giuste per evitare errori tipici. È un tema fondamentale quando lavori con form, database, API, CSV, file di testo o contenuti multilingua.

Codice completo

<?php
declare(strict_types=1);

// Esempio di stringa UTF-8 con caratteri accentati ed emoji
$testo = "Città, caffè, naïve ☕";

// 1) Verifica se la stringa è valida UTF-8
function isUtf8(string $value): bool
{
    return mb_check_encoding($value, ´UTF-8´);
}

// 2) Calcola la lunghezza corretta di una stringa multibyte
function utf8Length(string $value): int
{
    return mb_strlen($value, ´UTF-8´);
}

// 3) Estrae una sottostringa senza rompere i caratteri multibyte
function utf8Substring(string $value, int $start, ?int $length = null): string
{
    if ($length === null) {
        return mb_substr($value, $start, null, ´UTF-8´);
    }

    return mb_substr($value, $start, $length, ´UTF-8´);
}

// 4) Converte il testo in maiuscolo/minuscolo in modo corretto
function utf8Upper(string $value): string
{
    return mb_strtoupper($value, ´UTF-8´);
}

function utf8Lower(string $value): string
{
    return mb_strtolower($value, ´UTF-8´);
}

// 5) Normalizza gli spazi: utile per input utente
function normalizeSpaces(string $value): string
{
    $value = trim($value);
    $value = preg_replace(´/s+/u´, ´ ´, $value);

    return $value ?? ´´;
}

// 6) Converte una stringa da una codifica nota a UTF-8
function convertToUtf8(string $value, string $sourceEncoding = ´ISO-8859-1´): string
{
    $converted = mb_convert_encoding($value, ´UTF-8´, $sourceEncoding);

    return $converted;
}

// 7) Esempio pratico di elaborazione di un nome utente
function formatDisplayName(string $input): string
{
    $input = normalizeSpaces($input);

    // Controllo base: evita stringhe vuote dopo la pulizia
    if ($input === ´´) {
        return ´´;
    }

    // Capitalizza ogni parola con gestione UTF-8
    $words = explode(´ ´, mb_strtolower($input, ´UTF-8´));
    $formatted = [];

    foreach ($words as $word) {
        $firstChar = mb_substr($word, 0, 1, ´UTF-8´);
        $rest = mb_substr($word, 1, null, ´UTF-8´);
        $formatted[] = mb_strtoupper($firstChar, ´UTF-8´) . $rest;
    }

    return implode(´ ´, $formatted);
}

// Demo
echo "Testo originale: " . $testo . PHP_EOL;
echo "UTF-8 valido? " . (isUtf8($testo) ? ´Sì´ : ´No´) . PHP_EOL;
echo "Lunghezza: " . utf8Length($testo) . PHP_EOL;
echo "Prime 8 lettere: " . utf8Substring($testo, 0, 8) . PHP_EOL;
echo "Maiuscolo: " . utf8Upper($testo) . PHP_EOL;
echo "Minuscolo: " . utf8Lower($testo) . PHP_EOL;

$nome = "   mArIo   roSSi  ";
echo "Nome formattato: " . formatDisplayName($nome) . PHP_EOL;
?>

Spiegazione

Il punto chiave è questo: molte funzioni native di PHP, come strlen() o substr(), lavorano sui byte e non sui caratteri. Con una stringa ASCII semplice il problema non si vede, ma con caratteri come è, à, ñ o emoji, il risultato può essere errato.

1. Verificare la validità UTF-8

La funzione mb_check_encoding() controlla se una stringa rispetta una codifica specifica. È molto utile quando ricevi dati da fonti esterne: form, file importati, API legacy o database con encoding non uniforme.

Se una stringa non è valida UTF-8, molte operazioni successive possono produrre risultati imprevedibili. Fare un controllo iniziale ti permette di intercettare subito il problema.

2. Misurare correttamente la lunghezza

Con mb_strlen() ottieni il numero di caratteri reali, non di byte. Questo è importante per:

  • validare campi come username o titoli;
  • tagliare testi per anteprime;
  • imporre limiti di input coerenti con l’esperienza utente.

Ad esempio, una parola di 10 caratteri accentati può occupare più di 10 byte, quindi strlen() darebbe un valore fuorviante.

3. Estrarre sottostringhe senza corrompere il testo

mb_substr() è l’alternativa corretta a substr() quando lavori con UTF-8. Se tagli una stringa nel punto sbagliato usando funzioni byte-based, rischi di spezzare un carattere multibyte e ottenere simboli corrotti o caratteri mancanti.

Nel codice, la funzione utf8Substring() incapsula questo comportamento e rende il tuo codice più leggibile e riutilizzabile.

4. Gestire maiuscole e minuscole

Le funzioni mb_strtoupper() e mb_strtolower() fanno conversioni case-aware per testo multibyte. Questo è fondamentale in contesti come:

  • normalizzazione di dati utente;
  • ricerca case-insensitive lato applicazione;
  • formattazione di nomi e titoli.

Attenzione però: la capitalizzazione delle lingue non è sempre banale. In alcuni casi, una semplice conversione letterale non basta. Per usi avanzati, può essere utile valutare librerie dedicate o regole linguistiche specifiche.

5. Pulire e normalizzare gli spazi

La funzione normalizeSpaces() mostra una pratica molto comune: eliminare spazi superflui e ridurre sequenze di whitespace a un solo spazio. Questo è utile per dati inseriti dall’utente, ad esempio nomi, indirizzi o descrizioni brevi.

La regex /s+/u include il modificatore u, importante per trattare correttamente il testo in UTF-8.

6. Convertire da altre codifiche

Non sempre i dati arrivano già in UTF-8. In sistemi legacy potresti incontrare ISO-8859-1, Windows-1252 o altre codifiche. La funzione mb_convert_encoding() consente di convertire il contenuto in UTF-8 prima di elaborarlo.

Questo passaggio è spesso decisivo quando importi file CSV o testi da vecchi sistemi gestionali.

7. Esempio pratico: formattare un nome visualizzato

La funzione formatDisplayName() combina più tecniche:

  • normalizza gli spazi;
  • trasforma il testo in minuscolo;
  • capitalizza ogni parola;
  • mantiene la compatibilità con caratteri accentati.

È un esempio concreto di come la gestione corretta della codifica migliori la qualità dei dati mostrati all’utente.

Best practice

  • Usa UTF-8 ovunque: file sorgenti, database, output HTML, API e input utente dovrebbero parlare la stessa lingua.
  • Preferisci le funzioni mb_* quando lavori con testo multilingua: mb_strlen, mb_substr, mb_strtolower, mb_strtoupper.
  • Valida l’encoding all’ingresso: intercettare subito dati non validi evita bug difficili da diagnosticare.
  • Non usare strlen/substr alla cieca su testo non ASCII: funzionano sui byte, non sui caratteri.
  • Normalizza i dati prima di salvarli: spazi, encoding e formattazione coerente semplificano il lavoro a valle.
  • Gestisci con attenzione i dati legacy: se un file o un database usa una codifica diversa, converti sempre prima di elaborare.

Riepilogo

La gestione corretta della codifica UTF-8 è una competenza essenziale nello sviluppo PHP moderno. Non si tratta solo di “vedere bene le lettere accentate”, ma di garantire che tutte le operazioni sulle stringhe — lunghezza, estrazione, confronto, formattazione e conversione — siano affidabili.

In questo tutorial hai visto come:

  • verificare se una stringa è valida UTF-8;
  • misurare la lunghezza reale di un testo multibyte;
  • estrarre sottostringhe senza rompere i caratteri;
  • convertire correttamente maiuscole e minuscole;
  • normalizzare e convertire dati provenienti da codifiche diverse.

Se lavori con testo proveniente da utenti, database o sistemi esterni, trattare bene la codifica non è un dettaglio: è una base di qualità del codice.

Approfondisci con risorse ufficiali

Add as preferred source on Google
SHARE