Il comando cat di Linux è uno dei comandi Linux più usati. È usato prin­ci­pal­men­te per mostrare il contenuto di un file sulla riga di comando. Tuttavia, vi sono numerosi altri scopi di utilizzo che il­lu­stre­re­mo nel presente articolo.

Cos’è il comando cat di Linux?

No­no­stan­te il suo nome, il comando cat non ha nulla a che fare con i gatti. Di fatto, il comando fa qualcosa di piuttosto banale: il comando cat di Linux legge il contenuto dei file e lo mostra sulla riga di comando. L’origine del nome deriva dal termine “con­ca­te­na­re” (ulteriori in­for­ma­zio­ni su questo aspetto verranno fornite più avanti).

Guardiamo lo schema di base che si applica quando si richiama il comando cat di Linux. Come potete vedere, scriviamo prima “cat”, seguito even­tual­men­te da opzioni, e poi il nome o il percorso del file o dei file da vi­sua­liz­za­re:

cat [Opzioni] <Nome/i file>

Il comando cat di Linux fa parte delle “GNU Core Utilities” (coreutils), una raccolta di comandi di base della riga di comando. I coreutils sono un “Free and Open Source Software” (FOSS) e sono presenti pra­ti­ca­men­te in tutte le di­stri­bu­zio­ni di Linux. Inoltre, il comando cat di Linux è di­spo­ni­bi­le sia con macOS che con Windows quando si usa il “sot­to­si­ste­ma Windows per Linux” (WSL/WSL2).

Consiglio

Per de­ter­mi­na­re se il comando cat di Linux è di­spo­ni­bi­le sul vostro sistema, procedete nel modo di seguito indicato. Aprite una riga di comando ed eseguite lì il comando “which cat”. Se il comando cat di Linux è presente sul vostro sistema, viene vi­sua­liz­za­to il percorso del file binario cat (ad esempio “/bin/cat”). Se viene vi­sua­liz­za­to un messaggio di errore, il comando cat di Linux non è di­spo­ni­bi­le sul vostro sistema.

Opzioni del comando cat di Linux

Come la maggior parte dei comandi per il terminale, il comando cat di Linux è con­trol­la­to da parametri opzionali quando viene ri­chia­ma­to. Queste opzioni seguono il nome del comando. Occorre notare che viene fatta una di­stin­zio­ne tra maiuscole e minuscole. Di solito ci sono due grafie per la maggior parte delle opzioni:

1. Forma ab­bre­via­ta: -, per esempio “cmd -h”

La forma breve non è molto eloquente. Diverse opzioni possono essere combinate in una, ad esempio “ls -la” invece di “ls -l -a”. La forma breve è adatta per lavorare ra­pi­da­men­te con comandi co­no­sciu­ti sulla riga di comando.

2. Forma estesa: --, per esempio “cmd –help”

La forma estesa è facile da capire, ma richiede più tempo per la scrittura e occupa più spazio. La forma estesa è adatta alla creazione di script. I nomi delle opzioni eloquenti sono usati per scopi di do­cu­men­ta­zio­ne.

Diamo un’occhiata alle opzioni più im­por­tan­ti del comando cat di Linux.

Opzione Spie­ga­zio­ne
-h, --help Vi­sua­liz­za l’aiuto del comando cat di Linux
-n Numera le righe dell’output
-s Combina più righe vuote in una sola
-b Numera tutte le righe dell’output tranne le righe vuote
-v Emette caratteri in­vi­si­bi­li
-e Come -v, incluso il marcatore di fine riga
-t Come -v, incluso il marcatore di ta­bu­la­zio­ne
-et Com­bi­na­zio­ne di -e e -t; emette tutti i caratteri in­vi­si­bi­li

Cosa significa di fatto con­ca­te­na­zio­ne?

Il nome del comando cat di Linux deriva da “con­ca­te­na­re”, a sua volta ricavato dal termine di origine latina “catena”. La con­ca­te­na­zio­ne è un concetto im­por­tan­te nell’in­for­ma­ti­ca. Il termine descrive il con­ca­te­na­men­to, l’al­li­nea­men­to o l’unione di elementi di strutture di dati di con­te­ni­to­ri simili. In par­ti­co­la­re, nella maggior parte dei linguaggi, diversi array o stringhe possono essere combinati in un unico array o in un’unica stringa. In questo processo, i singoli elementi dei con­te­ni­to­ri con­ca­te­na­ti sono riuniti in un nuovo con­te­ni­to­re man­te­nen­do l’ordine.

Un semplice esempio in pseu­do­co­di­ce: passiamo alla funzione cat diverse stringhe, che vengono combinate in una sola stringa:

cat("Pietro ", "e ", "Paolo") -> "Pietro e Paolo"

Il comando cat di Linux fa con­cet­tual­men­te la stessa cosa: come elementi, elabora righe rag­grup­pa­te all’interno di file.

Diversi linguaggi di pro­gram­ma­zio­ne usano simboli diversi per l’operatore di con­ca­te­na­zio­ne delle stringhe. Guardiamo alcuni esempi di linguaggi di pro­gram­ma­zio­ne diffusi. In tutti i casi, il risultato della con­ca­te­na­zio­ne è la stringa “Pietro e Paolo”:

Operatore Lin­guag­gio(i) Esempio
+ Java, Ja­va­Script, Python Pietro + "e" + " Paolo"
. PHP, Perl Pietro . "e" . " Paolo"
.. Lua Pietro ... "e" ... " Paolo"
~ Twig Pietro ~ "e" ~ " Paolo"
& Vi­sual­Ba­sic Pietro & "e" & " Paolo"

Alcuni linguaggi, in par­ti­co­la­re Python, usano lo stesso operatore per con­ca­te­na­re altre strutture di dati del con­te­ni­to­re come le liste:

# concatenare le liste
[1, 2, 3] + [45, 56, 67]
# -> [1, 2, 3, 45, 56, 67]
# nota bene NON:
# [[1, 2, 3], [45, 56, 67]]
# concatenare le tuple
(1, 2) + (33, 44)
# -> (1, 2, 33, 44)

Il lin­guag­gio di sta­ti­sti­ca “R” è in­te­res­san­te; non conosce un operatore di con­ca­te­na­zio­ne. Viene invece usata la funzione “c()”. Avete tre tentativi per in­do­vi­na­re per cosa significa “c” – ecco la risposta giusta: “con­ca­te­na­te”. Qui viene mostrata la con­ca­te­na­zio­ne annidata di diversi valori:

c(c(1, 2, 3), c(45, 56, 67))
# -> 1, 2, 3, 45, 56, 67

Come viene uti­liz­za­to in pratica il comando cat di Linux?

L’uso effettivo del comando cat di Linux è limitato, in linea con la filosofia UNIX “fai una cosa, e falla bene”. La maggior parte degli scenari operativi risultano dal con­ca­te­na­men­to del comando con altri comandi. Vengono uti­liz­za­ti i rein­di­riz­za­men­ti dell’input e dell’output standard. In par­ti­co­la­re, si tratta dei co­sid­det­ti “pipe” e “redirect”, che sono ap­pron­ta­ti dalla “shell”; il loro uso si estende a tutti i comandi:

Rein­di­riz­za­men­to Simbolo Impiego Spie­ga­zio­ne
Pipe | cmd1 | cmd2 Inoltro dell’output del comando cmd1 all’input del comando cmd2
Input-Redirect < cmd < data Legge l’input al comando cmd pro­ve­nien­te dal file data
Output-Redirect > cmd > data Scrive l’output del comando cmd nel file data; nell’even­tua­li­tà, il file esistente viene so­vra­scrit­to
Output-Redirect >> cmd >> data Scrive l’output del comando cmd nel file data nell’even­tua­li­tà, il file esistente viene esteso

Il comando cat di Linux viene spesso usato con una serie di altri comandi Linux. Vediamo alcuni dei più comuni.

Comando Linux Spie­ga­zio­ne
split Divide un file in pezzi; l’ope­ra­zio­ne può essere invertita con la funzione cat
uniq Rimuove le righe di input che si ripetono più di una volta
sort Ordina le righe di input in modo al­fa­nu­me­ri­co
head, tail Limita l’output alle righe all’inizio/alla fine

Passiamo ora ai casi di uso comune del comando cat di Linux.

Usare il comando cat di Linux per produrre file sulla riga di comando

Pro­ba­bil­men­te l’uso più comune del comando cat di Linux è quello di emettere l’intero contenuto di un file sulla riga di comando, il che è utile per dare una rapida occhiata a un file. A dif­fe­ren­za dell’apertura del file in un editor, non dovete aver paura di mo­di­fi­ca­re il file per sbaglio. Ecco un esempio di output di un file sulla riga di comando:

cat ./path/to/file.txt

Vediamo alcuni scenari comuni. Im­ma­gi­na­te di essere collegati via SSH su un server su cui è operativo WordPress. Siete nella directory prin­ci­pa­le di WordPress e volete vi­sua­liz­za­re il contenuto del file di con­fi­gu­ra­zio­ne “wp-config.php”. In questo caso basta ri­chia­ma­re il comando cat di Linux nel modo seguente:

cat wp-config.php

Spesso è suf­fi­cien­te l’output di un file sulla riga di comando. Tuttavia, in alcuni casi potremmo voler copiare il contenuto del file negli appunti. Inoltre, l’output visibile sulla riga di comando può rap­pre­sen­ta­re un rischio in caso di dati sensibili. In entrambi i casi, è una buona idea inoltrare l’output del comando cat di Linux a un programma che scrive i dati negli appunti. Con macOS è di­spo­ni­bi­le a tal fine lo strumento per la riga di comando “pbcopy”; con Windows con WSL/2 e le varie di­stri­bu­zio­ni Linux sono di­spo­ni­bi­li strumenti equi­va­len­ti come “clip” o “xclip”.

Con­si­de­ria­mo il seguente esempio: vogliamo copiare la nostra chiave pubblica SSH per creare un re­po­si­to­ry GitHub. Sup­po­nia­mo inoltre che la chiave chiamata “id_rsa.pub” si trovi nella directory “.ssh/” nella nostra directory utente. Poi con macOS ri­cor­ria­mo allo stra­ta­gem­ma ri­chia­man­do il comando cat di Linux nel modo seguente:

cat ~/.ssh/id_rsa.pub > pbcopy

Come sug­ge­ri­sce il nome del comando cat di Linux, è possibile combinare diversi file ed emetterli in una sola volta. Im­ma­gi­nia­mo di aver salvato liste di frutta, verdura e latticini in tre file nella directory “food/”. Ri­chia­man­do il comando cat di Linux nel modo seguente, com­bi­nia­mo tutte e tre le liste in una sola e la scriviamo nel file “food.txt”:

cat ./food/fruit.txt ./food/veggies.txt ./food/dairy.txt > food.txt

Come avviene di solito sulla riga di comando, possiamo usare il se­gna­po­sto "*" per se­le­zio­na­re tutti i file in una directory:

cat ./food/*.txt > food.txt

Scrivere testo in un file con il comando cat di Linux

Usando i rein­di­riz­za­men­ti di output già men­zio­na­ti, si può scrivere testo in un file con il comando cat di Linux. Tale funzione può essere uti­liz­za­ta in tre modi:

  1. Creare un nuovo file in cui viene scritto il testo inserito.
  2. So­vra­scri­ve­re un file esistente con il testo inserito.
  3. Allegare il testo inserito a un file esistente.

Ana­liz­zia­mo questi tre casi. Per prima cosa, scriviamo testo in un file non esistente dalla riga di comando:

  1. Ri­chia­ma­re il comando cat di Linux e inoltrare l’output a un file non esistente. Il comando accetta dati dall’input standard finché non viene letto il carattere di fine file (“End-of-file”, EOF):
cat > new.txt
  1. Inserire il testo de­si­de­ra­to sulla riga di comando.
  2. Terminare l’in­se­ri­men­to premendo la com­bi­na­zio­ne di tasti [Ctrl] + [D]. Questa com­bi­na­zio­ne di tasti cor­ri­spon­de al carattere di fine file.

Il testo inserito si trova ora nel file “new.txt”. Ve­ri­fi­chia­mo ciò ri­chia­man­do il comando “cat new.txt”.

Ap­pli­chia­mo lo stesso approccio per allegare il testo inserito a un file esistente:

  1. Ri­chia­ma­re il comando cat di Linux e inoltrare l’output al file esistente:
cat >> existing.txt
  1. Inserire il testo de­si­de­ra­to sulla riga di comando.
  2. Terminare l’in­se­ri­men­to premendo la com­bi­na­zio­ne di tasti [Ctrl] + [D].

Se usiamo il simbolo ">" invece dell’inoltro dell’output ">>", il file esistente viene so­vra­scrit­to con il testo inserito. At­ten­zio­ne quando si impiega questa funzione: il contenuto pre­ce­den­te del file è perso ir­re­vo­ca­bil­men­te!

Preparare i dati per un’ulteriore ela­bo­ra­zio­ne con il comando cat di Linux

Un uso comune del comando cat di Linuxè quello di combinare dati da più file. Spesso i dati aggregati passano at­tra­ver­so un filtro ai fini della pre­pa­ra­zio­ne a un’ulteriore ela­bo­ra­zio­ne. Questo schema si verifica sempre quando dati simili sono di­stri­bui­ti su più file. Ogni file contiene una voce per riga. Pensate, per esempio, a liste di nomi, indirizzi IP o simili.

Per avere una visione d’insieme di tutte le ca­rat­te­ri­sti­che dei dati, si pone il seguente compito: vogliamo combinare tutte le voci, ri­muo­ven­do qualsiasi voce duplicata. Infine, le voci devono essere ordinate e scritte in un nuovo file. Come esempio concreto, im­ma­gi­nia­mo di avere un insieme di file di testo. Ogni file contiene i nomi degli attori in un par­ti­co­la­re episodio della serie comica “I Simpson”. Se com­bi­nia­mo le voci di tutti i file come descritto, otteniamo una lista di tutti gli attori dei Simpson.

I file descritti nel nostro esempio con gli attori dei Simpson dai singoli episodi avrebbero sche­ma­ti­ca­men­te un aspetto simile a questo:

simpsons-1.txt simpsons-2.txt simpsons-3.txt
Li­sa­Mar­ge­Ho­mer­Flan­ders Bar­tLi­sa­Ho­mer­Mi­lhou­se Bart­Mag­gie­Nel­son

Sup­po­nia­mo inoltre che i singoli file di testo si trovino nella directory “simpsons/”. Basta dunque ri­chia­ma­re il comando cat di Linux nel modo seguente, con­ca­te­na­to con i comandi “uniq” e “sort”, per scrivere la lista di tutti gli attori dei Simpson nel file “simpsons.txt”:

cat ./simpsons/*.txt | uniq | sort > simpsons.txt

Nu­me­ra­zio­ne delle righe di un file di testo con il comando cat di Linux

Un uso comune del comando cat di Linux è quello di numerare le linee di un file di testo. Im­ma­gi­nia­mo di avere un file di testo con voci, per l’esattezza una voce per riga. Ora vogliamo anteporre a ogni riga con il numero di riga. Questa funzione è utile, per esempio, quando tra­smet­tia­mo il file ri­sul­tan­te a un altro utente per la revisione. Ciò permette a entrambe le parti di fare ri­fe­ri­men­to a righe spe­ci­fi­che nella cor­ri­spon­den­za.

Con il comando cat di Linux, questa ope­ra­zio­ne è molto semplice da attuare. Usiamo l’opzione “-n” e un rein­di­riz­za­men­to dell’output:

cat -n doc.txt > doc.numbered.txt

Nello scenario descritto, può essere utile numerare tutte le righe tranne quelle vuote. Inoltre, com­bi­nia­mo diverse righe vuote in una sola. Per questo si usa la com­bi­na­zio­ne delle opzioni “-s” e “-b”:

cat -sb doc.txt > doc.numbered.txt

Combinare i file modello con il comando cat di Linux

Un modello ben noto della pro­gram­ma­zio­ne web è quello di as­sem­bla­re documenti da singoli elementi. Dalla com­bi­na­zio­ne delle co­sid­det­te parti modello con parti uniche risultano documenti diversi con una struttura coerente. Nor­mal­men­te si usa PHP con l’istru­zio­ne “include” o un lin­guag­gio di template speciale come Twig. Tuttavia, lo stesso principio può essere im­ple­men­ta­to anche con il comando cat di Linux.

Im­ma­gi­nia­mo di avere diverse parti di modello nella directory “parts/”. L’in­te­sta­zio­ne e il piè di pagina devono essere identici in tutti i documenti generati. La struttura e il contenuto dell’in­te­sta­zio­ne e del piè di pagina sono definiti nei file “header.html” e “footer.html”. Inoltre, ci sono diversi file con il contenuto effettivo dei documenti nella directory “main/”. I documenti finiti vengono salvati nella directory di output “www/”. Per creare un documento, è suf­fi­cien­te ri­chia­ma­re il comando cat di Linux nel modo seguente:

cat ./parts/header.html ./main/home.html ./parts/footer.html > ./www/index.html

Un altro scenario operativo: Una base di codice deve essere corredata di un testo di licenza per la pub­bli­ca­zio­ne. La licenza deve essere inserita all’inizio di ogni file di codice. Im­ma­gi­nia­mo il seguente layout di directory:

  • file di codice sorgente Python con esten­sio­ne “.py” nella directory “src/”
  • un file di licenza “license.py” nella directory “inc/”
  • una directory ini­zial­men­te vuota “dist/” per ar­chi­via­re i file elaborati

Usiamo il comando cat di Linux all’interno di un ciclo for. Ogni volta che il corpo del ciclo viene eseguito, lo stesso file di licenza viene con­ca­te­na­to con uno dei file sorgente. Il risultato viene scritto in un nuovo file di codice sorgente con lo stesso nome:

for file in ./src/*.py ; do
    cat ./inc/license.py "$file" > "./dist/${file}"
done

Unire file divisi con il comando cat di Linux

Il comando cat di Linux viene usato perlopiù per elaborare file di testo semplici. Tuttavia, il comando funziona anche con i file binari. Questa fun­zio­na­li­tà è utile in alcuni casi. Da un lato, i comandi Linux “split” o “csplit” possono essere usati per rias­sem­bla­re file che sono stati divisi in più parti. Mostriamo di seguito l’approccio generale:

# nome del file da disassemblare
file_name="./path/to/file"
# specifichiamo esplicitamente l’estensione del file per aggiungerla dopo l’assemblaggio
extension="txt"
# disassemblare il file originale in parti da 10 kilobyte con il prefisso 'part_'
split -b 10k "${file_name}.${extension}" part_
# assemblare le singole parti in un nuovo file
cat part_* > combined
# ripristinare l’estensione originale del file
mv combined "combined.${extension}"

D’altra parte, il comando cat di Linux si presta a combinare download parziali. Molti strumenti con­sen­to­no di in­ter­rom­pe­re i download e di farli pro­se­gui­re in un momento suc­ces­si­vo. Questo è par­ti­co­lar­men­te utile quando si scarica un file di grandi di­men­sio­ni con una con­nes­sio­ne di rete debole. Provate pure l’esempio sul vostro sistema:

# creare una cartella di prova sul desktop
mkdir ~/Desktop/cat-test/
# passare alla cartella di prova
cd ~/Desktop/cat-test/
# immagine del gatto di dominio pubblico da WikiMedia
image=https://upload.wikimedia.org/wikipedia/commons/f/fa/Cat_using_computer.jpg
# scaricare l’immagine con "curl" in due parti
curl -s -r 0-500000 "$image" -o first-half &
curl -s -r 500001- "$image" -o second-half &
wait
# combinare le parti e scrivere sul file JPEG
cat first-half second-half > image.jpg

Combinare i flussi di dati con il comando cat di Linux

Il comando cat di Linux può essere usato per combinare i flussi di dati nell’ela­bo­ra­zio­ne video. Mostriamo di seguito il modello generale. Per prima cosa, creiamo diversi brevi flussi video da un’immagine JPEG usando il comando ffmpeg. Poi li com­bi­nia­mo in un unico video continuo:

# creare un ciclo (loop) dall’immagine
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1 \
    still.ts
# creare una dissolvenza di apertura (fade-in) dall’immagine
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1,fade=in:0:75 \
    fadein.ts
# creare una dissolvenza di chiusura (fade-out) dall’immagine
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1,fade=out:0:75 \
    fadeout.ts
# combinare fade-in, loop e fade-out
cat fadein.ts still.ts fadeout.ts > video.ts

Quando non dovreste usare il comando cat di Linux?

L’uso superfluo del comando cat di Linux è un noto “anti-pattern”. Ciò è descritto in numerosi articoli; esiste ad­di­rit­tu­ra un “ri­co­no­sci­men­to per l’utilizzo inutile di cat”. La regola di base è la seguente: il comando cat di Linux dovrebbe essere usato quando è ne­ces­sa­rio combinare diversi file. Se volete elaborare un singolo file, questa ope­ra­zio­ne è so­li­ta­men­te possibile senza cat.

Vediamo l’approccio generale che può aiutarci a mi­ni­miz­za­re l’uso inutile del comando cat di Linux. Il seguente schema si trova spesso nei con­tri­bu­ti dei forum e negli articoli dei blog:

cat example.txt | less

Il comando cat di Linux viene ri­chia­ma­to per leggere un singolo file. L’output viene trasmesso tramite rein­di­riz­za­men­to della pipe al comando less per vi­sua­liz­za­re il contenuto del file pagina per pagina. Tuttavia, ciò è possibile anche in modo più semplice:

less < example.txt

Ri­chia­mia­mo il comando less e usiamo il rein­di­riz­za­men­to dell’input della shell per leggere il file. E anche questo approccio può essere ul­te­rior­men­te sem­pli­fi­ca­to:

less example.txt

Invece di usare il rein­di­riz­za­men­to dell’input, tra­smet­tia­mo il file da elaborare al comando less. Questa ope­ra­zio­ne è possibile perché quasi tutti i comandi di Linux prendono i nomi dei file come parametri.

Quali al­ter­na­ti­ve ci sono al comando cat di Linux?

Come descritto sopra, il comando cat di Linux viene spesso usato inu­til­men­te. Esistono al­ter­na­ti­ve per alcuni degli scenari d’uso più comuni. Qui mostriamo tre esempi:

Comando Uso al­ter­na­ti­vo Esempio
less / more Emettere il contenuto del file pagina per pagina sulla riga di comando less file.txt, more file.txt
touch Creare un nuovo file vuoto touch new.txt
echo Scrivere testo nel file echo "testo" > file.txt

Quali sono i comandi simili al comando cat di Linux?

Vi sono alcuni comandi Linux simili al comando cat. Per mantenere un tono “scherzoso”, i nomi di questi comandi ri­pren­do­no spesso il termine “cat”. In­nan­zi­tut­to esiste il comando tac, il cui nome è sem­pli­ce­men­te cat letto al contrario. Ecco come funziona il comando tac: come il comando cat di Linux, ma con l’output invertito. Di con­se­guen­za, quando il comando tac viene ri­chia­ma­to con un singolo file, l’ultima riga viene emessa per prima, anziché la prima come con cat.

Un altro comando con un nome simile al comando cat di Linux è il comando nc, un’ab­bre­via­zio­ne per “netcat”. Il comando viene co­mu­ne­men­te definito come il “col­tel­li­no svizzero per TCP/IP”. Invece di operare su file locali come cat, netcat legge e scrive dati su con­nes­sio­ni di rete. Potete ottenere maggiori in­for­ma­zio­ni nel nostro articolo sull’argomento.

Come al­ter­na­ti­va più recente al comando cat di Linux, è stato aggiunto il comando bat. Sulla pagina GitHub del comando, questo viene definito come “Un clone di cat con le ali” (“A cat clone with wings”). Il comando bat mantiene la fun­zio­na­li­tà di base del comando cat di Linux, ma offre alcune comode funzioni. In par­ti­co­la­re, il comando bat aggiunge l’evi­den­zia­zio­ne della sintassi all’output dei file di codice sorgente.

Vai al menu prin­ci­pa­le