Alt hvad du behøver at vide om Bash For Loops i Linux

Bash-scripts er et yderst effektivt middel til automatisering af opgaver, især dem der drager fordel af andre eksisterende programmer. Denne automatisering kræver ofte gentagelse af en lignende operation flere gange, hvilket er netop hvor til løkke kommer til sin ret.

Linux- og Mac-systemadministratorer er typisk fortrolige med scripting via terminalen, men selv Windows-brugere kan kom ind på handlingen med Windows Subsystem til Linux.

Sådan får du Linux Bash Shell på Windows 10

Har du brug for Linux ikke tid til at skifte til en anden pc eller køre en VM? Kør Linux i Windows 10 med en Bash shell-terminal i stedet!

Sådan fungerer Bash-scripts

Et bash-script er simpelthen en almindelig tekstfil, der indeholder en række kommandoer, som bash-skallen kan læse og udføre. Bash er standardskallen i pre-Catalina macOS og de fleste Linux-distributioner.

Hvis du aldrig har arbejdet med et shell-script før, skal du begynde med det absolut enkleste tilfælde. Dette giver dig mulighed for at øve på nøglekoncepter, herunder oprettelse af scriptet og dets udførelse.

Opret først følgende fil et bekvemt sted (ideelt set skal du åbne en terminal og navigere til den ønskede mappe først):

#! / bin / bash
ekko "Hej, verden"

Den første linje fortæller hvad der kører dette program, hvordan man kører det (dvs. ved hjælp af bash-tolken). Den anden er bare en kommando som enhver anden, du kan indtaste på kommandolinjen. Gem filen som hej_verden.sh, derefter:

$ chmod + x hello_world.sh
$ ./hello_world.sh

Det chmod kommandoen på første linje gør filen eksekverbar, hvilket betyder at den kan køres ved at skrive dens navn, som i den anden linje.

Hvis du ser ordene "Hej, verden" vises trykt på en linje i din terminal, fungerer alt efter behov.

Sådan fungerer sløjfer

I generel programmering er der to hovedtyper af for loop: numerisk og for hver. Den numeriske type er traditionelt den mest almindelige, men i bash-brug er det normalt omvendt.

Numerisk for sløjfer fokuserer typisk på et enkelt heltal, der bestemmer, hvor mange iterationer der skal udføres, for eksempel:

for (i = 0; i <100; i ++) {
/ * udsagn at udføre gentagne gange * /
}

Dette er en velkendt sløjfe, der vil gentage nøjagtigt 100 gange, medmindre jeg ændres i sløjfen, eller en anden erklæring får udførelsen af ​​for-sløjfen til at stoppe.

Foreach-sløjfer har derimod en tendens til at fungere på strukturer som lister eller arrays og gentages for hvert element i samlingen:

folk = ["Peter", "Paul", "Mary"]
foreach (mennesker som person) {
hvis (person == "Paul") {
...
}
}

Nogle sprog bruger en lidt anden syntaks, der bytter rækkefølgen af ​​indsamling og vare:

folk = ["Peter", "Paul", "Mary"]
for (person i mennesker) {
hvis (person == "Paul") {
...
}
}

For i sløjfer

I bash er forgrunden — eller for i—Løkke er mere almindelig. Den grundlæggende syntaks er simpelthen:

til arg i [liste]
gør
/ * udsagn at udføre gentagne gange * /
/ * værdien af ​​arg kan opnås ved hjælp af $ arg * /
Færdig

For eksempel at gentage gennem tre eksplicit navngivne filer:

til fil i en. c to. c tre. c
gør
ls "$ fil"
Færdig

Hvis der findes sådanne filer i den aktuelle mappe, vil output fra dette script være:

one.c
two.c
three.c

I stedet for et fast sæt filer kan listen opnås via et globmønster (et inklusive wildcards - specialtegn, der repræsenterer andre tegn). I det følgende eksempel gentages for-loop på tværs af alle filer (i den aktuelle mappe), hvis navne ender på ".xml":

til fil i * .xml
gør
ls -l "$ fil"
Færdig

Her er nogle eksempler på output:

$ -rw-r - r-- 1 bobby personale 2436 3. nov 2019 feed.xml
$ -rw-r - r-- 1 bobby-personale 6447 27. oktober 16:24 sitemap.xml

Dette kan se meget ud som en langvarig måde at gøre:

$ ls -l * .xml

Men der er en væsentlig forskel: for loop udfører ls programmere 2 separate gange, med et enkelt filnavn, der sendes til det hver gang. I det separate ls-eksempel matcher globmønsteret (* .xml) først filnavne og sender dem alle som individuelle kommandolinjeparametre til en forekomst af ls.

Her er et eksempel, der bruger Toilet (ordoptælling) program for at gøre forskellen mere åbenbar:

$ wc -l * .xml
44 feed.xml
231 sitemap.xml
275 i alt

Det Toilet programmet tæller antallet af linjer i hver fil separat og udskriver derefter et samlet antal på tværs af dem alle. I modsætning hertil, hvis Toilet fungerer inden for en for loop:

til fil i * .xml
gør
wc -l $ fil
Færdig

Du ser stadig optællingen for hver fil:

44 feed.xml
231 sitemap.xml

Men der er ingen samlet opsummering i alt, fordi Toilet køres isoleret, hver gang sløjfen gentages.

Når en liste ikke er en liste

Der er en meget let og almindelig fejl, når der behandles for sløjfer på grund af den måde, bash håndterer citerede argumenter / strenge på. Gennemse en liste over filer skal gøres således:

til fil i en. c to. c

Ikke sådan:

til fil i "one.c two.c"

Det andet eksempel lukker filnavne i dobbelt anførselstegn, hvilket resulterer i en liste med kun en enkelt parameter; for-løkken udføres kun en gang. Dette problem kan undgås ved at bruge en variabel i sådanne tilfælde:

FILES = "one.c two.c"
til fil i $ FILES
gør
...
Færdig

Bemærk, at selve variabeldeklarationen behøver at omslutte dens værdi i dobbelt anførselstegn!

For Uden en liste

Uden noget at gentage igennem fungerer en for-loop på de kommandolinjeargumenter, der blev leveret til scriptet, når de blev påberåbt. For eksempel, hvis du har et script med navnet args.sh indeholdende følgende:

#! / bin / sh
for en
gør
ekko $ a
Færdig

Derefter udfører args.sh dig følgende:

$ ./args.sh en to tre
en
to
tre

Bash genkender denne sag og behandler for en gør som svarende til for en i $ @ do hvor $ @ er en særlig variabel, der repræsenterer kommandolinjeargumenter.

Efterligning af et traditionelt numerisk til løkke

Bash-scripts beskæftiger sig ofte med lister over filer eller linjer med output fra andre kommandoer, så den type type loop er almindelig. Imidlertid understøttes den traditionelle c-stil-handling stadig:

for ((i = 1; i <= 5; i ++))
gør
ekko $ i
Færdig

Dette er den klassiske form med tre dele, hvori:

1. en variabel initialiseres (i = 1), når sløjfen først opstår
2. sløjfen fortsætter, så længe betingelsen (i <= 5) er sand
3. hver gang rundt om løkken forøges variablen (i ++)

At skifte mellem to værdier er et almindeligt nok krav, at der er et kortere, lidt mindre forvirrende alternativ:

for jeg i {1..5}
gør
ekko $ i
Færdig

Bøjleudvidelsen, der finder sted, oversætter effektivt ovenstående for loop til:

for i i 1 2 3 4

Finere sløjfekontrol med pause og fortsæt

Mere kompleks for sløjfer har ofte brug for en måde at afslutte tidligt eller straks genstarte hovedsløjfen med den næste værdi igen. For at gøre dette låner bash pausen og fortsætter udsagn, der er almindelige i andre programmeringssprog. Her er et eksempel, der bruger begge dele til at finde den første fil, der er mere end 100 tegn lang:

#! / bin / bash
til fil i *
gør
hvis [! -f "$ fil"]
derefter
ekko "$ -fil er ikke en fil"
Blive ved
fi
num_chars = $ (wc -c echo $ -filen er "$ num_chars tegn lang"
hvis [$ num_chars -gt 100]
derefter
ekko "Fundet $ fil"
pause
fi
Færdig

For-loop fungerer her på alle filer i den aktuelle mappe. Hvis filen ikke er en almindelig fil (f.eks. Hvis det er et bibliotek), bruges fortsættelseserklæringen til at genstarte sløjfen med den næste fil igen. Hvis det er en almindelig fil, bestemmer den anden betingede blok, om den indeholder mere end 100 tegn. I så fald bruges break-erklæringen til straks at forlade for-loop (og nå til slutningen af ​​scriptet).

Konklusion

Et bash-script er en fil, der indeholder et sæt instruktioner, der kan udføres. En for loop tillader, at en del af et script gentages mange gange. Ved hjælp af variabler, eksterne kommandoer og break and continue-udsagn kan bash-scripts anvende mere kompleks logik og udføre en bred vifte af opgaver.

Apples fortrolighedsetiketter for apps er muligvis ikke helt nøjagtige

Rapporten antyder, at Apples app-fortrolighedsetiketter kan have nogle problemer.

Om forfatteren