Werken met Linux-pipes, omleiding en tekstverwerking

Korte bestanden zijn gemakkelijk volledig te tonen. Lange bestanden zijn gemakkelijker te lezen als de weergave op je wacht. Noch cat, noch de normale leesweergave van less bewerkt het bestand.

Tekst tonen of samenvoegen met cat

cat notes.txt stuurt het volledige bestand naar de standaarduitvoer, normaal gesproken je terminal. De naam komt van concatenate (aaneenschakelen): als je meerdere bestandsnamen opgeeft, toont het hun inhoud in de opgegeven volgorde. Het voegt geen kop tussen bestanden in.

Stel dat a.txt de regels “a” en “b” bevat en b.txt “c d”. Voer uit:

cat -n a.txt b.txt

Je ziet drie genummerde regels. De nummering loopt door over de twee bestanden; -n nummert de uitvoer, niet de opgeslagen bestanden. Gebruik cat a.txt b.txt > ab.txt om de samengevoegde tekst op te slaan. Het nieuwe bestand bevat de drie oorspronkelijke regels zonder nummering. Als je -n toevoegt, worden ook de nummers opgeslagen.

Als je een groot bestand toont, kan het begin buiten het zichtbare scherm verdwijnen. Met een paginagewijze tekstviewer houd je controle over de weergave. less /etc/services opent een lang tekstbestand en toont een scherm vol tekst. Het kan het eerste scherm tonen voordat het hele bestand is gelezen, wat helpt bij grote bestanden.

Navigeren in less

De shellprompt is verborgen zolang less actief is. Het programma wacht op een navigatietoets:

Hoofdletters maken verschil: g en G gaan naar tegenovergestelde uiteinden. Druk op q als je klaar bent met lezen; als je op een nieuwe shellprompt wacht zonder af te sluiten, kan de tekstviewer vastgelopen lijken.

Zoeken in de weergave

Typ /, voer een woord in en druk op Enter om vooruit te zoeken. Zo vindt /ssh de volgende overeenkomende tekst. Typ ?ssh en Enter om achteruit te zoeken. Daarna herhaalt n de zoekopdracht in de huidige richting, terwijl N in de tegenovergestelde richting gaat. Na een achterwaartse zoekopdracht gaat n verder achteruit.

De zoekopdracht is een reguliere expressie. /^# vindt een regel die begint met “#”, omdat ^ het begin van een regel markeert. Je kunt de patroonregels apart leren en nu eenvoudige woorden gebruiken.

less -N notes.txt voegt regelnummers toe aan de weergave. Voor brede records houdt less -S notes.txt een lange regel op één schermregel door het zichtbare rechterdeel af te kappen; met de pijlen links en rechts ga je zijwaarts. De tekst blijft in het bestand staan. Zonder -S lopen lange regels door op extra schermregels. more is een oudere paginagewijze tekstviewer met minder navigatiemogelijkheden.

Door de uitvoer van een ander commando bladeren

Met ls -l /usr/bin | less kun je door de lange bestandslijst bladeren. De pipe levert de lijst aan de tekstviewer. Voor een bestaand bestand opent less notes.txt het direct; cat notes.txt | less voegt een extra commando toe voor dezelfde weergave.

Gebruik deze commando's voor tekst. Als je een binair programma zoals /bin/ls toont, kunnen stuurtekens verschijnen en kan de terminal vreemde tekens weergeven. Gebeurt dat, typ dan reset en druk op Enter om de weergave te herstellen.

Als je alleen de eerste of meest recente vermeldingen van een bestand nodig hebt, raakt het nuttige deel verborgen als je alles toont. head selecteert het begin en tail het einde. Beide tonen standaard 10 regels.

Een aantal regels kiezen

Als numbers.txt 1 tot en met 100 bevat, één getal per regel, toont head numbers.txt 1 tot en met 10, terwijl tail numbers.txt 91 tot en met 100 toont. Gebruik -n om het aantal te wijzigen:

head -n 3 numbers.txt
tail -n 3 numbers.txt

Het eerste commando toont 1, 2, 3. Het tweede toont 98, 99, 100. Als een bestand minder regels heeft dan gevraagd, toont het commando wat beschikbaar is.

head -c 5 selecteert vijf bytes in plaats van vijf regels. Voor tekst die begint met “banana” toont het “banan”. Bytes zijn opslageenheden; bij UTF-8-tekst kan een teken meer dan één byte gebruiken, dus een aantal bytes is niet altijd gelijk aan een aantal tekens.

Een beginpositie correct lezen

Een plusteken verandert de betekenis van tail -n. Vergelijk:

tail -n +2 scores.csv laat de eerste regel weg, handig als die regel kolomkoppen bevat. Het selecteert niet alleen de tweede regel. Op het genummerde bestand toont tail -n +98 numbers.txt 98 tot en met 100.

GNU head accepteert ook een negatief aantal: head -n -97 numbers.txt laat de laatste 97 regels weg, zodat 1 tot en met 3 overblijven. Het teken hoort bij het aantal en maakt deel uit van de instructie.

Een bereik in het midden selecteren

Om regels 11 tot en met 20 te tonen, behoud je eerst alles tot en met regel 20. Daarna behoud je de laatste 10 regels van die selectie:

head -n 20 numbers.txt | tail -n 10

Na head zijn de gegevens 1 tot en met 20. De laatste tien regels zijn 11 tot en met 20. Het aantal regels in een bereik met beide grenzen inbegrepen is het eindnummer min het beginnummer plus één; die laatste één zorgt ervoor dat beide grenzen meetellen. Met tail -n 11 zou ook regel 10 worden meegenomen.

Beide commando's kunnen uit een pipe lezen als er geen invoerbestand is opgegeven. ls /etc | head -n 5 beperkt een bestandslijst tot de eerste vijf namen. Onthoud bij ls -lt | head -n 4 dat de eerste uitvoerregel de regel “total” is: daarna volgen slechts drie vermeldingen.

Een bestand zien groeien

tail -f /var/log/app.log toont eerst de laatste regels, wacht daarna en toont tekst die aan het bestand wordt toegevoegd. Gebruik dit terwijl een programma nieuwe vermeldingen schrijft. Druk op Ctrl+C om het volgen te stoppen en naar de shell terug te keren. De wachtende weergave is bewust zo ontworpen; die verschilt van de voltooide eenmalige uitvoer van gewoon tail.

tail -F probeert het ook opnieuw en blijft de bestandsnaam volgen als een logbestand tijdens rotatie wordt verwijderd en opnieuw aangemaakt. Bij meerdere invoerbestanden voorzien head en tail de uitvoer van elk bestand van een kopregel zoals “==> fruit.txt <==”. Voeg -q toe als je de geselecteerde tekst zonder die kopregels nodig hebt.

Een commando communiceert via standaardstromen. Als je invoer en uitvoer als afzonderlijke routes ziet, begrijp je hoe hetzelfde programma vanaf een toetsenbord of uit een bestand kan lezen, of de uitvoer van een ander commando kan ontvangen.

De drie stromen herkennen

Een bestandsdescriptor is het nummer waarmee een open gegevensstroom wordt aangeduid. Een gewoon shellcommando erft deze drie:

Hoewel stdout en stderr normaal gesproken hetzelfde scherm delen, zijn het afzonderlijke verbindingen. Een programma kan tijdens dezelfde uitvoering een resultaat op stdout melden en een probleem op stderr toelichten.

Zo toont ls /etc/hostname /nonexistent > out.txt één bestaand pad en stuit het op één ontbrekend pad. De bestandsvermelding gaat naar out.txt. De melding “No such file or directory” blijft op de terminal verschijnen omdat > stdout omleidt, niet stderr. Een fout op het scherm betekent niet dat de omleiding van uitvoer is mislukt.

Een commando invoer uit een bestand geven

Commando's zoals cat, sort, wc, grep, head en tail kunnen stdin lezen als er geen invoerbestand is opgegeven. Voer alleen sort uit, typ enkele regels en druk aan het begin van een lege regel op Ctrl+D. Dat geeft het einde van de invoer aan, waarna sort de gesorteerde regels kan tonen. Met Ctrl+C stop je het commando in plaats van de invoer te voltooien.

De invoeroperator < verbindt een bestand met stdin:

wc -l < fruit.txt

Als fruit.txt zes regels heeft die elk eindigen met een nieuweregelteken, is de uitvoer “6”. Vergelijk dit met wc -l fruit.txt, dat “6 fruit.txt” toont. Bij de omgeleide vorm opent de shell het bestand en ontvangt wc een gegevensstroom zonder de oorspronkelijke bestandsnaam. Bij de vorm met een argument opent wc het genoemde bestand zelf.

De shell bereidt omleidingen voor voordat het programma wordt gestart. sort < fruit.txt en < fruit.txt sort verbinden daarom hetzelfde bestand met dezelfde invoerstroom. De gebruikelijke plaatsing na het commando is gemakkelijker te lezen.

Enkele regels direct aanleveren

Een here-document plaatst invoer onder het commando. Het woord na << markeert waar die invoer eindigt:

cat <<EOF > greeting.txt
Hello
See you soon
EOF

cat ontvangt de twee begroetingsregels op stdin en schrijft ze naar het uitvoerbestand. De laatste regel bevat alleen EOF; dat is een scheidingsteken en maakt geen deel uit van de opgeslagen tekst. Je kunt een ander woord als scheidingsteken gebruiken als de afsluitende regel er precies mee overeenkomt.

In Bash levert een here-string één tekenreeks plus een nieuweregelteken. wc -w <<< "a b c" meldt drie woorden. Met deze twee vormen lever je invoer direct aan zonder eerst een invoerbestand te maken.

Lees de pijl voordat je het commando uitvoert

sort < fruit.txt leest het bestand. sort > fruit.txt opent het als uitvoerbestemming, maakt bestaande inhoud leeg en wacht op invoer vanaf het toetsenbord. De shell voert die vernietigende opening uit voordat sort wordt gestart. Houd invoerbestanden gescheiden van uitvoerbestemmingen, tenzij het commando een gedocumenteerde manier heeft om zijn invoer veilig bij te werken.

Omleiding verandert de bestemming van een gegevensstroom. Het is een bewerking van de shell, dus dezelfde operatoren werken met veel verschillende programma's. Bepaal eerst welke stroom je wilt sturen en of een bestaand bestand moet worden vervangen of uitgebreid.

Normale resultaten opslaan of achteraan toevoegen

echo one > log.txt maakt het bestand aan of maakt het leeg voordat het de regel “one” schrijft. Een daaropvolgend echo two >> log.txt voegt “two” achteraan toe, zodat er twee regels zijn. >> maakt ook een ontbrekend bestand aan.

ls /etc/hostname /nonexistent > out.txt 2> err.txt scheidt de geslaagde bestandsvermelding van de fout voor het ontbrekende pad. De descriptor moet direct tegen de operator aan staan. ls 2> err.txt leidt fouten om; ls 2 > err.txt vraagt ls om een bestand met de naam “2” te tonen en leidt de normale uitvoer om.

Stromen in de juiste volgorde combineren

2>&1 richt stderr op de huidige bestemming van stdout. Lees omleidingen van links naar rechts:

ls /etc/hostname /nonexistent > all.txt 2>&1

Eerst gaat stdout naar all.txt. Daarna kopieert stderr die verbinding. Beide stromen bereiken nu het bestand. &> all.txt van Bash is een kortere vorm en &>> all.txt voegt beide stromen achteraan toe.

Als je de volgorde omkeert, verandert het resultaat:

ls /etc/hostname /nonexistent 2>&1 > out.txt

Eerst wordt stderr gericht op de plaats waar stdout op dat moment naartoe gaat: de terminal. Daarna gaat stdout naar het bestand. Stderr behoudt de eerdere verbinding, zodat de fout zichtbaar blijft. 2>&1 maakt op dat moment een verbinding; stderr volgt niet elke latere wijziging van stdout.

Een gegevensstroom bewust weggooien

/dev/null gooit gegevens weg die ernaartoe worden geschreven. find / -name passwd 2>/dev/null laat overeenkomende paden op stdout staan en verbergt tegelijk meldingen zoals “Permission denied”. Die meldingen kunnen aangeven welke directory's niet zijn doorzocht, dus door ze weg te gooien verlies je ook informatie over gaten in de zoekopdracht.

Een invoerbestand beschermen

Schrijf geen sort fruit.txt > fruit.txt. De shell maakt het doelbestand leeg voordat sort het leest. Gebruik een ander uitvoerpad, controleer het resultaat en hernoem het daarna. Specifiek voor sort gebruikt sort -o fruit.txt fruit.txt de ondersteunde optie voor een uitvoerbestand om dat bestand veilig bij te werken.

Bash kan ook onbedoeld overschrijven weigeren:

set -o noclobber

Met deze instelling mislukt gewone > voor een bestaand gewoon bestand. >> voegt nog steeds achteraan toe. Gebruik >| om bewust te overschrijven of set +o noclobber om de instelling uit te schakelen. De bescherming is nuttig als je herhaaldelijk rapporten opslaat, maar verandert niets aan de eigen opties van een commando om bestanden te schrijven.

Een pipe, geschreven als |, verbindt de normale uitvoer van het ene commando met de invoer van het volgende. Je kunt meerdere kleine taken verbinden zonder daartussen een tijdelijk bestand op te slaan.

De stroom van tekst volgen

In ls /etc | wc -l schrijft ls namen en telt wc -l de nieuweregeltekens die het ontvangt. Een commando dat stdin leest, tekst selecteert of wijzigt en naar stdout schrijft, heet een filter. sort, uniq, wc, cut, grep, head en tail kunnen allemaal als filter dienen.

De algemene vorm is command1 | command2 | command3. Elke stap ontvangt de uitvoer van de vorige stap; die kan een andere vorm hebben dan het oorspronkelijke bestand. Een latere stap kan regels of kolommen die een eerdere stap heeft verwijderd niet terughalen.

Een telling stapsgewijs opbouwen

Stel dat fruit.txt zes regels bevat: “banana”, “apple”, “cherry”, “apple”, “banana”, “apple”. Om de verschillende namen te tellen, voer je eerst uit:

sort fruit.txt

De uitvoer bevat drie regels met “apple”, twee met “banana” en één met “cherry”. Gelijke namen staan nu naast elkaar. Voeg een stap toe:

sort fruit.txt | uniq

uniq verwijdert aangrenzende herhalingen, zodat “apple”, “banana” en “cherry” overblijven. Ten slotte meldt sort fruit.txt | uniq | wc -l 3. Als je het oorspronkelijke bestand direct zou tellen, zou je zes regels krijgen en daarmee een andere vraag beantwoorden.

Voer de steeds langere pijplijn uit en bekijk het resultaat voordat je het volgende commando toevoegt. Voeg bij zeer lange uitvoer tijdelijk | head toe om de eerste tien regels te zien. Zo zie je gemakkelijker of een kopregel niet is verwijderd of een veld verkeerd is geselecteerd.

Fouten gescheiden houden

Een gewone pipe voert stdout door, niet stderr. Met één bestaand en één ontbrekend pad telt ls /etc/hostname /nonexistent | wc -l de ene normale regel met een bestandsvermelding. De fout verschijnt nog steeds op de terminal.

Om meldingen in de gegevens op te nemen, gebruik je ls /etc/hostname /nonexistent 2>&1 | wc -l, dat in dit voorbeeld twee regels telt. |& van Bash combineert stdout en stderr ook in de pipe. Of het nuttig is fouten mee te nemen, hangt af van wat je met de uiteindelijke telling wilt uitdrukken.

De stappen worden gelijktijdig uitgevoerd. tail -f /var/log/app.log | grep ERROR toont nieuw toegevoegde overeenkomende regels op de terminal. Dit is een liveweergave, geen proces dat wacht tot het bestand klaar is. Programma's kunnen uitvoer echter bufferen; onmiddellijke weergave is niet gegarandeerd voor elke mogelijke pijplijn.

Onderweg een kopie opslaan

tee schrijft zijn invoer zowel naar een bestand als naar stdout:

sort fruit.txt | uniq | tee unique.txt | wc -l

De terminal toont 3, terwijl unique.txt de drie namen opslaat. tee -a voegt achteraan toe in plaats van het opgeslagen bestand te vervangen. Als je tee eerder plaatst, wordt een eerdere vorm van de gegevens opgeslagen.

Een pipe verbindt met een commando, terwijl > een bestand aanwijst. ls > less maakt een bestand met de naam “less” aan; het start de tekstviewer niet. Het ontvangende commando moet ook stdin lezen: als je tekst via een pipe naar echo of ls stuurt, wordt die tekst niet omgezet in argumenten voor die commando's.

Tellen en ordenen zijn afzonderlijke taken. Bepaal voordat je telt of je records, woorden, bytes of verschillende waarden nodig hebt. Bepaal voordat je dubbele regels verwijdert of gelijke regels al naast elkaar staan.

Met wc het juiste tellen

Gewoon wc file meldt regels, woorden en bytes, in die volgorde, en daarna de bestandsnaam. De fruitlijst van zes regels met “banana”, “apple”, “cherry”, “apple”, “banana”, “apple” geeft “6 6 39 fruit.txt”. Elke regel draagt zijn letters plus een byte voor het nieuweregelteken bij.

Een laatste stuk tekst zonder nieuweregelteken wordt niet meegeteld door wc -l. Tekst met “one”, een nieuweregelteken en daarna “two” geeft daarom een telling van 1. In UTF-8 gebruikt “café” gevolgd door een nieuweregelteken zes bytes maar vijf tekens, omdat “é” twee bytes gebruikt. Bij meerdere invoerbestanden toont wc hun aantallen en een extra totaal.

Tekstsortering of numerieke sortering kiezen

sort schrijft geordende regels zonder het invoerbestand te wijzigen. De standaardvolgorde volgt de huidige taalinstelling. sort -f vergelijkt zonder onderscheid tussen hoofdletters en kleine letters.

Tekstsortering vergelijkt tekens: “100”, “25”, “9” verschijnen in die volgorde omdat hun eerste cijfers “1”, “2”, “9” zijn. sort -n vergelijkt numerieke waarden en geeft 9, 25, 100. Voeg -r toe voor omgekeerde volgorde, zoals in sort -rn. sort -h begrijpt achtervoegsels voor groottes zoals “2K”, “300M” en “1G”.

Op een veld sorteren

Voor records gescheiden door komma's stelt -t, het scheidingsteken in. -k3,3nr selecteert alleen veld 3, vergelijkt numeriek en keert de volgorde om:

tail -n +2 scores.csv | sort -t, -k3,3nr | head -n 3

Bij “name,city,score” gevolgd door “Ana,Lisbon,82”, “Ben,Oslo,75”, “Chen,Lisbon,91”, “Dara,Oslo,68” en “Eli,Lisbon,88” is het resultaat Chen, Eli en daarna Ana met hun volledige records. De eerste stap laat de kopregel weg. Anders telt de niet-numerieke scoresleutel van die regel als nul tijdens het numeriek sorteren.

Zonder -t scheidt witruimte de velden. -k2 laat de sleutel lopen van veld 2 tot het einde van de regel; -k2,2 beperkt die tot veld 2.

Dubbele regels groeperen voordat je ze telt

uniq vergelijkt elke regel met de aangrenzende reeks. In de ongesorteerde fruitlijst laat het alle zes regels staan omdat er geen gelijke namen naast elkaar staan. sort fruit.txt | uniq toont de drie verschillende namen; sort -u fruit.txt kan ook een gesorteerde lijst met unieke waarden opleveren.

Na het sorteren meldt uniq -c het aantal per reeks: “3 apple”, “2 banana”, “1 cherry”, met spaties als opvulling bij de aantallen. uniq -d toont één exemplaar van elke herhaalde waarde en uniq -u toont alleen waarden die één keer voorkomen. uniq -i negeert hoofdletterverschillen bij het vergelijken.

Gebruik sort fruit.txt | uniq -c | sort -rn om de meest voorkomende waarden bovenaan te zetten. De eerste sortering groepeert identieke regels; de laatste sorteert hun aantallen. Als je de eerste sortering weglaat, worden verspreide reeksen afzonderlijk geteld.

Een record bevat vaak meer informatie dan nodig is voor een vraag. cut selecteert velden of vaste posities uit elke regel en schrijft de selectie naar stdout. Het verandert de volgorde niet en bewerkt het oorspronkelijke bestand niet.

Velden selecteren op hun scheidingsteken

Een scheidingsteken scheidt velden. In /etc/passwd scheiden dubbele punten de gebruikersnaam, tijdelijke aanduiding voor het wachtwoord, gebruikers-ID, groeps-ID, volledige naam, homedirectory en loginshell. Voor dit voorbeeldrecord:

alice:x:1001:1001:Alice Smith:/home/alice:/bin/bash

cut -d: -f1,6 toont “alice:/home/alice”. Veldnummers beginnen bij 1 en het scheidingsteken blijft tussen geselecteerde velden staan. cut -d: -f5 toont “Alice Smith”; de spatie binnenin maakt deel uit van dat veld omdat het scheidingsteken een dubbele punt is.

De lijst selecteert velden en bepaalt geen nieuwe volgorde. cut -d, -f3,1 toont nog steeds eerst veld 1 en daarna veld 3. Standaard is het scheidingsteken een tab, dus cut -f2 file selecteert het tweede veld dat door tabs wordt gescheiden.

Een regel zonder scheidingsteken wordt volledig getoond. Zo toont cut -f2 “no tabs here” ongewijzigd omdat er geen tab in staat. Voeg -s toe om regels zonder scheidingsteken te onderdrukken. Een regel die scheidingstekens bevat maar een gevraagd veld mist, is een ander geval; -s is geen algemene test voor volledige records.

Vaste posities selecteren

cut -c1-5 selecteert posities 1 tot en met 5. Op het accountrecord hierboven toont het “alice”. Selectie op positie is geschikt voor tekst met vaste veldbreedte, waarbij de gewenste kolommen op elke regel op dezelfde plaats beginnen. Veldselectie is geschikt voor records waarvan de veldlengtes verschillen maar de scheidingstekens gelijk blijven.

Het gedrag van scheidingstekens controleren

Met cut -d' ' -f2 is elke afzonderlijke spatie een scheidingsteken. De tekst “a b” heeft een leeg tweede veld tussen de twee spaties, dus het resultaat is een lege regel. Als herhaalde spaties alleen opvulling tussen kolommen zijn, brengt tr -s ' ' | cut -d' ' -f2 elke reeks spaties eerst terug tot één spatie.

cut behandelt ook komma's binnen waarden tussen aanhalingstekens als scheidingstekens. Een CSV-waarde tussen aanhalingstekens zoals “Smith, Ann” wordt niet automatisch bij elkaar gehouden. Gebruik alleen eenvoudige voorbeelden met scheidingstekens als de veldgrenzen echt overeenkomen met de regel voor het scheidingsteken.

Waarden uit een geselecteerde kolom tellen

Om steden in scores.csv te tellen, begin je met cut -d, -f2 scores.csv. Met de records voor Ana, Ben, Chen, Dara en Eli toont dit “city”, “Lisbon”, “Oslo”, “Lisbon”, “Oslo”, “Lisbon”. Daarna:

cut -d, -f2 scores.csv | tail -n +2 | sort | uniq -c | sort -rn

Door de eerste regel weg te laten, verwijder je “city”. Sorteren groepeert de drie vermeldingen van Lisbon en de twee van Oslo; uniq -c telt ze en de laatste sortering zet “3 Lisbon” vóór “2 Oslo”. Als je de stap voor de kopregel vergeet, ontstaat een extra waarde, “1 city”, omdat een kop voor deze commando's nog steeds tekst is.

grep doorzoekt tekst en toont normaal gesproken elke regel met een overeenkomst. Een bruikbare zoekopdracht begint met de keuze van zowel het patroon als het soort resultaat dat je nodig hebt: regels, aantallen, regelnummers of bestandsnamen.

Begin met een patroon tussen aanhalingstekens

De gebruikelijke vorm is grep 'pattern' file. Zonder bestandsargument leest grep stdin. Zoekopdrachten zijn hoofdlettergevoelig, tenzij je -i toevoegt.

Stel dat server.log vijf vermeldingen bevat: een INFO-regel over het opstarten, een ERROR-regel over een volle schijf, een WARN-regel over een nieuwe poging, een regel met “error timeout” in kleine letters en een INFO-regel over een back-up. grep 'ERROR' server.log toont alleen de regel met ERROR in hoofdletters. grep -i 'error' server.log toont beide foutregels.

Zet patronen tussen aanhalingstekens, ook als ze eenvoudig lijken. grep 'disk full' server.log zoekt naar de twee woorden samen. Zonder aanhalingstekens gebruikt grep disk full server.log “disk” als patroon en behandelt het “full” als een extra bestandsnaam. Aanhalingstekens voorkomen ook dat de shell sterren en andere speciale tekens expandeert voordat grep ze ontvangt.

Kies de uitvoer die je nodig hebt

Je kunt opties combineren: grep -ic 'error' server.log meldt 2, terwijl grep -n 'WARN' server.log regel 3 aanwijst. -c telt overeenkomende regels, niet het aantal keer dat een overeenkomst daarin voorkomt. Een regel met “error error” telt als één regel mee.

Bekijk de regels “error”, “terror”, “errors” en “Error found”. Gewoon grep 'error' vindt overeenkomsten in de eerste drie. grep -w 'error' vindt alleen een overeenkomst in de eerste, omdat “error” geen volledig woord is in “terror” of “errors”. Als je -i toevoegt, komt ook “Error found” overeen. -x vereist dat een volledige regel overeenkomt, dus “Error found” voldoet nog steeds niet aan een zoekopdracht naar een volledige regel “error”.

Meerdere bestanden doorzoeken

Als meerdere bestanden worden doorzocht, zet grep normaal gesproken bestandsnamen vóór de overeenkomsten. grep -r 'TODO' notes doorzoekt bestanden in de hele directoryboom. Voeg -l toe om alleen namen van bestanden met overeenkomsten te tonen: grep -rl 'TODO' notes. De hoofdletter -L toont bestanden zonder overeenkomst. Dit zijn resultaten van bestandsselectie, geen aantallen overeenkomende regels.

Bepaal of het patroon letterlijk is

Standaard interpreteert grep een reguliere expressie. Een punt komt overeen met één willekeurig teken, dus '10.0.0.7' kan ook overeenkomen met “10a0b0c7”. grep -F '10.0.0.7' file zoekt naar de exacte tekst. Door elke punt af te schermen met een backslash, zoals in '10\.0\.0\.7', maak je de punten ook letterlijk.

grep -q onderdrukt de normale uitvoer en rapporteert via zijn afsluitstatus: 0 voor een overeenkomst, 1 voor geen overeenkomst en bij GNU grep normaal gesproken 2 voor een fout. Een ontbrekend invoerbestand is een fout, geen bewijs dat het patroon ontbrak.

In een pijplijn telt grep -i 'error' server.log | wc -l overeenkomende regels, net als grep -ic. De eerste vorm laat ruimte voor andere filters tussen het selecteren en tellen van regels.

Een reguliere expressie, of regex, beschrijft tekst die kan overeenkomen. grep zoekt normaal gesproken overal in een regel naar een overeenkomend deel en toont vervolgens de hele regel. De meeste letters komen overeen met zichzelf; speciale tekens beschrijven posities, keuzes of herhaling.

Een teken of positie vinden

De punt . komt overeen met één teken binnen een regel. Bij de regels “cat”, “cart”, “coat”, “cut”, “act”, “scat” en “color” komt het patroon 'c.t' overeen met “cat”, “cut” en “scat”. De laatste bevat “cat” als overeenkomend deel. “coat” heeft twee tekens tussen “c” en “t”, dus één punt kan die niet allebei dekken.

Gebruik ankers om posities te beperken. ^ markeert het begin van een regel en $ het einde:

grep '^c.t$' words.txt toont alleen “cat” en “cut”. Door beide uiteinden te verankeren sluit je een langere regel zoals “scat” uit.

Eén teken uit een verzameling kiezen

Een expressie tussen vierkante haken komt overeen met één teken. [ao] betekent “a” of “o”, dus 'c[ao]t' komt overeen met het deel “cat” van “cat” en “scat”. [0-9] beschrijft een cijfer. Een dakje direct na de openingshaak keert de verzameling om: 'c[^a]t' komt overeen met “cut”, maar niet met “cat”. Dit dakje sluit een teken uit; het markeert daar niet het begin van een regel.

Benoemde klassen beschrijven categorieën binnen de huidige taalinstelling. [[:digit:]] selecteert een cijfer, [[:alpha:]] een letter, [[:alnum:]] een letter of cijfer en [[:upper:]] of [[:lower:]] respectievelijk een hoofdletter of kleine letter. [[:space:]] omvat spaties, tabs en andere witruimtetekens. Behoud beide paren vierkante haken: de klassenaam staat binnen de buitenste verzamelingsexpressie.

Het voorgaande onderdeel herhalen

* betekent nul of meer voorkomens van het onderdeel direct ervoor. 'ca*t' kan overeenkomen met “ct”, “cat” of “caat”. Het komt ook overeen met “act”, omdat die regel “ct” bevat, met nul voorkomens van “a”. Om een willekeurige reeks tekens te vinden, combineer je punt en ster als .*.

'^c.*t$' komt in de woordenlijst overeen met “cat”, “cart”, “coat” en “cut”. Een jokerteken voor bestandsnamen en een reguliere expressie gebruiken verschillende regels voor de ster: het shellpatroon *.txt beschrijft namen die eindigen op “.txt”, maar de reguliere expressie voor dat einde is '\.txt$'.

Een speciaal teken letterlijk maken

Een backslash kan een speciale betekenis wegnemen. \. komt overeen met een echte punt, \* met een ster en \[ met een vierkante openingshaak. [.] selecteert ook een letterlijke punt. grep '\.conf$' file selecteert regels die eindigen op “.conf”.

Bij het doorzoeken van een configuratiebestand kun je eenvoudige commentaarregels en lege regels verwijderen met grep -v '^#' app.conf | grep -v '^$'. De eerste test herkent commentaarregels alleen als “#” het eerste teken is. De standaard eenvoudige syntaxis behandelt ?, +, accolades, | en ronde haken zonder backslash als gewone tekens. GNU grep ondersteunt operatorvormen met een backslash; grep -E biedt uitgebreide syntaxis zonder die backslashes.

Uitgebreide reguliere expressies voegen handige manieren toe om optionele onderdelen, herhaalde groepen en alternatieven uit te drukken. Gebruik grep -E zodat het patroon volgens deze syntaxis wordt gelezen. De punt, ankers, verzamelingen en ster behouden hun eerdere betekenis.

Herhalingen tellen

Een operator volgt op het onderdeel waarop die betrekking heeft. Dat onderdeel kan één teken, een expressie tussen vierkante haken of een groep zijn:

'logs?' komt overeen met “log” en “logs”: alleen de “s” is optioneel. 'ca+t' vereist ten minste één “a” en komt dus overeen met “cat” en het overeenkomende deel in “scat”, maar niet met “ct” binnen “act”. Als je -E weglaat, wordt een vraagteken of plusteken zonder backslash in de eenvoudige syntaxis letterlijke tekst.

Gebruik voor een volledige code van twee hoofdletters en vier cijfers:

grep -E '^[A-Z]{2}[0-9]{4}$' codes.txt

“AB1234” en “QZ0042” komen overeen. “A12345” heeft slechts één letter aan het begin, “ab1234” gebruikt kleine letters en “XY98765” heeft een extra cijfer. De twee ankers voorkomen dat een deel dat er geldig uitziet binnen een langere code wordt goedgekeurd. Als je -i toevoegt, wordt de code met kleine letters ook toegestaan.

Alternatieven groeperen

| betekent een alternatief binnen een uitgebreid patroon. 'cat|cut' zoekt overal in een regel naar een van beide woorden. Ronde haken bepalen de grenzen van een groep: 'c(a|o)t' kiest “a” of “o” tussen “c” en “t”. Een daaropvolgende kwantor geldt voor de hele groep, dus '(ab)+' komt overeen met één of meer herhalingen van “ab”.

Houd het patroon tussen aanhalingstekens. In grep -E cat|cut words.txt interpreteert de shell de verticale streep zonder aanhalingstekens als een pipe tussen commando's. In grep -E 'cat|cut' words.txt geeft de shell dat teken aan grep door als onderdeel van één patroon.

Overeenkomsten tonen in plaats van volledige regels

-o toont alleen overeenkomende delen, één per uitvoerregel. Het onderstaande commando haalt een getalvorm met punten uit een langere regel:

grep -Eo '([0-9]{1,3}\.){3}[0-9]{1,3}' server.log

Het deel tussen ronde haken bestaat uit één tot drie cijfers gevolgd door een letterlijke punt; {3} herhaalt dat drie keer. Het laatste deel voegt één tot drie cijfers toe. Het haalt “10.0.0.7” uit een regel die dat bevat, maar accepteert ook “999.999.999.999”. Een overeenkomst met een vorm controleert niet of elk getal binnen het geldige bereik van een adres valt.

Lege regels en commentaarregels samen verwijderen

grep -Ev '^[[:space:]]*(#|$)' app.conf selecteert actieve instellingen. Lees het patroon op volgorde: begin aan het begin, sta witruimte toe en zoek dan een overeenkomst met “#” of het einde van de regel. Het herkent daardoor zowel ingesprongen commentaarregels en regels met alleen witruimte als lege regels. -v behoudt de regels die niet aan die beschrijving voldoen, zoals “port=8080”. De oudere commandonaam egrep is verouderend in GNU grep; gebruik grep -E.

find doorloopt een directoryboom en test de items die het tegenkomt. Kies eerst de begindirectory: find project toont project zelf en de vermeldingen eronder. Door tests toe te voegen beperk je de selectie.

Namen, paden en typen vergelijken

find project -name '*.txt' selecteert namen die eindigen op “.txt” op elke plaats onder de begindirectory. Zet het jokerteken tussen aanhalingstekens zodat de shell het ongewijzigd doorgeeft. -name is hoofdlettergevoelig, dus voor een hoofdletterongevoelige overeenkomst met “Guide.TXT” heb je -iname '*.txt' nodig.

Het patroon moet overeenkomen met de volledige naam van het item, zonder de bovenliggende directory's. -name 'guide' komt niet overeen met “guide.txt”; -name 'guide*' wel. Gebruik -path '*/src/*' als het directorydeel van belang is. find toont de volgorde waarin het de boom doorloopt, dus voeg | sort toe als je geordende paden wilt.

-type f selecteert gewone bestanden, -type d directory's en -type l symbolische koppelingen. find project -type f -name '*.txt' vereist dat zowel de type- als de naamtest slaagt. Een directory met de naam “notes.txt” slaagt niet voor de bestandstypetest, ook al past de naam.

Vergelijkingen van grootte begrijpen

-size vergelijkt een grootte nadat die naar boven is afgerond op de geselecteerde eenheid. c betekent bytes, k kibibytes van 1.024 bytes, M mebibytes van 1.048.576 bytes en G gibibytes. Een plusteken ervoor betekent groter dan, een minteken kleiner dan en geen teken gelijk aan het opgegeven aantal eenheden.

Voor -size +100M moet de afgeronde grootte groter zijn dan 100 MiB-eenheden. Een bestand dat één byte groter is dan 100 MiB wordt afgerond op 101 eenheden en voldoet. Een niet-leeg bestand kleiner dan 1 MiB wordt afgerond op één eenheid, dus -size -1M vindt alleen lege bestanden. Gebruik een bytetest voor een exacte grens in bytes, of een kleinere eenheid voor een bruikbaar bereik voor kleine bestanden.

Ouderdom testen en diepte beperken

-mtime gebruikt voltooide perioden van 24 uur sinds de wijziging. -mtime -7 selecteert items die minder dan zeven dagen geleden zijn gewijzigd. -mtime +30 selecteert ouderdommen met meer dan 30 voltooide perioden: ten minste 31 dagen. -mmin -30 gebruikt minuten voor recente wijzigingen. -user alice selecteert een eigenaar en -empty selecteert lege bestanden of directory's.

Gebruik find project -maxdepth 1 -type f om de begindirectory en de directe vermeldingen daarin te bekijken zonder onderliggende directory's in te gaan. Zet -maxdepth vóór de tests.

Tests combineren en patronen behouden

Tests die naast elkaar staan betekenen EN. -o betekent OF, zoals in find project -name '*.txt' -o -name '*.md'. ! -name '*.c' keert een naamtest om. Zorg bij een eenvoudige selectie dat de relatie tussen de tests duidelijk is voordat je acties toevoegt.

De shell expandeert een jokerteken zonder aanhalingstekens in je huidige directory. Als daar alleen notes.txt overeenkomt, wordt find . -name *.txt een zoekopdracht naar die ene naam en worden andere tekstbestanden gemist. Bij meerdere lokale overeenkomsten kan het commando mislukken omdat extra namen binnen de testexpressie verschijnen.

Een zoekopdracht in beschermde directory's kan “Permission denied” melden. 2>/dev/null verbergt die fouten, maar maakt onleesbare directory's niet doorzoekbaar. find controleert de boom tijdens de uitvoering; een actief bestandssysteem kan nog veranderen voordat een later commando de gevonden paden gebruikt.

Nadat je bestanden hebt geselecteerd, kun je hun paden aan een ander commando geven. Door de selectie en de actie in dezelfde find-expressie te houden, voorkom je dat spaties binnen bestandsnamen worden behandeld als scheidingstekens tussen namen.

Een commando uitvoeren op elke overeenkomst

De actie -exec command {} \; voert het commando één keer per overeenkomend item uit. find vervangt {} door het pad van dat item. Bijvoorbeeld:

find project -name 'main.c' -exec wc -l {} \;

Als de overeenkomst project/src/main.c is, voert dit wc -l project/src/main.c uit. De afgeschermde puntkomma beëindigt de actie. De backslash voorkomt dat de shell de puntkomma eerst gebruikt om het hele shellcommando te beëindigen.

Gebruik {} + om groepen paden aan minder uitvoeringen van het commando door te geven:

find notes -type f -name '*.txt' -exec grep -l 'TODO' {} +

grep ontvangt de geselecteerde bestandspaden als argumenten en toont de paden van bestanden die “TODO” bevatten. Beide vormen behouden een pad zoals “notes/team plan.txt” als één argument. De vorm met + vermindert het aantal keren dat het commando moet worden gestart als veel bestanden overeenkomen.

Bestandsselectie combineren met tekstselectie

find test bestandseigenschappen; grep onderzoekt inhoud. Voeg -mtime -7 vóór de actie toe om alleen recent gewijzigde tekstbestanden te doorzoeken:

find notes -type f -name '*.txt' -mtime -7 -exec grep -l 'TODO' {} +

Eerst selecteren de tests voor naam, type en ouderdom bestanden. Daarna doorzoekt grep hun tekst. Alleen grep -r kan de inhoud van een boom doorzoeken, maar vervangt die tests voor bestandseigenschappen niet.

Pas verwijderen pas toe na controle van de selectie

-delete verwijdert overeenkomsten zonder bevestiging of mogelijkheid om dit ongedaan te maken. Voer eerst de selectie uit zonder verwijderactie en lees de paden. Voeg pas daarna -delete aan het einde toe, zoals in find /tmp/build -type f -name '*.tmp' -delete. Voor een bevestigingsvraag per item vraagt -ok rm {} \; om toestemming voordat het verwijdercommando wordt uitgevoerd.

Acties worden uitgevoerd terwijl de expressie wordt geëvalueerd. Als je -delete vóór -name '*.tmp' zet, vindt de verwijdering plaats voordat die naamtest haar kan beperken. Een latere test kan een item niet beschermen tegen een actie die al is uitgevoerd.

Kies een snellere zoekmethode als die past

locate guide.txt doorzoekt een index met opgeslagen paden die “guide.txt” bevatten. Het kan snel antwoorden zonder de schijf te doorlopen. Omdat de database periodiek wordt vernieuwd, kan een nieuw bestand ontbreken of een verwijderd pad blijven staan. updatedb bouwt de index opnieuw op; voor een systeembrede update zijn meestal beheerdersrechten nodig. Sommige distributies vereisen een optioneel pakket zoals plocate.

which grep doorzoekt de directory's in PATH op een uitvoerbaar programmabestand en meldt vaak /usr/bin/grep. Het beschrijft niet elke manier waarop Bash een commando vindt. type echo kan bijvoorbeeld een ingebouwd commando herkennen, ook als er een extern programma met de naam “echo” bestaat. Gebruik type commandname voor de interpretatie van Bash, find voor een actuele zoekopdracht in de boom en locate voor een snelle zoekopdracht op naam via een index.

nano notes.txt opent tekst in een terminaleditor. Je kunt met de pijltoetsen navigeren en direct in de tekst typen. Als het bestand niet bestaat, begint nano met een lege buffer, de werktekst die in het geheugen wordt bewaard; bij het opslaan wordt het bestand op schijf aangemaakt.

De aanduidingen van sneltoetsen lezen

De onderste regels tonen toetscombinaties. ^ betekent Ctrl, dus ^X betekent Ctrl+X. M- betekent Meta, meestal Alt, dus M-U betekent Alt+U. Ctrl+G opent de hulp. Deze aanduidingen beschrijven toetsen die je samen indrukt, geen tekens die je in het bestand typt.

Een kleine wijziging maken en opslaan

Om “port=8080” in app.conf te wijzigen in “port=9090”:

1. Voer nano app.conf uit.
2. Druk op Ctrl+W, voer “8080” in en druk op Enter.
3. Verwijder bij de overeenkomst de vier cijfers en typ “9090”.
4. Druk op Ctrl+O en daarna op Enter om de bestandsnaam te bevestigen en op te slaan.
5. Druk op Ctrl+X om af te sluiten.

Terug in de shell zou grep 'port' app.conf “port=9090” moeten tonen. Dit controleert het opgeslagen bestand, niet alleen wat zichtbaar was in de editor.

Ctrl+O is opslaan, geen commando om een bestand te openen. Ctrl+R leest de inhoud van een ander bestand in de huidige buffer op de cursorpositie. Als je die acties verwart, kun je ongewenste tekst invoegen in het bestand dat je bewerkt.

Zoeken, vervangen en navigeren

Ctrl+W zoekt naar tekst. Alt+G gaat naar een opgegeven regelnummer, handig als een foutmelding een bepaalde regel aanwijst. Ctrl+C toont de huidige regel en kolom.

Alt+R, ook beschikbaar als Ctrl+, start een vervanging. Voer de te zoeken tekst in en daarna de vervanging. Antwoord bij elke overeenkomst Y om te vervangen of N om over te slaan; A vervangt alles. Afzonderlijke vervangingen kiezen helpt als dezelfde cijfers in meerdere instellingen voorkomen en er maar één moet veranderen.

Tekst verplaatsen en wijzigingen ongedaan maken

Door herhaaldelijk op Ctrl+K te drukken verzamel je opeenvolgende regels. Bij een gemarkeerde selectie knipt Ctrl+K de gemarkeerde tekst in plaats van de hele regel. Ctrl+U voegt die tekst dan in op de cursorpositie. Ongedaan maken is nuttig direct na een onbedoelde knip- of vervangactie.

Bewust afsluiten

Ctrl+X sluit af. Als de buffer niet-opgeslagen wijzigingen bevat, vraagt nano of je die wilt opslaan. Y slaat op, gevolgd door Enter om de naam te bevestigen; N sluit af zonder die wijzigingen op te slaan; Ctrl+C annuleert het afsluiten en keert terug naar het bewerken. Met N kies je ervoor werk weg te gooien; het is geen manier om verder te bewerken.

nano -l app.conf toont regelnummers en nano +12 app.conf begint bij regel 12. Als opslaan mislukt omdat je geen toestemming hebt, is de bewerkte buffer niet op dat pad opgeslagen. Systeembestanden vereisen passende rechten, bijvoorbeeld sudo nano /etc/hosts als voor een toegestane systeemwijziging beheerderstoegang nodig is. Gebruik voor het oefenen een bestand in je eigen directory.

vi notes.txt opent een terminaleditor in de normale modus. Een toets zoals x is daar een commando. Om tekst te typen, open je eerst de invoegmodus. Op veel Linux-systemen start vi Vim of een andere editor die compatibel is met vi.

Houd de modus in de gaten

Vim toont “-- INSERT --” tijdens het invoegen. Esc keert terug naar de normale modus. Vanuit de normale modus voegt i in vóór de cursor en a erna. I begint vóór het eerste teken van de regel dat geen witruimte is en behoudt de inspringing; A voegt toe aan het einde. o opent een regel eronder en O een regel erboven.

Navigeren zonder tekst te typen

In de normale modus gaan h, j, k en l naar links, omlaag, omhoog en rechts. Pijltoetsen werken ook. w gaat naar het volgende woord, 0 naar het begin van de regel en $ naar het einde. G springt naar de laatste regel. 1G springt naar de eerste; Vim biedt ook gg. Een getal vóór G selecteert een regel, dus 12G springt naar regel 12. :12 en Enter doen hetzelfde. Aantallen herhalen ook bewegingen: 5j gaat vijf regels omlaag.

Bewerken vanuit de normale modus

x verwijdert het teken onder de cursor. dd knipt een regel; 3dd knipt drie regels. yy kopieert een regel. Bij tekst die uit hele regels bestaat, plakt p onder de huidige regel en P erboven. Bij tekst die uit tekens bestaat, plakt p na de cursor en P ervoor.

cw vervangt de rest van het huidige woord en opent de invoegmodus. r gevolgd door een teken vervangt slechts één teken. u maakt een wijziging ongedaan; Ctrl+R van Vim voert die opnieuw uit. Een punt . herhaalt de laatste wijziging.

Een instelling zoeken en wijzigen

Om “8080” door “9090” te vervangen in app.conf, voer je vi app.conf uit en typ je daarna /8080 en Enter. Typ bij de eerste “8” cw, typ “9090” en druk op Esc. Typ :wq en Enter om op te slaan en af te sluiten.

Zoek achteruit met ?text en Enter. n herhaalt de huidige zoekrichting en N keert die om. Zoekopdrachten accepteren reguliere expressies. Om elk voorkomen in een bestand te vervangen, gebruikt :%s/8080/9090/g % voor alle regels en g voor alle voorkomens op elke regel. :set number toont regelnummers tijdens het bewerken.

Bewust opslaan of afsluiten

Vanuit de normale modus slaat :w en Enter op; :w newname.txt slaat op onder een nieuwe naam. :q sluit alleen af als niet-opgeslagen wijzigingen dat niet verhinderen. :wq, :x of ZZ slaat op en sluit af. :q! gooit niet-opgeslagen wijzigingen weg en sluit af.

Als typen onverwacht de cursor verplaatst of tekst verwijdert, druk je op Esc om de normale modus te openen en gebruik je daarna u om ongewenste bewerkingen ongedaan te maken voordat je verdergaat. Open de invoegmodus voordat je de vervangende tekst typt. Kies bij het afsluiten of je wilt opslaan of weggooien; het uitroepteken in :q! geeft toestemming om niet-opgeslagen werk weg te gooien.