Kapitel 1. GNU/Linux handledning

# Kapitel 1. GNU/Linux handledning

Jag tycker att lära sig ett datorsystem är som att lära sig ett nytt främmande språk. Även om handledningsböcker och dokumentation är till stor hjälp, måste du öva själv. För att hjälpa dig att komma igång på ett smidigt sätt tar jag upp några grundläggande punkter.

Den kraftfulla utformningen av Debian GNU/Linux kommer från operativsystemet Unix, dvs. ett operativsystem för flera användare och flera arbetsuppgifter. Du måste lära dig att dra nytta av kraften i dessa funktioner och likheter mellan Unix och GNU/Linux.

Var inte rädd för Unix-orienterade texter och förlita dig inte enbart på GNU/Linux-texter, eftersom du då går miste om mycket användbar information.

| Notera
Om du har använt något Unix-liknande system ett tag med kommandoradsverktyg känner du förmodligen till allt jag förklarar här. Använd det här som en verklighetskontroll och uppfräschning.

## 1.1. Grunderna i konsolen

### 1.1.1. Shell-prompten

När du startar systemet visas en teckenbaserad inloggningsskärm om du inte har installerat någon GUI-miljö som t.ex. skrivbordssystemet GNOME eller KDE. Anta att ditt värdnamn är `foo`, så ser inloggningsprompten ut på följande sätt.

Om du har installerat en GUI-miljö kan du fortfarande komma till den teckenbaserade inloggningsprompten med Ctrl-Alt-F3, och du kan återgå till GUI-miljön med Ctrl-Alt-F2 (se Avsnitt 1.1.6, ”Virtuella konsoler” nedan för mer information).

    foo login:

Vid inloggningsprompten skriver du ditt användarnamn, t.ex. `pingvin`, och trycker på Enter-tangenten, sedan skriver du ditt lösenord och trycker på Enter-tangenten igen.

| Notera
Enligt Unix-traditionen är användarnamn och lösenord för Debian-systemet skiftlägeskänsliga. Användarnamnet väljs vanligtvis endast från gemener. Det första användarkontot skapas vanligtvis under installationen. Ytterligare användarkonton kan skapas med adduser(8) av root.

Systemet startar med det hälsningsmeddelande som finns lagrat i "`/etc/motd`" (Message Of The Day) och visar en kommandotolk.

    Debian GNU/Linux 12 foo tty3

    foo login: penguin
    Password:

    Linux foo 6.5.0-0.deb12.4-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.5.10-1~bpo12+1 (2023-11-23) x86_64

    The programs included with the Debian GNU/Linux system are free software;
    the exact distribution terms for each program are described in the
    individual files in /usr/share/doc/*/copyright.

    Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
    permitted by applicable law.

    Last login: Wed Dec 20 09:39:00 JST 2023 on tty3
    foo:~$

Nu befinner du dig i skalet. Skalet tolkar dina kommandon.

### 1.1.2. Shell-prompten under GUI

Om du installerade en GUI-miljö under installationen visas den grafiska inloggningsskärmen när du startar systemet. Du skriver in ditt användarnamn och ditt lösenord för att logga in på det icke-privilegierade användarkontot. Använd fliken för att navigera mellan användarnamn och lösenord, eller använd musens primära klick.

Du kan få skalprompten under GUI-miljö genom att starta ett `x-terminal-emulatorprogram` som gnome-terminal(1), rxvt(1) eller xterm(1). Under GNOME-skrivbordsmiljön trycker du på SUPER-tangenten (Windows-tangenten) och skriver in "terminal" i sökprompten.

Under vissa andra skrivbordssystem (som `fluxbox`) kanske det inte finns någon uppenbar startpunkt för menyn. Om detta händer kan du prova att (höger)klicka på bakgrunden på skrivbordsskärmen och hoppas att en meny dyker upp.

### 1.1.3. Rotkontot

Kontot root kallas även superuser eller privilegierad användare. Från det här kontot kan du utföra följande systemadministrativa uppgifter.

- Läsa, skriva och ta bort alla filer på systemet oavsett deras filbehörigheter

- Ange filägarskap och behörigheter för alla filer på systemet

- Ange lösenordet för alla icke-privilegierade användare i systemet

- Logga in på alla konton utan deras lösenord

Den här obegränsade kraften i root-kontot kräver att du är hänsynsfull och ansvarsfull när du använder det.

| Varning
Dela aldrig med dig av root-lösenordet till andra.

| Notera

Filrättigheterna för en fil (inklusive maskinvaruenheter som CD-ROM etc. som bara är en annan fil för Debiansystemet) kan göra den oanvändbar eller otillgänglig för användare som inte är root. Även om användningen av root-kontot är ett snabbt sätt att testa den här typen av situation, bör den lösas genom korrekt inställning av filbehörigheter och användarens gruppmedlemskap (se Avsnitt 1.2.3, ”Behörigheter i filsystemet”).

### 1.1.4. Prompten för root-gränssnittet

Här följer några grundläggande metoder för att få root shell-prompten genom att använda root-lösenordet.

- Skriv `root` i den teckenbaserade inloggningsprompten.

- Skriv "`su -l`" från valfri användarprompt.

  - Detta bevarar inte den aktuella användarens miljö.

- Skriv "`su`" från vilken användarprompt som helst.

  - Detta bevarar en del av den aktuella användarens miljö.

### 1.1.5. GUI-verktyg för systemadministration

Om skrivbordsmenyn inte startar GUI-verktyg för systemadministration automatiskt med rätt behörighet kan du starta dem från root shell-prompten i en terminalemulator, t.ex. gnome-terminal(1), rxvt(1) eller xterm(1). Se Avsnitt 1.1.4, ”Prompten för root-gränssnittet” och Avsnitt 7.9, ”Anslutning till X-server”.

| Varning
Starta aldrig GUI-display/sessionshanteraren under root-kontot genom att skriva `root` i displayhanterarens prompt, t.ex. gdm3(1). Kör aldrig ett opålitligt GUI-program under X-fönstret när kritisk information visas, eftersom det kan avlyssna din X-skärm.

### 1.1.6. Virtuella konsoler

I Debians standardsystem finns det sex omkopplingsbara VT100-liknande teckenkonsoler tillgängliga för att starta kommandoraden direkt på Linux-värden. Om du inte befinner dig i en GUI-miljö kan du växla mellan de virtuella konsolerna genom att trycka på `vänster-Alt-tangenten` och en av tangenterna `F1` — `F6` samtidigt. Varje teckenkonsol tillåter oberoende inloggning till kontot och erbjuder fleranvändarmiljön. Den här fleranvändarmiljön är en fantastisk Unix-funktion och mycket beroendeframkallande.

Om du befinner dig i GUI-miljön får du tillgång till teckenkonsolen 3 genom att trycka på `Ctrl-Alt-F3`, dvs. `vänster Ctrl-tangent`, `vänster Alt-tangent` och `F3-tangenten` trycks in samtidigt. Du kan komma tillbaka till GUI-miljön, som normalt körs på den virtuella konsolen 2, genom att trycka på `Alt-F2`.

Alternativt kan du byta till en annan virtuell konsol, t.ex. konsol 3, från kommandoraden.

    # chvt 3

### 1.1.7. Så här lämnar du kommandotolken

Du skriver `Ctrl-D`, dvs. `vänster Ctrl-tangent` och `d-tangenten` trycks ihop, vid kommandotolken för att stänga skalaktiviteten. Om du befinner dig på teckenkonsolen återgår du till inloggningsprompten med detta. Även om dessa kontrolltecken kallas "kontroll D" med versaler, behöver du inte trycka på Shift-tangenten. Kortkommandot `^D` används också för `Ctrl-D`. Alternativt kan du skriva "exit".

Om du befinner dig på x-terminal-emulator(1) kan du stänga `x-terminal-emulatorfönstret` med detta.

### 1.1.8. Så här stänger du av systemet

Precis som alla andra moderna operativsystem där filoperationen innebär att data cachas i minnet för förbättrad prestanda, behöver Debiansystemet en korrekt avstängningsprocedur innan strömmen kan stängas av på ett säkert sätt. Detta för att bibehålla filernas integritet genom att tvinga alla ändringar i minnet att skrivas till disken. Om programvarans strömkontroll är tillgänglig, stänger avstängningsproceduren automatiskt av strömmen till systemet. (I annat fall kan du behöva trycka på strömbrytaren i några sekunder efter avstängningsproceduren)

Du kan stänga av systemet i det normala fleranvändarläget från kommandoraden.

    # shutdown -h now

Du kan stänga av systemet i enanvändarläge från kommandoraden.

    # poweroff -i -f

Se Avsnitt 6.3.8, ”Hur man stänger av fjärrsystemet på SSH”.

### 1.1.9. Återskapa en sund konsol

När skärmen går bärsärk efter att ha gjort några roliga saker som "`cat some-binary-file`", skriv "`reset`" i kommandotolken. Det är inte säkert att du ser kommandot ekas medan du skriver. Du kan också skriva "`clear`" för att städa upp på skärmen.

### 1.1.10. Ytterligare paketförslag för nybörjaren

Även om även den minimala installationen av Debian-systemet utan några skrivbordsmiljöuppgifter ger de grundläggande Unix-funktionerna, är det en bra idé att installera några ytterligare kommandorads- och curses-baserade teckenterminalpaket som `mc` och `vim` med apt-get(8) för nybörjare för att komma igång med följande.

    # apt-get update
     ...
    # apt-get install mc vim sudo aptitude
     ...

Om du redan har dessa paket installerade installeras inga nya paket.

Tabell 1.1. Lista över intressanta programpaket i textläge

paket | popcon | storlek | beskrivning
--- | --- | --- | ---
`mc` | V:39, I:179 | 1590 | En filhanterare i textläge med fullskärm
`sudo` | V:756, I:867 | 6774 | Ett program för att ge användare begränsade root-rättigheter
`vim` | V:81, I:342 | 4164 | Unix textredigerare Vi IMproved, en textredigerare för programmerare (standardversion)
`vim-tiny` | V:57, I:979 | 1867 | Unix textredigerare Vi IMproved, en textredigerare för programmerare (kompakt version)
`emacs-nox` | V:3, I:12 | 46564 | GNU-projektet Emacs, den Lisp-baserade extensibla textredigeraren
`w3m` | V:10, I:134 | 2853 | Webbläsare i textläge
`gpm` | V:8.2, I:9.1 | 524 | Klipp-och-klistra i Unix-stil på textkonsolen (daemon)

Det kan vara en bra idé att läsa några informativa dokumentationer.

Tabell 1.2. Förteckning över informativa dokumentationspaket

paket | popcon | storlek | beskrivning
--- | --- | --- | ---
`doc-debian` | I:884 | 185 | Dokumentation för Debian-projektet, (Debian FAQ) och andra dokument
`debian-policy` | I:7.3 | 5147 | Debians policyhandbok och relaterade dokument
`developers-reference` | V:0.2, I:2.4 | 2647 | Riktlinjer och information för Debian-utvecklare
`debmake-doc` | I:0.37 | 11803 | Guide för Debians underhållsansvariga
`debian-history` | I:0.56 | 6513 | Debian-projektets historia
`debian-faq` | I:882 | 791 | Debian FAQ

Du kan installera några av dessa paket på följande sätt.

    # apt-get install package_name

### 1.1.11. Ett extra användarkonto

Om du inte vill använda ditt huvudanvändarkonto för följande utbildningsaktiviteter kan du skapa ett utbildningsanvändarkonto, t.ex. `fisk` enligt följande.

    # adduser fish

Svara på alla frågor.

Detta skapar ett nytt konto med namnet `fish.` Efter din övning kan du ta bort detta användarkonto och dess hemkatalog genom att göra följande.

    # deluser --remove-home fish

På icke-Debian-system och specialiserade Debian-system måste ovanstående aktiviteter i stället använda verktygen useradd(8) och userdel(8) på lägre nivå.

### 1.1.12. sudo konfiguration

För den typiska arbetsstationen för en användare, t.ex. Debian-systemet på den bärbara datorn, är det vanligt att använda en enkel konfiguration av sudo(8) enligt följande för att låta en icke-privilegierad användare, t.ex. `pingvinen`, få administrativa rättigheter bara med sitt användarlösenord men utan root-lösenordet.

    # echo "penguin  ALL=(ALL) ALL" >> /etc/sudoers

Alternativt är det också vanligt att göra på följande sätt för att låta en icke-privilegierad användare, t.ex. `pingvinen`, få administrativa rättigheter utan lösenord.

    # echo "penguin  ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers

Detta trick bör endast användas för den arbetsstation som du administrerar och där du är den enda användaren.

| Varning
Skapa inte konton för vanliga användare på en arbetsstation med flera användare på det här sättet eftersom det skulle vara mycket dåligt för systemsäkerheten.

| Observera
Lösenordet och kontot för `pingvinen` i exemplet ovan kräver lika mycket skydd som root-lösenordet och root-kontot. Administrationsbehörighet i det här sammanhanget tillhör någon som är behörig att utföra systemadministrationsuppgifter på arbetsstationen. Ge aldrig någon chef på företagets administrativa avdelning eller din chef sådana rättigheter om de inte är behöriga och kompetenta.

| Notera

För att ge åtkomstbehörighet till begränsade enheter och begränsade filer bör du överväga att använda grupp för att ge begränsad åtkomst i stället för att använda `root-behörighet` via sudo(8).

Med en mer genomtänkt och noggrann konfiguration kan sudo(8) ge begränsade administrativa behörigheter till andra användare på ett delat system utan att dela root-lösenordet. Detta kan hjälpa till med ansvarsskyldigheten för värdar med flera administratörer så att du kan se vem som gjorde vad. Å andra sidan kanske du inte vill att någon annan ska ha sådana privilegier.

### 1.1.13. Speltid

Nu är du redo att leka med Debian-systemet utan risker så länge du använder det icke-privilegierade användarkontot.

Detta beror på att Debian-systemet, även efter standardinstallationen, är konfigurerat med korrekta filbehörigheter som förhindrar icke-privilegierade användare från att skada systemet. Naturligtvis kan det fortfarande finnas några hål som kan utnyttjas, men de som oroar sig för dessa frågor bör inte läsa detta avsnitt utan bör läsa Securing Debian Manual.

Vi lär oss Debian-systemet som ett Unix-liknande system med följande.

- Avsnitt 1.2, ”Unix-liknande filsystem” (enkla koncept)

- Avsnitt 1.3, ”Midnight Commander (MC)” (överlevnadsmetod)

- Avsnitt 1.4, ”Den grundläggande Unix-liknande arbetsmiljön” (enkel metod)

- Avsnitt 1.5, ”Det enkla shell-kommandot” (skalmekanism)

- Avsnitt 1.6, ”Unix-liknande textbehandling” (metod för textbearbetning)

## 1.2. Unix-liknande filsystem

I GNU/Linux och andra Unix-liknande operativsystem är filer organiserade i kataloger. Alla filer och kataloger är ordnade i ett stort träd med rot i "`/`". Det kallas ett träd eftersom filsystemet ser ut som ett träd om man ritar det, men det är upp och ner.

Dessa filer och kataloger kan vara utspridda över flera enheter. mount(8) används för att koppla filsystemet som finns på en enhet till det stora filträdet. Omvänt kopplar umount(8) loss det igen. På de senaste Linux-kärnorna kan mount(8) med vissa alternativ binda en del av ett filträd någon annanstans eller montera filsystemet som delat, privat, slav eller obindbart. Vilka monteringsalternativ som stöds för varje filsystem finns i "`/usr/share/doc/linux-doc-*/Documentation/filesystems/`".

Kataloger i Unix-system kallas mappar i vissa andra system. Observera också att det inte finns något begrepp för enhet som "`A:`" på något Unix-system. Det finns ett filsystem och allt är inkluderat. Detta är en enorm fördel jämfört med Windows.

### 1.2.1. Grunderna för Unix-filer

Här följer några grunderna för Unix-filer.

- Filnamn är skiftlägeskänsliga. Det vill säga "`MYFILE" och "``MyFile`" är olika filer.

- Rotkatalogen betyder roten till filsystemet och kallas helt enkelt "`/`". Förväxla inte detta med hemkatalogen för root-användaren: "`/root`".

- Varje katalog har ett namn som kan innehålla alla bokstäver eller symboler utom "`/`". Rotkatalogen är ett undantag; dess namn är "`/`" (uttalas "slash" eller "rotkatalogen") och den kan inte döpas om.

- Varje fil eller katalog betecknas med ett fullständigt kvalificerat filnamn, ett absolut filnamn eller en sökväg som anger den sekvens av kataloger som måste passeras för att nå den. De tre termerna är synonyma.

- Alla fullständigt kvalificerade filnamn börjar med katalogen "`/`", och det finns ett "`/`" mellan varje katalog eller fil i filnamnet. Den första "`/`" är den översta katalogen, och de andra "`/`":erna separerar successiva underkataloger, tills vi når den sista posten som är namnet på den faktiska filen. De ord som används här kan vara förvirrande. Ta följande fullständigt kvalificerade filnamn som exempel: "`/usr/share/keytables/us.map.gz`". Men människor hänvisar också till dess basnamn "`us.map.gz`" ensam som ett filnamn.

- Rotkatalogen har ett antal förgreningar, t.ex. "`/etc/`" och "`/usr/`". Dessa underkataloger förgrenar sig i sin tur till ännu fler underkataloger, t.ex. "`/etc/systemd/`" och "`/usr/local/`". Allt detta sammantaget kallas katalogträdet. Du kan tänka på ett absolut filnamn som en väg från trädets bas ( "`/`") till slutet av någon gren (en fil). Du hör också folk prata om katalogträdet som om det vore ett släktträd som omfattar alla direkta ättlingar till en enda figur som kallas rotkatalogen ( "`/`"): underkataloger har alltså föräldrar, och en sökväg visar en fils fullständiga härkomst. Det finns också relativa sökvägar som börjar någon annanstans än i rotkatalogen. Du bör komma ihåg att katalogen "..`/`" hänvisar till den överordnade katalogen. Denna terminologi gäller även för andra katalogliknande strukturer, t.ex. hierarkiska datastrukturer.

- Det finns ingen speciell komponent i katalogsökvägsnamnet som motsvarar en fysisk enhet, t.ex. hårddisken. Detta skiljer sig från RT-11, CP/M, OpenVMS, MS-DOS, AmigaOS och Microsoft Windows, där sökvägen innehåller ett enhetsnamn som till exempel "`C:\`". (Det finns dock katalogposter som hänvisar till fysiska enheter som en del av det normala filsystemet. Se Avsnitt 1.2.2, ”Internt i filsystemet”.)

| Notera

Även om du kan använda nästan vilka bokstäver eller symboler som helst i ett filnamn är det i praktiken en dålig idé att göra det. Det är bättre att undvika tecken som ofta har speciella betydelser på kommandoraden, t.ex. mellanslag, tabbar, nya rader och andra specialtecken: `{ } ( ) [ ] ' ` " \ / > < | ; ! # & ^ * % @ $` Om du vill separera ord i ett namn är punkt, bindestreck och understreck bra val. Du kan också skriva varje ord med stor bokstav, "`LikeThis`". Erfarna Linux-användare brukar undvika mellanslag i filnamn.

| Notera
Ordet "root" kan betyda antingen "root user" eller "root directory". Det bör framgå av sammanhanget där de används.

| Notera
Ordet path används inte bara för fullt kvalificerade filnamn enligt ovan utan även för kommandots sökväg. Den avsedda betydelsen framgår vanligtvis tydligt av sammanhanget.

Detaljerad bästa praxis för filhierarkin beskrivs i Filesystem Hierarchy Standard ( "`/usr/share/doc/debian-policy/fhs/fhs-2.3.txt.gz`" och hier(7)). Du bör komma ihåg följande fakta som start.

Tabell 1.3. Lista över användning av nyckelkataloger

katalog | användning av katalogen
--- | ---
`/` | rotkatalogen
`/etc/` | systemövergripande konfigurationsfiler
`/var/log/` | systemets loggfiler
`/home/` | alla hemkataloger för alla icke-privilegierade användare

### 1.2.2. Internt i filsystemet

I enlighet med Unix-traditionen tillhandahåller Debian GNU/Linux-systemet det filsystem under vilket fysiska data på hårddiskar och andra lagringsenheter finns, och interaktionen med hårdvaruenheter som konsolskärmar och seriella fjärrkonsoler representeras på ett enhetligt sätt under "`/dev/`".

Varje fil, katalog, named pipe (ett sätt för två program att dela data) eller fysisk enhet på ett Debian GNU/Linux-system har en datastruktur som kallas inode som beskriver dess associerade attribut, t.ex. användaren som äger den (owner), gruppen som den tillhör, tidpunkten för senaste åtkomst osv. Idén att representera nästan allt i filsystemet var en Unix-innovation, och moderna Linux-kärnor har utvecklat denna idé ännu mer. Nu kan till och med information om processer som körs i datorn hittas i filsystemet.

Denna abstrakta och enhetliga representation av fysiska enheter och interna processer är mycket kraftfull eftersom den gör det möjligt för oss att använda samma kommando för samma typ av operation på många helt olika enheter. Det är till och med möjligt att ändra hur kärnan fungerar genom att skriva data till speciella filer som är kopplade till pågående processer.

| Tips
Om du behöver identifiera korrespondensen mellan filträdet och den fysiska enheten, kör mount(8) utan argument.

### 1.2.3. Behörigheter i filsystemet

Filsystembehörigheter för Unix-liknande system definieras för tre kategorier av berörda användare.

- Användaren som äger filen(u)

- Andra användare i den grupp som filen tillhör(g)

- Alla andra användare(o) även kallad "världen" och "alla"

För filen tillåter varje motsvarande behörighet följande åtgärder.

- Behörigheten read(r) ger ägaren rätt att undersöka innehållet i filen.

- Skrivrättigheten(w) ger ägaren rätt att ändra filen.

- Behörigheten execute(x) ger ägaren rätt att köra filen som ett kommando.

För katalogen tillåter varje motsvarande behörighet följande åtgärder.

- Behörigheten read(r) tillåter ägaren att lista innehållet i katalogen.

- Skrivrättigheten(w) ger ägaren rätt att lägga till eller ta bort filer i katalogen.

- Behörigheten execute(x) ger ägaren åtkomst till filer i katalogen.

Här innebär exekveringsbehörigheten för en katalog inte bara att man får läsa filer i katalogen utan också att man får visa deras attribut, t.ex. storlek och ändringstid.

ls(1) används för att visa behörighetsinformation (med mera) för filer och kataloger. När den anropas med alternativet "`-l`" visas följande information i den ordning som anges.

- Typ av fil (första tecknet)

- Åtkomstbehörighet för filen (nio tecken, bestående av tre tecken vardera för användare, grupp och annan i denna ordning)

- Antal hårda länkar till filen

- Namnet på den användare som äger filen

- Namnet på den grupp som filen tillhör

- Filens storlek i tecken (bytes)

- Datum och tid för filen (mtime)

- Filens namn

Tabell 1.4. Lista över det första tecknet i "`ls -l`"-utdata

tecken | betydelse
--- | ---
`-` | normal fil
`d` | katalog
`l` | symlänk
`c` | tecken enhet nod
`b` | block enhet nod
`p` | namngivet rör
`s` | uttag

chown(1) används från rotkontot för att ändra filens ägare. chgrp(1) används från filens ägare eller rotkontot för att ändra filens grupp. chmod(1) används från filens ägare eller rotkontot för att ändra fil- och katalogåtkomstbehörigheter. Grundläggande syntax för att manipulera en `foo-fil` är följande.

    # chown newowner foo
    # chgrp newgroup foo
    # chmod  [ugoa][+-=][rwxXst][,...] foo

Du kan t.ex. skapa ett katalogträd som ägs av användaren `foo` och delas av gruppen `bar på` följande sätt.

    # cd /some/location/
    # chown -R foo:bar .
    # chmod -R ug+rwX,o=rX .

Det finns ytterligare tre speciella behörighetsbitar.

- Den inställda användar-ID-biten(s eller S istället för användarens x)

- Den inställda grupp-ID-biten(s eller S istället för gruppens x)

- Den kladdiga biten(t eller T istället för andras x)

Här skrivs utdata från "`ls -l`" för dessa bitar med stor bokstav om exekveringsbitar som döljs av dessa utdata är avaktiverade.

Om du anger set user ID för en körbar fil kan en användare köra den körbara filen med filens ägar-ID (t.ex. root). På samma sätt gör inställningen set group ID för en körbar fil att en användare kan köra den körbara filen med filens grupp-ID (t.ex. root). Eftersom dessa inställningar kan medföra säkerhetsrisker bör du vara extra försiktig när du aktiverar dem.

Om du anger set group ID för en katalog kan du använda BSD-liknande filskapande där alla filer som skapas i katalogen tillhör katalogens grupp.

Genom att ställa in sticky bit på en katalog förhindras att en fil i katalogen tas bort av en användare som inte är ägare till filen. För att säkra innehållet i en fil i kataloger som kan skrivas av alla, såsom ”`/tmp`”, eller i kataloger som kan skrivas av gruppen, måste man inte bara återställa skriv-behörigheten för filen utan också ställa in sticky bit på katalogen. Annars kan filen tas bort och en ny fil med samma namn skapas av vilken användare som helst som har skrivbehörighet till katalogen.

Här är några intressanta exempel på filbehörigheter.

    $ ls -l /etc/passwd /etc/shadow /dev/ppp /usr/sbin/exim4
    crw------T 1 root root   108, 0 Oct 16 20:57 /dev/ppp
    -rw-r--r-- 1 root root     2761 Aug 30 10:38 /etc/passwd
    -rw-r----- 1 root shadow   1695 Aug 30 10:38 /etc/shadow
    -rwsr-xr-x 1 root root   973824 Sep 23 20:04 /usr/sbin/exim4
    $ ls -ld /tmp /var/tmp /usr/local /var/mail /usr/src
    drwxrwxrwt 14 root root  20480 Oct 16 21:25 /tmp
    drwxrwsr-x 10 root staff  4096 Sep 29 22:50 /usr/local
    drwxr-xr-x 10 root root   4096 Oct 11 00:28 /usr/src
    drwxrwsr-x  2 root mail   4096 Oct 15 21:40 /var/mail
    drwxrwxrwt  3 root root   4096 Oct 16 21:20 /var/tmp

Det finns ett alternativt numeriskt läge för att beskriva filbehörigheter med chmod(1). Detta numeriska läge använder 3- till 4-siffriga breda oktala (radix=8) tal.

Tabell 1.5. Det numeriska läget för filbehörigheter i chmod(1)-kommandon

tecken | betydelse
--- | ---
1:a valfria siffran | summan av inställt användar-ID (=4), inställt grupp-ID (=2) och sticky bit (=1)
2:a siffran | summan av behörigheterna läsa (=4), skriva (=2) och köra (=1) för användaren
3:e siffran | dito för gruppen
4:e siffran | dito för övriga

Det här låter komplicerat men är faktiskt ganska enkelt. Om du tittar på de första kolumnerna (2-10) i kommandoutmatningen från "`ls -l`" och läser dem som en binär (radix=2) representation av filbehörigheter ("-" är "0" och "rwx" är "1"), bör de sista 3 siffrorna i det numeriska lägesvärdet vara begripliga som en oktal (radix=8) representation av filbehörigheter för dig.

Försök till exempel med följande

    $ touch foo bar
    $ chmod u=rw,go=r foo
    $ chmod 644 bar
    $ ls -l foo bar
    -rw-r--r-- 1 penguin penguin 0 Oct 16 21:39 bar
    -rw-r--r-- 1 penguin penguin 0 Oct 16 21:35 foo

| Tips
Om du behöver komma åt information som visas av "`ls -l`" i ett skalskript, bör du använda relevanta kommandon som test(1), stat(1) och readlink(1). Skalets inbyggda kommandon som "`[`" eller "`test`" kan också användas.

### 1.2.4. Kontroll av behörigheter för nyskapade filer: umask

Vilka behörigheter som tillämpas på en nyskapad fil eller katalog begränsas av det inbyggda kommandot `umask` i skalet. Se dash(1), bash(1) och builtins(7).

     (file permissions) = (requested file permissions) & ~(umask value)

Tabell 1.6. Exempel på umask-värde

umask | filbehörigheter skapade | katalogbehörigheter skapade | användning
--- | --- | --- | ---
`0022` | `-rw-r--r--` | `-rwxr-xr-x` | skrivbar endast av användaren
`0002` | `-rw-rw-r--` | `-rwxrwxr-x` | skrivbar av gruppen

Debian-systemet använder ett UPG-system (User Private Group) som standard. En UPG skapas varje gång en ny användare läggs till i systemet. En UPG har samma namn som den användare för vilken den skapades och den användaren är den enda medlemmen i UPG. UPG-systemet gör det säkert att sätta umask till `0002` eftersom varje användare har sin egen privata grupp. (I vissa Unix-varianter är det ganska vanligt att alla normala användare tillhör en enda `användare` grupp och det är en bra idé att sätta umask till `0022` för säkerhets skull i sådana fall)

| Tips
Aktivera UPG genom att lägga till "`umask 002`" i filen `~/.bashrc`.

### 1.2.5. Behörigheter för grupper av användare (group)

| Varning
Se till att spara osparade ändringar innan du startar om eller gör liknande åtgärder.

Du kan lägga till en `användarpingvin` till en `gruppfågel` i två steg:

- Ändra gruppkonfigurationen med hjälp av något av följande:

  - Kör "`sudo usermod -aG bird penguin`".

  - Utför "`sudo adduser penguin bird`". (endast på typiska Debian-system)

  - Kör "`sudo vigr`" för `/etc/group` och "`sudo vigr -s`" för `/etc/gshadow` för att lägga till `penguin` i raden för `bird`.

- Tillämpa konfigurationen med hjälp av något av följande:

  - Kall omstart och inloggning. (Bästa alternativet)

  - Logga ut via GUI-menyn och logga in. (Detta kanske inte fungerar i den moderna skrivbordsmiljön.)

Du kan ta bort en `användarpingvin` från en `gruppfågel` i två steg:

- Ändra gruppkonfigurationen med hjälp av något av följande:

  - Kör "`sudo usermod -rG bird penguin`".

  - Utför "`sudo deluser penguin bird`". (endast på typiska Debian-system)

  - Kör "`sudo vigr`" för `/etc/group` och "`sudo vigr -s`" för `/etc/gshadow` för att ta bort `penguin` i raden för `bird`.

- Tillämpa konfigurationen med hjälp av något av följande:

  - Kall omstart och inloggning. (Bästa alternativet)

  - Kör "`kill -TERM -1`" och gör några korrigeringsåtgärder, t.ex. "`systemctl restart NetworkManager.service`".

  - Logga ut via GUI-menyn är inte ett alternativ för Gnome Desktop.

Alla försök till varm omstart är bräckliga ersättningar för den riktiga kalla omstarten under det moderna skrivbordssystemet.

| Notera
Alternativt kan du dynamiskt lägga till användare i grupper under autentiseringsprocessen genom att lägga till raden "`auth optional pam_group.so`" i "`/etc/pam.d/common-auth`" och ställa in "`/etc/security/group.conf`". (Se Kapitel 4, Autentisering och åtkomstkontroll.)

The hardware devices are just another kind of file on the Debian system. If you have problems accessing devices such as USB flash drive and CD-ROM from a user account, you should make that user a member of the relevant group.

Vissa grupper som tillhandahålls av systemet gör det möjligt för medlemmarna att komma åt vissa filer och enheter utan `root-behörighet`.

Tabell 1.7. Lista över viktiga systemtillgängliga grupper för filåtkomst

grupp | beskrivning för tillgängliga filer och enheter
--- | ---
`dialout` | full och direkt tillgång till serieportar ( "`/dev/ttyS[0-3]`")
`dip` | begränsad tillgång till serieportar för uppringd IP-anslutning till betrodda motparter
`cdrom` | CD-ROM, DVD+/-RW-enheter
`audio` | ljud enhet
`video` | video enhet
`scanner` | skanner(s)
`adm` | loggar för systemövervakning
`staff` | några kataloger för mindre administrativt arbete: "`/usr/local`", "`/home`"

| Tips
Du måste tillhöra `dialout`-gruppen för att konfigurera om modemet, ringa upp var som helst osv. Men om `root` skapar fördefinierade konfigurationsfiler för betrodda peers i "`/etc/ppp/peers/`" behöver du bara tillhöra `dip`-gruppen för att skapa en uppringd IP-anslutning till dessa betrodda peers med kommandona pppd(8), pon(1) och poff(1).

Vissa grupper som tillhandahålls av systemet gör det möjligt för medlemmarna att utföra vissa kommandon utan `root-behörighet`.

Tabell 1.8. Lista över anmärkningsvärda systemlevererade grupper för särskilda kommandoexekveringar

grupp | tillgängliga kommandon
--- | ---
`sudo` | kör valfritt kommando med superuser-behörighet
`lpadmin` | utföra kommandon för att lägga till, ändra och ta bort skrivare från skrivardatabaser

En fullständig lista över användare och grupper som tillhandahålls av systemet finns i den senaste versionen av dokumentet "Användar och grupper" i "`/usr/share/doc/base-passwd/users-and-groups.html`" som tillhandahålls av paketet `base-passwd`.

Se passwd(5), group(5), shadow(5), newgrp(1), vipw(8), vigr(8) och pam_group(8) för kommandon för hantering av användar- och gruppsystemet.

### 1.2.6. Tidsstämplar

Det finns tre typer av tidsstämplar för en GNU/Linux-fil.

Tabell 1.9. Lista över olika typer av tidsstämplar

typ | betydelse (historisk Unix-definition)
--- | ---
mtime | filens modifieringstid`(ls -l)`
ctime | tid för ändring av filstatus`(ls -lc)`
atime | den senaste tiden för filåtkomst`(ls -lu)`

| Notera
ctime är inte filens skapelsetid.

| Notera
Det faktiska värdet på atime i GNU/Linux-system kan skilja sig från det i den historiska Unix-definitionen.

- Om du skriver över en fil ändras alla attribut mtime, ctime och atime för filen.

- Om du ändrar ägarskap eller behörighet för en fil ändras filens attribut ctime och atime.

- När du läser en fil ändras filens atime-attribut i det historiska Unix-systemet.

- Läsning av en fil ändrar atime-attributet för filen på GNU/Linux-systemet om dess filsystem är monterat med "`strictatime`".

- Om du läser en fil för första gången eller efter en dag ändras filens atime-attribut på GNU/Linux-systemet om filsystemet är monterat med "`relatime`". (standardbeteende sedan Linux 2.6.30)

- Läsning av en fil ändrar inte atime-attributet för filen på GNU/Linux-systemet om filsystemet är monterat med "`noatime`".

| Notera
Monteringsalternativen "`noatime`" och "`relatime`" införs för att förbättra filsystemets läsprestanda i normala användningsfall. Enkel filläsning med alternativet "`strictatime`" åtföljs av en tidskrävande skrivoperation för att uppdatera atime-attributet. Men atime-attributet används sällan förutom för filen mbox(5). Se mount(8).

Använd kommandot touch(1) för att ändra tidsstämplar för befintliga filer.

För tidsstämplar skriver kommandot `ls` ut lokaliserade strängar under icke-engelsk locale ( "`fr_FR.UTF-8`").

    $ LANG=C  ls -l foo
    -rw-rw-r-- 1 penguin penguin 0 Oct 16 21:35 foo
    $ LANG=en_US.UTF-8  ls -l foo
    -rw-rw-r-- 1 penguin penguin 0 Oct 16 21:35 foo
    $ LANG=fr_FR.UTF-8  ls -l foo
    -rw-rw-r-- 1 penguin penguin 0 oct. 16 21:35 foo

| Tips
Se Avsnitt 9.3.4, ”Anpassad visning av tid och datum” för att anpassa utdata från "`ls -l`".

### 1.2.7. Länkar

Det finns två metoder för att associera en fil "`foo`" med ett annat filnamn "`bar`".

- Hård länk

  - Duplicerat namn för en befintlig fil

  - "`ln foo bar`"

- Symbolisk länk eller symlänk

  - Särskild fil som pekar på en annan fil med namn

  - "`ln -s foo bar`"

Se följande exempel för förändringar i länkantal och de subtila skillnaderna i resultatet av kommandot `rm`.

    $ umask 002
    $ echo "Original Content" > foo
    $ ls -li foo
    1449840 -rw-rw-r-- 1 penguin penguin 17 Oct 16 21:42 foo
    $ ln foo bar     # hard link
    $ ln -s foo baz  # symlink
    $ ls -li foo bar baz
    1449840 -rw-rw-r-- 2 penguin penguin 17 Oct 16 21:42 bar
    1450180 lrwxrwxrwx 1 penguin penguin  3 Oct 16 21:47 baz -> foo
    1449840 -rw-rw-r-- 2 penguin penguin 17 Oct 16 21:42 foo
    $ rm foo
    $ echo "New Content" > foo
    $ ls -li foo bar baz
    1449840 -rw-rw-r-- 1 penguin penguin 17 Oct 16 21:42 bar
    1450180 lrwxrwxrwx 1 penguin penguin  3 Oct 16 21:47 baz -> foo
    1450183 -rw-rw-r-- 1 penguin penguin 12 Oct 16 21:48 foo
    $ cat bar
    Original Content
    $ cat baz
    New Content

Den hårda länken kan göras inom samma filsystem och delar samma inodnummer som alternativet "`-i`" med ls(1) avslöjar.

Symlänken har alltid den nominella filåtkomstbehörigheten "`rwxrwxrwx`", som visas i exemplet ovan, medan den faktiska åtkomstbehörigheten bestäms av behörigheten för den fil som den pekar på.

| Observera
Det är i allmänhet en bra idé att inte skapa komplicerade symboliska länkar eller hårda länkar alls om du inte har en mycket god anledning. Det kan orsaka mardrömmar där den logiska kombinationen av de symboliska länkarna resulterar i loopar i filsystemet.

| Notera
Det är i allmänhet att föredra att använda symboliska länkar framför hårda länkar, såvida du inte har ett gott skäl att använda en hård länk.

Katalogen "`.`.." länkar till den katalog den finns i, vilket innebär att länkantalet för en ny katalog börjar på 2. Katalogen "`.`.." länkar till den överordnade katalogen, vilket innebär att katalogens länkantal ökar när nya underkataloger läggs till.

Om du precis har gått över till Linux från Windows blir det snart tydligt hur väl utformad Unix filnamnslänkning är, jämfört med Windows närmaste motsvarighet till "genvägar". Eftersom det är implementerat i filsystemet kan applikationer inte se någon skillnad mellan en länkad fil och originalet. När det gäller hårda länkar är det verkligen ingen skillnad.

### 1.2.8. Namngivna pipes (FIFO)

En named pipe är en fil som fungerar som ett rör. Du lägger in något i filen och det kommer ut i andra änden. Därför kallas det FIFO, eller First-In-First-Out: det första du stoppar in i röret är det första som kommer ut i andra änden.

Om du skriver till en namngiven pipe avslutas inte den process som skriver till pipen förrän den information som skrivs har lästs från pipen. Om du läser från en namngiven pipe väntar läsprocessen tills det inte finns något att läsa innan den avslutas. Storleken på pipen är alltid noll --- den lagrar inte data, den länkar bara samman två processer på samma sätt som skalets "`|`"-syntax. Men eftersom pipen har ett namn behöver de två processerna inte finnas på samma kommandorad eller ens köras av samma användare. Pipes var en mycket inflytelserik innovation inom Unix.

Försök till exempel med följande

    $ cd; mkfifo mypipe
    $ echo "hello" >mypipe & # put into background
    [1] 8022
    $ ls -l mypipe
    prw-rw-r-- 1 penguin penguin 0 Oct 16 21:49 mypipe
    $ cat mypipe
    hello
    [1]+  Done                    echo "hello" >mypipe
    $ ls mypipe
    mypipe
    $ rm mypipe

### 1.2.9. Uttag

Uttag används i stor utsträckning av all Internetkommunikation, databaser och själva operativsystemet. Den liknar named pipe (FIFO) och gör det möjligt för processer att utbyta information även mellan olika datorer. För ett uttag behöver dessa processer inte köras samtidigt eller köras som barn till samma förfadersprocess. Detta är slutpunkten för interprocesskommunikation (IPC). Informationsutbytet kan ske över nätverket mellan olika värdar. De två vanligaste är Internet-uttaget och Unix-domän-uttaget.

| Tips
"`ss -t -u -a`" (from the `iproute2` package) provides a very useful overview of sockets that are open on a given system.

### 1.2.10. Enhetsfiler

Enhetsfiler hänvisar till fysiska eller virtuella enheter i systemet, t.ex. hårddisk, grafikkort, skärm eller tangentbord. Ett exempel på en virtuell enhet är konsolen, som representeras av "`/dev/console`".

Det finns 2 typer av enhetsfiler.

- Teckenenhet

  - Åtkomst till ett tecken i taget

  - 1 tecken = 1 byte

  - T.ex. tangentbordsenhet, serieport, …

- Blockenhet

  - nås i större enheter som kallas block

  - 1 block > 1 byte

  - T.ex. hårddisk, …

Du kan läsa och skriva enhetsfiler, även om filen mycket väl kan innehålla binär data som kan vara en obegriplig rappakalja för människor. Att skriva data direkt till dessa filer är ibland användbart för felsökning av maskinvaruanslutningar. Du kan t.ex. dumpa en textfil till skrivarenheten "`/dev/lp0`" eller skicka modemkommandon till lämplig serieport "`/dev/ttyS0`". Men om detta inte görs noggrant kan det orsaka en stor katastrof. Så var försiktig.

| Notera
För normal åtkomst till en skrivare använder du lp(1).

Enhetens nodnummer visas genom att köra ls(1) på följande sätt.

    $ ls -l /dev/sda /dev/sr0 /dev/ttyS0 /dev/zero
    brw-rw---T  1 root disk     8,  0 Oct 16 20:57 /dev/sda
    brw-rw---T+ 1 root cdrom   11,  0 Oct 16 21:53 /dev/sr0
    crw-rw---T  1 root dialout  4, 64 Oct 16 20:57 /dev/ttyS0
    crw-rw-rw-  1 root root     1,  5 Oct 16 20:57 /dev/zero

- "`/dev/sda`" har det större enhetsnumret 8 och det mindre enhetsnumret 0. Detta är läs-/skrivåtkomligt för användare som tillhör `diskgruppen`.

- "`/dev/sr0`" har det stora enhetsnumret 11 och det lilla enhetsnumret 0. Den är läs/skriv-åtkomlig för användare som tillhör `cdrom-gruppen`.

- "`/dev/ttyS0`" har det större enhetsnumret 4 och det mindre enhetsnumret 64. Detta är läs-/skrivåtkomligt för användare som tillhör `dialout-gruppen`.

- "`/dev/zero`" har det större enhetsnumret 1 och det mindre enhetsnumret 5. Detta är läs-/skrivåtkomligt för alla.

På ett modernt Linux-system fylls filsystemet under "`/dev/`" automatiskt av udev(7)-mekanismen.

### 1.2.11. Särskilda enhetsfiler

Det finns några speciella enhetsfiler.

Tabell 1.10. Lista över speciella enhetsfiler

enhetsfil | åtgärd | beskrivning av svar
--- | --- | ---
`/dev/null` | läs | return "tecken för slutet av filen (EOF)"
`/dev/null` | skriv | returnera ingenting (en bottenlös datadumpningsgrop)
`/dev/zero` | läs | returnera "tecknet `\0` (NUL)" (inte samma som siffran noll ASCII)
`/dev/random` | läs | returnera slumpmässiga tecken från en riktig slumptalsgenerator, vilket ger verklig entropi (långsamt)
`/dev/urandom` | läs | returnera slumpmässiga tecken från en kryptografiskt säker pseudorandomtalsgenerator
`/dev/full` | skriv | returnera felet disk full (ENOSPC)

Dessa används ofta i samband med shell-omdirigering (se Avsnitt 1.5.8, ”Typiska kommandosekvenser och omdirigering av skal”).

### 1.2.12. procfs och sysfs

Procfs och sysfs som är monterade på "`/proc`" och "`/sys`" är pseudofilsystem och exponerar interna datastrukturer i kärnan för användarutrymmet. Med andra ord är dessa poster virtuella, vilket innebär att de fungerar som ett bekvämt fönster in i operativsystemets funktion.

Katalogen "`/proc`" innehåller (bland annat) en underkatalog för varje process som körs i systemet och som har fått sitt namn efter process-ID (PID). Systemverktyg som hämtar information om processer, t.ex. ps(1), hämtar sin information från denna katalogstruktur.

Katalogerna under "`/proc/sys/`" innehåller gränssnitt för att ändra vissa kärnparametrar under körning. (Du kan göra samma sak genom det specialiserade sysctl(8)-kommandot eller dess förladdnings-/konfigurationsfil "`/etc/sysctl.d/*.conf`")

Många får panik när de upptäcker en fil - "`/proc/kcore`" - som i allmänhet är enorm. Det här är (mer eller mindre) en kopia av innehållet i datorns minne. Den används för att felsöka kärnan. Det är en virtuell fil som pekar på datorminnet, så oroa dig inte för dess storlek.

Katalogen under "`/sys`" innehåller exporterade datastrukturer för kärnan, deras attribut och länkarna mellan dem. Den innehåller också gränssnitt för att ändra vissa kärnparametrar under körning.

Se "`proc.txt(.gz`)", "`sysfs.txt(.gz`)" och andra relaterade dokument i dokumentationen för Linux-kärnan ("`/usr/share/doc/linux-doc-*/Documentation/filesystems/*`") som tillhandahålls av paketet `linux-doc-*`.

### 1.2.13. tmpfs

Tmpfs är ett temporärt filsystem som förvarar alla filer i det virtuella minnet. Data från tmpfs i sidcachen i minnet kan vid behov swappas ut till swaputrymmet på disken.

Katalogen "`/run`" monteras som tmpfs i den tidiga uppstartsprocessen. Detta gör det möjligt att skriva till den även när katalogen "`/`" är monterad som skrivskyddad. Detta är den nya platsen för lagring av transienta tillståndsfiler och ersätter flera platser som beskrivs i Filesystem Hierarchy Standard version 2.3:

- "`/var/run`" → "`/run`"

- "`/var/lock`" → "`/run/lock`"

- "`/dev/shm`" → "`/run/shm`"

Se "`tmpfs.txt(.gz`)" i dokumentationen för Linux-kärnan ( "`/usr/share/doc/linux-doc-*/Documentation/filesystems/*`") som tillhandahålls av paketet `linux-doc-*`.

## 1.3. Midnight Commander (MC)

Midnight Commander (MC) är en "schweizisk armékniv" från GNU för Linux-konsolen och andra terminalmiljöer. Detta ger nybörjare en menystyrd konsolupplevelse som är mycket lättare att lära sig än standard Unix-kommandon.

Du kan behöva installera Midnight Commander-paketet som heter "`mc`" enligt följande.

    $ sudo apt-get install mc

Använd kommandot mc(1) för att utforska Debian-systemet. Detta är det bästa sättet att lära sig. Utforska några intressanta platser bara med hjälp av markörknapparna och Enter-tangenten.

- "`/etc`" och dess underkataloger

- "`/var/log`" och dess underkataloger

- "`/usr/share/doc`" och dess underkataloger

- "`/usr/sbin`" och "`/usr/bin`"

### 1.3.1. Anpassning av MC

För att få MC att byta arbetskatalog vid avslutning och `cd` till katalogen föreslår jag att du ändrar "`~/.bashrc`" så att det innehåller ett skript som tillhandahålls av `mc-paketet`.

    . /usr/lib/mc/mc.sh

Se mc(1) (under alternativet "`-P`") för anledningen. (Om du inte förstår exakt vad jag menar här, kan du göra det senare)

### 1.3.2. Starta MC

MC kan startas på följande sätt.

    $ mc

MC sköter alla filoperationer via menyn, vilket kräver minimal ansträngning av användaren. Tryck bara på F1 för att komma till hjälpskärmen. Du kan leka med MC genom att trycka på markör- och funktionsknappar.

| Notera
I vissa konsoler, t.ex. gnome-terminal(1), kan tangenttryckningar på funktionstangenter stjälas av konsolprogrammet. Du kan inaktivera dessa funktioner i menyn "Inställningar" → "Allmänt" och "Genvägar" för `gnome-terminal`.

Om du stöter på problem med teckenkodning som visar skräptecken kan du lägga till "`-a`" på MC:s kommandorad för att förhindra problem.

Om detta inte löser dina problem med MC-displayen, se Avsnitt 8.3.1, ”Terminalens konfiguration”.

### 1.3.3. Filhanterare i MC

Standard är två katalogpaneler som innehåller fillistor. Ett annat användbart läge är att ställa in det högra fönstret på "information" för att se information om filåtkomsträttigheter etc. Nedan följer några viktiga tangenttryckningar. När daemon gpm(8) körs kan man även använda musen på Linux teckenkonsoler. (Se till att trycka på shift-tangenten för att få det normala beteendet för klipp och klistra i MC)

Tabell 1.11. De viktigaste bindningarna för MC

nyckel | nyckelbindning
--- | ---
`F1` | hjälp meny
`F3` | intern filvisare
`F4` | intern redaktör
`F9` | aktivera rullgardinsmeny
`F10` | avsluta Midnight Commander
`Tab` | flytta mellan två fönster
`Insert` eller `Ctrl-T` | markera fil för en operation med flera filer, t.ex. kopiering
`Del` | radera fil (var försiktig - ställ in MC till säkert raderingsläge)
Piltangenter | självförklarande

### 1.3.4. Trix på kommandoraden i MC

- `cd-kommandot` ändrar den katalog som visas på den valda skärmen.

- `Ctrl-Enter` eller `Alt-Enter` kopierar ett filnamn till kommandoraden. Använd detta med kommandona cp(1) och mv(1) tillsammans med kommandoradsredigering.

- `Alt-Tab` visar valmöjligheter för filnamnsexpansion i skalet.

- Man kan ange startkatalogen för båda fönstren som argument till MC, t.ex. "`mc /etc /root`".

- `Esc` + `n-nyckel` → `Fn` (d.v.s. `Esc` + `1` → `F1`, etc.; `Esc` + `0` → `F10`)

- Om du trycker på `Esc` före tangenten får du samma effekt som om du trycker på `Alt` och tangenten samtidigt, t.ex. skriv `Esc` + `c` för `Alt-C`. `Esc` kallas metatangent och skrivs ibland som "`M-`".

### 1.3.5. Den interna redaktören i MC

Den interna editorn har ett intressant klipp-och-klistra-system. Genom att trycka på `F3` markeras början av ett urval, ett andra `F3` markerar slutet av urvalet och markerar urvalet. Sedan kan du flytta markören. Om du trycker på F6 flyttas det markerade området till markörens plats. Om du trycker på F5 kopieras det markerade området och infogas på markörens plats. `F2` sparar filen. `F10` tar dig ut ur programmet. De flesta markörknappar fungerar intuitivt.

Denna editor kan startas direkt på en fil med hjälp av något av följande kommandon.

    $ mc -e filename_to_edit

    $ mcedit filename_to_edit

Detta är inte en editor för flera fönster, men man kan använda flera Linux-konsoler för att uppnå samma effekt. För att kopiera mellan fönster använder du Alt-Fn-tangenterna för att växla mellan virtuella konsoler och använder "File→Insert file" eller "File→Copy to file" för att flytta en del av en fil till en annan fil.

Denna interna editor kan ersättas med valfri extern editor.

Många program använder också miljövariablerna "`$EDITOR`" eller "`$VISUAL`" för att bestämma vilken editor som ska användas. Om du inte känner dig bekväm med vim(1) eller nano(1) från början kan du ställa in dessa till "`mcedit`" genom att lägga till följande rader i "`~/.bashrc`".

    export EDITOR=mcedit
    export VISUAL=mcedit

Jag rekommenderar att du ställer in dessa på "`vim`" om möjligt.

Om du inte känner dig bekväm med vim(1) kan du fortsätta att använda mcedit(1) för de flesta systemunderhållsuppgifter.

### 1.3.6. Den interna tittaren i MC

MC är en mycket smart viewer. Detta är ett utmärkt verktyg för att söka efter ord i dokument. Jag använder det alltid för filer i katalogen "`/usr/share/doc`". Det här är det snabbaste sättet att bläddra igenom massor av Linux-information. Den här visaren kan startas direkt med något av följande kommandon.

    $ mc -v path/to/filename_to_view

    $ mcview path/to/filename_to_view

### 1.3.7. Funktioner för automatisk start av MC

Tryck på Enter i en fil, så hanterar lämpligt program innehållet i filen (se Avsnitt 9.4.11, ”Anpassning av program som ska startas”). Detta är en mycket praktisk MC-funktion.

Tabell 1.12. Reaktionen på enter-tangenten i MC

filtyp | reaktion på enter-tangenten
--- | ---
exekverbar fil | exekvera kommando
huvudfil | rörinnehåll till visningsprogramvara
html fil | rörinnehåll till webbläsare
"`*.tar.gz`" och "`*.deb`" fil | bläddra i dess innehåll som i en underkatalog

För att dessa funktioner för visare och virtuella filer ska fungera bör visningsbara filer inte ställas in som körbara. Ändra deras status med hjälp av chmod(1) eller via MC-filmenyn.

### 1.3.8. Virtuellt filsystem för MC

MC kan användas för att komma åt filer via Internet. Gå till menyn genom att trycka på `F9`, "`Enter`" och "`h`" för att aktivera filsystemet Shell. Ange en URL i formen "`sh://[user@]machine[:options]/[remote-dir]`", som hämtar en fjärrkatalog som ser ut som en lokal katalog med hjälp av `ssh`.

## 1.4. Den grundläggande Unix-liknande arbetsmiljön

Även om du kan göra nästan allt med MC är det mycket viktigt att du lär dig att använda kommandoradsverktygen från skalprompten och blir bekant med den Unix-liknande arbetsmiljön.

### 1.4.1. Inloggningsskal

Eftersom inloggningsskalet kan användas av vissa systeminitialiseringsprogram är det klokt att behålla det som bash(1) och undvika att byta inloggningsskal med chsh(1).

Om du vill använda en annan interaktiv shell-prompt kan du ställa in den i GUI-terminalemulatorns konfiguration eller starta den från `~/.bashrc`, t.ex. genom att placera "`exec /usr/bin/zsh -i -`l" eller "`exec /usr/bin/fish -i -l`" i den.

Tabell 1.13. Lista över skalprogram

paket | popcon | storlek | POSIX skal | beskrivning
--- | --- | --- | --- | ---
`bash` | V:893, I:1000 | 7309 | Ja | Bash: GNU Bourne Again SHell (de facto-standard)
`bash-completion` | V:37, I:960 | 1952 | N/A | programmerbar komplettering för bash-skalet
`dash` | V:928, I:998 | 207 | Ja | Debian Almquist Shell, bra för shell-skript
`zsh` | V:41, I:70 | 2571 | Ja | Z-skal: standardskalet med många förbättringar
`tcsh` | V:4, I:15 | 1366 | Nej | TENEX C Shell: en förbättrad version av Berkeley csh
`mksh` | V:5.6, I:8.0 | 7713 | Ja | En version av Korn-skalet
`csh` | V:1.1, I:5.1 | 348 | Nej | OpenBSD C Shell, en version av Berkeley csh
`sash` | V:0.3, I:5.1 | 1245 | Ja | Fristående skal med inbyggda kommandon (inte avsett för standard "`/usr/bin/sh`")
`ksh` | V:0.3, I:7.7 | 65 | Ja | den riktiga AT&T-versionen av Korn-skalet
`rc` | V:0.09, I:0.77 | 182 | Nej | implementering av AT&T Plan 9 rc-skal
`posh` | V:0.00, I:0.23 | 195 | Ja | Policyanpassad ordinär SHell`(pdksh-derivat)`

| Tips
Även om POSIX-liknande skal delar den grundläggande syntaxen kan de skilja sig åt i beteendet för så grundläggande saker som skalvariabler och glob-expansioner. Kontrollera deras dokumentation för detaljer.

I det här handledningskapitlet betyder det interaktiva skalet alltid `bash`.

### 1.4.2. Anpassa bash

Du kan anpassa bash(1)-beteendet genom "`~/.bashrc`".

Försök till exempel med följande.

    # enable bash-completion
    if ! shopt -oq posix; then
      if [ -f /usr/share/bash-completion/bash_completion ]; then
        . /usr/share/bash-completion/bash_completion
      elif [ -f /etc/bash_completion ]; then
        . /etc/bash_completion
      fi
    fi

    # CD upon exiting MC
    . /usr/lib/mc/mc.sh

    # set CDPATH to a good one
    CDPATH=.:/usr/share/doc:~:~/Desktop:~
    export CDPATH

    PATH="${PATH+$PATH:}/usr/sbin:/sbin"
    # set PATH so it includes user's private bin if it exists
    if [ -d ~/bin ] ; then
      PATH="~/bin${PATH+:$PATH}"
    fi
    export PATH

    EDITOR=vim
    export EDITOR

| Tips
Du kan hitta fler tips för anpassning av `bash`, till exempel Avsnitt 9.3.6, ”Färgade kommandon”, i Kapitel 9, Tips för systemet.

| Tips
Paketet `bash-completion` möjliggör programmerbar komplettering för `bash`.

### 1.4.3. Särskilda tangenttryckningar

I den Unix-liknande miljön finns det några tangenttryckningar som har speciella betydelser. Observera att på en normal Linux-teckenkonsol är det bara de vänstra tangenterna `Ctrl` och `Alt` som fungerar som förväntat. Här är några viktiga tangenttryckningar att komma ihåg.

Tabell 1.14. Lista över tangentbindningar för bash

nyckel | beskrivning av nyckelbindning
--- | ---
`Ctrl-U` | radera raden före markören
`Ctrl-H` | radera ett tecken före markören
`Ctrl-D` | avsluta inmatning (avsluta shell om du använder shell)
`Ctrl-C` | avsluta ett pågående program
`Ctrl-Z` | tillfälligt stoppa programmet genom att flytta det till bakgrundsjobbet
`Ctrl-S` | stoppa utmatningen till skärmen
`Ctrl-Q` | återaktivera utmatning till skärm
`Ctrl-Alt-Del` | starta om/halta upp systemet, se inittab(5)
`Vänster-Alt-tangent` (valfritt, `Windows-tangent`) | metaknapp för Emacs och liknande användargränssnitt
`Up-arrow` | starta sökning i kommandohistoriken under `bash`
`Ctrl-R` | starta inkrementell sökning i kommandohistoriken under `bash`
`Tab` | fullständig inmatning av filnamnet till kommandoraden under `bash`
`Ctrl-V` `Tab` | inmatning `Tab` utan expansion till kommandoraden under `bash`

| Tips
Terminalfunktionen i `Ctrl-S` kan inaktiveras med hjälp av stty(1).

### 1.4.4. Operationer med musen

Musoperationer för text på Debian-system blandar 2 stilar med några vändningar:

- Traditionella musoperationer i Unix-stil:

  - använd 3 knappar (klicka)

  - använd PRIMARY

  - används av X-program som `xterm` och textprogram i Linux-konsolen

- Moderna musoperationer i GUI-stil:

  - använd 2 knappar (dra + klicka)

  - använda PRIMARY och CLIPBOARD

  - används i moderna GUI-program som `gnome-terminal`

Tabell 1.15. Lista över musoperationer och relaterade nyckelåtgärder på Debian

åtgärd | respons
--- | ---
Vänsterklicka-och-drag med musen | välj intervall som PRIMÄRt urval
Vänsterklicka | välj början på intervallet för PRIMARY-urvalet
Högerklicka (traditionellt) | välj slutet av intervallet för PRIMARY-urval
Högerklicka (modernt) | kontextberoende meny (klippa/kopiera/klistra in)
Mittenklicka eller `Shift-Ins` | infoga PRIMARY-urval vid markören
`Ctrl-X` | klippa PRIMARY-valet till CLIPBOARD
`Ctrl-C``(Skift-Ctrl-C` i terminal) | kopiera PRIMARY-urvalet till CLIPBOARD
`Ctrl-V` | klistra in CLIPBOARD vid markören

Här är det PRIMÄRA valet det markerade textområdet. I terminalprogrammet används istället `Shift-Ctrl-C` för att undvika att avsluta ett pågående program.

Det mellersta hjulet på en modern hjulmus betraktas som den mellersta musknappen och kan användas för mittklick. Om du klickar på vänster och höger musknapp tillsammans fungerar det som ett mittklick i ett mussystem med 2 knappar.

För att kunna använda en mus i Linux teckenkonsoler måste du ha gpm(8) igång som daemon.

### 1.4.5. Personsökaren

Kommandot less(1) är en förbättrad pager (filinnehållsläsare). Det läser filen som anges av dess kommandoargument eller dess standardinmatning. Tryck på "`h`" om du behöver hjälp när du bläddrar med kommandot `less`. Det kan göra mycket mer än more(1) och kan förstärkas genom att köra "`eval $(lesspipe`)" eller "`eval $(lessfile`)" i skalets startskript. Se mer i "`/usr/share/doc/less/LESSOPEN`". Alternativet "`-R`" tillåter utmatning av råa tecken och aktiverar ANSI-färg-escape-sekvenser. Se less(1).

| Tips
I kommandot `less` skriver du "`h`" för att se hjälpskärmen, skriver "`/`" eller "`?"` för att söka efter en sträng och skriver "`-i`" för att ändra skiftlägeskänsligheten.

### 1.4.6. Textredigeraren

Du bör bli skicklig i en av varianterna av Vim- eller Emacs-programmen som är populära i det Unix-liknande systemet.

Jag tror att det är rätt att vänja sig vid Vim-kommandon, eftersom Vi-editor alltid finns där i Linux/Unix-världen. (Egentligen är original `vi` eller nya `nvi` program som du hittar överallt. Jag valde Vim istället för nybörjare eftersom det erbjuder dig hjälp via `F1-tangenten` medan det är tillräckligt liknande och kraftfullare.)

Om du valde antingen Emacs eller XEmacs istället som ditt val av redigerare är det ett annat bra val, särskilt för programmering. Emacs har en uppsjö av andra funktioner också, inklusive att fungera som en nyhetsläsare, katalogredigerare, e-postprogram etc. När det används för programmering eller redigering av skalskript känner det på ett intelligent sätt igen formatet på det du arbetar med och försöker ge hjälp. En del människor hävdar att det enda program de behöver på Linux är Emacs. Tio minuters inlärning av Emacs nu kan spara timmar senare. Att ha GNU Emacs-manualen som referens när du lär dig Emacs rekommenderas starkt.

Alla dessa program levereras vanligtvis med handledningsprogram så att du kan lära dig dem genom övning. Starta Vim genom att skriva "`vim`" och tryck på F1-tangenten. Du bör åtminstone läsa de första 35 raderna. Gör sedan online-utbildningskursen genom att flytta markören till "`|tutor|`" och trycka på `Ctrl-]`.

| Notera
Bra editorer, som Vim och Emacs, kan hantera UTF-8 och andra exotiska kodningstexter korrekt. Det är en god idé att använda GUI-miljön i UTF-8-lokalen och att installera nödvändiga program och teckensnitt i den. Redigerare har alternativ för att ställa in filkodningen oberoende av GUI-miljön. Se deras dokumentation om multibyte-text.

### 1.4.7. Ange en standardtextredigerare

Debian levereras med ett antal olika redigeringsprogram. Vi rekommenderar att du installerar `vim-paketet`, som nämnts ovan.

Debian ger enhetlig åtkomst till systemets standardredigerare via kommandot "`/usr/bin/editor`" så att andra program (t.ex. reportbug(1)) kan anropa den. Du kan ändra den på följande sätt.

    $ sudo update-alternatives --config editor

Valet "`/usr/bin/vim.basic`" framför "`/usr/bin/vim.tiny`" är min rekommendation för nybörjare eftersom det stöder syntaxmarkering.

| Tips
Många program använder miljövariablerna "`$EDITOR`" eller "`$VISUAL`" för att bestämma vilken editor som ska användas (se Avsnitt 1.3.5, ”Den interna redaktören i MC” och Avsnitt 9.4.11, ”Anpassning av program som ska startas”). För konsekvens på Debian-systemet, ställ in dessa till "`/usr/bin/editor`". (Historiskt sett var "`$EDITOR`" "`ed`" och "`$VISUAL`" var "`vi`")

### 1.4.8. Använda vim

Den nya vim(1) startar sig själv med det sunda alternativet "`nocompatible`" och går in i `NORMAL-läget`.[1]

Tabell 1.16. Lista över grundläggande tangenttryckningar i Vim

läge | tangenttryckningar | åtgärd
--- | --- | ---
`NORMAL` | `:help|only` | visa hjälpfilen
`NORMAL` | `:e filnamn.ext` | öppna ny buffert för att redigera `filnamn.ext`
`NORMAL` | `:w` | skriv över aktuell buffert till originalfilen
`NORMAL` | `:w filename.ext` | skriv aktuell buffert till `filnamn.ext`
`NORMAL` | `:q` | avsluta `vim`
`NORMAL` | `:q!` | tvinga att avsluta `vim`
`NORMAL` | `:only` | stäng alla andra öppna fönster
`NORMAL` | `:set nocompatible?` | kontrollera om `vim` är i det sunda `icke-kompatibla` läget
`NORMAL` | `:set nocompatible` | ställa in `vim` till det sunda `icke-kompatibla` läget
`NORMAL` | `i` | gå till `INSERT-läget`
`NORMAL` | `R` | gå till `REPLACE-läget`
`NORMAL` | `v` | gå till `VISUAL-läget`
`NORMAL` | `V` | gå in i det linjära `VISUAL-läget`
`NORMAL` | `Ctrl-V` | gå in i det blockvisa `VISUAL-läget`
utom `TERMINAL-JOB` | `ESC-tangent` | gå till `NORMAL-läge`
`NORMAL` | `:term` | gå till läget `TERMINAL-JOB`
`TERMINAL-NORMAL` | `i` | gå till läget `TERMINAL-JOB`
`TERMINAL-JOB` | `Ctrl-W` `N` (eller `Ctrl-\` `Ctrl-N`) | gå till läget `TERMINAL-NORMAL`
`TERMINAL-JOB` | `Ctrl-W` `:` | gå in i `Ex-läge` i `TERMINAL-NORMAL-läge`

Använd programmet "`vimtutor`" för att lära dig `vim` genom en interaktiv handledningskurs.

Programmet `vim` ändrar sitt beteende för inmatade tangenttryckningar baserat på läge. Att skriva in tangenttryckningar till bufferten görs mest i `INFOGNING`-läge och `ERSÄTT`-läge. Flyttning av markören görs mestadels i `NORMAL`-läge. Interaktiva val görs i `VISUELLT`-läge. Om du skriver "`:`" i `NORMAL`-läge ändras läget till `Ex`-läget. `Ex`-läget accepterar kommandon.

| Tips
Vim levereras med Netrw-paketet. Netrw stöder läsning av filer, skrivning av filer, bläddring i kataloger över ett nätverk och lokal bläddring! Prova Netrw med "`vim .`" (en punkt som argument) och läs dess manual på "`:help netrw`".

För avancerad konfiguration av `vim`, se Avsnitt 9.2, ”Anpassa vim”.

### 1.4.9. Registrering av skalets aktiviteter

Utdata från shell-kommandot kan rulla bort från skärmen och gå förlorade för alltid. Det är bra att logga shell-aktiviteter i filen så att du kan granska dem senare. Den här typen av dokumentation är viktig när du utför systemadministrativa uppgifter.

| Tips
Den nya Vim (version>=8.2) kan användas för att spela in skalaktiviteterna på ett rent sätt med hjälp av `TERMINAL-JOB-läget`. Se Avsnitt 1.4.8, ”Använda vim”.

Den grundläggande metoden för att registrera skalaktiviteten är att köra den under script(1).

Försök till exempel med följande

    $ script
    Script started, file is typescript

Utför de shell-kommandon som finns i `skriptet`.

Tryck på `Ctrl-D` för att avsluta `skriptet`.

    $ vim typescript

Se Avsnitt 9.1.1, ”Spela in skalaktiviteterna på ett rent sätt”.

### 1.4.10. Grundläggande Unix-kommandon

Låt oss lära oss grundläggande Unix-kommandon. Här använder jag "Unix" i dess generiska betydelse. Alla Unix-klonade operativsystem erbjuder vanligtvis motsvarande kommandon. Debian-systemet är inget undantag. Oroa dig inte om vissa kommandon inte fungerar som du önskar nu. Om `alias` används i skalet är motsvarande kommandoutgångar annorlunda. De här exemplen är inte avsedda att utföras i den här ordningen.

Prova alla följande kommandon från det icke-privilegierade användarkontot.

Tabell 1.17. Lista över grundläggande Unix-kommandon

kommando | beskrivning
--- | ---
`pwd` | visningsnamn för aktuell katalog/arbetskatalog
`whoami` | visa aktuellt användarnamn
`id` | visa aktuell användaridentitet (namn, uid, gid och tillhörande grupper)
`file foo` | visa en filtyp för filen "`foo`"
`type -p commandname` | visa en filplats för kommandot "`kommandonamn`"
`which commandname` | , ,
`type commandname` | visa information om kommandot "`kommandonamn`"
`apropos nyckelord` | hitta kommandon relaterade till "`nyckelord`"
`man -k nyckelord` | , ,
`whatis kommandonamn` | visa en förklaring på en rad för kommandot "`kommandonamn`"
`man -a commandname` | visa förklaring till kommandot "`kommandonamn`" (Unix-stil)
`info kommandonamn` | visa en ganska lång förklaring på kommandot "`kommandonamn`" (GNU-stil)
`ls` | lista innehållet i en katalog (icke-dot-filer och kataloger)
`ls -a` | lista innehållet i en katalog (alla filer och kataloger)
`ls -A` | lista innehållet i en katalog (nästan alla filer och kataloger, d.v.s. hoppa över "`.`.." och "`.`")
`ls -la` | lista allt innehåll i katalogen med detaljerad information
`ls -lai` | lista allt innehåll i katalogen med inode-nummer och detaljerad information
`ls -d` | lista alla kataloger under den aktuella katalogen
`tree` | visa innehållet i filträdet
`lsof foo` | lista öppen status för filen "`foo`"
`lsof -p pid` | lista över filer som öppnats av process-ID: "`pid`"
`mkdir foo` | skapa en ny katalog "`foo`" i den aktuella katalogen
`rmdir foo` | ta bort en katalog "`foo`" i den aktuella katalogen
`cd foo` | ändra katalog till katalogen "`foo`" i den aktuella katalogen eller i den katalog som anges i variabeln "`$CDPATH`"
`cd /` | ändra katalog till rotkatalogen
`cd` | ändra katalog till den aktuella användarens hemkatalog
`cd /foo` | ändra katalog till den absoluta sökvägen katalog "`/foo`"
`cd ..` | ändra katalog till den överordnade katalogen
`cd ~foo` | ändra katalog till hemkatalogen för användaren "`foo`"
`cd -` | ändra katalog till föregående katalog
`</etc/motd pager` | visa innehållet i "`/etc/motd`" med hjälp av standard personsökaren
`touch junkfile` | skapa en tom fil "`skräpfil`"
`cp foo bar` | kopiera en befintlig fil "`foo`" till en ny fil "`bar`"
`rm skräpfil` | ta bort en fil "`skräpfil`"
`mv foo bar` | byta namn på en befintlig fil "`foo`" till ett nytt namn "`bar`" ("`bar`" får inte existera)
`mv foo bar` | flytta en befintlig fil "`foo`" till en ny plats`"bar/foo`" (katalogen "`bar`" måste existera)
`mv foo bar/baz` | flytta en befintlig fil "`foo`" till en ny plats med det nya namnet "`bar/baz`" (katalogen "`bar`" måste finnas men katalogen "`bar/baz`" får inte finnas)
`chmod 600 foo` | gör en befintlig fil "`foo`" till att vara icke-läsbar och icke-skrivbar av de andra personerna (icke-exekverbar för alla)
`chmod 644 foo` | gör en befintlig fil "`foo`" så att den blir läsbar men inte skrivbar för andra personer (ej exekverbar för alla)
`chmod 755 foo` | gör en befintlig fil "`foo`" så att den blir läsbar men inte skrivbar av andra personer (körbar för alla)
`find . -name pattern` | hitta matchande filnamn med hjälp av shell "`mönster`" (långsammare)
`locate -d . pattern` | hitta matchande filnamn med hjälp av shell "`mönster`" (snabbare med hjälp av regelbundet genererad databas)
`grep -e "mönster" *.html` | hitta ett "`mönster`" i alla filer som slutar med "`.html`" i den aktuella katalogen och visa dem alla
`top` | visa processinformation i helskärm, skriv "`q`" för att avsluta
`ps aux | pager` | visa information om alla processer som körs med BSD-stil
`ps -ef | pager` | visa information om alla processer som körs med hjälp av Unix system-V-stil
`ps aux | grep -e "[e]xim4*"` | visa alla processer som körs "`exim`" och "`exim4`"
`ps axf | pager` | visa information om alla processer som körs med ASCII-bildutskrift
`kill 1234` | döda en process som identifieras av process-ID:"1234"
`gzip foo` | komprimera "`foo`" för att skapa`"foo.gz`" med hjälp av Lempel-Ziv-kodning (LZ77)
`gunzip foo.gz` | dekomprimera`"foo.gz`" för att skapa "`foo`"
`bzip2 foo` | komprimera "`foo`" för att skapa`"foo.bz2`" med Burrows-Wheeler blocksorteringsalgoritm för textkomprimering och Huffman-kodning (bättre komprimering än `gzip`)
`bunzip2 foo.bz2` | dekomprimera`"foo.bz2`" för att skapa "`foo`"
`xz foo` | komprimera "`foo`" för att skapa`"foo.xz`" med hjälp av Lempel-Ziv-Markov-kedjealgoritmen (bättre komprimering än `bzip2`)
`unxz foo.xz` | dekomprimera`"foo.xz`" för att skapa "`foo`"
`tar -xvf foo.tar` | extrahera filer från arkivet`"foo.tar`"
`tar -xvzf foo.tar.gz` | extrahera filer från gzippat`"foo.tar.`gz"-arkiv
`tar -xvjf foo.tar.bz2` | extrahera filer från arkivet`"foo.tar.bz2`"
`tar -xvJf foo.tar.xz` | extrahera filer från arkivet`"foo.tar.xz`"
`tar -cvf foo.tar bar/` | arkivera innehållet i mappen`"bar/`" i arkivet`"foo.tar`"
`tar -cvzf foo.tar.gz bar/` | arkivera innehållet i mappen`"bar/`" i det komprimerade arkivet`"foo.tar.gz`"
`tar -cvjf foo.tar.bz2 bar/` | arkivera innehållet i mappen`"bar/`" i arkivet`"foo.tar.bz2`"
`tar -cvJf foo.tar.xz bar/` | arkivinnehållet i mappen`"bar/`" i arkivet`"foo.tar.xz`"
`zcat README.gz | pager` | visa innehållet i den komprimerade filen "`README.gz`" med hjälp av standardsökaren
`zcat README.gz > foo` | skapa en fil "`foo`" med det dekomprimerade innehållet i "`README.gz`"
`zcat README.gz >> foo` | lägg till det dekomprimerade innehållet i "`README.gz`" i slutet av filen "`foo`" (om den inte finns, skapa den först)

| Notera

Unix har en tradition att dölja filnamn som börjar med "`.`". Det är vanligtvis filer som innehåller konfigurationsinformation och användarinställningar.

För `cd-kommando`, se builtins(7).

Standard personsökaren i Debian-systemet med bara ben är more(1) som inte kan rulla tillbaka. Genom att installera `less-paketet` med kommandoraden "`apt-get install` `less", blir less`(1) standard personsökare och du kan bläddra tillbaka med markörknapparna.

"`[`" och "`]`" i det reguljära uttrycket i kommandot "`ps aux | grep -e "[e]xim4*"`" ovan gör att `grep` undviker att matcha sig själv. "`4*`" i det reguljära uttrycket betyder 0 eller fler upprepningar av tecknet "`4`", vilket gör att `grep` kan matcha både "`exim`" och "`exim4`". Även om "`*`" används i skalets filnamnsglob och i det reguljära uttrycket har de olika betydelser. Lär dig det reguljära uttrycket från grep(1).

Gå igenom kataloger och kika in i systemet med hjälp av ovanstående kommandon som träning. Om du har frågor om något av konsolkommandona kan du läsa manualsidan.

Försök till exempel med följande

    $ man man
    $ man bash
    $ man builtins
    $ man grep
    $ man ls

Stilen på man pages kan vara lite svår att vänja sig vid, eftersom de är ganska kortfattade, särskilt de äldre, mycket traditionella. Men när man väl har vant sig kommer man att uppskatta deras kortfattade form.

Observera att många Unix-liknande kommandon, inklusive de från GNU och BSD, visar kortfattad hjälpinformation om du anropar dem på något av följande sätt (eller utan några argument i vissa fall).

    $ commandname --help
    $ commandname -h

## 1.5. Det enkla shell-kommandot

Nu har du en viss känsla för hur man använder Debian-systemet. Låt oss titta djupt in i mekanismen för kommandokörning i Debiansystemet. Här har jag förenklat verkligheten för nybörjaren. Se bash(1) för den exakta förklaringen.

Ett enkelt kommando är en sekvens av komponenter.

1. Tilldelning av variabler (valfritt)

2. Kommando namn

3. Argument (valfritt)

4. Omdirigeringar (valfritt: `>`, `>>`, `<`, `<<`, etc.)

5. Kontrolloperator (valfritt: `&&` , `||`, nyrad, `;`, `&`, `(`, `)` )

### 1.5.1. Kommandokörning och miljövariabler

Värdena på vissa miljövariabler ändrar beteendet hos vissa Unix-kommandon.

Standardvärdena för miljövariablerna fastställs initialt av PAM-systemet och sedan kan vissa av dem återställas av vissa tillämpningsprogram.

- PAM-systemet, t.ex. `pam_env`, kan ställa in miljövariabler med `/etc/pam.conf`", "`/etc/environment`" och "`/etc/default/locale`".

- The modern GUI environment run from the user mode systemd unit (see systemd.unit(5)) sets its environment variables by a file in the "`~/.config/environment.d/`" directory.

- Den användarspecifika programinitialiseringen kan återställa miljövariabler genom "`~/.profile`", "~/`.bash_profile`" och "~/`.bashrc`".

### 1.5.2. Variabeln "`$LANG`"

Standardlokalen definieras i miljövariabeln "`$LANG`" och konfigureras som "`LANG=xx_YY.UTF-8`" av installationsprogrammet eller av den efterföljande grafiska gränssnittskonfigurationen, t.ex. "Inställningar" → "Region och språk" → "Språk" / "Format" för GNOME.

| Notera
Jag rekommenderar att du för tillfället bara konfigurerar systemmiljön med variabeln "`$LANG`" och håller dig borta från variablerna "`$LC_*`" om det inte är absolut nödvändigt.

Det fullständiga locale-värdet som ges till variabeln "`$LANG`" består av 3 delar: "`xx_YY.ZZZZ`".

Tabell 1.18. De 3 delarna av locale-värdet

lokalt värde | betydelse
--- | ---
`xx` | ISO 639 språkkoder (gemener) som t.ex. "en"
`YY` | ISO 3166 landskoder (versaler), t.ex. "US"
`ZZZZ` | codeset, alltid inställd på "UTF-8"

Tabell 1.19. Lista över lokala rekommendationer

lokal rekommendation | Språk (område)
--- | ---
`en_US.UTF-8` | Engelska (USA)
`en_GB.UTF-8` | Engelska (Storbritannien)
`fr_FR.UTF-8` | Franska (Frankrike)
`de_DE.UTF-8` | Tyska (Tyskland)
`it_IT.UTF-8` | Italien (Italienska)
`es_ES.UTF-8` | Spanien (Spanska)
`ca_ES.UTF-8` | Katalanska (Spanien)
`sv_SE.UTF-8` | Svenska (Sverige)
`pt_BR.UTF-8` | Portugisiska (Brasiliansk)
`ru_RU.UTF-8` | Ryska (Ryssland)
`zh_CN.UTF-8` | Kinesiska (f.d. republiken Kina)
`zh_TW.UTF-8` | Kinesiska (Taiwan R.O.C.)
`ja_JP.UTF-8` | Japanska (Japan)
`ko_KR.UTF-8` | Koreanska (Republiken Korea)
`vi_VN.UTF-8` | Vietnamesiska (Vietnam)

Ett typiskt kommando utförs med en skalradsekvens enligt följande.

    $ echo $LANG
    en_US.UTF-8
    $ date -u
    Wed 19 May 2021 03:18:43 PM UTC
    $ LANG=fr_FR.UTF-8 date -u
    mer. 19 mai 2021 15:19:02 UTC

Här körs programmet date(1) med olika locale-värden.

- För det första kommandot är "`$LANG`" inställt på systemets standardvärde för locale "`en_US.UTF-8`".

- För det andra kommandot sätts "`$LANG`" till det franska UTF-8-lokalvärdet "`fr_FR.UTF-8`".

De flesta kommandokörningar har vanligtvis inte någon föregående miljövariabeldefinition. I exemplet ovan kan du alternativt köra kommandot på följande sätt.

    $ LANG=fr_FR.UTF-8
    $ date -u
    mer. 19 mai 2021 15:19:24 UTC

| Tips
När du lämnar in en felrapport är det en bra idé att köra och kontrollera kommandot under "`en_US.UTF-8`"-lokal om du använder en icke-engelsk miljö.

För mer detaljerad information om locale-konfigurationen, se Avsnitt 8.1, ”Lokalen”.

### 1.5.3. Variabeln "`$PATH`"

När du skriver in ett kommando i skalet söker skalet efter kommandot i listan över kataloger som finns i miljövariabeln "`$PATH`". Värdet på miljövariabeln "`$PATH`" kallas också för skalets sökväg.

I standardinstallationen av Debian kanske miljövariabeln "`$PATH`" för användarkonton inte inkluderar "`/usr/sbin`" och "`/usr/sbin`". Till exempel måste kommandot `ifconfig` utfärdas med fullständig sökväg som "`/usr/sbin/ifconfig`". (Liknande `ip-kommando` finns i "`/usr/bin`".)

Du kan ändra miljövariabeln "`$PATH`" i Bash-skalet med filerna "`~/.bash_profile`" eller "~/`.bashrc`".

### 1.5.4. Variabeln "`$HOME`"

Många kommandon lagrar användarspecifik konfiguration i hemkatalogen och ändrar sitt beteende med hjälp av innehållet. Hemkatalogen identifieras av miljövariabeln "`$HOME`".

Tabell 1.20. Lista över "`$HOME`"-värden

värdet av "`$HOME`" | programgenomförande situation
--- | ---
`/` | program som körs av init-processen (daemon)
`/root` | program som körs från det normala rotskalet
`/home/normal_user` | program som körs från det vanliga användarskalet
`/home/normal_user` | programmet körs från den vanliga GUI-skrivbordsmenyn för användare
`/home/normal_user` | program körs som root med "`sudo program`"
`/root` | program körs som root med "`sudo -H program`"

| Tips
Shell expanderar "`~/`" till den aktuella användarens hemkatalog, dvs. "`$HOME/`". Shell expanderar "`~foo/`" till `foos` hemkatalog, dvs. "`/home/foo/`".

Se Avsnitt 12.1.5, ”Shell-miljövariabler” om `$HOME` inte är tillgängligt för ditt program.

### 1.5.5. Alternativ för kommandoraden

Vissa kommandon tar emot argument. Argument som börjar med "`-`" eller "`--`" kallas alternativ och styr kommandots beteende.

    $ date
    Thu 20 May 2021 01:08:08 AM JST
    $ date -R
    Thu, 20 May 2021 01:08:12 +0900

Här ändrar kommandoradsargumentet "`-R`" date(1)-beteendet så att datumsträngen matas ut i enlighet med RFC2822.

### 1.5.6. Skal glob

Ofta vill man att ett kommando ska fungera med en grupp filer utan att man behöver skriva in dem alla. Filnamnsexpansionsmönstret med hjälp av shell glob, (ibland kallat wildcards), underlättar detta behov.

Tabell 1.21. Mönster för skalglob

skalglobsmönster | beskrivning av matchningsregel
--- | ---
`*` | filnamnet (segmentet) börjar inte med "`.`"
`.*` | filename (segment) started with "`.`" (in Bash 5.2 and later, "`.`" and "`..`" are excluded by default)
`?` | exakt ett tecken
`[…]` | exakt ett tecken med alla tecken inom parentes
`[a-z]` | exakt ett tecken med valfritt tecken mellan "`a`" och "`z"`
`[^…]` | exakt ett annat tecken än något tecken inom parentes (utom "`^`")

Försök till exempel med följande

    $ mkdir junk; cd junk; touch 1.txt 2.txt 3.c 4.h .5.txt ..6.txt
    $ echo *.txt
    1.txt 2.txt
    $ echo *
    1.txt 2.txt 3.c 4.h
    $ echo *.[hc]
    3.c 4.h
    $ echo .*
    .5.txt ..6.txt
    $ echo .*[^.]*
    .5.txt ..6.txt
    $ echo [^1-3]*
    4.h
    $ cd ..; rm -rf junk

Se glob(7).

| Notera
Till skillnad från normal filnamnsexpansion av skalet, matchar skalmönstret "`*`" som testas i find(1) med "`-name`" test etc., det inledande "`.`" i filnamnet. (Ny POSIX-funktion )

| Notera
BASH kan anpassas för att ändra globbeteendet med de inbyggda alternativen i shopt, t.ex. "`dotglob`", "`noglob`", "`nocaseglob`", "`nullglob`", "`extglob`" osv. Se bash(1).

### 1.5.7. Returvärde för kommandot

Varje kommando returnerar sin exit-status (variabel: "`$?`") som returvärde.

Tabell 1.22. Kommandots utgångskoder

kommando Utgångsstatus | numeriskt returvärde | logiskt returvärde
--- | --- | ---
lyckades | noll, 0 | SANT
fel | ej noll, -1 | FALSK

Försök till exempel med följande.

    $ [ 1 = 1 ] ; echo $?
    0
    $ [ 1 = 2 ] ; echo $?
    1

| Notera
Observera att i det logiska sammanhanget för skalet behandlas framgång som det logiska TRUE som har 0 (noll) som sitt värde. Detta är något icke-intuitivt och behöver påminnas om här.

### 1.5.8. Typiska kommandosekvenser och omdirigering av skal

Låt oss försöka komma ihåg följande shell-kommandon som skrivs på en rad som en del av shell-kommandot.

Tabell 1.23. Idiom för Shell-kommandon

kommando idiom | beskrivning
--- | ---
`command &` | bakgrundskörning av `kommando` i underskalet
`kommando1 | kommando2` | Använd pipe för standard ut från `kommando1` till standard in från `kommando2` (samtidig körning)
`command1 2>&1 | command2` | skicka både standardutdata och standardfel från `kommando1` till standardinmatningen för `kommando2`(samtidig körning)
`command1 ; command2` | utföra `kommando1` och `kommando2` sekventiellt
`command1 && command2` | kör `kommando1`; om det lyckas, kör `kommando2` sekventiellt (returnerar success om både `kommando1` och `kommando2` lyckas)
`command1 || command2` | kör `kommando1`; om det inte lyckas, kör `kommando2` sekventiellt (returnerar success om `kommando1` eller `kommando2` lyckas)
`command > foo` | omdirigera `kommandots` standardutdata till en fil `foo` (överskriva)
`command 2> foo` | omdirigera `kommandots` standardfel till en fil `foo` (överskriva)
`command >> foo` | omdirigera standardutdata från `kommandot` till en fil `foo` (append)
`command 2>> foo` | omdirigera `kommandots` standardfel till en fil `foo` (append)
`command > foo 2>&1` | omdirigera både standardutdata och standardfel för `kommandot` till en fil `foo`
`command < foo` | omdirigera `kommandots` standardinmatning till en fil `foo`
`command << delimiter` | omdirigera `kommandots` standardinmatning till följande rader tills "`delimiter`" uppfylls (här dokument)
`command <<- delimiter` | omdirigera `kommandots` standardinmatning till följande rader tills "`delimiter`" uppfylls (här dokument, de inledande tabbtecknen tas bort från inmatningsraderna)

Debian-systemet är ett multitasking-system. Bakgrundsjobb gör det möjligt för användare att köra flera program i ett enda skal. Hanteringen av bakgrundsprocessen involverar skalets inbyggda funktioner: `jobs`, `fg`, `bg` och `kill`. Läs avsnitten i bash(1) under "SIGNALER" och "JOBBKONTROLL" och builtins(1).

Försök till exempel med följande

    $ </etc/motd pager

    $ pager </etc/motd

    $ pager /etc/motd

    $ cat /etc/motd | pager

Även om alla fyra exemplen på omdirigeringar av skal visar samma sak, kör det sista exemplet ett extra `cat-kommando` och slösar resurser utan anledning.

Med skalet kan du öppna filer med hjälp av den inbyggda funktionen `exec` med en godtycklig filbeskrivare.

    $ echo Hello >foo
    $ exec 3<foo 4>bar  # open files
    $ cat <&3 >&4       # redirect stdin to 3, stdout to 4
    $ exec 3<&- 4>&-    # close files
    $ cat bar
    Hello

Filbeskrivarna 0-2 är fördefinierade.

Tabell 1.24. Fördefinierade filbeskrivare

enhet | beskrivning | filbeskrivare
--- | --- | ---
`stdin` | standardinmatning | 0
`stdout` | standardutgång | 1
`stderr` | standardfel | 2

### 1.5.9. Kommando alias

Du kan ställa in ett alias för ett ofta använt kommando.

Försök till exempel med följande

    $ alias la='ls -la'

Nu fungerar "`la`" som en förkortning av "`ls -la`" som listar alla filer i formatet "long listing".

Du kan lista alla befintliga `alias med alias` (se bash(1) under "SHELL BUILTIN COMMANDS").

    $ alias
    ...
    alias la='ls -la'

Du kan identifiera den exakta sökvägen eller identiteten för kommandot efter `typ` (se bash(1) under "SHELL BUILTIN COMMANDS").

Försök till exempel med följande

    $ type ls
    ls is hashed (/bin/ls)
    $ type la
    la is aliased to ls -la
    $ type echo
    echo is a shell builtin
    $ type file
    file is /usr/bin/file

Här söktes `ls` nyligen medan "`file`" inte gjorde det, så "`ls`" är "hashed", dvs. skalet har ett internt register för snabb åtkomst till platsen för kommandot "`ls`".

| Tips
Se Avsnitt 9.3.6, ”Färgade kommandon”.

## 1.6. Unix-liknande textbehandling

I Unix-liknande arbetsmiljöer sker textbearbetningen genom att texten skickas genom kedjor av standardverktyg för textbearbetning. Detta var en annan viktig Unix-innovation.

### 1.6.1. Unix textverktyg

Det finns ett fåtal standardverktyg för textbehandling som används mycket ofta i Unix-liknande system.

- Inget reguljärt uttryck används:

  - cat(1) sammanfogar filer och skriver ut hela innehållet.

  - tac(1) sammanfogar filer och matar ut dem i omvänd ordning.

  - cut(1) väljer ut delar av rader och utdata.

  - head(1) matar ut den första delen av filerna.

  - tail(1) matar ut den sista delen av filer.

  - sort(1) sorterar rader i textfiler.

  - uniq(1) tar bort dubbletter av rader från en sorterad fil.

  - tr(1) översätter eller raderar tecken.

  - diff(1) jämför filer rad för rad.

- Grundläggande reguljära uttryck(BRE) används som standard:

  - ed(1) är en primitiv linjeeditor.

  - sed(1) är en strömredigerare.

  - grep(1) matchar text med mönster.

  - vim(1) är en skärmredigerare.

  - emacs(1) är en skärmredigerare. (något utökad BRE)

- Utökat reguljärt uttryck(ERE) används:

  - awk(1) gör enkel textbearbetning.

  - egrep(1) matchar text med mönster.

  - `tcl`(3tcl) kan göra all tänkbar textbehandling: Se re_syntax(3). Används ofta med `tk`(3tk).

  - perl(1) kan göra all tänkbar textbehandling. Se perlre(1).

  - pcre2grep(1) från `pcregrep-paketet` matchar text med Perl Compatible Regular Expressions (PCRE) -mönster.

  - python(1) med modulen `re` kan göra all tänkbar textbehandling. Se "`/usr/share/doc/python/html/index.html`".

Om du inte är säker på exakt vad dessa kommandon gör kan du använda "`man` command" för att ta reda på det själv.

| Notera
Sorteringsordning och intervalluttryck är lokalberoende. Om du vill att ett kommando ska fungera på traditionellt sätt ska du använda C locale eller C.UTF-8 locale i stället för normala UTF-8 locale (se Avsnitt 8.1, ”Lokalen”).

| Notera
Reguljära uttryck i Perl`(perlre`(1)), Perl Compatible Regular Expressions (PCRE) och reguljära uttryck i Python som erbjuds av modulen `re` har många gemensamma tillägg till den normala ERE.

### 1.6.2. Vanliga uttryck

Reguljära uttryck används i många textbehandlingsverktyg. De är analoga med shell globs, men de är mer komplicerade och kraftfulla.

Det reguljära uttrycket beskriver matchningsmönstret och består av texttecken och metatecken.

Ett metatecken är bara ett tecken med en speciell betydelse. Det finns två huvudstilar, BRE och ERE, beroende på textverktygen enligt beskrivningen ovan.

Tabell 1.25. Metatecken för BRE och ERE

BRE | ERE | beskrivning av det reguljära uttrycket
--- | --- | ---
`\ . [ ] ^ $ *` | `\ . [ ] ^ $ *` | gemensamma metatecken
`\+ \? \( \) \{ \} \|` |  | BRE endast "`\`" escapade metatecken
| `+ ? ( ) { } |` | ERE endast icke-"`\`"-escapade metatecken
`c` | `c` | matcha icke-metatecken "`c`"
`\c` | `\c` | matcha ett bokstavligt tecken "`c`" även om "`c`" är metatecken själv
`.` | `.` | matcha alla tecken inklusive ny rad
`^` | `^` | position i början av en sträng
`$` | `$` | position i slutet av en sträng
`\<` | `\<` | position i början av ett ord
`\>` | `\>` | position i slutet av ett ord
`[abc…]` | `[abc…]` | matcha alla tecken i "`abc..."`
`[^abc…]` | `[^abc…]` | matcha alla tecken utom i "`abc..."`
`r*` | `r*` | matcha noll eller flera reguljära uttryck som identifieras av "`r`"
`r\+` | `r+` | matcha ett eller flera reguljära uttryck som identifieras av "`r`"
`r\?` | `r?` | matcha noll eller ett reguljärt uttryck som identifieras av "`r`"
`r1\|r2` | `r1|r2` | matcha ett av de reguljära uttryck som identifieras av "`r1`" eller "`r2`"
`\(r1\|r2\)` | `(r1|r2)` | matcha ett av de reguljära uttryck som identifieras av "`r1`" eller "`r2`" och behandla det som ett reguljärt uttryck inom parentes

Det reguljära uttrycket för `emacs` är i princip BRE men har utökats till att behandla "`+`" och "`?"` som metatecken som i ERE. Det finns alltså inget behov av att undkomma dem med "`\`" i det reguljära uttrycket i `emacs`.

grep(1) kan användas för att utföra en textsökning med hjälp av ett reguljärt uttryck.

Försök till exempel med följande

    $ egrep 'GNU.*LICENSE|Yoyodyne' /usr/share/common-licenses/GPL
    GNU GENERAL PUBLIC LICENSE
    GNU GENERAL PUBLIC LICENSE
    Yoyodyne, Inc., hereby disclaims all copyright interest in the program

| Tips
Se Avsnitt 9.3.6, ”Färgade kommandon”.

### 1.6.3. Ersättningsuttryck

För ersättningsuttrycket har vissa tecken särskilda betydelser.

Tabell 1.26. Ersättningsuttrycket

ersättningsuttryck | beskrivning av den text som ska ersätta ersättningsuttrycket
--- | ---
`&` | vad det reguljära uttrycket matchade (använd `\&` i `emacs`)
`\n` | vad det n:te reguljära uttrycket inom parentes matchade ("n" är ett nummer)

För ersättningssträngar i Perl används "$&" i stället för "&" och "$n" i stället för "\n".

Försök till exempel med följande

    $ echo zzz1abc2efg3hij4 | \
    sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/=&=/'
    zzz=1abc2efg3hij4=
    $ echo zzz1abc2efg3hij4 | \
    sed -E -e 's/(1[a-z]*)[0-9]*(.*)$/=&=/'
    zzz=1abc2efg3hij4=
    $ echo zzz1abc2efg3hij4 | \
    perl -pe 's/(1[a-z]*)[0-9]*(.*)$/=$&=/'
    zzz=1abc2efg3hij4=
    $ echo zzz1abc2efg3hij4 | \
    sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/\2===\1/'
    zzzefg3hij4===1abc
    $ echo zzz1abc2efg3hij4 | \
    sed -E -e 's/(1[a-z]*)[0-9]*(.*)$/\2===\1/'
    zzzefg3hij4===1abc
    $ echo zzz1abc2efg3hij4 | \
    perl -pe 's/(1[a-z]*)[0-9]*(.*)$/$2===$1/'
    zzzefg3hij4===1abc

Här bör du vara extra uppmärksam på stilen för det parentesförsedda reguljära uttrycket och hur de matchade strängarna används i textutbytesprocessen i olika verktyg.

Dessa reguljära uttryck kan också användas för markörrörelser och textutbyte i vissa redigeringsverktyg.

Det bakre snedstrecket "`\`" i slutet av raden i shell-kommandoraden undviker newline som ett tecken för vitt utrymme och fortsätter inmatningen i shell-kommandoraden till nästa rad.

Läs alla relaterade manualsidor för att lära dig dessa kommandon.

### 1.6.4. Global substitution med reguljära uttryck

Kommandot ed(1) kan ersätta alla förekomster av "`FROM_REGEX`" med "`TO_TEXT`" i "`file`".

    $ ed file <<EOF
    ,s/FROM_REGEX/TO_TEXT/g
    w
    q
    EOF

Kommandot sed(1) kan ersätta alla förekomster av "`FROM_REGEX`" med "`TO_TEXT`" i "`file`".

    $ sed -i -e 's/FROM_REGEX/TO_TEXT/g' file

Kommandot vim(1) kan ersätta alla förekomster av "`FROM_REGEX`" med "`TO_TEXT`" i "`file`" med hjälp av ex(1)-kommandon.

    $ vim '+%s/FROM_REGEX/TO_TEXT/gc' '+update' '+q' file

| Tips
"`c`"-flaggan i det ovanstående ger en interaktiv bekräftelse för varje substitution.

Flera filer ( "`file1`", "`file2`" och "`file3`") kan bearbetas med reguljära uttryck på samma sätt som i vim(1) eller perl(1).

    $ vim '+argdo %s/FROM_REGEX/TO_TEXT/gce|update' '+q' file1 file2 file3

| Tips
Flaggan "`e`" i ovanstående exempel förhindrar att felet "Ingen matchning" bryter en mappning.

    $ perl -i -p -e 's/FROM_REGEX/TO_TEXT/g;' file1 file2 file3

I exemplet med perl(1) står "`-i`" för redigering på plats av varje målfil och "`-p`" för en implicit loop över alla givna filer.

| Tips
Om du använder argumentet "`-i.bak" i` stället för "`-i`" behålls varje originalfil genom att "`.bak`" läggs till i filnamnet. Detta gör det lättare att återställa fel vid komplexa utbyten.

| Notera
ed(1) och vim(1) är BRE; perl(1) är ERE.

### 1.6.5. Extrahera data från textfilstabell

Låt oss betrakta en textfil som heter "`DPL`" i vilken några Debian-projektledares namn från före 2004 och deras startdatum listas i ett mellanslagsseparerat format.

    Ian     Murdock   August  1993
    Bruce   Perens    April   1996
    Ian     Jackson   January 1998
    Wichert Akkerman  January 1999
    Ben     Collins   April   2001
    Bdale   Garbee    April   2002
    Martin  Michlmayr March   2003

| Tips
Se "En kort historik över Debian" för den senaste historiken över Debians ledarskap.

Awk används ofta för att extrahera data från den här typen av filer.

Försök till exempel med följande

    $ awk '{ print $3 }' <DPL                   # month started
    August
    April
    January
    January
    April
    April
    March
    $ awk '($1=="Ian") { print }' <DPL          # DPL called Ian
    Ian     Murdock   August  1993
    Ian     Jackson   January 1998
    $ awk '($2=="Perens") { print $3,$4 }' <DPL # When Perens started
    April 1996

Skal som Bash kan också användas för att analysera den här typen av filer.

Försök till exempel med följande

    $ while read first last month year; do
        echo $month
      done <DPL
    ... same output as the first Awk example

Här använder det inbyggda kommandot `read` tecken i "`$IFS`" (internal field separators) för att dela upp rader i ord.

Om du ändrar "`$IFS`" till "`:`" kan du analysera "`/etc/passwd`" på ett snyggt sätt med shell.

    $ oldIFS="$IFS"   # save old value
    $ IFS=':'
    $ while read user password uid gid rest_of_line; do
        if [ "$user" = "bozo" ]; then
          echo "$user's ID is $uid"
        fi
      done < /etc/passwd
    bozo's ID is 1000
    $ IFS="$oldIFS"   # restore old value

(Om Awk används för att göra motsvarande, använd "`FS=':'`" för att ange fältseparatorn)

IFS används också av skalet för att dela upp resultat av parameterutvidgning, kommandosubstitution och aritmetisk utbyggnad. Dessa förekommer inte inom dubbel- eller enkelciterade ord. Standardvärdet för IFS är mellanslag, tabb och ny rad kombinerat.

Var försiktig med att använda detta shell IFS-trick. Konstiga saker kan hända, när skalet tolkar vissa delar av skriptet som dess input.

    $ IFS=":,"                        # use ":" and "," as IFS
    $ echo IFS=$IFS,   IFS="$IFS"     # echo is a Bash builtin
    IFS=  , IFS=:,
    $ date -R                         # just a command output
    Sat, 23 Aug 2003 08:30:15 +0200
    $ echo $(date -R)                 # sub shell --> input to main shell
    Sat  23 Aug 2003 08 30 36 +0200
    $ unset IFS                       # reset IFS to the default
    $ echo $(date -R)
    Sat, 23 Aug 2003 08:30:50 +0200

### 1.6.6. Skriptavsnitt för piping-kommandon

Följande skript gör trevliga saker som en del av en pipe.

Tabell 1.27. Lista över skriptutdrag för piping-kommandon

skriptutdrag (skriv en rad) | effekt av kommando
--- | ---
`find /usr -print` | hitta alla filer under "`/usr`"
`seq 1 100` | skriv 1 till 100
`| xargs -n 1 command` | kör kommandot upprepade gånger med varje objekt från pipe som argument
`| xargs -n 1 echo` | dela upp white-space-separerade objekt från pipe i linjer
`| xargs echo` | sammanfoga alla linjer från röret till en linje
`| grep -e regex_pattern` | extrahera rader från rör som innehåller regex_mönster
`| grep -v -e regex_pattern` | extrahera rader från rör som inte innehåller regex_mönster
`| cut -d: -f3 -` | extrahera tredje fältet från pipe separerat med "`:`" (passwd-fil etc.)
`| awk '{ print $3 }'` | extrahera tredje fältet från pipe separerat med blanksteg
`| awk -F'\t' '{ print $3 }'` | extrahera tredje fältet från rör separerat med flik
`| col -bx` | ta bort backspace och expandera tabbar till mellanslag
`| expand -` | expandera flikar
`| sort| uniq` | sortera och ta bort dubbletter
`| tr 'A-Z' 'a-z'` | konvertera versaler till gemener
`| tr -d '\n'` | sammanfoga rader till en rad
`| tr -d '\r'` | ta bort CR
`| sed 's/^/# /'` | lägg till "`#`" i början av varje rad
`| sed 's/\.ext//g'` | ta bort `.ext`
`| sed -n -e 2p` | skriv ut den andra raden
`| head -n 2 -` | skriv ut de första 2 raderna
`| tail -n 2 -` | skriv ut de 2 sista raderna

Ett skalskript på en rad kan loopa över många filer med hjälp av find(1) och xargs(1) för att utföra ganska komplicerade uppgifter. Se Avsnitt 10.1.5, ”Idiom för urval av filer” och Avsnitt 9.4.9, ”Upprepa ett kommando loopa över filer”.

När det blir för komplicerat att använda det interaktiva läget i skalet kan du överväga att skriva ett skalskript (se Avsnitt 12.1, ”Shell-skriptet”).

[1] Även den äldre `vim` kan starta i det sunda läget "`nocompatible`" genom att starta den med alternativet "`-N`".

Förord |  | Kapitel 2. Debians pakethantering