Linux commando: cat

Bijna iedereen die Linux gebruikt, grijpt binnen het eerste uur naar cat. Je typt het om een configuratiebestand te lezen, om een log te bekijken, of om een kort script op het scherm te dumpen. Het voelt als "het commando dat een bestand toont". Dat klopt, maar het is niet het hele verhaal, en het is niet eens wat de naam betekent. De echte taak van cat is om bestanden samen te voegen, en zodra je dat inziet, valt er veel van Unix op zijn plaats.

2. Waar komt de naam vandaan?

De naam cat is een afkorting van concatenate, wat "aan elkaar rijgen" betekent. Het heeft niets met het dier te maken.

cat  =  conCATenate

De naam vertelt je precies het oorspronkelijke doel. In het vroege Unix draaide je cat part1 part2 part3 als je drie bestanden tot een wilde samenvoegen, en je ving de gecombineerde uitvoer op. Een enkel bestand op het scherm tonen was een gelukkig bijverschijnsel: een bestand samenvoegen en het resultaat op de terminal laten vallen.

Zoals de meeste vroege Unix-commando's is de naam bewust kort gehouden. Het vroege Unix werd getypt op trage teletype-terminals die elk teken op papier afdrukten, dus korte namen bespaarden zowel tijd als papier. Daarom is het cat en niet "concatenate".

4. Eenvoudige toepassingen

4.1 De eenvoudigst mogelijke toepassing

Geef cat een bestandsnaam en het toont dat bestand op het scherm. In de voorbeelden hieronder is de regel die begint met $ wat je typt, en de regels eronder zijn wat het systeem terug afdrukt.

$ cat notes.txt
Buy milk
Call the dentist
Finish the report

Het hele bestand wordt in een keer naar de terminal gestuurd. Dat is ideaal voor korte bestanden: een configuratiebestand, een klein script, een notitie. Voor lange bestanden is het het verkeerde gereedschap, en sectie 7 legt uit waarom.

4.2 Meerdere bestanden samenvoegen: de oorspronkelijke taak

Geef cat meer dan een bestand en het drukt ze op volgorde af, het ene na het andere, zonder scheiding ertussen. Dit is de samenvoeging die de naam belooft:

$ cat chapter1.txt chapter2.txt chapter3.txt
(de volledige tekst van hoofdstuk 1)
(de volledige tekst van hoofdstuk 2)
(de volledige tekst van hoofdstuk 3)

Op zichzelf overspoelt dit alleen het scherm. Het wordt nuttig zodra je de gecombineerde stroom ergens heen stuurt, en dat brengt ons bij omleiding.

4.3 Het resultaat opslaan in een nieuw bestand

De shell-operator > leidt de standaarduitvoer om naar een bestand in plaats van naar het scherm. Combineer die met cat om bestanden echt tot een nieuw bestand samen te voegen:

$ cat chapter1.txt chapter2.txt chapter3.txt > book.txt

Nu bevat book.txt de drie hoofdstukken, op volgorde, als een bestand. Deze ene regel is de reden dat cat bestaat. Merk op dat het samenvoegen door cat gebeurt, maar het opslaan door de > van de shell, niet door cat zelf.

Een nuttig onderscheid: cat produceert een stroom, de shell bepaalt waar de stroom heen gaat. > schrijft die naar een nieuw bestand, >> voegt die toe aan een bestaand bestand, en een pipe | geeft die door aan het volgende commando.

4.4 Lezen vanaf het toetsenbord

Draai cat helemaal zonder bestandsnaam en het leest van standaardinvoer, wat standaard je toetsenbord is. Het echoot elke regel die je typt terug totdat je op Ctrl-D drukt, de toets die "einde van invoer" betekent:

$ cat
hello
hello
this is a test
this is a test
[Ctrl-D]

Combineer dat met een omleiding en je hebt de klassieke, snelle manier om een kort bestand te maken zonder een editor te openen:

$ cat > shopping.txt
milk
eggs
bread
[Ctrl-D]
$ cat shopping.txt
milk
eggs
bread

Je typt de regels, drukt op Ctrl-D, en de tekst belandt in shopping.txt. Het is geen editor, dus je kunt niet terug om een regel hierboven te verbeteren, maar voor drie regels is het sneller dan wat dan ook.

6. Gevorderde toepassingen

6.1 Toevoegen en bestanden opbouwen

Met >> voeg je toe aan het einde van een bestand in plaats van het te overschrijven. Zo bouw je een bestand stukje bij beetje op:

$ cat header.txt > page.html      # begin opnieuw (overschrijft)
$ cat body.txt >> page.html       # voeg toe aan het einde
$ cat footer.txt >> page.html     # voeg opnieuw toe aan het einde

Wees voorzichtig met de enkele >: die maakt het doelbestand eerst leeg voordat er wordt geschreven. Een veelgemaakte en pijnlijke fout is cat a.txt > a.txt, die het bestand leegt voordat cat het ooit leest. Om een bestand met andere samen te voegen op zijn eigen plek, schrijf je eerst naar een nieuwe naam.

6.2 Het streepje: bestanden en standaardinvoer mengen

Een enkel streepje - staat voor standaardinvoer in de lijst met bestanden, zodat je doorgesluisde gegevens tussen echte bestanden kunt invoegen. Dit voorbeeld plaatst een kop, dan wat een ander commando stuurt, dan een voettekst:

$ echo "=== start ===" | cat header.txt - footer.txt

Hier drukt cat header.txt af, dan de tekst die op standaardinvoer binnenkomt (de regel van echo), dan footer.txt. Het streepje is een kleine functie die cat in een flexibele stroom-samenvoeger verandert.

6.3 Here-documents: een betere manier om een blok te schrijven

De truc met toetsenbord en Ctrl-D uit sectie 4 heeft een nettere neef die een here-document heet. Je geeft de shell een markeerwoord, en alles tot aan dat woord wordt de invoer. Dit is de professionele manier om een blok tekst in een bestand te schrijven, zeker in scripts:

$ cat > config.yml <<EOF
server: web01
port: 8080
debug: false
EOF

Alles tussen <<EOF en de afsluitende EOF wordt aan cat gevoerd, dat het naar config.yml schrijft. De markering mag elk woord zijn; EOF is gewoon de gebruikelijke afspraak. Als je de markering aanhaalt als <<'EOF', laat de shell $variabelen ongemoeid in plaats van ze uit te breiden, wat van belang is wanneer het blok dollartekens bevat.

6.4 cat als bouwsteen in pipes

Omdat cat gewoon tekst afdrukt, sluit het naadloos aan op de rest van de Unix-gereedschapskist via een pipe:

$ cat access.log | wc -l           # tel de regels
$ cat *.txt | sort | uniq          # samenvoegen, sorteren, dubbele weghalen
$ cat notes.md | grep TODO         # zoek overeenkomende regels

Het middelste voorbeeld is waar cat echt uitblinkt: veel bestanden (*.txt) samenvoegen tot een enkele stroom voordat die aan sort wordt doorgegeven. Dat is echte samenvoeging die echt werk verzet. Het eerste en laatste voorbeeld zijn echter een valkuil die sectie 7 uitlegt.

6.5 tac: cat achterstevoren

GNU levert een metgezel die tac heet, wat cat achterstevoren gespeld is en precies dat doet: het drukt een bestand af met de regels in omgekeerde volgorde, de laatste regel eerst.

$ tac notes.txt
Finish the report
Call the dentist
Buy milk

Het is echt nuttig voor logs, waar de nieuwste regels onderaan staan. tac error.log | head toont je de meest recente regels eerst.

8. Best practices

• Gebruik cat waar het naar vernoemd is. Grijp ernaar wanneer je meerdere bestanden samenvoegt. Voor een enkel bestand dat een ander commando voedt, geef je dat commando rechtstreeks de bestandsnaam.
• Draai cat niet op een groot bestand. Gebruik less om het te lezen, of head en tail voor de uiteinden. Zo spaar je je terminalbuffer en je geduld.
• Leid nooit een bestand naar zichzelf om. cat a > a leegt het bestand. Schrijf naar een nieuwe naam en hernoem die daarna zo nodig.
• Maak verborgen tekens zichtbaar als een match mislukt. Als een script zich niet gedraagt, draai dan cat -A om tabs, spaties aan het einde en verdwaalde regeleindes bloot te leggen.
• Grijp zonder aarzelen naar de handleiding. De gewoonte die beginners van professionals onderscheidt, is niet het uit het hoofd kennen van elke optie; het is het typen van man cat op het moment dat er een vraag opkomt.

$ man cat                            # de volledige handleiding
$ cat --help                         # een snel overzicht van de opties (GNU)
$ info coreutils 'cat invocation'    # de uitgebreide GNU-handleiding

10. Samenvatting

Het commando cat lijkt triviaal, maar het is een heldere les in hoe Unix invoer leest en uitvoer schrijft.

• cat betekent "concatenate" (samenvoegen). Zijn echte taak is bestanden samenvoegen en het resultaat naar standaarduitvoer sturen; een bestand tonen is het eenvoudige geval.
• Het stamt uit Unix in 1971 en draait, onveranderd in essentie, vandaag op elk Unix-achtig systeem.
• cat a b c > out voegt bestanden samen tot een nieuw bestand. > overschrijft, >> voegt toe, en een pipe | geeft de stroom door aan het volgende commando.
• Zonder bestandsnaam leest cat het toetsenbord tot Ctrl-D. Een here-document (<<EOF) is de nettere manier om een blok tekst te schrijven.
• Nuttige opties: -n en -b nummeren regels, -s knijpt lege regels samen, en -A onthult tabs, regeleindes en verborgen tekens.
• Het streepje - betekent standaardinvoer, zodat je doorgesluisde gegevens tussen echte bestanden kunt invoegen. tac drukt een bestand achterstevoren af.
• Vermijd de "useless use of cat": als het volgende commando zelf een bestand kan lezen, sla dan cat en de pipe over.
• Onder de motorkap is cat een kleine lus van read() en write() over de drie standaardstromen: stdin (0), stdout (1) en stderr (2). Het kopieert bytes zonder ze te interpreteren.
• Weet waar cat stopt: less om lange bestanden te lezen, head en tail voor de uiteinden, grep om te zoeken, tee om tegelijk op te slaan en te tonen, en xxd of strings voor binaire bestanden.
• Bij twijfel, typ man cat.

Dit is de snelle referentie die het bewaren waard is:

cat file             toon een bestand
cat a b c            voeg bestanden samen, op volgorde, naar het scherm
cat a b c > out      voeg bestanden samen tot een nieuw bestand
cat f1 >> f2         voeg f1 toe aan het einde van f2
cat > file           typ tekst, eindig met Ctrl-D
cat -n file          druk af met regelnummers
cat -A file          toon tabs, regeleindes en stuurtekens
cat -s file          knijp herhaalde lege regels samen
grep x file          NIET cat file | grep x
less file            lees een lang bestand op de juiste manier
tee file             sla een stroom op in een bestand EN op het scherm
tac file             druk een bestand achterstevoren af