Våldsamt slag

Den stabila versionen checkades ut den 14 september 2022 . Det finns overifierade ändringar i mallar eller .
GNU Bourne-Again Shell

Typisk session i bash
Sorts UNIX-skal
Författare Brian Fox
Utvecklaren Chet Ramey
Skrivet i Xi
Operativ system UNIX-liknande
Gränssnittsspråk Engelska , flerspråkig ( gettext )
Första upplagan 8 juni 1989
Hårdvaruplattform x86_64 [2] och i686 [2]
senaste versionen
betaversion 5.2-beta ( 13 april 2022 )
Läsbara filformat Bash script [d]
Licens GNU General Public License
Hemsida gnu.org/software/bash/
 Mediafiler på Wikimedia Commons

Bash (från engelska  B ourne a gain shell , ordlek "Born again"-skal -  "reborn"-skal) är en förbättrad och moderniserad variant av Bourne-skalets kommandoskal . Ett av de mest populära moderna UNIX- skalen . Särskilt populärt i Linux- miljön , där det ofta används som ett förinstallerat kommandoskal.

Det är en kommandoprocessor som vanligtvis fungerar interaktivt i ett textfönster. Bash kan också läsa kommandon från en fil som kallas script (eller script ). Liksom alla Unix-skal, stöder den fil- och katalogkomplettering, kommandoutmatningsersättning, variabler, kontroll över exekveringsordning, gren- och loop-satser. Nyckelord, syntax och andra grundläggande funktioner i språket lånades från sh . Andra funktioner, som historia, har kopierats från csh och ksh . Bash överensstämmer i princip med POSIX- standarden , men med ett antal tillägg [3] .

Namnet "bash" är en akronym för engelskan.  Bourne-again-shell ("ett annat-Bourne-shell") och är en lek med ord: Bourne-shell är en av de populära varianterna av skalet för UNIX (sh), författad av Stephen Bourne ( 1978 ), förbättrad 1987 av Brian Fox . Efternamnet Bourne (Född) återspeglar det engelska ordet born , som betyder "född", därav: born-again-command shell.

I september 2014 upptäcktes en allmänt utnyttjad Bashdoor-sårbarhet i bash .

Syntaxskillnader

De allra flesta viktiga Bourne-skalskript kan köras utan modifiering i bash, med undantag för de som hänvisar till Bourne specialvariabler eller använder Bourne inbyggda. Bash-kommandosyntaxen inkluderar idéer lånade från Korn-skalet ( ksh ) och C-skalet ( csh ), såsom kommandoradsredigering, kommandohistorik, katalogstack, variabler $RANDOMoch $PPID, kommandosubstitutionssyntax $(…). När det används som ett interaktivt skal, stöder Bash automatisk komplettering av programnamn, filer, variabler etc. med hjälp av tangenten Tab ↹.

Interna kommandon

Bash-tolken har många inbyggda kommandon, av vilka några har liknande körbara filer i operativsystemet . Observera dock att det oftast inte finns några man-sidor för inbyggda kommandon , och när du försöker se hjälpen för ett inbyggt kommando kommer du faktiskt att se hjälp för den körbara filen. Den körbara filen och det inbyggda kommandot kan skilja sig åt i parametrar. Information om inbyggda kommandon listas på bashman-sidan:

man bash

Ingång Utgång
echo matar ut ett uttryck eller innehållet i en variabel ( stdout ), men har begränsningar i användningen [4]
printf formaterat utdatakommando, utökad version av kommandotecho
read "läser" värdet på en variabel från standardinmatning ( stdin ), interaktivt är det tangentbordet
Filsystem
cd ändrar den aktuella katalogen
pwd visar namnet på den  aktuella arbetskatalogen
pushd vänder den aktuella katalogen
popd returnerar den aktuella katalogen efterpushd
dirs listar eller rensar innehållet i bunten med kataloger som sparats viapushd
Åtgärder på variabler
let utför aritmetiska operationer på variabler
eval översätter en lista med argument från en lista till kommandon
set ändrar värdena för interna skriptvariabler
unset tar bort en variabel
export exporterar en variabel, vilket gör den tillgänglig för underordnade processer
declare,typeset sätta och/eller införa begränsningar för variabler
getopts används för att analysera argument som skickas till skriptet från kommandoraden
Scenariohantering
source, .(prick) kör det angivna skriptet
exit ovillkorlig uppsägning av manuset
exec ersätter den nuvarande processen med en ny som startas av kommandotexec
shopt låter dig ändra nycklarna (alternativ) på skalet "i farten"
Lag
true returnerar utgångskod noll (framgång)
false returnerar en utgångskod som indikerar fel
type prog skriver ut hela sökvägen till prog
hash prog minns vägen till prog
help COMMAND skriver ut en kort hjälp om att använda det interna kommandot COMMAND
Hantera uppgifter som körs i skalet
jobs visar en lista över uppgifter som körs i kommandoskalet eller information om en specifik uppgift efter dess nummer
fg växlar inmatningsströmmen till den aktuella uppgiften (eller till en specifik uppgift, om dess nummer anges) och fortsätter dess exekvering
bg fortsätter utförandet av den för närvarande avstängda uppgiften (eller specifika uppgifter, om deras nummer anges) i bakgrunden
wait väntar på att de angivna uppgifterna ska slutföras

Skript

I det enklaste fallet är ett skript  en enkel lista med kommandon som skrivits till en fil. Kommandoprocessorn måste veta att den måste bearbeta den här filen, och inte bara läsa dess innehåll. Detta görs av en speciell konstruktion som kallas shebang : #!. Symbolen #anger en kommentar, men i det här fallet betyder shebang att det efter denna speciella symbol finns en väg till tolken för att exekvera skriptet.

Syntax

Bash-kommandosyntaxen är en utökad Bourne-skalkommandosyntax. Den definitiva bash-kommandosyntaxspecifikationen finns i Bash Reference Manual som distribueras av GNU Project . [5]

"Hej världen" #!/usr/bin/env bash echo 'Hello World!'

Detta skript innehåller bara två rader. Den första raden talar om för systemet vilket program som används för att köra filen. Den andra raden är den enda åtgärden som det här skriptet utför, det skriver faktiskt "Hello world!" i terminalen.

Kör skriptet

För att göra ett skript körbart kan följande kommandon användas:

chmod +rx scriptname # ge läs-/körbehörigheter till alla användare chmod u+rx scriptname # ge läs-/körbehörigheter endast till "ägaren" av skriptet

Av säkerhetsskäl ingår .inte sökvägen till den aktuella katalogen i miljövariabeln $PATH. För att köra skriptet måste du därför uttryckligen ange sökvägen till den aktuella katalogen där skriptet finns:

./skriptnamn

Dessutom kan du uttryckligen skicka en sådan fil till Bash- tolkenbash för exekvering med kommandot :

bash skriptnamn

I detta fall krävs varken inställning av åtkomsträttigheter eller användning av en sekvens #!i koden.

I/O-omdirigering

bash har inbyggda filbeskrivningar : 0 (stdin), 1 (stdout), 2 (stderr).

Det finns speciella symboler för operationer med dessa och användardefinierade handtag: >(output redirection), <(input redirection). Tecknen &, -kan föregå deskriptornumret; till exempel att 2>&1 omdirigera deskriptor 2 (stderr) till deskriptor 1 (stdout).

0<filenameeller<filename Omdirigerar indata från en filfilename
1>filenameeller>filename Omdirigerar utdata till filen "filnamn". Om alternativet är inaktiverat noclobberskrivs filen över av inkommande data
1>|filenameeller>|filename Omdirigera utdata till filen "filnamn", filen skrivs över av inkommande data
1>>filenameeller >>filename Omdirigera utdata till filen "filnamn", lägg till data i slutet av filen. Om filen inte finns skapas den
2>filename Omdirigerar standardfelutgången till "filnamn"
2>>filename Omdirigera standardfelutgången till filen "filnamn", lägg till data i slutet av filen. Om filen inte finns skapas den
&>filename Omdirigerar utdata och fel till "filnamn"
2>&1 Omdirigerar felutgång till standardutgång

Bash har en anpassad omdirigeringssyntax som inte stöds av Bourne-skalet. Ett exempel på att omdirigera standardutdata och standardfel samtidigt:

kommando & > fil

Detta är lättare att skriva än motsvarande kommando i Bourne-skalsyntaxen.

kommando > fil 2 > & 1

Omdirigera "från skriptkod"

Syntax för heredoc :

  • Med tolkningen av variabler och språkkonstruktioner inuti blocket:
$a = 'multiline' kommando <<MYDOC123 $a text $(<$HOME/my_file.txt) MYDOC123
  • Utan att tolka variabler:
kommandot <<'PERLCODE' my $first='Hej'; min $second='värld'; säg join(', ',$first,$second),'!'; PERLCODE
  • Med den initiala indragningen borttagen (endast flikindragning stöds):
kommando <<-'TABSTRIP' för ((i=0; i<10; i++)) gör eko "$i" gjort TABSTRIP

Sedan version 2.05b kan bash omdirigera standardindata från en sträng med följande syntax för " här strängar ":

kommando <<< "sträng som ska läsas som standardinmatning"

Om strängen innehåller mellanslag måste den vara omgiven av citattecken eller apostrof, eller mellanslagen måste escapes med ett omvänt snedstreck.

Var försiktig: strängen som skrivs in med här strängar innehåller en implicit radavslutningssekvens: antingen 1 extra byte av radmatning eller 2 extra byte: vagnretur och radmatning.

katt - <<< '123' | wc -c # Resultat: 4 cat < ( echo -n '123' ) | wc -c # Resultat: 3 wc -c <<< '123' # Resultat: 4 echo -n 123 | wc -c # Resultat: 3

Från och med version 4.1 [6] blev det möjligt att ange en avslutande sekvens av tecken på en rad och, omedelbart efter den, en parentes. Detta kan vara användbart för att tilldela en here-doc innehållsvariabel:

var = $( cat - <<'TERMSEQ' Februari. Få lite bläck och gråt! Skriv snyftande om februari Medan det mullrande slasket bränner svart på våren. TERMSEQ )

Detta kommer att generera ett varningsmeddelande i BASH.

Omdirigering för processen som helhet

Exempel (omdirigera standardutdata till en fil, skriva data, stänga filen, tömma stdout):

# gör Filedescriptor(FD) 6 till en kopia av stdout (FD 1) exec 6 > & 1 # öppna filen "test.data" för att skriva exec 1 >test.data # producera något innehållseko " data:data:data" # stäng fil "test.data" exec 1 > & - # gör stdout till en kopia av FD 6 (återställ stdout) exec 1 > & 6 # stäng FD6 exec 6 > & -

Öppna och stänga filer:

# öppen fil test.data för läsning av exec 6 <test.data # läs till slutet av filen under läsning -u 6 dta do echo " $dta " done # close file test.data exec 6 < & -

Kommandoutgångsersättning

Fånga utdata från externa kommandon:

# exekvera 'date' och lägg resultatet i VAR VAR = " $( date ) " echo " $VAR " #skriver ut datumet då föregående rad anropades

Strängar med nolltecken stöds inte, efterföljande rader går förlorade, till skillnad från pipes och andra fil- I/O .

Villkorlig operator

#!/usr/bin/env bash T1 = 'foo' T2 = 'bar' om [[ $T1 == " $T2 " ]] sedan echo 'villkor uppfyllt' annars echo 'villkor misslyckades' fi

Observera att citattecken runt vänster sida är valfria. [7]

Cyklar

#!/usr/bin/env bash för i i "Number" { 1 ..10 } gör eko " $i " klar #!/usr/bin/env bash RÄKNARE = ​​0 while [[ $COUNTER -lt 10 ]] # Så länge villkoret är TRUE (returnerar 0) exekvera slingans kropp do echo Räknaren är $COUNTER låt COUNTER = COUNTER+1 Gjort #!/usr/bin/env bash i = 0 tills [[ $i -eq 10 ]] # Utför loop body tills villkoret är FALSE (returnerar icke-0) gör eko " $i " i = $(( $ i + 1 )) gjort #!/usr/bin/env bash # inom dubbla parenteser, variabler kan skrivas i C-stil (utan $ och mellanslagsseparerade operatorer och operander) för (( i = 0 ; i < 10 ; i++ )) do echo - n " $i ; " klar

Arrayer

Bash implementerar bara endimensionella arrayer. Index kan vara antingen heltalsvärden ("vanlig" array ) eller strängar ( " associative array " eller "hash").

Trots föreningen av syntaxen för att arbeta med vanliga och associativa arrayer är de förra inte en variant av de senare, varken ur slutanvändarens synvinkel eller ur tolkens interna logik.

Som en naturlig följd av bashs stöd för "associativa" nycklar, finns det en mycket begränsad förmåga att emulera flerdimensionella arrayer.

Allmänna operationer

Få en sträng som består av alla [8] element i en array separerade med ett mellanslag.

värden = " ${ arr [@] } "

Få en sträng med alla [8] index eller nycklar i en array, oavsett om de är numeriska eller text:

keys = " ${ !arr[@] } "

Bulk ersätt den första förekomsten av delsträngen "MAY" med "MARCH" i alla [8] element i arrayen och returnerar en sträng som består av de resulterande elementen i arrayen, åtskilda av ett mellanslag:

values ​​​​= " ${ arr [@]/MAJ/MARS } "

Samma, men i varje [8] element i arrayen kommer alla förekomster av delsträngen "MAY" att ersättas:

values ​​​​= " ${ arr [@]//MAJ/MARS } "

Hittills fungerar inte alla möjligheter som anges i dokumentationen korrekt för arrayer. Till exempel:

[ -v 'array_name' ]

fungerar inte korrekt för en tom array. [9]

Operationer på indexerade arrayer

Bash har stöd för endimensionella arrayer. Arrayelement kan initieras i formen: my_array[xx]. Du kan också explicit deklarera en array i ett skript med hjälp av direktivet declare:

deklarera -en min_array

Individuella element i en array kan nås med hjälp av hängslen: "${my_array[xx]}".

Det finns två sätt att initiera en indexerad array:

ett)

Array =( element1 element2 element3 )

2)

temp_array [ 0 ]= element1 temp_array [ 5 ]= element temp_array [ 9 ]= elementN

Lägga till element i slutet av en indexerad array:

declare -a arrAnimals arrAnimals =( hund elefant häst ko räv koala sköldpadda ) # Visa innehållet i arrayen: echo " ${ arrAnimals [@] } " # Lägg till ett nytt element i slutet av arrAnimals array: "pig" arrAnimals +=( gris ) # Och visa innehållet i arrayen igen: echo " ${ arrAnimals [@] } "

Hämta det första elementet i en array:

echo " ${ arrAnimals [0] } "

Både indexerade och associativa arrayer stöder så kallad "slicing":

# Ett annat sätt att få det första elementet i ett arrayeko " $ { arrAnimals [@]: 0 : 1 } " # Skriv ut 3 arrayelement med start från den andra: echo " ${ arrAnimals [@]: 2 : 3 } "

Obs: i fallet med associativa arrayer kommer ordningen på värdena i det allmänna fallet att vara slumpmässig (bestäms av hashfunktionen som används), så segmentoperationen på en associativ array, även om den är acceptabel, har en extremt begränsad omfattning av praktisk applikation.

I arrayer med numeriska index är "omvänd" ("negativ") adressering tillåten, vilket ger dig tillgång till element från slutet av arrayen:

# Värdet på det sista elementet i arrayekot " $ { arrAnimals [-1] } " # Värdet på det näst sista elementet i arrayekot " $ { arrAnimals [-2] } " # ... och så vidare.

Med det inbyggda kommandot mapfile(synonym: readarray), kan du visa innehållet i en textfil i en indexerad array:

deklarera -a fileWithLogins mapfile fileWithLogins </etc/passwd för (( i = 0 ; i< ${# fileWithLogins [@] } ; i++ )) gör echo "Line # $i : ${ fileWithLogins [ $i ] } " klar Associativa arrayoperationer

Från och med version 4.0 introducerade bash stöd för associativa arrayer (så kallade hash-arrayer).

Associativa arrayer deklareras med den -Ainbyggda kommandonyckeln declare:

deklarera -A hshArray

Precis som med indexerade arrayer kan två olika syntaxer användas för att fylla i associativa arrayer:

ett)

TheCapitalOf [ Georgia ]= 'Tbilisi' TheCapitalOf [ Australien ]= 'Canberra' TheCapitalOf [ Pakistan ]= 'Islamabad'

2)

TheCapitalOf =([ Georgia ]= 'Tbilisi' [ Australien ]= 'Canberra' [ Pakistan ]= 'Islamabad' )

Associativa arrayer kan efterlikna stöd för flerdimensionella arrayer:

deklarera -A a # deklarerar en associativ array 'a' i = 1 ; j = 2 # initiera flera index a [ $i , $j ]= 5 # tilldela värdet "5" till cellen "$i,$j" (dvs. "1,2") eko ${ a [ $i , $j ] } # skriv ut lagrade värden från "$i,$j"

Tyvärr, i nuvarande versioner av bash, är det inte möjligt att kopiera innehållet i en associativ array till en annan genom en enkel uppgift. Detta problem kan bara kringgås, för vilket det finns två fundamentalt olika tillvägagångssätt:

1) Emulera deklarationen för den andra hashen från början genom att kopiera deklarationen för den första hashen:

deklarera -A hsh1 hsh1 =( ... ) source < ( deklarera -p hsh1 | sed 's/^declare -A hsh1/declare -A hsh2/' )

2) Gå igenom alla [8] element i källhash och kopiera dem till målhash:

deklarera -A hsh1 hsh2 hsh1 =( ... ) för k i " ${ !hsh1[@] } " gör hsh2 [ " $k " ]= " ${ hsh1 [ " $k " ] } " klar Säkert arbete med arrayer

Arrayer är ett bekvämt sätt att skicka dynamiskt genererade argument till funktioner eller kommandon. I det här fallet är varje element i arrayen ett separat argument.

args =( ls -l -a / ) ls " ${ args [@] } " # ls -l -a / ls ${ args [@] } # ls -l -a / ls ${ args [*] } # ls -l -a /

Men när man använder arrayer på detta sätt bör man vara försiktig på grund av särdragen med att expandera arrays när man använder specialtecken @och som index *.

Om arrayen är omgiven av citattecken och utökas med hjälp av index @, så bildas en sträng med ord, där varje ord är ett separat element i arrayen. Men om du inte omger arrayexpansionen med dubbla citattecken kan du få ett helt annat resultat: mellanslag som ingår i arrayelementen blir ordavgränsare.

args =( -l -a '/home/user/Desktop' ) ls " ${ args [@] } " # visa innehållet i katalogen '/home/user/Desktop' ls ${ args [@] } # fel: katalogerna '/home/user/Desktop' och './desk' existerar inte

En array med index *, omgiven av dubbla citattecken, expanderas till en enda rad och sammanfogar alla element i arrayen genom de avgränsare som lagras i variabeln IFS. Om du inte anger dubbla citattecken utökas arrayen på samma sätt som när du använder ett index @.

args =( '' usr local bin ) IFS = '/' ls " ${ args [*] } " # visa innehållet i '/usr/local/bin'-katalogen IFS = '/' ls ${ args [*] } # listar innehållet i katalogerna '.', './usr', './local' och './bin' en efter en

När du skapar en array från innehållet i en textvariabel måste du ta hänsyn till eventuell närvaro av mellanslag i texten. Till exempel, som ett av sätten att skapa en array från en sträng med en uppräkning, kan du överväga att ersätta avgränsningstecknet med ett mellanslag. Förekomsten av utrymmen i delade element kommer dock att leda till fragmentering av själva elementen i delar.

array =( ${ text //,/ } ) # fel: text i variabeln 'text' kan innehålla blanksteg IFS = ',' array =( $text ) # korrekt: avgränsaren är ett kommatecken. IFS = ',' read -r -a array <<< " $text " # korrekt (alternativt omdirigering av innehållet i variabeln 'text' till kommandot 'read')

Att skapa en array från text som tas emot som utdata från kommandon eller från en fil kan leda till fel, eftersom inte bara nyrader, utan även mellanslag med tabbar kommer att betraktas som avgränsare som standard [10] .

array =( " $( ls ) " ) # fel: mellanslag i filnamn kan dela upp ett filnamn i två arrayelement IFS = $'\n' array =( " $( ls ) " ) # korrekt: endast radöversättningar kommer att vara avgränsaren mapfile -t array < < ( ls ) # korrekt: alternativ via inbyggt mapfile-kommando

Transportör

Pipelinjen skickar utdata från föregående kommando till ingången för nästa, eller till ingången av skalet. Metoden används ofta för att länka en sekvens av kommandon till en enda kedja. Transportören indikeras med rörsymbolen | .

Exempel ( grep fungerar som ett filter på stdout):

cat filnamn | grep mönster

Logiska operationer

Logiskt ELLER betecknas som ||. I villkorliga operationer returnerar operatören ||0 (framgång) om en av operanderna är sann.

Logisk AND betecknas som &&. I villkorssatser &&returnerar operatorn 0 (framgång) om och endast om båda operanderna är sanna.

Notera: Möjlig förvirring i förståelsen uppstår från det faktum att kommandot true (och framgångsrikt slutförande av ett kommando) slutar med en returkod på 0, framgång ( falsetvärtom, inte 0), medan det booleska värdet sant/falskt är icke -noll/ är lika med noll.

Exempel:

om falskt ; eka sedan "lyckat" ; annars ekar "misslyckat" ; fi utan framgång låt "a=((1 && 0 && 123))" ; echo $? ; echo $a 1 # Kommandoavslutningskod (noll resultat av utvärdering av ett aritmetiskt uttryck) 0 # Värdet på variabeln "a", resultatet av en logisk operation if (( 1 && 0 && 123 )) ; eko sedan "sant" ; annars eko "falskt" ; fi falskt låt "a=(( 1 && 123 && -345 ))" ; echo $? ; echo $a 0 # Kommando utgångskod 1 # Värde för variabel "a", resultatet av logisk operation if (( 1 && 123 && -345 )) ; eko sedan "sant" ; annars eko "falskt" ; fi sant falskt && eko "Framgång" || eko "misslyckande" Misslyckat slutförande

Heltalsmatematik

Bash kan utföra heltalsberäkningar inom en process med hjälp av kommando ((…))och variabel $((…))[11] syntax , som visas nedan:

VAR = 55 # Sätt VAR till 55 (( VAR = VAR + 1 )) # Lägg till en till VAR. Notera frånvaron av '$'-tecknet (( VAR += 1 )) # Stenografi för inkrement (( ++VAR )) # Ett annat sätt att öka VAR med ett. Utför ett prefixökning (( VAR++ )) # Ett annat sätt att öka VAR med ett. Utför ett postfix inkrementeko $ (( VAR * 22 )) # Multiplicera VAR med 22 och skicka resultatet till kommandot echo $ [ VAR * 22 ] # Äldre sätt att göra samma sak (( VAR <<3)) # Vänsterskifte bitvis (samma som VAR*8) ((VAR>>3 )) # Bitskift höger (samma som VAR/8)

Kommandot ((…))kan också användas i villkorliga uttalanden, eftersom dess initiala parameter är 0 eller 1, vilket kan tolkas som sant eller falskt:

om (( VAR == Y * 3 + X * 2 )) sedan eko Ja fi (( Z > 23 )) && eko Ja

Kommandot ((…))stöder följande jämförelseoperatorer: == != > < >= <=.

Bash stöder inte pågående beräkningar med flyttal. Endast Unix Korn-skalet (version 1993 ) och zsh (sedan version 4.0) stöder denna funktion.

Lista över matematiska operationer: +, -, *, /, **(exponentiering), %(modulo division, resten av division), let - låter dig använda förkortningar av aritmetiska kommandon (minska antalet variabler som används; till exempel: a += bekvivalent a = a + b, etc.).

Variabler och argument

Argument:

$$ pid av det aktuella skalet (själva skriptprocessen)
$! pid av den sista processen i bakgrunden
$? returkod för den senaste processen (funktion eller skript)
$x där x  är numret på parametern som skickas till skriptet ( $1, $2etc. $0 är det senaste skriptet som kördes)
$# antal kommandoradsargument
$* alla [8] argument som en enda sträng (ord)
$@ samma som $*, men varje [8] parameter presenteras som en separat rad (ord)
$- lista över flaggor som skickas till skriptet
$_ innehåller det sista argumentet för föregående kommando

Inbyggda variabler:

$BASH sökväg till bash körbar
$BASHPID PID för aktuell bash * (se not)
$BASH_VERSINFO[n] array av 6 element som innehåller bash versionsinformation
$BASH_VERSION version av Bash installerad på systemet
$DIRSTACK innehållet i toppen av katalogstacken
$EDITOR standardredigerare
$EUID "effektivt" användaridentifikationsnummer (effektivt användar-ID)
$FUNCNAME nuvarande funktionsnamn
$GLOBIGNORE en lista över jokertecken som kommer att ignoreras när filnamnsersättning utförs (globning)
$GROUPS grupper som den aktuella användaren tillhör
$HOME användarens hemkatalog
$HOSTNAME nätverksvärdnamn
$HOSTTYPE maskintyp (identifierar hårdvaruarkitektur)
$IFS fältavgränsare i inmatningssträngen
$LC_COLLATE ställer in sorteringsordningen för tecken, i filnamnsersättningsoperationer och i jokerteckensökningar
$LC_CTYPE definierar teckenkodning
$LINENO Radnummer för det körbara skriptet
$MACHTYPE hårdvaruarkitektur
$OLDPWD tidigare arbetskatalog
$OSTYPE typ av operativsystem
$PATH sökväg (inkluderar kataloger /usr/bin/, /usr/X11R6/bin/etc. /usr/local/bin)
$PIPESTATUS Kanalens (pipeline) returkod
$PPID PID (identifierare) för den överordnade processen
$PS1 kommandoraden
$PS2 sekundär kommandoradsprompt, visas när ytterligare input förväntas från användaren. Visas vanligtvis som ">"
$PS3 tertiär prompt, visas när användaren måste göra ett val i ett uttalandeselect
$PS4 nivå 4-prompt, utskriven (modifierad) i början av varje rad av felsökningsutdata när skriptet anropas med -x. Visas vanligtvis som "+", "++" osv.
$PWD fungerande (nuvarande) katalog
$REPLY standardvariabeln där användarens input från kommandot skrivsread
$SECONDS skriptets körtid (i sekunder)
$SHELLOPTS lista över giltiga tolkalternativ (skrivskyddad)
$SHLVL skalhäckningsnivå
  • Notera: skiljer sig från $$ under vissa omständigheter, till exempel underskal som inte kräver att bash återinitieras.

Exempel:

$ echo $(echo $BASHPID $$) $$ $BASHPID 25680 16920 16920 16920 # | | | | # | | | -- $BASHPID utanför underskalet # | | -- $$ utanför underskalet # | -- $$ inuti underskalet # -- $BASHPID inuti underskalet


Reguljära uttryck inom en process

Bash 3.0 stöder inbyggda reguljära uttryck med en syntax som liknar Perls :

[[ sträng = ~regex ]]

Syntaxen för reguljära uttryck finns dokumenterad på man 7 regex-dokumentationssidorna. Exit-statusen är satt till 0 om det reguljära uttrycket matchade strängen och 1 om inte. Värdet på ett underuttryck inom parentes kan erhållas [8] via en variabel ${BASH_REMATCH[@]}, till exempel:

REGEXP = 'foo(bar)bl(.*)' om [[ "abcfoobarbletch" = ~ $REGEXP ]] eko då "Regex matchad sträng!" echo " $BASH_REMATCH " # utskrifter: foobarbletch echo " ${ BASH_REMATCH [1] } " # utskrifter: bar echo " ${ BASH_REMATCH [2] } " # utskrifter: etch fi

Inbyggda reguljära uttryck är vanligtvis snabbare än att köra ett externt grep-kommando eftersom motsvarande reguljära uttryck exekveras inom bash-processen. Om det reguljära uttrycket eller strängen innehåller mellanslag eller metatecken (som *eller ?), måste de omges av citattecken. Det rekommenderas att använda en variabel för att hålla det reguljära uttrycket, som i exemplet ovan, för att undvika problem med escapende specialtecken. Du kan använda bash-utdata med ett alternativ -xför att kontrollera hur bash analyserar ditt reguljära uttryck.

Utvidgning av parentes

Funktionen för expansion av klammer är lånad från csh . Det gör att en godtycklig sträng kan bildas med en liknande teknik, som görs med filnamn. Men i bash behöver de genererade strängarna inte vara filnamn. Resultatet av varje strängexpansion sorteras inte, ordningen bevaras från vänster till höger:

# Detta är en funktion av bash echo a { p,c,d,b } e # ape ace ade abe

Du bör inte använda den här funktionen om skriptet ska porteras, eftersom strängexpansion i traditionella skript inte fungerar:

# Traditionellt skal ger inte samma resultat eko a { p,c,d,b } e # a{p,c,d,b}e

När parentesexpansion används i kombination med jokertecken, expanderas parenteserna först och sedan bearbetas resultatet normalt. Således kan en lista över JPEG- och PNG-bilder i den aktuella katalogen erhållas så här:

ls*. { jpg,jpeg,png } # parenteser utökas till *.jpg *.jpeg *.png, varefter en jokerteckensökning utförs

Snabbtangenter

  • Tab ↹: Komplettera raden bakom markören automatiskt.
  • Ctrl++ ! Ctrl: !Upprepa det sista kommandot.
  • Ctrl+ a: Flyttar markören till början av raden (motsvarande tangenten Home).
  • Ctrl+ b: Flyttar markören ett tecken bakåt (motsvarande tangenten ←).
  • Ctrl+ r: Sök med tidigare inskrivna kommandon.
  • Ctrl+ : Skickar en SIGINT-c signal till det aktuella jobbet, som vanligtvis (men inte alltid) avslutar och stänger det.
  • Ctrl+ d: Skickar en EOF- markör som (såvida den inte är inaktiverad av ett alternativ och den aktuella raden inte innehåller någon text) stänger det aktuella skalet (motsvarande exit-kommandot ), när den matas in i det körande programmet, avslutar inmatningen om det inte finns någon text på raden , annars avslutar raden utan en linjeavslutning.
  • Ctrl+ d: Tar bort det aktuella tecknet (endast om det finns text på den aktuella raden) (motsvarande tangenten Delete).
  • Ctrl+ e: Flyttar markören till slutet av raden (motsvarande tangenten End).
  • Ctrl+ f: Flyttar markören ett tecken framåt (motsvarande tangenten →).
  • Ctrl+ h: Tar bort föregående tecken (samma som tangenten ← Backspace).
  • Ctrl+ i: Motsvarar nyckeln Tab ↹.
  • Ctrl+ j: Motsvarar nyckeln ↵ Enter.
  • Ctrl+ k: Rensar innehållet på raden efter markören och kopierar det till urklippet för bash-instansen (kill ring).
  • Ctrl+ l: Rensar innehållet på skärmen (motsvarande kommandot clear).
  • Ctrl+ m: Motsvarar nyckeln ↵ Enter.
  • Ctrl+ n: (nästa) rullar till nästa kommando (motsvarande tangenten ↓).
  • Ctrl+ o: Utför det hittade kommandot i historiken och väljer nästa rad i förhållande till den aktuella raden i historiken för redigering.
  • Ctrl+ p: (föregående) rullar till föregående kommando (motsvarande tangenten ↑).
  • Ctrl+ q: Återuppta processutgång.
  • Ctrl+ s: Stäng av processutgång (stopp).
  • Ctrl+ t: Byt intilliggande tecken.
  • Ctrl+ u: Rensar innehållet i raden upp till markören och kopierar det till urklippet för bash-instansen (kill ring).
  • Ctrl+ w: Tar bort ordet upp till markören och kopierar det till urklippet för bash-instansen (kill ring).
  • Ctrl+ y: Lägger till innehållet i urklippet för bash-instansen från markörpositionen.
  • Ctrl+ z: Skickar en SIGTSTP- signal till det aktuella jobbet, som avbryter dess exekvering och återupptar att ta emot kommandon. För att återuppta exekveringen i bakgrunden kan du ge kommandot bg. För att ta tillbaka den från bakgrunden eller suspendera kan du köra fg.
  • Ctrl+ /: Avsluta den aktuella processen med en kärndump genom att signalera det.
  • Ctrl+ _( Ctrl+ ⇧ Shift+ -): Ångra redigering.
  • Alt+ >: Hoppa till det sista kommandot i historien.
  • Alt+ b: (bakåt) flyttar markören ett ord bakåt (motsvarande Ctrl+ -tangenten ←).
  • Alt+ d: Förkortar ordet efter markören.
  • Alt+ f: (framåt) flyttar markören ett ord framåt (motsvarande Ctrl+ -tangenten →).
  • Alt+ t: Byter de två orden före markören.
  • Alt+ .: Lägger till det sista argumentet till föregående kommando.
  • Alt+ c: Ändra bokstaven under markören till versal.
  • Alt+ l: Ändra bokstaven under markören till gemener.
  • Ctrl++ x Ctrl: xFlyttar markören till början av raden från den aktuella positionen och tillbaka.
  • Ctrl++ x Ctrl: eRedigerar den aktuella raden i $EDITOR-programmet, eller vi om det inte är fördefinierat.
  • Ctrl++ x Ctrl: vVisa versionsinformationen för den aktuella bash-instansen.

Starta skript

Bash anropar kommandon från många olika skript vid start.

När bash anropas som ett interaktivt inloggningsskal är det första det gör att läsa och köra kommandon från en fil /etc/profile, om den filen finns. Efter att ha läst den här filen tittar den på följande filer i följande ordning: ~/.bash_profile, ~/.bash_loginoch ~/.profile, läser och anropar kommandon från den första som finns och är läsbar. Vid utgång läser bash och kör kommandon från ~/.bash_logout.

När ett interaktivt skal startas, men inte för inloggning, läser och kör bash kommandon från filer /etc/bash.bashrcoch ~/.bashrcom de finns. Detta kan åsidosättas med alternativet -norc. Alternativet -rcfile filekommer att tvinga bash att använda kommandona från filen fileistället för /etc/bash.bashrcoch ~/.bashrc.

Portabilitet

Den första raden i skriptet bör vara en post #!/bin/bashom den absoluta sökvägen till den körbara filen är känd, eller #!/usr/bin/env bashför att automatiskt bestämma sökvägen till den körbara genom kommandot env med hjälp av miljövariabeln PATH [12] .

Skalskript skrivna med bash-specifika funktioner fungerar inte på system som använder Bourne-skalet (sh) eller en av dess motsvarigheter om inte bash har installerats som ett extra skal. Detta problem blev särskilt viktigt när Ubuntu började skicka Debians Almquist-skal (streck) som standardskriptskal i oktober 2006, vilket fick många skript att gå sönder.

Grafiskt gränssnitt till skript

Det finns många program som låter dig skapa ett grafiskt gränssnitt för bash-skript.

  • dialog  är ett verktyg som låter dig skapa dialogrutor i konsolen med hjälp av biblioteken curses och ncurses .
  • whiptail  är en analog till dialogverktyget, det använder salamanderbiblioteket .
  • zenity  är den mest populära GUI-applikationen för skript.
  • kdialog  är en analog av zenity i KDE-miljön .
  • yad  är en gaffel av zenity, med fler funktioner.
  • xdialog  är en ersättning för dialog, designad för att ge terminalstartade program gränssnittet för X Window System .
  • gtkdialog  är det mest funktionella verktyget för att skapa grafiska applikationer i bash-skript.

Se även

Anteckningar

  1. ↑ Ramey C. Bash-5.2 Release tillgänglig  (engelska) - 2022.
  2. ↑ 1 2 GNU Guix - 2012.
  3. ↑ William McCarty. Lär dig Debian GNU/Linux .  13. Erövra BASH-skalet . O'Reilly Media (6 oktober 1999) . Hämtad 6 december 2018. Arkiverad från originalet 9 november 2017.
  4. ↑ Kan inte visa värdet för en variabel som innehåller -n(till skillnad från printf -- '%s\n' "${переменная}") eftersom den -ntolkas som en kommandoparameter echo.
  5. ↑ Bash Reference Manual Arkiverad 13 maj 2019 på Wayback Machine .
  6. ↑ Bash News . Tillträdesdatum: 18 januari 2017. Arkiverad från originalet 1 februari 2017.
  7. ↑ BashGuide/TestsAndConditionals Arkiverad 12 februari 2014 på Wayback Machine  - Gregs Wiki.
  8. ↑ 1 2 3 4 5 6 7 8 Citat måste användas för att få alla element, inklusive element från mellanslag och tomma strängar.
  9. ↑ Här används apostroferna korrekt.
  10. ↑ bash(1) : GNU Bourne-Again SHell - Linuxmanpage  . linux.die.net. Hämtad 11 juli 2017. Arkiverad från originalet 27 december 2019.
  11. ↑ Föråldrad version: $[…].
  12. ↑ env(1) - Linux manualsida . man7.org. Hämtad 21 januari 2017. Arkiverad från originalet 13 januari 2017.

Länkar

 Unix-kommandon
 Verktyg POSIX.1-2008
 GNU Coreutils
Filverktyg
Textverktyg
Shell verktyg
 Användargränssnitt på Unix-liknande system
Skrivbordsmiljöer
Stiftelsen GTK
Qt Foundation
Motivbas _
Övrig
Grafiska
skal
Fönsterhanterare
Sammansatt
Ram
Staplad

Om Wayland- protokollet
Kommandoskal
X fönstersystem
 GNU-projekt
Berättelse
Licenser
Programvara
_
Personligheter
Andra ämnen
 Verktyg POSIX.1-2008