Vad läses?
Read är ett bash -inbyggt kommando som läser innehållet i en rad till en variabel. Det möjliggör orddelning som är knuten till den speciella skalvariabeln IFS. Det används främst för att fånga användarinmatning men kan användas för att implementera funktioner som tar input från standardingång.
Bash read inbyggd kommandohjälp
Innan vi går in på hur vi använder kommandot read i bash -skript, så här får vi hjälp. Där bör du se alla tillgängliga alternativ för läskommandot tillsammans med beskrivningar som vi kommer att försöka täcka i exemplen.
Kommandorad
hjälp läsa
Produktion
läsa:läsa [-ers] [-en matris] [-d dela] [-jag text] [-n nchars] [-N nchars]
[-p -prompt] [-t timeout] [-u fd] [namn ...]
Läs en rad från standardingången ochdeladet på fält.
Läser en enda rad från standardingången eller frånfildeskriptor FD
omde-utillvalet levereras. Linjen ärdelain på fältsommed ord
delning, och det första ordet tilldelas det första NAMNET, det andra
ord till andra NAMN, och så vidare, med eventuella överblivna ord tilldelade
desistaNAMN. Endast tecknen hittadesi $ IFSerkännssomord
avgränsare.
Om inga NAME tillhandahålls, radenläsaär lagrativariabeln SVAR.
Alternativ:
-tillarray tilldela ordenläsatill sekventiella index för matrisen
variabel ARRAY, som börjar med noll
-davgränsaFortsätta fram tillsdet första tecknet i DELIM ärläsa, snarare
än newline
-e använder Readline för att få radeniett interaktivt skal
-itext använda TEXTsomden inledande textenförLäsrad
-nncharslämna tillbakaefter att ha läst NCHARS -karaktärer snarare än att vänta
fören ny linje, men hedra en avgränsareomfärre än
NCHARS -tecken ärläsaföre avgränsaren
-Nncharslämna tillbakaförst efter att ha läst exakt NCHARS -tecken, om inte
EOF påträffas ellerläsa gångerut, ignorerar någon
avgränsare
-sprompt mata ut strängen PROMPT utan en efterföljande ny rad innan
försöker attläsa
-rdolåt inte backslashes undkomma några karaktärer
-sdointekastade utingång som kommer från en terminal
-tPaustidut ochlämna tillbakafelomtillkomplettlinje av
ingång är inteläsainom TIMEOUT sekunder. Värdet på
TMOUT -variabeln är standard timeout. TIMEOUT kan vara en
bråknummer. Om TIMEOUT är0,läsareturnerar
omedelbart, utan att försökaläsaeventuell data, återkommer
endast framgångomingång är tillgänglig på det angivna
fildeskriptor. Deutgångstatus är större än128
omtidsgränsen överskrids
-ufdläsafrånfildeskriptor FD istället för standardingången
Avsluta status:
Delämna tillbakakoden är noll, om inte slutet på filen påträffas,läsa gångerut
(i som falldenär större än 128), en variabel tilldelningsfel
Fånga användarinmatning
Interaktiva bash -skript är ingenting utan att fånga användarinmatning. Den inbyggda läsningen ger metoder för att användarinmatning kan fångas i ett bash -skript.
Fånga en rad ingångar
För att fånga en rad inmatade NAMN och alternativ krävs inte av läsning. När NAME inte har angetts används en variabel med namnet REPLY för att lagra användarinmatning.
Kommandon
{kastade ut -n 'Skriv något och tryck på enter:';
läsa;
kastade utDu skrev$ {REPLY}
}
Produktion
Skriv något och tryck på enter: något(ny linje)Du skrev något
Fånga ett inmatningsord
För att fånga ett inmatningsord krävs alternativet -d. I fallet med ett ord skulle vi ställa -d till ett mellanslag, läsa '-d'. Det är när användaren trycker på mellanslagstangenten läses in för att svara med ordet.
Observera att när alternativet -d är inställt fungerar inte backspace som förväntat. För att backa, medan du försöker fånga ett inmatningsord, kan alternativet -e användas, läs -e ‘-d’.
Kommandon
kastade ut -n 'Skriv något och tryck på mellanslag:';
läsa '-d';
kastade ut '';
kastade ut 'Du skrev$ {REPLY}'
}
Produktion
Skriv något och tryck på mellanslag: något(Plats)Du skrev något
Fråga användare
I interaktiva bash -skript kan en användare behöva ett meddelande för att berätta för användaren vilken input som förväntas. Vi kan alltid åstadkomma detta med hjälp av det inbyggda ekot. Det visar sig dock att det finns ett alternativ med läsning.
Be användaren om ett ord
För att fånga ett inmatningsord använde vi eko för att skriva Skriv något och slå mellanslag: till standardutmatning innan vi läste ‘-d’. Med alternativet -p kan ett meddelande visas innan du läser från standardingång.
Kommandon
{läsa -s 'Skriv något och tryck på mellanslag:' '-d';
kastade ut '';
kastade ut 'Du skrev$ {REPLY}'
}
Produktion
Skriv något och tryck på mellanslag: något(Plats)Du skrev något
Be användaren om en hemlighet
När du fångar in användarinmatning utan att det dyker upp i terminalen kommer alternativet -s till nytta. read -s -p låter dig fånga och dölja användarinmatning enligt följande.
Kommandon
{läsa -s -s 'Skriv något jag lovar att hålla det hemligt:'
kastade ut '';
kastade ut 'Din hemlighet är säker hos mig';avstängdSVAR;
kastade ut '$ {REPLY}'
}
Produktion
Skriv något jag lovar att hålla det hemligt:Din hemlighet är säker hos mig
Funktioner med läsning
Här är exempel på funktioner i bash som använder läs och standardinmatning
Kärnkoncept
Funktioner som använder läs använder standardiserade ingångar och parametrar. Huvudinmatning som ska bearbetas, t.ex. linjer i en fil, skickas in via standardinmatning via ett rör. Annan inmatning om-någon och alternativ skickas in som parametrar.
läsa -t 1NAME1 NAME2 ...läsaär eninbyggt kommando
-t 1 förhindrar att bash -skriptet väntar på obestämd tid på att en rad ska returneras genom standardinmatning. Om standardinmatningen initialt är tom, återgår funktionen med en utgångskod på 142 vilket indikerar att inget datum har lästs inom den inställda tidsgränsen
NAME1 NAME2 är variabelnamn... många variabelnamn kan listas
Nu när grundarbetet är klart, låt oss se hur välkända funktioner ser ut som implementerade med läsning.
Gå med i funktionen läs
Antag att vi vill ha en kopplingsfunktion som tar en lista med ord och returnerar en annan lista med ord som sammanfogas av en avgränsare. Så här kan vi implementera en kopplingsfunktion med läsning.
Manus#!/bin/bash
## Ansluta sig
## version 0.0.2 - fixa rekursionsparametrar
####################################################
Ansluta sig() { { lokalbegränsare;begränsare='$ {1-}';lokaloutdelimiter;
outdelimiter='$ {2-.}';}
lokalbil
lokalcdr
lokalIFS
IFS='$ {indelimiter}'
läsa -t 1bil cdr|| lämna tillbaka
testa '$ {cdr}' || { kastade ut '$ {bil}';lämna tillbaka;}
kastade ut '$ {bil}$ {outdelimiter}$ {cdr}' | $ {FUNCNAME} '$ {indelimiter}'
'$ {outdelimiter}'
}
####################################################
## genererat av create-stub2.sh v0.1.2
## på mån, 17 juni 2019 12:24:59 +0900
## ser
####################################################
Källa: join.sh
Kommandorad
Produktion
a.bKommandorad
kastade uta b| Ansluta sig | Ansluta sig. |Produktion
till|bKartfunktioner med läsning
Antag att vi vill ha en kartfunktion som tar en lista och returnerar en annan lista som innehåller samma antal element som ändras av en annan funktion. Så här kan vi implementera en kartfunktion med läsning.
Manus#!/bin/bash
## Karta
## version 0.0.1 - initial
####################################################
Karta() { { lokalfunction_name;funktionsnamn='$ {1}';}
lokalbil
lokalcdr
lokalIFS
IFS='$ {indelimiter-}'
läsa -t 1bil cdr|| lämna tillbaka
testa '$ (deklarera -f $ {function_name})' || lämna tillbaka
testa '$ {bil}' || { Sann;lämna tillbaka;}
$ {function_name} $ {bil}
kastade ut '$ {cdr}' | $ {FUNCNAME} '$ {function_name}'
}
####################################################
## genererat av create-stub2.sh v0.1.2
## tis, 18 juni 2019 08:33:49 +0900
## ser
####################################################
Källa: map.sh
Kommandon
kastade ut {1..10} |karta pow
Produktion
14
9
16
25
36
49
64
81
100
Filterfunktion med läsning
Antag att vi vill ha en filterfunktion som tar en lista och returnerar en underlista med element som uppfyller villkor som ställs av en annan funktion. Så här kan vi implementera en filterfunktion med läsning.
Manus#!/bin/bash
## filter
## version 0.0.1 - initial
####################################################
filtrera() { { lokalfunction_name;funktionsnamn='$ {1}';}
lokalbil
lokalcdr
lokalIFS
IFS='$ {indelimiter-}'
läsa -t 1bil cdr|| lämna tillbaka
testa '$ (deklarera -f $ {function_name})' || lämna tillbaka
testa '$ {bil}' || { Sann;lämna tillbaka;}
$ {function_name} '$ {bil}' || kastade ut -n '$ {bil}'
kastade ut '$ {cdr}' | $ {FUNCNAME} '$ {function_name}'
}
####################################################
## genererat av create-stub2.sh v0.1.2
## tis, 18 juni 2019 13:19:54 +0900
## ser
####################################################
Källa: filter.sh
Kommandon
udda() { lokal -i i=$ {1};testa !$((i% 2 )) -ekv 1;}kastade ut {1..10} |filter udda
Produktion
1 3 5 7 9Slingor med läsning
Slingor med läsning låter dig iterera genom rader i en fil som ska genereras eller redan finns.
Grundläggande läsögla för vänster sida (lhs)
Vi har ett kommando eller en funktion (lhs) som kan generera rader i en fil som kan slingas igenom med hjälp av läs- och en stund -slinga.
Konstrueralhs| medan läsa
do
Sann
Gjort
lhs är enkommandosom returnerar en lista med rader
Kommandon
seq 5 | medan läsaido
kastade ut $ {i}
Gjort
Produktion
12
3
4
5
Grundläggande läsögla för höger sida (rhs)
Vi har en fil (rhs) med rader som kan loopas igenom med läsning och en stund -loop.
Konstrueramedan läsa
do
Sann
Gjort <rhs
rhs är enfilinnehållande rader
Kommandon
seq 5 >rhsmedan läsai
do
kastade ut $ {i}
Gjort <rhs
Produktion
1
2
3
4
5
Anpassade ls medan loop används med läsning
Vi har en ström av ord som vi skulle vilja gå igenom genom att läsa.
Konstruera(
IFS=''
lhs| medan läsa
do
Sann
Gjort
)
lhs är en lista med ord
Kommandon
(IFS=''
kastade ut {1..5} | medan läsai
do
kastade ut '$ {i}
Gjort
)
Produktion
1 2 3 4 5Läser från valfri fd istället för standardinmatning
Det inbyggda läsningsalternativet som ofta lämnas orört är det som låter dig specificera vilken filbeskrivning du vill läsa från, läs -u FD. Som standard anses FD vara standardinmatning.
Kärnkoncept
När en fil som öppnas tilldelas filbeskrivare. IO -omdirigering i bash gör att en fil kan stå öppen med en specifik filbeskrivning. Vi får skriva till filen, läsa från den och stänga den när vi är klara.
_(){
katt /dev/null>myfifo;# tom myfifo
exec 3<myfifo;# öppna filen myfifo som fd 3
kastade ut 'Hej världen! - från fd 3 ' >myfifo;# skriva till myfifo
läsa -u 3;# läs rad från fd 3
exec 3> &-;# stäng fd 3
kastade ut $ {REPLY} # utgångslinje läst från fd 3 före stängning
}
_# Hej världen! från fd 3
Bygga ett tåg med filbeskrivare och läs -u FD
Bara för skojs skull bestämde jag mig för att bygga ett tåg med filbeskrivare och läsa -u FD. Till varje filbeskrivare skrivs ett nummer. Varje filbeskrivare läser från filbeskrivaren 1 nedan och lägger till sig själv.
Kommandorad
våldsamt slaglinuxhint.com/bygga/test-read-fd.sh tåg10Produktion
initierar fds ...initierar fd3...
fd3intialiserad
initierar fd4...
fd4intialiserad
fds intialiserade
läser från fd3och4...
4 3
fds innan städning
0 1 2 3 4 5
städar upp ...
städa fds ...
Gjortstäda upp fds
fds efter städning
0 1 2 3
Hoppa över funktion med read -u FD
Om du springer
du namnger -tillMINGW64_NT-10,0DESKTOP-XVVVVVV 2.7.0(0,307/5/3)
2017.-02-17 14:tjugox86_64 Msys
våldsamt slag --version
GNUvåldsamt slag, version 4.4.12(1)-släpp(x86_64-pc-msys)
det kan vara möjligt på grund av en bugg att implementera en hoppfunktion som hoppar över följande rad i ett bash -skript utanför funktioner innan manuskällan läses. Observera att det inte fungerar på de flesta system. Till exempel,
du namnger -tillLinux 4.9.0-8-amd64#1 Debian SMP 4.9.144-3.1 (2019-02-19) x86_64 GNU/Linux
våldsamt slag --version
GNUvåldsamt slag, version 4.4.12(1)-släpp(x86_64-pc-linux-gnu)
hoppa flyger inte.
Fungera
hoppa() { läsa -u 31;}
Kommandon
hoppakastade utrad hoppade över
Sann
Produktion
(tömma)Slutsats
Läs inbyggd bash gör mer än att fånga användarens input. Den kan användas i funktioner, slingor och utbyten mellan filbeskrivare som används i bash -skript. Ibland kan utforskning med läs- och filbeskrivare ge påskägg.