Bash läskommando

Bash Read Command



Läs eller dö vänner. Läskommandot är lika viktigt som positionsparametrar och ekokommando. Hur ska du annars fånga användarinmatning, acceptera lösenord, skriva funktioner, slinga och kika in i filbeskrivare? Läs vidare.

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

kastade uta b| Ansluta sig

Produktion

a.b

Kommandorad

kastade uta b| Ansluta sig | Ansluta sig. |

Produktion

till|b

Kartfunktioner 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

NS() { lokal -i i=$ {1};kastade ut$((i** 2 ));}
kastade ut {1..10} |karta pow

Produktion

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

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

Konstruera

lhs| medan läsa
do
Sann
Gjort
lhs är enkommandosom returnerar en lista med rader

Kommandon

seq 5 | medan läsai
do
kastade ut $ {i}
Gjort

Produktion

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

Konstruera

medan läsa
do
Sann
Gjort <rhs

rhs är enfilinnehållande rader

Kommandon

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

Lä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åg10

Produktion

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

hoppa
kastade 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.