Excel: rimuovere celle “vuote” da array dinamici (spillage) con FILTER, TRIM e LET

In Excel con gli array dinamici (spillage) capita spesso di vedere celle che sembrano vuote ma contengono spazi o caratteri invisibili: il classico FILTER non basta. Qui trovi formule robuste, spiegazioni ed esempi per ripulire l’array e mantenere solo i valori “reali”.

Indice

Perché compaiono “celle vuote” in un array dinamico

Quando una formula dinamica (ad esempio FILTER, UNIQUE, TEXTSPLIT ecc.) “spilla” risultati in un’area come G5:G17, alcune celle possono apparire vuote ma in realtà contenere:

uno o più spazi (normali o non interrompibili);
caratteri non stampabili (tab, a capo, BOM, zero‑width space);
stringhe vuote restituite da formule (""), che visivamente sembrano vuote ma non sono celle veramente vuote;
spazi stretti usati come separatori delle migliaia in dati importati (es. 1 234 con narrow no‑break space).

Se applichi il filtro “classico”:

=FILTER(G5:G17; G5:G17 &lt;&gt; "")

le voci con “spazi invisibili” passano comunque il predicato e quindi rimangono. Serve allora una pulizia preventiva del contenuto o un predicato più intelligente.

Soluzioni rapide (tabella riassuntiva)

Scenario	Formula d’esempio	Idea di fondo
Celle veramente vuote	`=FILTER(G5:G17; G5:G17 <> "")`	Il predicato `<>""` filtra tutto ciò che non è vuoto.
Celle piene di spazi	`=LET(t; SUBSTITUTE(G5:G17; " "; ""); FILTER(t; t <> ""))`	1) Rimuovi gli spazi; 2) filtri il vettore ripulito.
Stringa unica da “risplittare”	`=LET(t; SUBSTITUTE(F3; " "; ""); MID(t; SEQUENCE(LEN(t)); 1))`	Elimini gli spazi dalla stringa in F3, poi `MID`+`SEQUENCE` generano un array di caratteri.
Caratteri invisibili / NBSP	`=LET(r; G5:G17; s; SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(r; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); ""); m; TRIM(CLEAN(s)); FILTER(r; LEN(m)>0))`	Sostituisci gli spazi “speciali”, pulisci (`CLEAN`) e rifinisci (`TRIM`), poi filtra dove la lunghezza > 0.

Nota pratica
• TRIM rimuove spazi iniziali/finali e comprime spazi multipli interni a singolo spazio; SUBSTITUTE può eliminare o sostituire ogni occorrenza del carattere scelto.
• Le funzioni dinamiche (FILTER, LET, SEQUENCE, BYROW, ecc.) sono disponibili in Microsoft 365 / Excel 2021 e successivi. In versioni precedenti servono formule matriciali tradizionali o passaggi con Testo in colonne / Power Query.

Capire il “vero” contenuto di una cella

Prima di ripulire, conviene diagnosticare cosa c’è davvero in una cella sospetta:

=LEN(G5) — se > 0, la cella contiene qualcosa (anche uno spazio o "").
=CODE(LEFT(G5;1)) — identifica il codice del primo carattere secondo il set corrente (utile per spazi non interrompibili 160).
=UNICODE(LEFT(G5;1)) — identifica il codice Unicode (ad es. zero‑width space 8203, narrow NBSP 8239, BOM 65279).
=ISBLANK(G5) — TRUE solo per celle realmente vuote (non vale per "").

Per analizzare in massa un vettore, puoi “mappare” il codice del primo carattere su ogni elemento (Microsoft 365):

=MAP(G5:G17; LAMBDA(x; UNICODE(LEFT(x;1))))

Tre casi d’uso spiegati passo‑passo

Celle veramente vuote (nessun carattere, nessuna formula)

Se il tuo array contiene celle vuote “pure”, basta il filtro base:

=FILTER(G5:G17; G5:G17 &lt;&gt; "")

In alternativa, per distinguere da "" (stringa vuota prodotta da una formula), usa ISBLANK:

=FILTER(G5:G17; NOT(ISBLANK(G5:G17)))

Questo predicato include tutte le celle che non sono realmente vuote, ma esclude quelle prive di contenuto. Ricorda: una cella con formula =IF(condizione; "valore"; "") non è “vuota” per ISBLANK, anche se LEN() restituisce 0.

Celle piene di spazi (anche molteplici)

Se il problema sono spazi “visibili” (codice 32), il pattern più pulito usa LET per non ricalcolare più volte la pulizia:

=LET(t; TRIM(G5:G17); FILTER(G5:G17; LEN(t)&gt;0))

Questa variante conserva gli spazi singoli tra parole, elimina gli spazi superflui e scarta le celle che erano composte solo da spazi. Se invece vuoi eliminare tutti gli spazi (interni compresi) prima di filtrare:

=LET(t; SUBSTITUTE(G5:G17; " "; ""); FILTER(G5:G17; t &lt;&gt; ""))

Stringa unica da “risplittare” in array

Se l’intervallo non è un vettore, ma una singola stringa concatenata (ad es. in F3) con spazi indesiderati, puoi rimuovere gli spazi e spezzare in caratteri:

=LET(t; SUBSTITUTE(F3; " "; ""); MID(t; SEQUENCE(LEN(t)); 1))

Se invece vuoi tokenizzare in parole mantenendo un solo spazio tra parole valide:

=TEXTSPLIT(TRIM(F3); " ")

Nota: TEXTSPLIT è disponibile in Microsoft 365. Se importi testi dal web potresti dover sostituire anche non‑breaking space (CHAR(160)) con uno spazio normale prima di TRIM:

=LET(t; SUBSTITUTE(F3; CHAR(160); " "); TEXTSPLIT(TRIM(t); " "))

La soluzione “robusta”: gestire gli spazi speciali e i caratteri invisibili

Quando i dati provengono da PDF, CMS, ERP o scraping web, gli spazi non sono tutti uguali: il famigerato NBSP (160), il narrow NBSP (8239) e gli zero‑width (8203) non vengono rimossi da TRIM/CLEAN da soli. Ecco un predicato unificato che funziona nella maggior parte dei casi reali:

=LET(
  r; G5:G17;
  s; SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(r; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); "");
  m; TRIM(CLEAN(s));
  FILTER(r; LEN(m)&gt;0)
)

Se desideri anche uscire con il testo normalizzato (non l’originale), filtra direttamente m:

=LET(
  r; G5:G17;
  s; SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(r; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); "");
  m; TRIM(CLEAN(s));
  FILTER(m; LEN(m)&gt;0)
)

Perché funziona? CLEAN rimuove i caratteri non stampabili ASCII (0–31). Prima però convertiamo i “non‑stampabili” Unicode più comuni: sostituiamo NBSP e narrow NBSP con spazi normali (che TRIM sa gestire) ed eliminiamo BOM/zero‑width. Infine LEN(m)>0 scarta le pseudo‑celle vuote.

Versione riutilizzabile con LAMBDA (la più elegante)

Crea due funzioni personalizzate nel Gestore Nomi (Microsoft 365):

Nome: PulisciTesto
Riferito a: =LAMBDA(x; TRIM(CLEAN(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(x; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); ""))))
Nome: HaContenuto
Riferito a: =LAMBDA(x; LEN(PulisciTesto(x))>0)

Da quel momento, la formula diventa leggibile e riutilizzabile:

=LET(r; G5:G17; FILTER(PulisciTesto(r); HaContenuto(r)))

Filtrare tenendo conto degli spazi interni “validi”

Vuoi mantenere le parole separate da spazio, ma eliminare doppie spaziature o celle composte solo da spazi? Usa:

=FILTER(G5:G17; LEN(TRIM(G5:G17))&gt;0)

Se ci sono NBSP o zero‑width, anteponi la normalizzazione minima:

=LET(t; SUBSTITUTE(SUBSTITUTE(G5:G17; CHAR(160); " "); UNICHAR(8239); " "); FILTER(G5:G17; LEN(TRIM(t))&gt;0))

Esempio completo: dal dato sporco all’array pulito

Supponi che G5:G12 contenga i seguenti valori (gli spazi speciali sono indicati tra parentesi):

Riga	Valore “visivo”	Note
G5	`Mario Rossi`	Valore valido
G6		NBSP (`160`)
G7		3 spazi normali
G8	`Luigi Bianchi`	Spazio NBSP tra parole
G9	`""`	Stringa vuota da formula
G10		Zero‑width space (`8203`)
G11	`Anna Verdi`	Doppia spaziatura
G12	`Paolo Neri`	Spazi laterali e interni

Applicando:

=LET(
  r; G5:G12;
  s; SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(r; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); "");
  m; TRIM(CLEAN(s));
  FILTER(m; LEN(m)&gt;0)
)

otterrai lo spill di:

Mario Rossi
Luigi Bianchi (NBSP normalizzato)
Anna Verdi (doppia spaziatura compressa)
Paolo Neri (spazi laterali rimossi, interni compressi)

Tutte le pseudo‑righe vuote (spazi, NBSP, zero‑width, "") vengono scartate.

Array bidimensionali: filtrare righe o colonne “non vuote”

Se devi filtrare righe intere di una tabella in base alla presenza di almeno un valore “reale” nella riga:

=LET(
  r; B5:E20;
  k; BYROW(r; LAMBDA(x; 
        LEN(TRIM(CLEAN(
          SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(TEXTJOIN("" ; TRUE ; x); CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); "")
        )))&gt;0
     ));
  FILTER(r; k)
)

Per colonne usa BYCOL:

=LET(
  r; B5:E20;
  k; BYCOL(r; LAMBDA(x; 
        LEN(TRIM(CLEAN(
          SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(TEXTJOIN("" ; TRUE ; x); CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); "")
        )))&gt;0
     ));
  CHOOSECOLS(r; FILTER(SEQUENCE(COLUMNS(r)); k))
)

Prestazioni: evitare ricalcoli inutili

Usa LET per memorizzare risultati intermedi (es. la versione normalizzata della colonna), così TRIM/CLEAN/SUBSTITUTE non vengono eseguiti più volte.
Normalizza a monte una sola volta in una colonna d’appoggio (es. H:H) e applica FILTER su quella colonna: spesso è più veloce in dataset > 100k righe.
Evita SUBSTITUTE annidati dentro FILTER se puoi definirli in un nome (Gestore Nomi) o in una colonna calcolata.
Verifica i separatori: se il tuo Excel usa la virgola come separatore di argomento, sostituisci ; con , nelle formule.

Alternative senza formule dinamiche (versioni precedenti)

Formula matriciale classica

Per Excel 2016 e precedenti (senza FILTER), puoi “compattare” l’elenco con un’estrazione indicizzata. Inserisci in una nuova colonna e conferma con CTRL+MAIUSC+INVIO (CSE), quindi copia verso il basso:

=IFERROR(
  INDEX($G$5:$G$17;
    SMALL(
      IF(LEN(TRIM(CLEAN(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE($G$5:$G$17; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); "")))))&gt;0;
        ROW($G$5:$G$17)-ROW($G$5)+1
      );
      ROWS($A$1:A1)
    )
  );
  ""
)

Power Query (Ottieni & Trasforma)

Seleziona la colonna → Dati → Da tabella/intervallo.
In Power Query, usa Sostituisci valori per: NBSP → spazio, zero‑width → vuoto (puoi incollarli copiandoli dalla cella).
Applica Trasforma → Formatta → Pulisci e Ritaglia.
Filtra le righe con Lunghezza > 0 e carica il risultato in un foglio.

Checklist rapida

Controlla LEN e UNICODE sul primo carattere per capire la natura del “vuoto”.
Normalizza NBSP (160), narrow NBSP (8239), BOM (65279) e zero‑width (8203).
Usa TRIM + CLEAN per rifinire.
Filtra con LEN(normalizzato)>0.
Per grandi volumi, salva l’intermedio con LET o in una colonna d’appoggio.

FAQ veloci

TRIM non rimuove tutti gli spazi. Perché?
Perché TRIM lavora sullo spazio “normale” (codice 32). NBSP e altri spazi speciali non sono toccati: sostituiscili prima con SUBSTITUTE.

Preferisco lasciare intatti gli spazi interni tra parole. Si può?
Sì: usa LEN(TRIM(testo))>0 come predicato. Mantieni gli spazi tra parole, elimina quelli inutili e le celle “solo spazi”.

Ho numeri con spazi sottili (1 234). Come li converto?
Normalizza gli spazi e poi usa NUMBERVALUE se necessario:
=NUMBERVALUE(SUBSTITUTE(A1; UNICHAR(8239); " "); ","; ".")

Perché ISBLANK mi dà FALSE su una cella “vuota”?
Perché contiene una formula che restituisce "" o contiene spazi/caratteri invisibili. ISBLANK è TRUE solo quando la cella non contiene niente.

Modello pronto all’uso

Se vuoi un’unica formula “prendi e incolla” per il caso più comune (colonna singola con spazi/invisibili):

=LET(
  r; G5:G17;
  s; SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(r; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); "");
  m; TRIM(CLEAN(s));
  FILTER(m; LEN(m)&gt;0)
)

Best practice finali

Nomina intervalli e funzioni LAMBDA per riutilizzare la pulizia in progetti futuri.
Documenta nel foglio (ad es. in un riquadro note) quali caratteri rimuovi e perché, così chi eredita il file capisce la logica.
Testa i casi limite con valori “artificiali” contenenti NBSP, zero‑width, tab e fine riga (CHAR(9), CHAR(10)).
Valuta Power Query per pipeline ripetibili di pulizia dati quando l’origine è esterna (CSV, web, ERP).

In sintesi

Gli “pseudo‑vuoti” non sono un bug di FILTER, ma un problema di normalizzazione. Con pochi passaggi — sostituzione degli spazi speciali, CLEAN e TRIM, e un predicato basato su LEN() — il tuo spill mostrerà solo voci realmente popolate. Usa LET per prestazioni migliori e, quando serve, generalizza con LAMBDA. Il risultato: liste affidabili, pulite e pronte per tabelle pivot, validazioni dati e dashboard.

Appendice: snippet utili

Individuare righe solo‑spazi in una tabella:
=BYROW(B5:E20; LAMBDA(x; LEN(TRIM(CLEAN(TEXTJOIN("" ; TRUE ; SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(x; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); "")))))=0))
Contare quante voci “valide” ci sono in un array:
=SUM(--(LEN(TRIM(CLEAN(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(G5:G17; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); ""))))>0))
Evidenziare con Formattazione condizionale le celle “solo spazi”: usa una regola con formula
=LEN(TRIM(CLEAN(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(G5; CHAR(160); " "); UNICHAR(8239); " "); UNICHAR(65279); ""); UNICHAR(8203); ""))))=0

Suggerimenti aggiuntivi

Verifica cosa c’è davvero in una cella:
- =LEN(G5) → se restituisce > 0, la cella non è vuota.
- Combina con =CODE(LEFT(G5;1)) per scoprire caratteri non stampabili.
Filtrare tenendo conto di spazi interni: se vuoi mantenere gli spazi che separano parole ma ignorare quelli superflui (doppie spaziature), usa: =FILTER(G5:G17; LEN(TRIM(G5:G17))>0)
Prestazioni: per grandi dataset, evita di nidificare più volte TRIM/SUBSTITUTE dentro FILTER; meglio usare LET per memorizzare il risultato intermedio una sola volta.

Compatibilità e localizzazione

Se la tua installazione usa la virgola come separatore degli argomenti, sostituisci ogni ; con , nelle formule.
Le funzioni illustrate (FILTER, LET, BYROW, TEXTSPLIT, MAP) richiedono Microsoft 365 / Excel 2021+. In edizioni precedenti usa la formula matriciale proposta o Power Query.

Con queste tecniche il foglio restituirà solo le voci realmente popolate, eliminando gli “pseudo‑vuoti” causati da spazi indesiderati o caratteri invisibili e mettendo al sicuro formule, tabelle e dashboard da risultati inattesi.

—

Se hai necessità particolari (p.es. conservare spazi multipli interni, distinguere "" da celle realmente vuote, o normalizzare ulteriori caratteri Unicode come UNICHAR(8288)/UNICHAR(8291)), parti dal blocco robusto e aggiungi le sostituzioni necessarie.