Hvad læses?
Read er en bash indbygget kommando, der læser indholdet af en linje til en variabel. Det giver mulighed for ordopdeling, der er knyttet til den særlige skalvariabel IFS. Det bruges primært til at fange brugerinput, men kan bruges til at implementere funktioner, der tager input fra standardindgang.
Hjælp til indlæsning af basisk kommando
Inden vi dykker ned i, hvordan du bruger kommandoen read i bash -scripts, får vi her hjælp til. Der skulle du se alle de tilgængelige muligheder for read -kommandoen sammen med beskrivelser, som vi vil forsøge at dække i eksemplerne.
Kommandolinje
Hjælp Læs
Produktion
Læs:Læs [-ere] [-en matrix] [-d del] [-jeg tekst] [-n nchars] [-N nchars]
[-p prompt] [-t timeout] [-u fd] [navn ...]
Læs en linje fra standardindgangen ogdeledet i felter.
Læser en enkelt linje fra standardindgangen eller frafildeskriptor FD
hvisdet-uoption leveres. Linjen erdeleind i feltersommed ord
opdeling, og det første ord tildeles det første NAVN, det andet
ord til det andet NAVN og så videre med eventuelle ord, der er tilovers
detsidstNAVN. Kun tegnene blev fundeti $ IFSgenkendessomord
afgrænsere.
Hvis der ikke leveres NAME, skal linjenLæser gemtiREPLY -variablen.
Muligheder:
-tilarray tildele ordeneLæstil sekventielle indekser i arrayet
variabel ARRAY, der starter ved nul
-dafgrænseBlive ved så længedet første tegn i DELIM erLæs, hellere
end ny linje
-e brug Readline til at få linjenien interaktiv skal
-jegtekst brug TEKSTsomden indledende teksttilLæselinje
-nncharsVend tilbageefter at have læst NCHARS -tegn frem for at vente
tilen ny linje, men ære en afgrænserhvisfærre end
NCHARS -tegn erLæsfør afgrænsningen
-NncharsVend tilbagekun efter at have læst nøjagtigt NCHARS -tegn, medmindre
EOF er stødt på ellerLæs gangeud og ignorerer enhver
afgrænser
-sprompt output strengen PROMPT uden en efterfølgende ny linje før
forsøger atLæs
-rgøreikke tillade omvendte skråstreger at undslippe tegn
-sgøreikkesmed udinput fra en terminal
-ttiden er gåettidud ogVend tilbagefiaskohvistilkompletlinje af
input er ikkeLæsinden for TIMEOUT sekunder. Værdien af
TMOUT -variablen er standard timeout. TIMEOUT kan være en
brøknummer. Hvis TIMEOUT er0,Læsvender tilbage
med det samme uden at prøveLæseventuelle data, vender tilbage
kun succeshvisinput er tilgængelig på den angivne
fildeskriptor. DetAfslutstatus er større end128
hvistimeout overskrides
-ufdLæsfrafildeskriptor FD i stedet for standardindgangen
Afslut status:
DetVend tilbagekoden er nul, medmindre der findes enden på filen,Læs gangeud
(i hvilken sagdeter større end 128), en variabel tildeling fejler
Fanger brugerinput
Interaktive bash -scripts er intet uden at fange brugerinput. Den indbyggede læsning giver metoder til, at brugerinput kan fanges i et bash -script.
Fange en linje af input
For at fange en række input er NAMEs og muligheder ikke påkrævet ved læsning. Når NAME ikke er angivet, bruges en variabel med navnet REPLY til at gemme brugerinput.
Kommandoer
{smed ud -n 'Skriv noget, og tryk på enter:';
Læs;
smed udDu skrev$ {REPLY}
}
Produktion
Skriv noget, og tryk på enter: noget(ny linje)Du skrev noget
Fange et ord med input
For at fange et ord med input, er indstillingen -d påkrævet. I tilfælde af et ord ville vi sætte -d til et mellemrum, læse '-d'. Det er, når brugeren trykker på mellemrumstasten læst vil indlæse SVAR med ordet.
Bemærk, at når indstillingen -d er indstillet, fungerer backspace ikke som forventet. For at gå tilbage, mens du forsøger at fange et ord med input, kan indstillingen -e bruges, læs -e '-d'.
Kommandoer
smed ud -n 'Skriv noget, og tryk på mellemrum:';
Læs '-d';
smed ud '';
smed ud 'Du skrev$ {REPLY}'
}
Produktion
Skriv noget, og tryk på mellemrum: noget(plads)Du skrev noget
Spørg bruger
I interaktive bash -scripts, der beder om, at en bruger kan kræve en besked for at fortælle brugeren, hvilket input der forventes. Vi kan altid opnå dette ved hjælp af det indbyggede ekko. Det viser sig imidlertid, at der er en mulighed ved hjælp af læsning.
Spørg brugeren om et ord
Ved at fange et ord med input, brugte vi ekko til at skrive Skriv noget og slå mellemrum: til standardoutput, før vi læste ‘-d’. Indstillingen -p tillader, at en meddelelse vises, før den læses fra standardindgang.
Kommandoer
{Læs -s 'Skriv noget, og tryk på mellemrum:' '-d';
smed ud '';
smed ud 'Du skrev$ {REPLY}'
}
Produktion
Skriv noget, og tryk på mellemrum: noget(plads)Du skrev noget
Spørg brugeren om en hemmelighed
Når du fanger brugerinput, uden at det vises i terminalen, er -s -indstillingen praktisk. read -s -p giver dig mulighed for at fange og skjule brugerinput som følger.
Kommandoer
{Læs -s -s 'Skriv noget, jeg lover at holde det hemmeligt:'
smed ud '';
smed ud 'Din hemmelighed er sikker hos mig';ikke indstilletSVAR ;
smed ud '$ {REPLY}'
}
Produktion
Skriv noget, jeg lover at holde det hemmeligt:Din hemmelighed er sikker hos mig
Funktioner ved hjælp af læs
Her er eksempler på funktioner i bash, der bruger read og standard input
Kernekoncept
Funktioner ved hjælp af læsning gør brug af standard input og parametre for rør. Hovedinput, der skal behandles, f.eks. Linjer i en fil, sendes ind via standardindgang via et rør. Andet input-event-input og option sendes ind som parametre.
Læs -t 1NAME1 NAME2 ...Læser enindbygget kommando
-t 1 forhindrer bash -scriptet i at vente på ubestemt tid på en linje, der skal returneres via standardinput. Hvis standardindgangen i første omgang er tom, vender funktionen tilbage med en exit -kode på 142, hvilket betyder, at der ikke blev læst en dato inden for den indstillede timeout -periode
NAME1 NAME2 er variabelnavne... mange variabelnavne kan være angivet
Nu hvor grundarbejdet er sat, lad os se, hvordan velkendte funktioner ser ud implementeret ved hjælp af læsning.
Deltag i funktion ved hjælp af læs
Antag, at vi ønsker en joinfunktion, der tager en liste med ord og returnerer en anden liste med ord, der er forbundet med en afgrænser. Sådan kan vi implementere en joinfunktion ved hjælp af read.
Manuskript#!/bin/bash
## tilslutte
## version 0.0.2 - fix rekursionsparametre
#################################################### #
tilslutte() { { lokalbegrænser;begrænser='$ {1-}';lokaloutdelimiter;
outdelimiter='$ {2-.}';}
lokalbil
lokalcdr
lokalIFS
IFS='$ {indelimiter}'
Læs -t 1bil cdr|| Vend tilbage
prøve '$ {cdr}' || { smed ud '$ {bil}';Vend tilbage;}
smed ud '$ {bil}$ {outdelimiter}$ {cdr}' | $ {FUNCNAME} '$ {indelimiter}'
'$ {outdelimiter}'
}
#################################################### #
## genereret af create-stub2.sh v0.1.2
## på man, 17. juni 2019 12:24:59 +0900
## se
#################################################### #
Kilde: join.sh
Kommandolinje
Produktion
a.bKommandolinje
smed uda b| tilslutte | tilslutte. |Produktion
til|bKortfunktioner ved hjælp af læs
Antag, at vi ønsker en kortfunktion, der tager en liste og returnerer en anden liste, der indeholder det samme antal elementer, der ændres af en anden funktion. Sådan kan vi implementere en kortfunktion ved hjælp af read.
Manuskript#!/bin/bash
## kort
## version 0.0.1 - initial
#################################################### #
kort() { { lokalfunktionsnavn;funktionsnavn='$ {1}';}
lokalbil
lokalcdr
lokalIFS
IFS='$ {indelimiter-}'
Læs -t 1bil cdr|| Vend tilbage
prøve '$ (erklær -f $ {function_name})' || Vend tilbage
prøve '$ {bil}' || { sand;Vend tilbage;}
$ {function_name} $ {bil}
smed ud '$ {cdr}' | $ {FUNCNAME} '$ {function_name}'
}
#################################################### #
## genereret af create-stub2.sh v0.1.2
## tir, 18. juni 2019 08:33:49 +0900
## se
#################################################### #
Kilde: map.sh
Kommandoer
smed ud {1..10} |kort pow
Produktion
14
9
16
25
36
49
64
81
100
Filterfunktion ved hjælp af læs
Antag, at vi ønsker en filterfunktion, der tager en liste og returnerer en underliste over elementer, der opfylder betingelser, der er angivet af en anden funktion. Sådan kan vi implementere en filterfunktion ved hjælp af read.
Manuskript#!/bin/bash
## filter
## version 0.0.1 - initial
#################################################### #
filter() { { lokalfunktionsnavn;funktionsnavn='$ {1}';}
lokalbil
lokalcdr
lokalIFS
IFS='$ {indelimiter-}'
Læs -t 1bil cdr|| Vend tilbage
prøve '$ (erklær -f $ {function_name})' || Vend tilbage
prøve '$ {bil}' || { sand;Vend tilbage;}
$ {function_name} '$ {bil}' || smed ud -n '$ {bil}'
smed ud '$ {cdr}' | $ {FUNCNAME} '$ {function_name}'
}
#################################################### #
## genereret af create-stub2.sh v0.1.2
## tir, 18. juni 2019 13:19:54 +0900
## se
#################################################### #
Kilde: filter.sh
Kommandoer
ulige() { lokal -jeg jeg=$ {1};prøve !$((jeg% 2 )) -ækv 1;}smed ud {1..10} |filter ulige
Produktion
1 3 5 7 9Loops ved hjælp af read
Loops ved hjælp af læsning giver dig mulighed for at gentage linjer i en fil, der skal genereres eller allerede findes.
Grundlæggende mens læse loop for venstre side (lhs)
Vi har en kommando eller funktion (lhs), der kan generere linjer i en fil, der kan sløjfes igennem ved hjælp af læse og et stykke loop.
Konstruerelhs| mens Læs
gøre
sand
Færdig
lhs er enkommandoder returnerer en liste med linjer
Kommandoer
seq 5 | mens Læsjeggøre
smed ud $ {i}
Færdig
Produktion
12
3
4
5
Grundlæggende mens læse loop for højre side (rhs)
Vi har en fil (rhs) med linjer, der kan sløjfes igennem ved hjælp af læse og et stykke loop.
Konstrueremens Læs
gøre
sand
Færdig <rhs
rhs er enfilindeholdende linjer
Kommandoer
seq 5 >rhsmens Læsjeg
gøre
smed ud $ {i}
Færdig <rhs
Produktion
1
2
3
4
5
Brugerdefinerede lhs, mens loop bruges ved læsning
Vi har en strøm af ord, som vi gerne vil gå igennem ved hjælp af læsning.
Konstruere(
IFS=''
lhs| mens Læs
gøre
sand
Færdig
)
lhs er en liste med ord
Kommandoer
(IFS=''
smed ud {1..5} | mens Læsjeg
gøre
smed ud '$ {i}
Færdig
)
Produktion
1 2 3 4 5Læser fra enhver fd i stedet for standard input
Den indbyggede indlæsning, der ofte forbliver uberørt, er den, der giver dig mulighed for at specificere, hvilken filbeskrivelse du vil læse fra, læse -u FD. Som standard anses FD for at være standardindgang.
Kernekoncept
Når en fil åbnes, tildeles filbeskrivelser. IO -omdirigering i bash gør det muligt at lade en fil stå åben med en specifik filbeskrivelse. Vi får lov til at skrive til filen, læse fra den og lukke den, når vi er færdige.
_(){
kat /dev/nul>myfifo;# tom myfifo
exec 3<myfifo;# åben fil myfifo som fd 3
smed ud 'Hej Verden! - fra fd 3 ' >myfifo;# skriv til myfifo
Læs -u 3;# læs linje fra fd 3
exec 3> &-;# luk fd 3
smed ud $ {REPLY} # output linje læst fra fd 3 før lukning
}
_# Hej Verden! fra fd 3
Bygger et tog med filbeskrivelser og read -u FD
Bare for sjov besluttede jeg at bygge et tog med filbeskrivelser og læse -u FD. Til hver filbeskrivelse skrives et tal. Hver filbeskrivelse læser fra filbeskrivelsen 1 herunder og tilføjer sig selv.
Kommandolinje
bashlinuxhint.com/bygge/test-read-fd.sh tog10Produktion
initialiserer fds ...initialisering fd3...
fd3intialiseret
initialisering fd4...
fd4intialiseret
fds intialiseret
læsning fra fd3og4...
4 3
fds inden oprydning
0 1 2 3 4 5
gøre rent ...
rydder op i fds ...
Færdigoprydning af fds
fds efter oprydning
0 1 2 3
Spring funktion ved hjælp af read -u FD
Hvis du løber
uname -tilMINGW64_NT-10,0DESKTOP-XVVVVVV 2.7.0(0,307/5/3)
2017-02-17 14:tyvex86_64 Msys
bash --version
GNUbash, version 4.4.12(1)-frigøre(x86_64-pc-msys)
det kan være muligt på grund af en fejl at implementere en springfunktion, der springer over følgende linje i et bash -script uden for funktioner, før scriptkilden læses. Bemærk, at det ikke fungerer på de fleste systemer. For eksempel,
uname -tilLinux 4.9.0-8-amd64#1 Debian SMP 4.9.144-3.1 (2019-02-19) x86_64 GNU/Linux
bash --version
GNUbash, version 4.4.12(1)-frigøre(x86_64-pc-linux-gnu)
spring flyver ikke.
Fungere
springe() { Læs -u 31;}
Kommandoer
springesmed udlinje sprunget over
sand
Produktion
(tom)Bundlinie
Den indbyggede indlæsning gør mere end at fange brugerinput. Det kan bruges i funktioner, sløjfer og udvekslinger mellem filbeskrivelser, der bruges i bash -scripts. Lejlighedsvis kan udforskning ved hjælp af læse- og filbeskrivelser give påskeæg.