Was wird gelesen?
Read ist ein in der Bash integrierter Befehl, der den Inhalt einer Zeile in eine Variable einliest. Es ermöglicht die Wortaufteilung, die an die spezielle Shell-Variable IFS gebunden ist. Es wird hauptsächlich zum Abfangen von Benutzereingaben verwendet, kann jedoch verwendet werden, um Funktionen zu implementieren, die Eingaben von der Standardeingabe übernehmen.
Bash liest die eingebaute Befehlshilfe
Bevor wir uns mit der Verwendung des Lesebefehls in Bash-Skripten befassen, erhalten Sie hier Hilfe. Dort sollten Sie alle verfügbaren Optionen für den Lesebefehl zusammen mit Beschreibungen sehen, die wir in den Beispielen abdecken werden.
Befehlszeile
Hilfe lesen
Ausgabe
lesen:lesen [-ers] [-ein Array] [-d teilen] [-ich schreibe] [-n nchars] [-N nchars]
[-p Eingabeaufforderung] [-t Zeitüberschreitung] [-u fd] [Name ...]
Lesen Sie eine Zeile aus der Standardeingabe undTeiltes in Felder.
Liest eine einzelne Zeile aus der Standardeingabe oder ausDateiDeskriptor FD
wenndas-uOption geliefert wird. Die Linie istTeiltin Felderwiemit Wort
Aufteilung, und das erste Wort wird dem ersten NAMEN zugeordnet, das zweite
Wort an den zweiten NAMEN usw., wobei alle übrig gebliebenen Wörter zugewiesen werden
dasletzteNAME. Nur die gefundenen Charakterein $IFSsind erkanntwieWort
Trennzeichen.
Wenn keine NAMEn angegeben werden, wird die Zeilelesenwird gelagertindie REPLY-Variable.
Optionen:
-zuArray weise die Wörter zulesenzu sequentiellen Indizes des Arrays
Variables ARRAY, beginnend bei Null
-Ddelimfortsetzen bis umdas erste Zeichen von DELIM istlesen, eher
als Zeilenumbruch
-e Verwenden Sie Readline, um die Zeile zu erhaltenineine interaktive Shell
-ichText verwenden TEXTwieder AusgangstextzumZeile lesen
-nncharsRückkehrnach dem Lesen von NCHARS-Zeichen, anstatt zu warten
zumein Zeilenumbruch, aber beachten Sie ein Trennzeichenwennweniger als
NCHARS-Zeichen sindlesenvor dem Trennzeichen
-NncharsRückkehrerst nachdem genau NCHARS-Zeichen gelesen wurden, es sei denn
EOF wird angetroffen oderlesen malaus, ignoriere alle
Trennzeichen
-PPrompt gibt die Zeichenfolge PROMPT ohne abschließenden Zeilenumbruch aus
versuchenlesen
-Rtunkeine Backslashes als Escapezeichen zulassen
-StunnichtrauswerfenEingabe von einem Terminal
-TAuszeitZeitraus undRückkehrVersagenwennzuKomplettLinie von
Eingabe ist nichtleseninnerhalb von TIMEOUT-Sekunden. Der Wert der
Die Variable TMOUT ist die Standardzeitüberschreitung. TIMEOUT kann a . sein
gebrochene Zahl. Wenn TIMEOUT ist0,lesenkehrt zurück
sofort, ohne es zu versuchenlesenalle Daten, zurück
nur erfolgwennEingang ist auf den angegebenen verfügbar
DateiBeschreibung. DieAusfahrtStatus ist größer als128
wenndas Timeout ist überschritten
-ufdlesenvonDateiDeskriptor FD anstelle der Standardeingabe
Ausgangsstatus:
DieRückkehrcode ist null, es sei denn, das Dateiende wird erkannt,lesen malaus
(in welcher Falles's größer als 128), ein Variablenzuweisungsfehler
Auffangen von Benutzereingaben
Interaktive Bash-Skripte sind nichts, ohne Benutzereingaben abzufangen. Das eingebaute Read stellt Methoden bereit, mit denen Benutzereingaben in einem Bash-Skript abgefangen werden können.
Abfangen einer Eingabezeile
Um eine Zeile mit Eingaben abzufangen, werden beim Lesen keine NAMEn und Optionen benötigt. Wenn NAME nicht angegeben ist, wird eine Variable namens REPLY verwendet, um Benutzereingaben zu speichern.
Befehle
{rauswerfen -n 'Geben Sie etwas ein und drücken Sie die Eingabetaste:';
lesen;
rauswerfenDu hast getippt${ANTWORT}
}
Ausgabe
Geben Sie etwas ein und drücken Sie die Eingabetaste: etwas(Neue Zeile)Du hast etwas eingegeben
Ein Wort der Eingabe fangen
Um ein Eingabewort abzufangen, ist die Option -d erforderlich. Im Fall eines Wortes würden wir -d auf ein Leerzeichen setzen, lesen Sie ‚-d‘. Das heißt, wenn der Benutzer die Leertaste drückt, wird REPLY mit dem Wort geladen.
Beachten Sie, dass die Rücktaste nicht wie erwartet funktioniert, wenn die Option -d festgelegt ist. Um beim Versuch, ein Eingabewort abzufangen, die Rückwärtstaste zu setzen, kann die Option -e verwendet werden, lesen Sie -e ‚-d‘.
Befehle
rauswerfen -n 'Geben Sie etwas ein und drücken Sie die Leertaste: ';
lesen '-D ';
rauswerfen '';
rauswerfen 'Du hast getippt${ANTWORTEN}'
}
Ausgabe
Geben Sie etwas ein und drücken Sie die Leertaste: etwas(Platz)Du hast etwas eingegeben
Benutzer auffordern
In interaktiven Bash-Skripten kann die Aufforderung eines Benutzers eine Nachricht erfordern, um dem Benutzer mitzuteilen, welche Eingabe erwartet wird. Wir können dies immer mit dem eingebauten Echo erreichen. Es stellt sich jedoch heraus, dass es eine Option mit read gibt.
Benutzer nach einem Wort auffordern
Um ein Eingabewort abzufangen, haben wir echo verwendet, um Type etwas zu schreiben und Leerzeichen zu drücken: in die Standardausgabe, bevor wir '-d' lesen. Mit der Option -p kann eine Nachricht angezeigt werden, bevor die Standardeingabe gelesen wird.
Befehle
{lesen -P 'Geben Sie etwas ein und drücken Sie die Leertaste: ' '-D ';
rauswerfen '';
rauswerfen 'Du hast getippt${ANTWORTEN}'
}
Ausgabe
Geben Sie etwas ein und drücken Sie die Leertaste: etwas(Platz)Du hast etwas eingegeben
Benutzer zur Eingabe eines Geheimnisses auffordern
Wenn Sie Benutzereingaben abfangen, ohne dass sie im Terminal angezeigt werden, ist die Option -s praktisch. read -s -p ermöglicht es Ihnen, Benutzereingaben wie folgt abzufangen und zu verbergen.
Befehle
{lesen -S -P 'Geben Sie etwas ein, von dem ich verspreche, es geheim zu halten:'
rauswerfen '';
rauswerfen 'Dein Geheimnis ist bei mir sicher';unscharfANTWORT ;
rauswerfen '${ANTWORTEN}'
}
Ausgabe
Geben Sie etwas ein, von dem ich verspreche, es geheim zu halten:Dein Geheimnis ist bei mir sicher
Funktionen mit read
Hier sind Beispiele für Funktionen in bash, die Lese- und Standardeingaben verwenden
Kernkonzept
Funktionen, die read verwenden, verwenden Pipe-Standardeingaben und -parameter. Zu verarbeitende Haupteingaben wie Zeilen in einer Datei werden durch die Standardeingabe über eine Pipe übergeben. Andere Eingaben falls vorhanden und Option werden als Parameter übergeben.
lesen -T 1NAME1 NAME2 ...lesenist eineingebaut Befehl
-t 1 verhindert, dass das Bash-Skript unbegrenzt auf eine Zeile wartet, die über die Standardeingabe zurückgegeben wird. Wenn die Standardeingabe anfänglich leer ist, kehrt die Funktion mit einem Exit-Code von 142 zurück, was bedeutet, dass innerhalb des eingestellten Timeout-Zeitraums kein Datum gelesen wurde
NAME1 NAME2 sind Variablennamen... viele Variablennamen können aufgelistet werden
Nun, da die Grundlagen gelegt sind, sehen wir uns an, wie vertraute Funktionen aussehen, die mit read implementiert werden.
Join-Funktion mit read
Angenommen, wir möchten eine Join-Funktion, die eine Liste von Wörtern nimmt und eine weitere Liste von Wörtern zurückgibt, die durch ein Trennzeichen verbunden sind. So können wir eine Join-Funktion mit read implementieren.
Skript#!/bin/bash
## beitreten
## Version 0.0.2 - Rekursionsparameter korrigieren
################################################
beitreten() { { lokalBegrenzer;Begrenzer='$ {1}';lokalTrennzeichen;
Trennzeichen='$ {2-.}';}
lokalWagen
lokalcdr
lokalIFS
IFS='${indelimiter}'
lesen -T 1Auto-CD|| Rückkehr
Prüfung '${cdr}' || { rauswerfen '${Auto}';Rückkehr;}
rauswerfen '${Auto}${outdelimiter}${cdr}' | ${FUNCNAME} '${indelimiter}'
'${outdelimiter}'
}
################################################
## generiert von create-stub2.sh v0.1.2
## am Mo, 17 Jun 2019 12:24:59 +0900
## sehen
################################################
Quelle: beitreten.sh
Befehlszeile
Ausgabe
a.bBefehlszeile
rauswerfenein b| beitreten | beitreten. |Ausgabe
zu|BKartenfunktionen mit read
Angenommen, wir möchten eine map-Funktion, die eine Liste nimmt und eine andere Liste zurückgibt, die dieselbe Anzahl von Elementen enthält, die von einer anderen Funktion modifiziert wurden. So können wir eine Kartenfunktion mit read implementieren.
Skript#!/bin/bash
## Karte
## version 0.0.1 - initial
################################################
Karte() { { lokalFunktionsname ;Funktionsname='$ {1}';}
lokalWagen
lokalcdr
lokalIFS
IFS='${indelimiter-}'
lesen -T 1Auto-CD|| Rückkehr
Prüfung '$( deklariere -f ${function_name} )' || Rückkehr
Prüfung '${Auto}' || { wahr;Rückkehr;}
${function_name} ${Auto}
rauswerfen '${cdr}' | ${FUNCNAME} '${function_name}'
}
################################################
## generiert von create-stub2.sh v0.1.2
## am Di, 18. Juni 2019 08:33:49 +0900
## sehen
################################################
Quelle: map.sh
Befehle
rauswerfen {1..10} |Karte pow
Ausgabe
14
9
16
25
36
49
64
81
100
Filterfunktion mit read
Angenommen, wir möchten eine Filterfunktion, die eine Liste nimmt und eine Unterliste von Elementen zurückgibt, die Bedingungen einer anderen Funktion erfüllen. So können wir eine Filterfunktion mit read implementieren.
Skript#!/bin/bash
##filter
## version 0.0.1 - initial
################################################
Filter() { { lokalFunktionsname ;Funktionsname='$ {1}';}
lokalWagen
lokalcdr
lokalIFS
IFS='${indelimiter-}'
lesen -T 1Auto-CD|| Rückkehr
Prüfung '$( deklariere -f ${function_name} )' || Rückkehr
Prüfung '${Auto}' || { wahr;Rückkehr;}
${function_name} '${Auto}' || rauswerfen -n '${Auto}'
rauswerfen '${cdr}' | ${FUNCNAME} '${function_name}'
}
################################################
## generiert von create-stub2.sh v0.1.2
## am Di, 18. Juni 2019 13:19:54 +0900
## sehen
################################################
Quelle: filter.sh
Befehle
seltsam() { lokal -ich ich=$ {1};Prüfung !$((ich% 2 )) -eq 1;}rauswerfen {1..10} |ungerade filtern
Ausgabe
1 3 5 7 9Schleifen mit read
Schleifen mit read ermöglichen das Durchlaufen von Zeilen einer Datei, die erzeugt werden soll oder bereits vorhanden ist.
Einfache while-Leseschleife für die linke Seite (links)
Wir haben einen Befehl oder eine Funktion (lhs), die Zeilen in einer Datei generieren kann, die mit read und einer while-Schleife durchlaufen werden können.
Konstruierenlhs| während lesen
tun
wahr
getan
lhs ist aBefehldas gibt eine Liste von Zeilen zurück
Befehle
seq 5 | während lesenichtun
rauswerfen ${i}
getan
Ausgabe
12
3
4
5
Einfache while-Leseschleife für die rechte Seite (rechts)
Wir haben eine Datei (rhs) mit Zeilen, die mit read und einer while-Schleife durchlaufen werden können.
Konstruierenwährend lesen
tun
wahr
getan <rhs
rhs ist aDateienthaltende Zeilen
Befehle
seq 5 >rhswährend lesenich
tun
rauswerfen ${i}
getan <rhs
Ausgabe
1
2
3
4
5
Benutzerdefinierte lhs while-Schleife mit read
Wir haben einen Strom von Wörtern, die wir mit read durchschleifen möchten.
Konstruieren(
IFS=''
lhs| während lesen
tun
wahr
getan
)
lhs ist eine Liste von Wörtern
Befehle
(IFS=''
rauswerfen {1..5} | während lesenich
tun
rauswerfen '${i}
getan
)
Ausgabe
1 2 3 4 5Lesen von jedem fd anstelle von Standardeingaben
Die eingebaute Read-Option, die oft unangetastet bleibt, ist diejenige, mit der Sie angeben können, aus welchem Dateideskriptor gelesen werden soll, read -u FD. Standardmäßig wird FD als Standardeingabe verwendet.
Kernkonzept
Beim Öffnen einer Datei werden Dateideskriptoren zugewiesen. Die IO-Umleitung in der Bash ermöglicht es, eine Datei mit einem bestimmten Dateideskriptor geöffnet zu lassen. Wir dürfen in die Datei schreiben, aus ihr lesen und sie schließen, wenn wir fertig sind.
_(){
Katze /Entwickler/Null>myfifo;# leeres myfifo
ausführender 3<myfifo;# öffne die Datei myfifo als fd 3
rauswerfen 'Hallo Welt! - ab fd 3' >myfifo;# schreibe an myfifo
lesen -u 3;# Zeile aus fd 3 lesen
ausführender 3> &-;# schließen fd 3
rauswerfen ${ANTWORTEN} # Ausgabezeile aus fd 3 vor dem Schließen gelesen
}
_# Hallo Welt! ab fd 3
Bauen Sie einen Zug mit Dateideskriptoren und lesen Sie -u FD
Aus Spaß habe ich beschlossen, einen Zug mit Dateideskriptoren zu bauen und -u FD zu lesen. Zu jedem Dateideskriptor wird eine Nummer geschrieben. Jeder Dateideskriptor liest aus dem untenstehenden Dateideskriptor 1 und hängt an sich selbst an.
Befehlszeile
bashlinuxhint.com/bauen/test-read-fd.sh train10Ausgabe
fds initialisieren...fd . initialisieren3...
fd3initialisiert
fd . initialisieren4...
fd4initialisiert
fds initialisiert
Lesen von fd3und4...
4 3
fds vor dem Aufräumen
0 1 2 3 4 5
Aufräumen ...
fds aufräumen...
getanfds aufräumen
fds nach dem aufräumen
0 1 2 3
Skip-Funktion mit read -u FD
Wenn du läufst
dein Name -zuMINGW64_NT-10,0DESKTOP-XVVVVVV 2.7.0(0,307/5/3)
2017.-02-17 14:zwanzigx86_64 Msys
bash --Ausführung
GNUbash, Version 4.4.12(1)-Veröffentlichung(x86_64-pc-msys)
es kann aufgrund eines Fehlers möglich sein, eine Skip-Funktion zu implementieren, die die folgende Zeile in einem Bash-Skript außerhalb von Funktionen überspringt, bevor die Skriptquelle gelesen wird. Beachten Sie, dass es auf den meisten Systemen nicht funktioniert. Zum Beispiel,
dein Name -zuLinux 4.9.0-8-amd64#1 Debian SMP 4.9.144-3.1 (2019-02-19) x86_64 GNU/Linux
bash --Ausführung
GNUbash, Version 4.4.12(1)-Veröffentlichung(x86_64-pc-linux-gnu)
überspringen fliegt nicht.
Funktion
überspringen() { lesen -u 31;}
Befehle
überspringenrauswerfenZeile übersprungen
wahr
Ausgabe
(leer)Endeffekt
Das in bash eingebaute Read kann mehr als nur Benutzereingaben abfangen. Es kann in Funktionen, Schleifen und Austauschen zwischen Dateideskriptoren verwendet werden, die in Bash-Skripten verwendet werden. Gelegentlich kann die Exploration mit Lese- und Dateideskriptoren Ostereier ergeben.