Om vi trycker på uppil ser vi att det föregående kommandot, kaekfjaeifj, dyker upp igen efter prompten. Det här kallas kommandohistorik. De flesta Linuxdistributioner minns som standard de senaste 1 000 kommandona. Trycker vi på nedil försvinner det tidigare kommandot.

Hämta fram föregående kommando igen med uppil. Provar vi vänster- och högerpil ser vi att vi kan placera markören var som helst på kommandoraden. Det gör det enkelt att redigera kommandon.

Även om skalet kretsar kring tangentbordet kan du också använda mus i terminalemulatorn. En mekanism i fönstersystemet (motorn som får GUI:t att fungera) stödjer en snabb teknik för kopiera och klistra in. Om du markerar text genom att hålla nere vänster musknapp och dra över texten (eller dubbelklicka på ett ord) kopieras den till en buffert som fönstersystemet håller. Ett tryck på mittenknappen klistrar in texten vid markören. Prova. Det fungerar i de flesta skrivbordsmiljöer.

Obs: Låt dig inte frestas att använda Ctrl-c och Ctrl-v för kopiera och klistra in i terminalfönstret. Det fungerar inte. De styrkoderna har andra betydelser i skalet och tilldelades många år innan Microsoft Windows släpptes. Använd Shift-Ctrl-c och Shift-Ctrl-v i terminalfönstret i stället.

Din grafiska skrivbordsmiljö (troligen KDE eller GNOME) har förmodligen sin fokuseringspolicy inställd på "klicka för att fokusera", i ett försök att bete sig som Windows. Det innebär att ett fönster måste klickas på för att få fokus (bli aktivt). Detta är motsatsen till det traditionella beteendet "fokus följer mus", som innebär att ett fönster får fokus bara genom att muspekaren förs över det. Fönstret kommer inte till förgrunden förrän du klickar på det, men det kommer att kunna ta emot inmatning. Att ställa in fokuseringspolicyn till "fokus följer mus" gör kopiera-och-klistra-tekniken ännu mer användbar. Prova om du kan (vissa skrivbordsmiljöer stödjer det inte längre). Jag tror att om du ger det en chans kommer du att föredra det. Du hittar denna inställning i konfigurationsprogrammet för din fönsterhanterare.

Även om vi inte har någon terminalemulator som körs fortsätter flera terminalsessioner att köra bakom det grafiska skrivbordet. Vi kan komma åt dessa sessioner, som kallas virtuella terminaler eller virtuella konsoler, genom att trycka på Ctrl-Alt-F1 till Ctrl-Alt-F6 på de flesta Linux-distributioner. När en session nås presenteras en inloggningsprompt där vi kan ange vårt användarnamn och lösenord. För att växla från en virtuell konsol till en annan trycker du på Alt-F1 till Alt-F6. På de flesta system kan vi återgå till det grafiska skrivbordet genom att trycka på Alt-F7.

En absolut sökväg börjar i rotkatalogen och följer gren för gren tills vägen till önskad katalog eller fil är klar. På vårt system finns till exempel en katalog där många av systemets program är installerade. Den katalogens sökväg är /usr/bin. Det betyder att det från rotkatalogen (som markeras av inledande snedstreck) finns en katalog som heter usr och i den en katalog som heter bin.

Nu ser vi att vi har bytt aktuell arbetskatalog till /usr/bin och att den är full av filer. Märkte du att skalprompten ändrades? Av bekvämlighetsskäl är den ofta inställd att automatiskt visa namnet på arbetskatalogen.

Medan en absolut sökväg börjar i rotkatalogen och leder till sitt mål, börjar en relativ sökväg i arbetskatalogen. Då används ett par särskilda notationer för att beskriva relativa lägen i filsystemträdet. Dessa är . (punkt) och .. (två punkter).

Notationen . syftar på arbetskatalogen och .. syftar på arbetskatalogens överordnade katalog. Låt oss till exempel byta arbetskatalog till /usr/bin igen.

Anta nu att vi vill byta arbetskatalog till överordnad katalog för /usr/bin, alltså /usr. Det kan vi göra på två sätt, antingen med en absolut sökväg:

eller med en relativ sökväg:

Två olika metoder med samma resultat. Vilken ska vi använda? Den som kräver minst tangenttryckningar.

På samma sätt kan vi byta arbetskatalog från /usr till /usr/bin på två sätt, antingen med en absolut sökväg:

eller med en relativ sökväg:

Det finns en viktig sak att påpeka här. I nästan alla fall kan vi utelämna ./. Det är underförstått. Att skriva

gör samma sak. I allmänhet gäller att om vi inte anger en sökväg till något, så antas arbetskatalogen.

I tabell 2-1 ser vi några praktiska sätt att snabbt byta aktuell arbetskatalog.

Här kommer en viktig poäng om hur de flesta kommandon fungerar. Kommandon följs ofta av en eller flera flaggor som ändrar beteendet och dessutom av ett eller flera argument, alltså det som kommandot arbetar med. Därför ser de flesta kommandon ut så här:

De flesta kommandon använder flaggor som består av ett enda tecken med inledande bindestreck, till exempel -l. Många kommandon, särskilt från GNU-projektet, stöder också långa flaggor med två inledande bindestreck, till exempel ett helt ord. Många kommandon tillåter också att flera korta flaggor skrivs ihop. I exemplet nedan får ls två flaggor: l för långt format och t för sortering efter filens ändringstid.

Vi lägger till den långa flaggan --reverse för att vända sorteringsordningen.

Observera att kommandoflaggor, liksom filnamn i Linux, är skiftlägeskänsliga.

Som vi såg tidigare gör flaggan -l att ls visar resultat i detaljerat format. Det formatet innehåller mycket användbar information. Här är katalogen Examples från ett äldre Ubuntu-system:

Tabell 3-2 visar de olika fälten och deras betydelse.

Text är en enkel en-till-en-mappning mellan tecken och tal. Det är kompakt: femtio tecken text blir 50 byte data. Det är viktigt att förstå att text bara innehåller denna enkla mappning mellan tecken och tal. Det är inte samma sak som ett ordbehandlingsdokument, till exempel skapat i Microsoft Word eller LibreOffice Writer. Sådana filer innehåller, till skillnad från enkel ASCII-text, många icke-textuella element som beskriver struktur och formatering. Rena ASCII-textfiler innehåller bara själva tecknen och några få enkla styrkoder, som tabbar, vagnretur och radmatning.

I ett Linuxsystem lagras många filer i textformat, och det finns många Linuxverktyg som arbetar med textfiler. Även Windows känner igen formatets betydelse. Det välkända programmet NOTEPAD.EXE är en redigerare för rena ASCII-textfiler.

Varför vill vi granska textfiler? Därför att många filer som innehåller systeminställningar (konfigurationsfiler) lagras i detta format, och att kunna läsa dem ger oss insikt i hur systemet fungerar. Dessutom lagras en del av de faktiska program som systemet använder (skript) i detta format. I senare kapitel lär vi oss att redigera textfiler för att ändra systeminställningar och skriva egna skript, men just nu nöjer vi oss med att titta på innehållet.

Kommandot less används så här:

När less väl startat kan vi bläddra framåt och bakåt i en textfil. För att granska filen som definierar systemets alla användarkonton skriver vi till exempel:

När less är igång kan vi läsa filens innehåll. Om filen är längre än en sida kan vi bläddra upp och ned. För att avsluta less trycker vi q. Tabell 3-3 listar de vanligaste tangentbordskommandona i less.

Tabell 4-4 listar några vanliga flaggor för cp.

Tabell 4-5 visar några typiska användningsfall för cp.

mv delar flera flaggor med cp, enligt tabell 4-6.

Var särskilt försiktig med jokertecken. Här är ett klassiskt exempel. Om du vill ta bort bara HTML-filer i en katalog skriver du:

Det är korrekt. Men om du av misstag sätter ett mellanslag mellan \* och .html så här:

kommer rm att ta bort alla filer i katalogen och därefter klaga på att det inte finns någon fil som heter .html.

Ett användbart tips: när du använder jokertecken med rm, testa mönstret först med ls. Då ser du vilka filer som kommer att tas bort. Tryck sedan uppåtpil för att hämta kommandot och ersätt ls med rm.

Hårda länkar är det ursprungliga Unixsättet att skapa länkar, jämfört med symboliska länkar som är modernare. Som standard har varje fil en enda hård länk som ger filen dess namn. När vi skapar en hård länk skapar vi en extra katalogpost för en fil. Hårda länkar har två viktiga begränsningar:

En hård länk går inte att skilja från själva filen. Till skillnad från en symbolisk länk syns ingen särskild markering i en kataloglistning. När en hård länk tas bort försvinner länken, men filens innehåll finns kvar (det vill säga att utrymmet inte frigörs) tills alla länkar till filen har tagits bort.

Det är viktigt att känna till hårda länkar eftersom du kan stöta på dem då och då, men i modern praxis används oftare symboliska länkar, som vi går vidare med nu.

Symboliska länkar skapades för att komma runt begränsningarna hos hårda länkar. De fungerar genom att skapa en särskild filtyp som innehåller en textpekare till den refererade filen eller katalogen. På det sättet fungerar de ungefär som genvägar i Windows, även om symboliska länkar förstås fanns långt tidigare.

En fil som en symbolisk länk pekar på och själva länken är i stort sett oskiljbara i användning. Om vi till exempel skriver till den symboliska länken skrivs data till den refererade filen. Men när vi tar bort en symbolisk länk är det bara länken som tas bort, inte filen. Om filen tas bort före länken kommer länken att finnas kvar men peka på ingenting. Då säger man att länken är bruten. I många implementationer visar ls brutna länkar i en avvikande färg, till exempel rött.

Länkkonceptet kan kännas förvirrande, men håll ut. Vi ska prova allt det här i praktiken, och då klarnar det.

mkdir används för att skapa kataloger. För att skapa vår playground-katalog ser vi först till att vi står i hemkatalogen och skapar sedan den nya katalogen.

För att göra playground lite mer intressant skapar vi två kataloger i den: dir1 och dir2. Vi byter aktuell arbetskatalog till playground och kör mkdir igen.

Lägg märke till att mkdir tar flera argument och därför kan skapa båda katalogerna med ett enda kommando.

Nu lägger vi in lite data i playground genom att kopiera en fil. Med kommandot cp kopierar vi filen passwd från katalogen /etc till aktuell arbetskatalog.

Notera att vi använder kortformen för aktuell arbetskatalog, den avslutande punkten. Om vi nu kör ls ser vi filen.

För att se vad flaggan -v gör upprepar vi kopieringen med utförlig utdata.

cp kopierade filen igen men visade nu ett kort meddelande om operationen. Lägg märke till att cp skrev över den första kopian utan varning. Även här antar cp att vi vet vad vi gör. För att få en fråga lägger vi till flaggan -i (interaktiv).

Svarar du y skrivs filen över; alla andra tecken (till exempel n) gör att cp lämnar filen som den är.

Namnet passwd känns inte särskilt lekfullt, och det här är ju en lekplats, så vi byter namn till något annat.

Nu skickar vi runt fun lite genom att flytta den omdöpta filen till katalogerna och tillbaka igen. Först till dir1:

Sedan från dir1 till dir2:

Till sist tillbaka till aktuell arbetskatalog:

Nu provar vi länkar. Vi börjar med att skapa några hårda länkar till vår datafil:

Nu har vi fyra instanser av filen fun. Låt oss titta i playground-katalogen.

Vi ser att det andra fältet i listningen för både fun och fun-hard innehåller siffran 4, vilket är antalet hårda länkar som nu finns till filen. Kom ihåg att en fil alltid har minst en länk eftersom filens namn skapas via en länk. Hur vet vi då att fun och fun-hard faktiskt är samma fil? Här hjälper ls inte hela vägen. Vi ser att fun och fun-hard har samma storlek (fält 5), men listningen räcker inte för att vara säker. Då måste vi gå lite djupare.

Kommandot ls kan visa så kallad inodinformation. Det anropas med flaggan -i.

I den här versionen av listningen är det första fältet inodnumret, och som vi ser delar fun och fun-hard samma inodnummer, vilket bekräftar att de är samma fil.

Symboliska länkar skapades för att lösa de två nackdelarna med hårda länkar:

Symboliska länkar är en särskild filtyp som innehåller en textpekare till målfilen eller målkatalogen. Att skapa symboliska länkar liknar att skapa hårda länkar.

Det första exemplet är rakt på sak: vi lägger till flaggan -s för att skapa en symbolisk länk i stället för en hård. Men de två följande då? Kom ihåg att när vi skapar en symbolisk länk skapar vi en textbeskrivning av var målfilen finns relativt länken. Det syns tydligare i ls-utdata:

Listningen för fun-sym i dir1 visar med inledande l att det är en symbolisk länk, och att den pekar på ../fun, vilket stämmer. Relativt platsen för fun-sym finns fun i katalogen ovanför. Notera också att längden på den symboliska länken är 6, alltså antalet tecken i strängen ../fun, och inte längden på filen som länken pekar på.

När vi skapar symboliska länkar kan vi använda antingen absoluta sökvägar, som här:

eller relativa sökvägar, som i vårt tidigare exempel. I de flesta fall är relativa sökvägar att föredra, eftersom de oftast gör att ett katalogträd med symboliska länkar och mål kan byta namn eller flyttas utan att länkar bryts.

Utöver vanliga filer kan symboliska länkar också peka på kataloger.

Som vi gick igenom tidigare används rm för att ta bort filer och kataloger. Vi använder det nu för att städa lite på vår övningsplats. Först tar vi bort en av våra hårda länkar.

Det fungerade som väntat. Filen fun-hard är borta, och länkräkningen för fun har minskat från fyra till tre, vilket syns i andra fältet i listningen.

Nu tar vi bort filen fun, och för nöjes skull lägger vi till -i för att se vad som händer.

Skriv y i prompten så tas filen bort. Titta sedan på ls-utdata. Ser du vad som hände med fun-sym? Eftersom den är en symbolisk länk till en fil som inte längre finns är länken nu bruten.

De flesta Linuxdistributioner konfigurerar ls så att brutna länkar syns tydligt. En bruten länk är inte farlig i sig, men den är rörig. Om vi försöker använda en bruten länk får vi detta:

Vi städar lite till och tar bort de symboliska länkarna.

En sak att minnas om symboliska länkar är att de flesta filoperationer utförs på länkens mål, inte på länken själv. rm är ett undantag. När vi tar bort en länk är det länken som tas bort, inte målet.

Till sist tar vi bort vår playground-katalog. Vi går tillbaka till hemkatalogen och använder rm med den rekursiva flaggan (-r) för att ta bort playground och allt innehåll, inklusive underkataloger.

Filhanterarna i både GNOME och KDE erbjuder ett enkelt och automatiskt sätt att skapa symboliska länkar. I GNOME skapar du en länk i stället för att kopiera eller flytta filen genom att hålla Ctrl+Shift medan du drar filen. I KDE visas en liten meny när en fil släpps, där du kan välja att kopiera, flytta eller länka filen.

Kommandot type är ett inbyggt skalkommando som visar vilken typ av kommando skalet kommer att köra för ett givet kommandonamn. Det används så här:

Här är command namnet på kommandot vi vill undersöka. Titta på några exempel:

Här ser vi resultat för tre olika kommandon. Lägg märke till raden för ls: ls är faktiskt ett alias för ls med flaggan --color=auto tillagd. Nu vet vi varför utdata från ls visas i färg.

Ibland finns mer än en version av ett körbart program installerad på ett system. Det är ovanligt på skrivbordssystem, men inte ovanligt på större servrar. För att ta reda på den exakta platsen för ett körbart program använder vi which.

which fungerar bara för körbara program, inte för inbyggda kommandon eller alias som ersätter faktiska körbara program. Om vi till exempel försöker använda which på cd får vi ingen respons eller ett felmeddelande:

Det här är ett fint sätt att säga "kommando hittades inte".

bash har inbyggd hjälp för varje inbyggt kommando. För att använda den skriver du help följt av namnet på det inbyggda kommandot. Exempel:

Den faktiska utdatan är längre, men det viktiga är att help ger kortfattad dokumentation specifik för inbyggda kommandon.

En notering om notation: när hakparenteser förekommer i beskrivningen av ett kommandos syntax markerar de valfria delar. Ett lodstreck anger ömsesidigt uteslutande alternativ. Ta det föregående cd-kommandot som exempel:

Denna notation säger att kommandot cd valfritt kan följas av antingen -L eller -P; vidare, om flaggan -P anges kan flaggan -e läggas till, följt av det valfria argumentet dir.

Även om utdata från help för kommandot cd är kortfattad och korrekt, är den inte alls pedagogisk. Tips: genom att använda help med flaggan -m visar help sin utdata i ett alternativt format som liknar en manualsida.

Många körbara program stöder flaggan --help som visar en beskrivning av kommandots syntax och flaggor. Till exempel:

Vissa program stöder inte --help, men prova ändå. Ofta resulterar det i ett felmeddelande som ändå visar användningsinformationen.

De flesta körbara program som är avsedda för kommandoraden har en formell dokumentationssida, en manualsida (man page). Ett särskilt sidvisarprogram som heter man används för att visa dem.

Manualsidor kan variera lite i format, men innehåller vanligtvis följande:

Manualsidor innehåller däremot oftast inte exempel och är avsedda som uppslagsverk, inte handledningar. Som exempel kan vi visa manualsidan för kommandot ls.

På de flesta Linuxsystem använder man less för att visa manualsidan, så alla välbekanta less-kommandon fungerar även där.

Manualen som man visar är uppdelad i avsnitt och täcker inte bara användarkommandon utan även systemadministrationskommandon, programmeringsgränssnitt, filformat med mera. Tabell 5-1 beskriver upplägget.

Ibland behöver vi hänvisa till ett visst avsnitt i manualen för att hitta det vi söker. Det gäller särskilt om vi letar efter ett filformat som också är namnet på ett kommando. Utan avsnittsnummer får vi alltid den första träffen, troligen i avsnitt 1. För att ange avsnittsnummer använder vi man så här:

Här är ett exempel:

Detta visar manualsidan som beskriver filformatet för /etc/passwd.

Det går också att söka i listan över manualsidor efter möjliga träffar utifrån en sökterm. Det är grovt men ibland hjälpsamt.

Det första fältet i varje rad av utdatan är namnet på manualsidan, och det andra fältet visar avsnittet. Observera att man med flaggan -k gör samma sak som apropos.

Programmet whatis visar namnet och en enradig beskrivning av en manualsida som matchar ett angivet nyckelord:

Notering:

Som vi har sett är manualsidorna som medföljer Linux och andra Unix-liknande system avsedda som referensdokumentation, inte som handledningar. Många manualsidor är svårlästa, men priset för svårast går troligen till manualsidan för bash.

GNU-projektet tillhandahåller ett alternativ till manualsidor för sina program, kallat info. Info-manualer visas med ett läsarprogram som, passande nog, heter info.

Infosidor är hyperlänkade ungefär som webbsidor. Programmet info läser info-filer som är strukturerade i enskilda noder, var och en med ett enskilt ämne. En hyperlänk känns igen på sin inledande asterisk och aktiveras genom att placera markören på den och trycka Enter.

För att starta info skriver du info valfritt följt av programnamnet. Tabell 5-2 beskriver kommandona som används för att styra läsaren medan en info-sida visas.

De flesta kommandoradsprogram vi har diskuterat hittills ingår i GNU-projektets coreutils-paket, så genom att skriva:

visas en menysida med hyperlänkar till varje program i coreutils-paketet.

Många programpaket installerade i systemet har dokumentationsfiler i katalogen /usr/share/doc. De flesta lagras i ren text och kan visas med less. Vissa filer är i HTML-format och kan visas i en webbläsare. Vi kan också stöta på filer som slutar med .gz. Det betyder att de är komprimerade med gzip. Gzip-paketet innehåller en särskild variant av less som heter zless och som kan visa innehållet i gzip-komprimerade textfiler.

Bit-hinken är ett gammalt Unixbegrepp, och eftersom det är så allmängiltigt har det dykt upp i många delar av Unixkulturen. Om någon säger att dina kommentarer skickas till /dev/null vet du nu vad det betyder.

Kommandot cat läser en eller flera filer och kopierar dem till standard ut:

Vi kan använda det för att visa filer utan sidindelning.

Eftersom cat kan ta mer än en fil som argument kan det också användas för att slå ihop filer.

Om cat inte får något argument läser det från standard in.

Utan filnamnsargument kopierar cat standard in till standard ut, och vi ser textraden upprepad. Vi kan använda det beteendet för att skapa korta textfiler:

Vi kan använda cat för att kopiera filen till stdout igen.

Nu provar vi att omdirigera standard in.

Med omdirigeringsoperatorn < ändrar vi källan för standard in från tangentbordet till filen lazy_dog.txt.

OBS:

Omdirigeringsoperatorn kopplar ett kommando till en fil, medan rörledningsoperatorn kopplar utdata från ett kommando till indata för ett annat kommando.

Lärdomen här är att omdirigeringsoperatorn > tyst skapar eller skriver över filer, så den bör behandlas med respekt.

Kommandot uniq används ofta tillsammans med sort. Som standard tar det bort dubbletter från en sorterad lista.

Kommandot wc (word count) används för att visa antal rader, ord och byte i filer.

Flaggan -l begränsar utdata till att bara visa antal rader. I kombination med en rörledning är det ett smidigt sätt att räkna saker.

grep är ett kraftfullt program för att hitta textmönster i filer.

Anta att vi vill hitta alla filer i vår programlista som innehåller ordet zip i namnet:

Här är några praktiska flaggor för grep:

Ibland vill vi inte ha all utdata från ett kommando. Vi kanske bara vill ha de första eller sista raderna. Kommandot head skriver ut de första 10 raderna i en fil, och tail skriver ut de sista 10. Antalet kan ändras med flaggan -n.

Dessa kommandon kan också användas i rörledningar:

Genom att använda -n med både head och tail kan vi ta ut ett utdrag från mitten av en fil:

tail har också en flagga som gör det möjligt att följa innehållet i en fil i realtid. Det är användbart för att bevaka hur loggfiler skrivs.

Med flaggan -f fortsätter tail att övervaka filen, och när nya rader läggs till visas de omedelbart. Det fortsätter tills vi trycker Ctrl-c.

I Linux finns ett kommando som heter tee och som skapar en T-koppling på röret. Programmet tee läser från standard in och kopierar till både standard ut och till en eller flera filer. Det är användbart när vi vill fånga innehållet i en rörledning i ett mellanled.

När jag blir ombedd att förklara skillnaden mellan Windows och Linux använder jag ofta en leksaksjämförelse. Windows är som en Game Boy: det kommer förseglat, polerat och begränsat till vad någon annan bestämt att du behöver. Linux, å andra sidan, är som världens största Mekano-låda: en enorm samling delar som kan anta vilken form din fantasi önskar. Det gör vad du vill.

Mekanismen bakom jokertecken kallas sökvägsexpansion. Om vi provar några av teknikerna från tidigare kapitel ser vi att de egentligen är just expansioner. Givet en hemkatalog som ser ut så här:

För att matcha filnamn som börjar med en punkt (dolda filer) måste vi vara försiktiga, eftersom skalet normalt inte expanderar filnamn som börjar med en punkt.

Som vi kanske minns från introduktionen av cd har tilde-tecknet (~) en särskild betydelse. När det används i början av ett ord expanderas det till hemkatalogen för den angivna användaren, eller - om ingen användare anges - hemkatalogen för aktuell användare.

Skalet kan utföra aritmetik via expansion. Det gör att vi kan använda skalprompten som en räknare.

Aritmetisk expansion använder formen:

där uttryck är ett aritmetiskt uttryck som består av värden och operatorer.

Aritmetisk expansion stöder bara heltal (inga decimaler), men kan utföra en hel del olika operationer. Tabell 7-1 beskriver några av operatorerna. Mellanslag är inte signifikanta i aritmetiska uttryck, och uttryck kan nästlas.

Kanske den märkligaste expansionen kallas klammerexpansion. Med den kan vi skapa flera textsträngar från ett mönster som innehåller klammerparenteser. Exempel:

Den vanligaste tillämpningen är att skapa listor med filer eller kataloger som ska skapas.

Vi rör bara kort vid parameterexpansion i det här kapitlet, men vi kommer tillbaka till den grundligt senare. Det är en funktion som oftast är mer användbar i skalskript än direkt på kommandoraden. Många av dess möjligheter bygger på systemets förmåga att lagra små datamängder och ge varje sådan mängd ett namn. Många sådana datamängder - mer korrekt kallade variabler - finns tillgängliga för oss att granska. Variabeln USER innehåller till exempel vårt användarnamn. För att anropa parameterexpansion och visa innehållet i USER gör vi så här:

Om vi stavar namnet på en variabel fel sker expansionen ändå, men resultatet blir en tom sträng.

Kommandosubstitution låter oss använda utdata från ett kommando som en expansion.

Vi är inte begränsade till enkla kommandon. Hela rörledningar kan också användas.

Första typen av citering vi tittar på är dubbla citationstecken. Om vi placerar text i dubbla citationstecken förlorar alla specialtecken sin särskilda betydelse och behandlas som vanliga tecken. Undantagen är $, \ (omvänt snedstreck) och ` (omvänd apostrof).

Det betyder att orduppdelning, sökvägsexpansion, tildeexpansion och klammerexpansion undertrycks, men parameterexpansion, aritmetisk expansion och kommandosubstitution utförs fortfarande.

Om vi behöver undertrycka alla expansioner använder vi enkla citationstecken. Här är en jämförelse mellan ociterat, dubbla citationstecken och enkla citationstecken:

Ibland vill vi citera bara ett enda tecken. Då kan vi sätta ett omvänt snedstreck före tecknet. I detta sammanhang kallas det escape-tecken. Ofta görs detta inuti dubbla citationstecken för att selektivt förhindra expansion:

Backslash-tecknet har en särskild betydelse i dubbla citationstecken. Det används för att skapa escape-sekvenser som representerar specialtecken.

Om vi vill att ett omvänt snedstreck ska visas, escape:ar vi det med \\.

Följande tabell listar tangenter för att flytta markören:

Eftersom vi kan göra misstag när vi skriver kommandon behöver vi ett effektivt sätt att rätta dem. Tabell 8-2 beskriver tangentkommandon för redigering av tecken på kommandoraden.

I Readline-dokumentationen används termerna killing och yanking för det vi vanligtvis kallar klippa ut och klistra in. Det som klipps ut lagras i en buffert (ett tillfälligt minnesområde) som kallas kill-ring.

Många av de tangenter vi har använt är modifierare (Ctrl och Alt) kombinerade med andra tangenter. Det finns en tredje modifierare som kallas Meta. På moderna tangentbord finns det ingen tangent som heter Meta, men den finns ofta som Alt-tangenten. För att använda Meta-tangenten håller du ner Alt och trycker på en annan tangent. Till exempel: Meta-a.

Kompletteringsfunktionen är programmerbar och kan anpassas för olika typer av kommandon och argument.

Vi kan när som helst visa innehållet i historiklistan så här:

Som standard lagrar de flesta moderna Linuxdistributioner de senaste 1000 kommandona. Vi ser hur värdet ändras i kapitel 11.

Anta att vi vill hitta kommandon vi använde för att lista /usr/bin. Ett sätt är:

88 är radnumret i historiklistan. Vi kan använda det direkt med en annan expansionstyp som kallas historikexpansion. För att använda raden gör vi så här:

bash expanderar !88 till innehållet på rad 88 i historiklistan.

bash kan också söka i historiklistan inkrementellt. Tryck Ctrl-r följt av texten du söker efter. När du hittar den kan du antingen trycka Enter för att köra kommandot eller Ctrl-j för att kopiera raden från historiklistan till den aktuella kommandoraden.

Skalprompten återkommer, och kommandoraden är laddad och redo. Tabell 8-5 listar tangenter för att hantera historiklistan.

Skalet erbjuder en särskild expansionstyp för poster i historiklistan med tecknet !. Vi har redan sett hur utropstecknet kan följas av ett tal för att infoga en historikpost. Flera andra expansioner finns också, enligt tabell 8-6.

Var försiktig med formerna !sträng och !?sträng om du inte är helt säker på vad historiken innehåller. Vi kan minska risken något genom att lägga till :p till expansionen. Då skriver skalet ut resultatet av expansionen och lägger det i historiken. Exempel:

Nu när kommandot har hämtats och placerats som senaste post i historiken kan vi köra det med uppåtpil + Enter eller !! + Enter.

Utöver historikfunktionen i bash innehåller de flesta Linuxdistributioner ett program som heter script som kan användas för att spela in en hel terminalsession och lagra den i en fil.

Om ingen fil anges används filen typescript.

För att ändra läge (behörigheter) för en fil eller katalog används kommandot chmod. Observera att bara filens ägare eller superanvändaren kan ändra en fils eller katalogs läge. chmod stödjer två olika sätt att ange lägessändringar: oktalt tal och symbolisk notation.

Oktal (bas 8) och dess kusin hexadecimal (bas 16) är talsystem som ofta används för att uttrycka tal i datorer. Vi människor, tack vare att vi (eller åtminstone de flesta av oss) föds med tio fingrar, räknar i bas 10. Datorer föddes däremot med bara ett finger och räknar därför i binärt (bas 2). Deras talsystem har bara två siffror: 0 och 1. Binär räkning ser ut så här:

Med tre oktala siffror kan vi ställa in filläget för ägaren, gruppägaren och övriga.

Genom att ange argumentet 600 kunde vi ställa in ägarens behörigheter till läs- och skrivbehörighet samtidigt som vi tog bort alla behörigheter från gruppägaren och övriga.

chmod stödjer också symbolisk notation för att ange fillägen. Symbolisk notation delas in i tre delar:

För att ange vem som påverkas används en kombination av tecknen u, g, o och a.

Behörigheter anges med tecknen r, w och x. Tabell 9-6 ger några exempel.

Nu när vi har sett hur behörigheter för filer och kataloger ställs in kan vi bättre förstå behörighetsdialogerna i det grafiska gränssnittet. I både Filer (GNOME) och Dolphin (KDE) kan man högerklicka på en fil- eller katalogikon för att visa en egenskapsdialog. Här är ett exempel från GNOME:

Här kan vi se inställningarna för ägaren, gruppen och övriga.

Även om vi vanligtvis ser en oktal behörighetsmask uttryckt som ett tresiffrigt tal är det tekniskt korrektare att uttrycka den med fyra siffror. Förutom läs-, skriv- och körbehörighet finns det några andra, mindre använda, behörighetsinställningar: setuid (4000), setgid (2000) och sticky (1000).

Exempel i ls-utdata:

Kommandot su används för att starta ett skal som en annan användare. Syntaxen ser ut så här:

Om flaggan -l inkluderas blir den resulterande skalsessionen ett inloggningsskal för den angivna användaren. Det betyder att användarens miljö laddas och att arbetskatalogen byts till användarens hemkatalog. Det är oftast det vi vill ha.

Om ingen användare anges antas superanvändaren. Notera att (lite märkligt) -l kan förkortas till -, vilket är den vanligaste formen.

Kommandot sudo liknar su på många sätt men har viktiga extra möjligheter. Administratören kan konfigurera sudo så att en vanlig användare får köra kommandon som en annan användare (oftast superanvändaren) på ett kontrollerat sätt. I synnerhet kan användaren begränsas till ett eller flera specifika kommandon och inga andra.

En annan viktig skillnad är att sudo inte kräver tillgång till superanvändarens lösenord. Vid autentisering med sudo används användarens eget lösenord.

För att se vilka privilegier som beviljas av sudo kan vi använda flaggan -l.

Ett återkommande problem för vanliga användare är att utföra uppgifter som kräver superanvändarprivilegier. Det handlar om saker som att installera och uppdatera programvara, redigera systemkonfigurationsfiler och komma åt enheter. I Windows-världen löser man ofta detta genom att ge användarna administratörsrättigheter. Det gör att de kan utföra dessa uppgifter, men det innebär också att program som körs av användaren har samma behörigheter. I de flesta fall är det önskvärt, men det tillåter även skadlig programvara (som virus) att härja fritt på datorn.

I Unix-världen har det alltid funnits en tydligare uppdelning mellan vanliga användare och administratörer, tack vare Unix fleranvändararv. Metoden i Unix är att ge superanvändarprivilegier bara vid behov. För detta används vanligen kommandona su och sudo.

Förr i tiden förlitade sig de flesta Linux-distributioner på su för detta ändamål. su krävde inte den konfiguration som sudo krävde, och att ha ett root-konto är tradition i Unix. Det skapade dock ett problem. Användarna frestades att arbeta som root i onödan. Faktum är att vissa användare körde sina system enbart som root-användaren, eftersom det gör sig av med alla de irriterande "permission denied"-meddelandena. Det är så man sänker säkerheten i ett Linux-system till nivån hos ett Windows-system. Ingen bra idé.

När Ubuntu introducerades valde skaparna en annan väg. Som standard inaktiverar Ubuntu inloggning till root-kontot (genom att inte sätta något lösenord för kontot) och använder istället sudo för att bevilja superanvändarprivilegier. Det initiala användarkontot ges full tillgång till superanvändarprivilegier via sudo, och kan ge liknande befogenheter till efterföljande användarkonton. Denna metod att bevilja privilegier är numera den accepterade standarden i de flesta moderna distributioner.

I äldre Unixversioner ändrade kommandot chown bara filägare, inte gruppägare. För det ändamålet användes ett separat kommando, chgrp. Det fungerar i stort sett som chown, men är mer begränsat.

Även om kommandot ps kan avslöja mycket om vad maskinen gör ger det bara en ögonblicksbild av systemets tillstånd vid det ögonblick då ps körs. För att se en mer dynamisk bild av maskinens aktivitet använder vi kommandot top:

Programmet top visar en fortlöpande uppdaterad vy (som standard var tredje sekund) av systemets processer, sorterade efter processaktivitet. Namnet top kommer av att programmet används för att se de "översta" processerna i systemet. top-vyn består av två delar: en systemsammanfattning längst upp och därefter en tabell över processer sorterade efter processoraktivitet:

top tar emot ett antal tangentbordskommandon. De två mest intressanta är h, som visar programmets hjälpskärm, och q, som avslutar top.

Låt oss se vad som händer när vi kör xlogo igen. Skriv först kommandot xlogo och kontrollera att programmet kör. Gå sedan tillbaka till terminalfönstret och tryck Ctrl-c.

I en terminal avbryter Ctrl-c ett program. Det betyder att vi artigt ber programmet att avsluta sig. När vi tryckte Ctrl-c stängdes xlogo-fönstret och skalprompten kom tillbaka.

Anta att vi vill få tillbaka skalprompten utan att avsluta programmet xlogo. Det kan vi göra genom att lägga programmet i bakgrunden. Tänk på terminalen som att den har en förgrund (med sådant som syns på ytan, som skalprompten) och en bakgrund (med sådant som är dolt bakom ytan). För att starta ett program så att det omedelbart hamnar i bakgrunden lägger vi till ett et-tecken (&) efter kommandot.

Efter att kommandot skrevs dök xlogo-fönstret upp och skalprompten kom tillbaka, men några märkliga siffror skrevs också ut. Meddelandet är en del av skalets funktion för jobbstyrning. Med det talar skalet om att vi har startat jobb nummer 1 ([1]) och att det har PID 28236. Om vi kör ps kan vi se processen.

En process i bakgrunden tar inte emot tangentbordsinmatning från terminalen, inklusive försök att avbryta den med Ctrl-c. För att flytta tillbaka en process till förgrunden använder vi kommandot fg så här:

Kommandot fg, följt av ett procenttecken och jobbnumret (kallat en jobbspecifikation), gör jobbet. Om vi bara har ett bakgrundsjobb är jobbspecifikationen valfri. För att avsluta xlogo, tryck Ctrl-c.

Ibland vill vi stoppa en process utan att avsluta den. Ofta gör man det för att kunna flytta en process i förgrunden till bakgrunden. För att stoppa en förgrundsprocess och placera den i bakgrunden trycker vi Ctrl-z. Prova. Skriv xlogo vid prompten, tryck Enter och därefter Ctrl-z:

När xlogo har stoppats kan vi kontrollera att programmet verkligen har stannat genom att försöka ändra storlek på xlogo-fönstret. Vi kommer att se att det går att ändra storlek på fönstret, men logotypen ritas inte om, vilket visar att programmet är stoppat. Vi kan antingen fortsätta programmets körning i förgrunden med kommandot fg, eller återuppta körningen i bakgrunden med kommandot bg:

Som vi såg i utdata från kommandot ps (och även top) finns det ett processattribut som kallas niceness och som syftar på den schemaläggningsprioritet som ges till en process. I vissa situationer, till exempel vid videokodning eller processorbaserad ray tracing, kan vi vilja ge en process högre prioritet (mindre niceness). Och om vi i stället vill att en process ska använda mindre processortid kan vi ge den högre niceness. Niceness kan justeras med kommandona nice och renice. Det är viktigt att komma ihåg att bara superanvändaren får höja prioriteten för en process och att vanliga användare bara får sänka prioriteten för processer de själva äger.

Kommandot nice startar en process med en angiven niceness. Justeringar av niceness uttrycks från -20 (mest gynnsamt) till 19 (minst gynnsamt), med standardvärdet 0 (ingen justering). Låt oss se hur det fungerar. Föreställ dig att vi har ett program som heter cpu-hog och att vi vill köra det med lägre prioritet än dess normala 20. Vi kan starta programmet med nice så här:

Kommandot kill används för att skicka signaler till processer. Den vanligaste syntaxen ser ut så här:

Om ingen signal anges skickas signalen TERM som standard. Tabell 10-5 listar de vanligaste signalerna.

Processer, precis som filer, har ägare, och du måste vara ägare till en process eller superanvändare för att skicka signaler till den med kill.

För att visa en fullständig lista över signaler:

Som vi diskuterade ovan reagerar många kommandoradsprogram på signalen HUP genom att avslutas när deras styrande terminal "lägger på" (det vill säga stängs eller kopplas ned). För att förhindra detta kan vi starta programmet med kommandot nohup. Här är ett exempel.

Det går också att skicka signaler till flera processer som matchar ett angivet programnamn eller användarnamn med kommandot killall. Syntaxen ser ut så här:

För att se vad som finns lagrat i miljön kan vi använda antingen det inbyggda kommandot set i bash eller programmet printenv. Kommandot set visar både skalvariabler och miljövariabler, medan printenv bara visar de senare. Eftersom listan över miljöns innehåll blir ganska lång är det bäst att skicka utdata från något av kommandona till less.

Miljön innehåller ganska många variabler, och även om din miljö kan skilja sig från den som visas här kommer du sannolikt att hitta de variabler som listas i tabell 11-1.

Om vi tittar in i en typisk .bash_profile kan den se ut ungefär så här:

Rader som börjar med # är kommentarer och körs inte av skalet. De finns där för människors skull. Det första intressanta sker på fjärde raden, i följande kod:

Den sista punkten förtjänar lite mer utveckling. Skalvariabler är lokala för den aktuella instansen av skalet och kopieras inte till de barn som skalet startar. Låt oss visa det.

Först sätter vi en skalvariabel i vårt aktuella skal.

Ett annat praktiskt knep som skalet erbjuder är möjligheten att köra ett kommando och samtidigt ge det en tillfällig miljövariabel. Ibland vill vi köra ett program och ge det ett särskilt miljövärde. Ett bra exempel är kommandot man, som tittar efter en miljövariabel med namnet MANWIDTH som talar om för man hur brett dess utdata ska formateras.

Som allmän regel gäller att om vi vill lägga till kataloger i PATH eller definiera ytterligare miljövariabler, ska vi lägga dessa ändringar i .bash_profile (eller motsvarande fil enligt distributionen; Ubuntu använder till exempel .profile). För allt annat lägger vi ändringarna i .bashrc.

För att redigera (alltså ändra) skalets startfiler, liksom de flesta andra konfigurationsfiler i systemet, använder vi ett program som kallas textredigerare. En textredigerare är ett program som på vissa sätt liknar en ordbehandlare, eftersom den låter oss redigera ord på skärmen med en flyttbar markör. Den skiljer sig från en ordbehandlare genom att bara hantera ren text och ofta innehåller funktioner som är avsedda för att skriva program. Textredigerare är utvecklares centrala verktyg för att skriva kod och systemadministratörers centrala verktyg för att hantera de konfigurationsfiler som styr systemet.

Textredigerare startas från kommandoraden genom att vi skriver namnet på redigeraren följt av namnet på filen vi vill redigera. Om filen inte redan finns antar redigeraren att vi vill skapa en ny fil. Här är ett exempel med gedit:

Detta startar textredigeraren gedit och läser in filen some_file, om den finns.

Grafiska textredigerare är ganska självförklarande, så vi går inte igenom dem här. I stället koncentrerar vi oss på vår första textbaserade redigerare, nano. Låt oss starta nano och redigera filen .bashrc. Men innan vi gör det ska vi först öva lite "säker datoranvändning". Varje gång vi redigerar en viktig konfigurationsfil är det klokt att skapa en säkerhetskopia av filen först. Det skyddar oss om vi råkar förstöra filen under redigeringen. För att skapa en säkerhetskopia av filen .bashrc gör vi så här:

Det spelar ingen roll vad vi kallar säkerhetskopian, bara namnet är begripligt. Filändelser som .bak, .sav, .old och .orig är alla vanliga sätt att markera att det är en säkerhetskopia. Och kom ihåg att cp skriver över befintliga filer utan att säga till.

Nu när vi har en säkerhetskopia startar vi redigeraren.

När nano startar får vi en skärm som denna:

Kommentarer i konfigurationsfiler är viktiga för att dokumentera ändringar och göra filerna lättare att förstå.

Kommandot source (som kan förkortas .) är ett inbyggt skal-kommando som läser in en fil direkt i det aktuella skalet, som om dess innehåll hade skrivits in på tangentbordet. Ja, allt det där märkliga vi har sett i skalets startfiler är helt enkelt sådant som skalet förstår och kan agera på. Många äldre textbaserade operativsystem (DOS, CP/M och så vidare) fungerade mest som enkla programstartare. Unixskal kan förstås göra det också, som vi redan har sett, men de kan också göra mycket mer.

I startskärmen ovan ser vi texten "Running in Vi compatible mode." Det betyder att vim kör i ett läge som ligger närmare det vanliga beteendet hos vi än de utökade funktionerna i vim. I det här kapitlet vill vi använda vim med dess utökade beteende. Det går att lösa på flera sätt. Prova att köra vim i stället för vi. Om det fungerar kan du överväga att lägga till alias vi='vim' i filen .bashrc. Ett annat alternativ är att använda detta kommando för att lägga till en rad i din vim-konfigurationsfil:

För att lägga till text i filen måste vi först gå in i infogningsläge. Det gör vi genom att trycka i. Därefter bör vi längst ned på skärmen se följande om vim kör i sitt vanliga utökade läge (detta visas inte i kompatibilitetsläge för vi):

Nu kan vi skriva in lite text. Prova detta:

För att lämna infogningsläge och återgå till normalläge trycker vi Esc.

För att spara ändringen vi just gjorde i filen måste vi gå in i kommandoläge. Det gör vi genom att trycka : medan vi är i normalläge. Då bör ett kolon visas längst ned på skärmen.

vi har flera olika sätt att gå in i infogningsläge. Vi har redan använt kommandot i för att lägga in text.

Ett annat sätt att lägga in text är att "öppna" en rad. Det innebär att en tom rad förs in mellan två befintliga rader och att vi går in i infogningsläge. Detta finns i två varianter, som beskrivs i tabell 12-2.

Som väntat erbjuder vi flera olika sätt att ta bort text, och de kretsar alla kring två tangenttryckningar. Först har vi kommandot x, som tar bort tecknet där markören står. x kan föregås av ett tal som anger hur många tecken som ska tas bort. Kommandot d är mer allmänt användbart. Precis som x kan det föregås av ett tal som anger hur många gånger borttagningen ska göras. Dessutom följs d alltid av ett rörelsekommando som styr hur stor borttagningen blir. Tabell 12-3 ger några exempel.

Kommandot d tar inte bara bort text utan "klipper ut" den också. Varje gång vi använder d kopieras det som tas bort till en inklistringsbuffert (tänk urklipp), som vi senare kan hämta tillbaka med kommandot p för att klistra in innehållet efter markören eller med kommandot P för att klistra in det före markören.

vi är ganska strikt i sin syn på vad en rad är. Normalt går det inte att flytta markören till slutet av en rad och ta bort radslutstecknet för att slå ihop raden med raden nedanför. Därför har vi ett särskilt kommando, J (inte att förväxla med j, som används för markörförflyttning), för att sammanfoga rader.

Kommandot f söker i en rad och flyttar markören till nästa förekomst av ett angivet tecken. Kommandot fa skulle till exempel flytta markören till nästa förekomst av tecknet a på den aktuella raden. När vi väl har gjort en teckensökning inom en rad kan sökningen upprepas genom att skriva semikolon (;).

För att flytta markören till nästa förekomst av ett ord eller en fras används kommandot /. Det fungerar på samma sätt som vi tidigare lärde oss i programmet less. När du skriver / visas ett snedstreck längst ned på skärmen. Skriv sedan ordet eller frasen som ska sökas efter, följt av Enter. Markören flyttas då till nästa plats som innehåller söksträngen. En sökning kan upprepas med den föregående söksträngen genom kommandot n. Här är ett exempel:

Placera markören på första raden i filen. Skriv följande och tryck Enter:

vi använder kommandoläge för att utföra sök-och-ersätt-åtgärder (kallade substitution i vi) över ett radintervall eller en hel fil. För att ändra ordet Line till line i hela filen skulle vi skriva följande kommando:

Låt oss dela upp kommandot och se vad varje del gör.

För att växla från en fil till nästa använder vi :bn. För att gå tillbaka till föregående fil använder vi :bp.

Kommandot :buffers visar en lista över de filer som redigeras, och :buffer 2 växlar till buffert 2.

Det går också att lägga till filer i den aktuella redigeringssessionen. Kommandot :e i kommandoläge (kort för "edit"), följt av ett filnamn, öppnar ytterligare en fil. Låt oss avsluta den nuvarande sessionen och gå tillbaka till kommandoraden.

När vi redigerar flera filer vill vi ofta kopiera en del av en fil till en annan fil som vi arbetar med. Det görs enkelt med de vanliga yank-och-klistra-in-kommandona som vi använde tidigare. Vi kan visa det så här. Först byter vi till buffert 1 (foo.txt) genom att skriva:

Det går också att infoga en hel fil i en fil som vi redigerar. För att se detta i praktiken avslutar vi vår vi-session och startar en ny med bara en enda fil.

På den gamla goda tiden, när terminaler var kopplade till fjärrdatorer, fanns det många konkurrerande terminalmärken, och alla fungerade olika. De hade olika tangentbord och olika sätt att tolka styrinformation. Unix och Unix-liknande system har två ganska komplicerade delsystem för att hantera detta Babel av terminalstyrning (kallade termcap och terminfo). Om du letar längst in i inställningarna för din terminalemulator kan du hitta en inställning för typ av terminalemulering.

I ett försök att få terminaler att tala ett gemensamt språk tog American National Standards Institute (ANSI) fram en standarduppsättning teckensekvenser för styrning av bildskärmsterminaler. Gamla DOS-användare minns kanske filen ANSI.SYS, som användes för att aktivera tolkningen av dessa koder.

Teckenfärg styrs genom att man skickar en ANSI-escape-kod till terminalemulatorn, inbäddad i teckenströmmen som ska visas. Styrkoden "skrivs" inte ut på skärmen, utan tolkas i stället av terminalen som en instruktion. Som vi såg i tabell 13-1 används sekvenserna \[ och \] för att kapsla in tecken som inte skrivs ut. En ANSI-escape-kod börjar med \e (oktalt 033, koden som skapas av Esc), följt av ett valfritt teckenattribut och därefter en instruktion. Koden för att sätta textfärgen till normal (attribut = 0) och svart text ser till exempel ut så här: