Når du bruker en Linux-maskin, vil du oppdage at operasjonene er ganske forskjellige fra det du kanskje er vant til med Windows eller macOS. Du har tilgang til både et grafisk brukergrensesnitt og et kommandolinjegrensesnitt. Mens det grafiske grensesnittet kan virke som det enkleste valget for å utføre oppgaver, har kommandolinjen sine egne fordeler. Hvis du kjenner de viktigste Linux-terminalkommandoene godt, kan du få ting gjort raskt. En av de mest brukte kommandoene i Linux er `cat`-kommandoen. Den er forhåndsinstallert som en del av `coreutils`-pakken på alle Linux-distribusjoner, og syntaksen er den samme uavhengig av hvilken distribusjon du bruker. I denne artikkelen vil vi se nærmere på hvordan du bruker `cat`-kommandoen med noen praktiske eksempler.
Forklaring av `cat`-kommandoen i Linux (2023)
Før vi ser på de praktiske eksemplene, la oss først forstå hva `cat`-kommandoen er, sammen med dens syntaks og tilgjengelige alternativer. Deretter vil vi se hvordan du effektivt kan bruke `cat`-kommandoen til å vise enkeltfiler eller flere filer, slå sammen filer, sortere dem og mye mer.
Hva er `cat`-kommandoen i Linux?
`Cat`-kommandoen står for «concatenate» (sammenkoble), og det er en av de essensielle kommandoene i enhver Linux-brukers verktøykasse. Den ble først utviklet for UNIX-operativsystemet, men ble senere tilpasset for Linux og macOS. Hovedformålet med denne kommandoen er filhåndtering, og den lar brukerne opprette nye filer, vise filinnhold, overskrive filer, slå sammen to eller flere filer, og mer.
Hvordan bruke `cat`-kommandoen: Syntaks og alternativer
Før vi dykker ned i praktiske eksempler, la oss se på syntaksen for `cat`-kommandoen i Linux. Syntaksen er enkel og grei. Her er den, hvor du må bruke et alternativ sammen med filnavnene, avhengig av hva du ønsker å gjøre.
`cat` <alternativer> <filnavn(er)>
Noen av de vanlige alternativene som brukes med `cat`-kommandoen er:
| Alternativ | Beskrivelse |
| `-n` | Vis linjenumre for alle linjer |
| `-T` | Vis hvert tabulatortegn i filen |
| `-e` | Vis slutten av hver linje i filen |
| `-s` | Slå sammen påfølgende tomme linjer på slutten av filen som én |
| `-b` | Vis kun ikke-tomme linjer |
`cat`-kommandoeksempler i Linux-terminalen
Vis en enkelt fil
Den mest vanlige bruken av `cat`-kommandoen er å vise innholdet i en enkelt fil. Du kan bruke følgende syntaks for å vise en enkelt fil ved hjelp av `cat`-kommandoen:
`cat` <alternativ> <filnavn>
Vis flere filer
Ved å legge til navnene på filene etter hverandre, adskilt med mellomrom, kan du også bruke `cat`-kommandoen til å vise innholdet i flere filer. Se på følgende syntaks:
`cat` <alternativ> <fil_1> <fil_2> <fil_3>
Vis linjenumre
Som standard viser ikke `cat`-kommandoen linjenumrene til filinnholdet den skriver ut. For å vise linjenumre, bruk `-n`-flagget med `cat`-kommandoen i Linux:
`cat` -n <filnavn>
Lag en ny fil med `cat`-kommandoen
Vanligvis bruker vi kommandoen `touch` for å lage en ny fil, eller en teksteditor for å opprette og redigere en fil. Naturligvis kan ikke `cat`-kommandoen erstatte disse verktøyene, men du kan bruke `cat`-kommandoen for rask redigering av filer. Med `cat`-kommandoen kan du opprette en ny fil og legge til innhold i den. Syntaksen for å lage en ny fil ved hjelp av `cat`-kommandoen er:
`cat` > <nytt_filnavn>
Her er `>`-symbolet kjent som overskrivingsoperatoren, og det brukes til å overskrive en fil med nytt innhold. Siden filen er helt tom, vil det du skriver, legges til i filen. Når du er ferdig med å skrive til den nye filen, trykker du «ENTER» og deretter «CTRL + d» for å avslutte ledeteksten.
I eksemplet ovenfor kan du se at en ny fil, «test1.txt», er opprettet ved hjelp av `cat`-kommandoen, og filinnholdet vises i utdataene fra den andre `cat`-kommandoen.
Slå sammen to filer til en ny fil
Ved å bruke syntaksen nedenfor kan du også bruke `cat`-kommandoen til å kombinere to filer til én. Vi vil bruke append-operatoren (`>>`) for å legge til innholdet i den første filen på slutten av den andre filen ved hjelp av kommandoen nedenfor.
`cat` <alternativ> <fil_1> >> <fil_2>
I eksemplet ovenfor blir innholdet i filen «test1.txt» lagt til på slutten av «test2.txt» ved hjelp av `cat`-kommandoen. Det nye innholdet kan verifiseres med utdataene fra den andre `cat`-kommandoen, der vi viser den andre filen.
Kopier innholdet i en fil til en annen
Du kan til og med kopiere innholdet i en fil til en annen fil ved å bruke `cat`-kommandoen, som forklart nedenfor. Her brukes `>`-operatoren for å overskrive innholdet i `fil_1` til `fil_2`.
`cat` <fil_1> > <fil_2>
I eksemplet ovenfor har vi overskrevet innholdet i filen «test1.txt» med innholdet i filen «test2.txt» ved å bruke overskrivingsoperatoren.
Vis usynlige tegn
Som standard markerer ikke `cat`-kommandoen linjeslutt mens du skriver ut innholdet i en fil. For å vise linjeslutt, bruk `-E`-flagget sammen med kommandoen:
`cat` -E <filnavn>
Dette vil markere slutten av hver linje med et `$`-symbol. For å skrive ut faner i stedet for fire tomme mellomrom, bruk enten `-T`-flagget, i henhold til syntaksen vist nedenfor:
`cat` -T <filnavn>
Dette vil skrive ut alle tabulatortegn som `^I`. For å skrive ut alle andre usynlige tegn, bruk `-v`-flagget med `cat`-kommandoen, som vist i syntaksen nedenfor:
`cat` -v <filnavn>
Som du kan se i eksemplet ovenfor, er alle linjeslutt markert med et `$`-symbol, og tabulatorer er merket med et `^I`-tegn.
Kombiner flere tomme linjer som én
Noen ganger kan det være noen tomme linjer i filen som du ikke vil skrive ut. For å slå sammen alle tomme linjer som én, bruk `-s`-flagget med den opprinnelige `cat`-kommandoen.
`cat` -s <filnavn>
Vis filinnhold i omvendt rekkefølge (`tac`-kommandoen)
Vanligvis viser `cat`-kommandoen filinnholdet i formatet ovenfra og ned. Men når du lagrer noen direktestrømdata eller ser på en stor loggfil, blir de nyeste dataene lagt til sist, og det kan være vanskelig å bla gjennom en stor tekstblokk. I slike tilfeller kan du bruke `tac`-kommandoen i Linux, en alternativ versjon av `cat`-kommandoen, som skriver ut filinnholdet i omvendt rekkefølge. Syntaksen for å bruke `tac`-kommandoen er:
`tac` <filnavn>
Sortering av utdatainnhold fra filer
I Linux kan du kombinere to eller flere kommandoer ved hjelp av shell-omdirigering. Dette omdirigerer utdata fra en kommando til inngangen til den neste kommandoen. Du kan bruke overskrivingsoperatoren (`>`) og append-operatoren (`>>`), som er kjent som I/O-shell-omdirigering.
Det finnes også en annen type shell-omdirigering som kalles shell-piping, som brukes til å kjøre to eller flere kommandoer samtidig. Dette betyr at utdata fra en kommando vil bli omdirigert til neste kommando som inngang. Siden kommandoeksekveringen følger en bestemt struktur, kalles en slik struktur eller et slikt konsept en «pipeline». Rør-operatoren (`|`) skaper en pipeline for disse kommandoene som skal utføres i en bestemt rekkefølge.
Nå må du være klar over at `cat`-kommandoen skriver ut filinnholdet i samme rekkefølge som det er lagret i filen. Som navnet antyder, klassifiserer sorteringskommandoen utdataene i stigende eller synkende rekkefølge. Men ved å sende utdata fra `cat`-kommandoen via rør-operatoren til sorteringskommandoen, kan du få den endelige utgangen i ønsket sortert rekkefølge. Dette kan høres forvirrende og komplisert ut, men eksemplet nedenfor vil gjøre det tydelig. Syntaksen for å bruke de to kommandoene ved hjelp av en rør-operasjon er:
`cat` <alternativer> <filnavn> | `sort`
I eksemplet ovenfor, i stedet for å skrive ut innholdet i filen «test3.txt», sender `cat`-kommandoen innholdet til sorteringskommandoen som deretter sorterer det i alfabetisk rekkefølge, og til slutt skriver ut det sorterte resultatet.
Vis store filer med `cat`-kommandoen
Noen ganger kan selv et system med gode spesifikasjoner hakke når du prøver å vise innholdet i en stor fil. For så store filer bør du bruke `less`-kommandoen sammen med `cat`-kommandoen og rør-operatoren. Siden `less`-kommandoen bare laster inn en del av filen om gangen, bruker den ikke mye ressurser. Du kan bla opp eller ned for å se de andre delene av filen ved hjelp av piltastene. Syntaksen for å bruke `less`-kommandoen med `cat`-kommandoen er:
`cat` <big_file_name> | `less`
I eksemplet ovenfor, når du utfører kommandoen i henhold til syntaksen ovenfor, blir ikke filen skrevet ut på den samme terminalledeteksten. I stedet viser den filinnholdet i en ny terminalvisning, som vist i det andre bildet. Her kan du bla gjennom teksten ved hjelp av piltastene. For å gå til bunnen av teksten, bruk `GG`, og for å gå til toppen av teksten, bruk `gg`. For å gå ut av den nye terminalvisningen, trykk `q`.
`cat`-kommando Praktiske eksempler
`Cat`-kommandoen, sammen med `tac`-kommandoen, forenkler filhåndteringen betydelig for brukere som er komfortable med å bruke Linux-terminalen. Med alternativer og ekstra operatorer kan `cat`-kommandoen være svært nyttig for å forenkle arbeidsflyten din. I denne artikkelen har vi delt noen praktiske eksempler på hvordan du bruker `cat`-kommandoen til å opprette, legge til og vise filer på Linux-systemet. Hvis du vil lære mer om `cat`-kommandoen, kan du besøke den offisielle man-siden. Hvis du møter problemer når du bruker denne kommandoen, må du gjerne gi oss beskjed i kommentarene nedenfor.