Bash læse kommando

Bash Read Command

Læs eller dø venner. Read -kommandoen er lige så vigtig som positionsparametre og ekkokommandoen. Hvordan vil du ellers fange brugerinput, acceptere adgangskoder, skrive funktioner, sløjfe og kigge ind i filbeskrivelser? Læs videre.

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

smed uda b| tilslutte

Produktion

a.b

Kommandolinje

smed uda b| tilslutte | tilslutte. |

Produktion

til|b

Kortfunktioner 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

NS() { lokal -jeg jeg=$ {1};smed ud$((jeg** 2 ));}
smed ud {1..10} |kort pow

Produktion

1
4
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 9

Loops 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.

Konstruere

lhs| mens Læs
gøre
sand
Færdig
lhs er enkommandoder returnerer en liste med linjer

Kommandoer

seq 5 | mens Læsjeg
gøre
smed ud $ {i}
Færdig

Produktion

1
2
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.

Konstruere

mens Læs
gøre
sand
Færdig <rhs

rhs er enfilindeholdende linjer

Kommandoer

seq 5 >rhs
mens 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 5

Læ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 tog10

Produktion

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 -til
MINGW64_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 -til
Linux 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

springe
smed 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.