Wat wordt er gelezen?
Read is een bash ingebouwd commando dat de inhoud van een regel in een variabele leest. Het maakt het splitsen van woorden mogelijk die is gekoppeld aan de speciale shell-variabele IFS. Het wordt voornamelijk gebruikt voor het opvangen van gebruikersinvoer, maar kan worden gebruikt om functies te implementeren die invoer van standaardinvoer nodig hebben.
Bash lees ingebouwde opdracht help
Voordat we ingaan op het gebruik van het leescommando in bash-scripts, is hier hoe we hulp krijgen. Daar zou je alle beschikbare opties voor het leescommando moeten zien, samen met beschrijvingen die we in de voorbeelden zullen proberen te behandelen.
Opdrachtregel
helpen lezen
Uitgang:
lezen:lezen [-ers] [-een array] [-d delen] [-ik sms] [-n nchars] [-N nchars]
[-p prompt] [-t time-out] [-u fd] [naam ...]
Lees een regel van de standaardinvoer ensplitsenhet in velden.
Leest een enkele regel van de standaardinvoer, of vanhet dossierdescriptor FD
indiende-uoptie wordt geleverd. De lijn issplitsenin veldenalsmet woord
splitsen, en het eerste woord wordt toegewezen aan de eerste NAAM, de tweede
woord naar de tweede NAAM, enzovoort, met eventuele overgebleven woorden toegewezen aan
delaatsteNAAM. Alleen de tekens gevondenin $IFSworden herkendalswoord
scheidingstekens.
Als er geen NAMEN zijn opgegeven, wordt de regellezenis opgeslageninde REPLY-variabele.
Opties:
-totarray wijs de woorden toelezennaar sequentiële indices van de array
variabele ARRAY, beginnend bij nul
-NSdelimodoorgaan met tothet eerste teken van DELIM islezen, liever
dan nieuwe regel
-e gebruik Readline om de regel te verkrijgenineen interactieve shell
-ltekst gebruik TEKSTalsde eerste tekstvoorLees regel
-Nncharsopbrengstna het lezen van NCHARS-tekens in plaats van te wachten
vooreen nieuwe regel, maar respecteer een scheidingstekenindienminder dan
NCHARS-tekens zijnlezenvoor het scheidingsteken
-Nncharsopbrengstalleen na het lezen van exact NCHARS-tekens, tenzij
EOF wordt aangetroffen oflezen keeruit, het negeren van eventuele
scheidingsteken
-Pprompt output de string PROMPT zonder een afsluitende nieuwe regel ervoor
proberen omlezen
-Rdoenlaat backslashes niet ontsnappen aan tekens
-sdoennietgooide uitinvoer afkomstig van een terminal
-ttime-outtijduit enopbrengstmislukkingindientotcompleetlijn van
invoer is nietlezenbinnen TIMEOUT seconden. De waarde van de
De variabele TMOUT is de standaardtime-out. TIMEOUT kan een . zijn
fractioneel getal. Als TIMEOUT is0,lezengeeft terug
onmiddellijk, zonder te proberenlezenalle gegevens, retourneren
alleen succesindieninvoer is beschikbaar op de opgegeven
het dossierdescriptor. DeUitgangstatus is groter dan128
indiende time-out is overschreden
-ufdlezenvanhet dossierdescriptor FD in plaats van de standaardinvoer
Afsluitstatus:
Deopbrengstcode is nul, tenzij end-of-file wordt aangetroffen,lezen keeruit
(in die gevalhet's groter dan 128), een variabele toewijzingsfout
Gebruikersinvoer opvangen
Interactieve bash-scripts zijn niets zonder gebruikersinvoer te vangen. De ingebouwde leesfunctie biedt methoden waarmee gebruikersinvoer binnen een bash-script kan worden opgevangen.
Een invoerregel opvangen
Om een regel invoer te vangen, zijn NAMEN en opties niet vereist door te lezen. Als NAME niet is opgegeven, wordt een variabele met de naam REPLY gebruikt om gebruikersinvoer op te slaan.
Commando's
{gooide uit -N 'Typ iets en druk op enter: ';
lezen;
gooide uitjij typte${ANTWOORD}
}
Uitgang:
Typ iets en druk op enter: iets(nieuwe lijn)Je hebt iets getypt
Een woord van input vangen
Om een invoerwoord op te vangen, is de optie -d vereist. In het geval van een woord zouden we -d op een spatie zetten, lees '-d'. Dat is wanneer de gebruiker op de spatiebalk drukt om REPLY te laden met het woord.
Merk op dat wanneer de -d optie is ingesteld, de backspace niet werkt zoals verwacht. Om terug te gaan, terwijl u probeert een invoerwoord op te vangen, kan de -e optie worden gebruikt, lees -e '-d '.
Commando's
gooide uit -N 'Typ iets en druk op spatie: ';
lezen '-NS ';
gooide uit '';
gooide uit 'Je typte'${ANTWOORD}'
}
Uitgang:
Typ iets en druk op spatie: iets(ruimte)Je hebt iets getypt
Gebruiker vragen
In interactieve bash-scripts kan een gebruiker een bericht nodig hebben om de gebruiker te vertellen welke invoer wordt verwacht. We kunnen dit altijd bereiken met behulp van de ingebouwde echo. Het blijkt echter dat er een optie is om lezen te gebruiken.
Gebruiker om een woord vragen
Bij het vangen van een invoerwoord hebben we echo gebruikt om Typ iets te schrijven en op spatie te drukken: naar standaarduitvoer voordat u '-d' leest. Met de optie -p kan een bericht worden weergegeven voordat de standaardinvoer wordt gelezen.
Commando's
{lezen -P 'Typ iets en druk op spatie: ' '-NS ';
gooide uit '';
gooide uit 'Je typte'${ANTWOORD}'
}
Uitgang:
Typ iets en druk op spatie: iets(ruimte)Je hebt iets getypt
Gebruiker om een geheim vragen
Bij het opvangen van gebruikersinvoer zonder dat deze in de terminal verschijnt, is de optie -s handig. read -s -p stelt u in staat om gebruikersinvoer als volgt op te vangen en te verbergen.
Commando's
{lezen -s -P 'Typ iets dat ik beloof om het geheim te houden:'
gooide uit '';
gooide uit 'Jouw geheim is veilig bij mij';uitgeschakeldANTWOORD ;
gooide uit '${ANTWOORD}'
}
Uitgang:
Typ iets dat ik beloof om het geheim te houden:Jouw geheim is veilig bij mij
Functies met behulp van lezen
Hier zijn voorbeelden van functies in bash die lees- en standaardinvoer gebruiken
Kernbegrip
Functies die lezen gebruiken, maken gebruik van doorgesluisde standaardinvoer en parameters. Hoofdinvoer die moet worden verwerkt, zoals regels in een bestand, worden via standaardinvoer via een pijp ingevoerd. Andere invoer indien van toepassing en optie worden doorgegeven als parameters.
lezen -t 1NAAM1 NAAM2 ...lezenis eeningebouwd opdracht
-t 1 voorkomen dat het bash-script voor onbepaalde tijd wacht op een regel die wordt geretourneerd via standaardinvoer. Als de standaardinvoer aanvankelijk leeg is, keert de functie terug met een afsluitcode van 142, wat betekent dat er geen datum is gelezen binnen de ingestelde time-outperiode
NAME1 NAME2 zijn namen van variabelen... veel variabelenamen kunnen worden vermeld
Nu de basis is gelegd, laten we eens kijken hoe bekende functies eruit zien als ze zijn geïmplementeerd met lezen.
Join-functie met read
Stel dat we een join-functie willen die een lijst met woorden nodig heeft en een andere lijst met woorden teruggeeft die door een scheidingsteken worden samengevoegd. Hier is hoe we een join-functie kunnen implementeren met behulp van read.
Script#!/bin/bash
## meedoen
## versie 0.0.2 - recursieparameters repareren
################################################## #
meedoen() { { lokaalindelimiter;indelimiter='$ {1-}';lokaalscheidingsteken;
scheidingsteken='$ {2-.}';}
lokaalauto
lokaalcdr
lokaalIFS
IFS='${indelimiter}'
lezen -t 1auto cdr|| opbrengst
toets '${cdr}' || { gooide uit '${auto}';opbrengst;}
gooide uit '${auto}${outdelimiter}${cdr}' | ${FUNCNAME} '${indelimiter}'
'${outdelimiter}'
}
################################################## #
## gegenereerd door create-stub2.sh v0.1.2
## op ma, 17 jun 2019 12:24:59 +0900
## zien
################################################## #
Bron: join.sh
Opdrachtregel
Uitgang:
a.bOpdrachtregel
gooide uiteen b| meedoen | meedoen. |Uitgang:
tot|BKaartfuncties met read
Stel dat we een kaartfunctie willen die een lijst nodig heeft en een andere lijst teruggeeft die hetzelfde aantal elementen bevat die door een andere functie zijn gewijzigd. Hier is hoe we een kaartfunctie kunnen implementeren met behulp van read.
Script#!/bin/bash
## kaart
## versie 0.0.1 - initiaal
################################################## #
kaart() { { lokaalfunctienaam ;functienaam='$ {1}';}
lokaalauto
lokaalcdr
lokaalIFS
IFS='${indelimiter- }'
lezen -t 1auto cdr|| opbrengst
toets '$( declareren -f ${function_name} )' || opbrengst
toets '${auto}' || { waar;opbrengst;}
${function_name} ${auto}
gooide uit '${cdr}' | ${FUNCNAME} '${function_name}'
}
################################################## #
## gegenereerd door create-stub2.sh v0.1.2
## op di 18 jun 2019 08:33:49 +0900
## zien
################################################## #
Bron: map.sh
Commando's
gooide uit {1..10} |kaart pow
Uitgang:
14
9
16
25
36
49
64
81
100
Filterfunctie met read
Stel dat we een filterfunctie willen die een lijst nodig heeft en een sublijst van elementen retourneert die voldoen aan de voorwaarden die door een andere functie zijn ingesteld. Hier is hoe we een filterfunctie kunnen implementeren met behulp van read.
Script#!/bin/bash
## filter
## versie 0.0.1 - initiaal
################################################## #
filter() { { lokaalfunctienaam ;functienaam='$ {1}';}
lokaalauto
lokaalcdr
lokaalIFS
IFS='${indelimiter- }'
lezen -t 1auto cdr|| opbrengst
toets '$( declareren -f ${function_name} )' || opbrengst
toets '${auto}' || { waar;opbrengst;}
${function_name} '${auto}' || gooide uit -N '${auto}'
gooide uit '${cdr}' | ${FUNCNAME} '${function_name}'
}
################################################## #
## gegenereerd door create-stub2.sh v0.1.2
## op di 18 jun 2019 13:19:54 +0900
## zien
################################################## #
Bron: filter.sh
Commando's
vreemd() { lokaal -l l=$ {1};toets !$((l% 2 )) -eq 1;}gooide uit {1..10} |oneven filteren
Uitgang:
1 3 5 7 9Lussen met read
Met lussen die read gebruiken, kunt u door regels van een bestand lopen dat moet worden gegenereerd of al bestaat.
Basic while-leeslus voor de linkerkant (links)
We hebben een commando of functie (lhs) die regels in een bestand kan genereren die kunnen worden doorlopen met behulp van read en een while-lus.
construerenlhs| terwijl lezen
doen
waar
gedaan
lhs is eenopdrachtdie een lijst met regels retourneert
Commando's
volgende 5 | terwijl lezenldoen
gooide uit ${i}
gedaan
Uitgang:
12
3
4
5
Basis while-leeslus voor de rechterkant (rechts)
We hebben een bestand (rhs) met regels die kunnen worden doorlopen met behulp van een lees- en een while-lus.
construerenterwijl lezen
doen
waar
gedaan <rhs
rhs is eenhet dossiermet lijnen
Commando's
volgende 5 >rhsterwijl lezenl
doen
gooide uit ${i}
gedaan <rhs
Uitgang:
1
2
3
4
5
Aangepaste lhs while-lus met read
We hebben een stroom van woorden die we willen doorlopen met lezen.
construeren(
IFS=''
lhs| terwijl lezen
doen
waar
gedaan
)
lhs is een lijst met woorden
Commando's
(IFS=''
gooide uit {1..5} | terwijl lezenl
doen
gooide uit '${i}
gedaan
)
Uitgang:
1 2 3 4 5Lezen van elke fd in plaats van standaardinvoer
De ingebouwde leesoptie die vaak onaangeroerd blijft, is degene waarmee u kunt specificeren uit welke bestandsdescriptor u wilt lezen, read -u FD. Standaard wordt FD als standaardinvoer beschouwd.
Kernbegrip
Wanneer een bestand wordt geopend, worden bestandsbeschrijvingen toegewezen. Met IO-omleiding in bash kan een bestand open worden gelaten met een specifieke bestandsdescriptor. We mogen naar het bestand schrijven, eruit lezen en het sluiten als we klaar zijn.
_(){
kat /dev/nul>myfifo;# lege myfifo
uitvoerend 3<myfifo;# open myfifo als fd 3
gooide uit 'Hallo Wereld! - vanaf fd 3' >myfifo;# schrijf naar myfifo
lezen -u 3;# lees regel van fd 3
uitvoerend 3> &-;# sluit fd 3
gooide uit ${ANTWOORD} # uitgangsregel gelezen van fd 3 voor sluiting
}
_# Hallo Wereld! vanaf fd 3
Een trein bouwen met bestandsbeschrijvingen en lees -u FD
Gewoon voor de lol besloot ik een trein te bouwen met bestandsbeschrijvingen en -u FD te lezen. Aan elke bestandsdescriptor wordt een nummer geschreven. Elke bestandsdescriptor leest uit de onderstaande bestandsdescriptor 1 en voegt zichzelf toe.
Opdrachtregel
bashlinuxhint.com/bouwen/test-lees-fd.sh trein10Uitgang:
FDS initialiseren...initialiseren van fd3...
fd3geïnitialiseerd
initialiseren van fd4...
fd4geïnitialiseerd
fds geïnitialiseerd
lezen van fd3en4...
4 3
fds voor het opruimen
0 1 2 3 4 5
schoonmaken ...
fd's opruimen...
gedaanfds opruimen
fds na het opruimen
0 1 2 3
Skip-functie met read -u FD
Als je aan het rennen bent
je naam -totMINGW64_NT-10.0DESKTOP-XVVVVVV 2.7.0(0,307/5/3)
2017-02-17 14:twintigx86_64 Msys
bash --versie
GNUbash, versie 4.4.12(1)-uitgave(x86_64-pc-msys)
het kan mogelijk zijn door een bug om een skip-functie te implementeren die de volgende regel in een bash-script buiten functies overslaat voordat de scriptbron wordt gelezen. Merk op dat het niet op de meeste systemen werkt. Bijvoorbeeld,
je naam -totLinux 4.9.0-8-amd64#1 Debian SMP 4.9.144-3.1 (2019-02-19) x86_64 GNU/Linux
bash --versie
GNUbash, versie 4.4.12(1)-uitgave(x86_64-pc-linux-gnu)
overslaan vliegt niet.
Functie
overslaan() { lezen -u 31;}
Commando's
overslaangooide uitregel overgeslagen
waar
Uitgang:
(leeg)Waar het op neerkomt:
De ingebouwde ingebouwde bash doet meer dan gebruikersinvoer opvangen. Het kan worden gebruikt in functies, loops en uitwisselingen tussen bestandsdescriptors die in bash-scripts worden gebruikt. Af en toe kan verkenning met behulp van lees- en bestandsdescriptors paaseieren opleveren.