Co się czyta?
Read to wbudowane polecenie bash, które wczytuje zawartość wiersza do zmiennej. Pozwala na dzielenie na słowa, które jest powiązane ze specjalną zmienną powłoki IFS. Jest używany głównie do przechwytywania danych wejściowych użytkownika, ale może być używany do implementowania funkcji pobierających dane wejściowe ze standardowego wejścia.
Wbudowana pomoc dotycząca poleceń odczytu Bash
Zanim zagłębimy się w to, jak używać polecenia read w skryptach basha, oto jak uzyskać pomoc. Powinieneś tam zobaczyć wszystkie opcje dostępne dla polecenia odczytu wraz z opisami, które postaramy się omówić w przykładach.
Wiersz poleceń
Wsparcie czytać
Wyjście
czytać:czytać [-ers] [-tablica] [-d udostępnij] [-ja tekst] [-n nznaków] [-N nznarów]
[-p monit] [-t limit czasu] [-u fd] [Nazwa ...]
Odczytaj linię ze standardowego wejścia ipodziałto na pola.
Czyta pojedynczą linię ze standardowego wejścia lub zplikdeskryptor FD
Jeśliten-uopcja jest dostarczana. Linia jestpodziałw polajakze słowem
dzielenie, a pierwsze słowo jest przypisane do pierwszego IMIĘ, drugie
słowo do drugiego IMIĘ i tak dalej, z pozostałymi słowami przypisanymi do
tenostatniNAZWA. Tylko odnalezione postaciew $IFSsą rozpoznawanejaksłowo
ograniczniki.
Jeśli nie podano NAZWY, wierszczytaćjest przechowywanywzmienna ODPOWIEDŹ.
Opcje:
-dotablica przypisz słowaczytaćdo kolejnych indeksów tablicy
zmienna ARRAY, zaczynając od zera
-Ddelimkontyntynuj dopókipierwszą postacią DELIM jestczytać, raczej
niż nowa linia
-użyj Readline, aby uzyskać linięwinteraktywna powłoka
-itekst użyj TEKSTjakpoczątkowy tekstdlaCzytaj linię
-nncharypowrótpo przeczytaniu znaków NCHARS zamiast czekania
dlaznak nowej linii, ale szanuj ogranicznikJeślimniej niż
Znaki NCHARS sączytaćprzed ogranicznikiem
-Nncharypowrótdopiero po przeczytaniu dokładnie znaków NCHARS, chyba że
Napotkano EOF lubczytać czasysię, ignorując jakiekolwiek
ogranicznik
-Pznak zachęty wypisz przedtem napis PROMPT bez kończącego się znaku nowej linii
próbowaćczytać
-rrobićnie pozwalaj, aby ukośniki odwrotne uciekały przed jakimikolwiek znakami
-srobićniewyrzuciłwejście pochodzące z terminala
-Tkoniec czasuczassię ipowrótniepowodzenieJeślidokompletnylinia z
wejście nie jestczytaćw ciągu TIMEOUT sekund. Wartość
Zmienna TMOUT jest domyślnym limitem czasu. LIMIT CZASU może być
liczba ułamkowa. Jeśli LIMIT CZASU wynosi0,czytaćzwroty
natychmiast, bez próbczytaćwszelkie dane, powracające
tylko sukcesJeśliwejście jest dostępne na określonym
plikdeskryptor. tenWyjściestatus jest większy niż128
Jeśliprzekroczono limit czasu
-ufdczytaćzplikdeskryptor FD zamiast standardowego wejścia
Stan wyjścia:
tenpowrótkod ma wartość zero, chyba że napotkano koniec pliku,czytać czasyna zewnątrz
(w który Obudowatojest większe niż 128), przypisanie zmiennej err
Przechwytywanie danych wejściowych użytkownika
Interaktywne skrypty bash są niczym bez przechwytywania danych wejściowych użytkownika. Wbudowane read udostępnia metody, które mogą zostać przechwycone przez użytkownika w skrypcie bash.
Łapanie linii wejściowej
Aby przechwycić linię danych wejściowych NAZWY i opcje nie są wymagane przez read. Gdy NAME nie jest określona, zmienna o nazwie REPLY jest używana do przechowywania danych wprowadzonych przez użytkownika.
Polecenia
{wyrzucił -n 'Wpisz coś i naciśnij enter: ';
czytać;
wyrzuciłWpisałeś${ODPOWIEDŹ}
}
Wyjście
Wpisz coś i naciśnij enter: coś(Nowa linia)Wpisałeś coś
Łapanie słowa wejściowego
Aby złapać słowo wejściowe, wymagana jest opcja -d. W przypadku słowa ustawilibyśmy -d na spację, przeczytaj '-d'. To jest, gdy użytkownik naciśnie spację, przeczytaj załaduje ODPOWIEDŹ ze słowem.
Zauważ, że gdy ustawiona jest opcja -d, backspace nie działa zgodnie z oczekiwaniami. Aby cofnąć się, próbując złapać słowo wejściowe, można użyć opcji -e, przeczytaj -e ‘-d’.
Polecenia
wyrzucił -n 'Wpisz coś i naciśnij spację: ';
czytać '-D ';
wyrzucił '';
wyrzucił 'Wpisałeś${ODPOWIEDŹ}'
}
Wyjście
Wpisz coś i naciśnij spację: coś(przestrzeń)Wpisałeś coś
Pytaj użytkownika
W interaktywnych skryptach basha monitowanie użytkownika może wymagać komunikatu informującego użytkownika, jakich danych wejściowych oczekuje. Zawsze możemy to osiągnąć za pomocą wbudowanego echa. Okazuje się jednak, że istnieje opcja odczytu.
Pytaj użytkownika o słowo
Chwytając słowo wejściowe, użyliśmy echa do napisania czegoś typu Wpisz coś i naciśnij spację: na standardowe wyjście przed odczytaniem ‘-d’. Opcja -p umożliwia wyświetlenie komunikatu przed odczytaniem ze standardowego wejścia.
Polecenia
{czytać -P 'Wpisz coś i naciśnij spację: ' '-D ';
wyrzucił '';
wyrzucił 'Wpisałeś${ODPOWIEDŹ}'
}
Wyjście
Wpisz coś i naciśnij spację: coś(przestrzeń)Wpisałeś coś
Pytaj użytkownika o sekret
Podczas przechwytywania danych wprowadzonych przez użytkownika bez pokazywania ich w terminalu, przydatna jest opcja -s. read -s -p pozwala przechwycić i ukryć dane wprowadzone przez użytkownika w następujący sposób.
Polecenia
{czytać -s -P „Wpisz coś, co obiecuję zachować w tajemnicy:”
wyrzucił '';
wyrzucił 'Twój sekret jest u mnie bezpieczny';nieoprawnyODPOWIADAĆ ;
wyrzucił '${ODPOWIEDŹ}'
}
Wyjście
Wpisz coś, co obiecuję zachować w tajemnicy:Twój sekret jest u mnie bezpieczny
Funkcje wykorzystujące read
Oto przykłady funkcji w bashu, które używają odczytu i standardowego wejścia
Podstawowa koncepcja
Funkcje wykorzystujące read korzystają ze standardowego wejścia i parametrów potokowych. Główne dane wejściowe do przetworzenia, takie jak wiersze w pliku, są przekazywane przez standardowe wejście przez potok. Inne dane wejściowe if-any i opcja są przekazywane jako parametry.
czytać -T 1NAZWA1 NAZWA2...czytaćjestwbudowany Komenda
-t 1 zapobiega oczekiwaniu przez skrypt bash w nieskończoność na zwrócenie linii przez standardowe wejście. Jeśli standardowe wejście jest początkowo puste, funkcja zwraca kod wyjścia 142 oznaczający, że żadna data nie została odczytana w ustalonym okresie czasu
NAZWA1 NAZWA2 to nazwy zmiennych... można wymienić wiele nazw zmiennych
Teraz, gdy przygotowania są już gotowe, zobaczmy, jak wyglądają znajome funkcje zaimplementowane za pomocą read.
Dołącz do funkcji za pomocą read
Załóżmy, że potrzebujemy funkcji join, która pobiera listę słów i zwraca inną listę słów połączonych ogranicznikiem. Oto jak możemy zaimplementować funkcję join za pomocą read.
Scenariusz#!/kosz/bash
## Przystąp
## wersja 0.0.2 - napraw parametry rekurencji
##################################################
Przystąp() { { lokalnyogranicznik;ogranicznik='{1-} $';lokalnyogranicznik;
odgranicznik='$ {2-.}';}
lokalnysamochód
lokalnycdr
lokalnyIFS
IFS='${oznacznik}'
czytać -T 1samochód CDR|| powrót
test '${cdr}' || { wyrzucił '${samochód}';powrót;}
wyrzucił '${samochód}${ogranicznik}${cdr}' | ${FUNCNAME} '${oznacznik}'
'${ogranicznik}'
}
##################################################
## wygenerowane przez create-stub2.sh v0.1.2
## dnia pon, 17 cze 2019 12:24:59 +0900
## zobaczyć
##################################################
Źródło: dołączyć.sh
Wiersz poleceń
Wyjście
a.bWiersz poleceń
wyrzuciłb| Przystąp | Przystąp. |Wyjście
do|bMapuj funkcje za pomocą read
Załóżmy, że potrzebujemy funkcji mapującej, która pobiera listę i zwraca inną listę zawierającą taką samą liczbę elementów, które są modyfikowane przez inną funkcję. Oto jak możemy zaimplementować funkcję mapy za pomocą read.
Scenariusz#!/kosz/bash
## mapa
## wersja 0.0.1 - początkowa
##################################################
mapa() { { lokalnynazwa_funkcji ;nazwa_funkcji='$ {1}';}
lokalnysamochód
lokalnycdr
lokalnyIFS
IFS='${indelimiter-}'
czytać -T 1samochód CDR|| powrót
test '$(deklaruj -f ${nazwa_funkcji} )' || powrót
test '${samochód}' || { prawda;powrót;}
${nazwa_funkcji} ${samochód}
wyrzucił '${cdr}' | ${FUNCNAME} '${nazwa_funkcji}'
}
##################################################
## wygenerowane przez create-stub2.sh v0.1.2
## we wtorek, 18 cze 2019 08:33:49 +0900
## zobaczyć
##################################################
Źródło: mapa.sh
Polecenia
wyrzucił {1...10} |mapa
Wyjście
14
9
16
25
36
49
64
81
100
Funkcja filtrowania za pomocą odczytu
Załóżmy, że potrzebujemy funkcji filtrującej, która pobiera listę i zwraca podlistę elementów spełniających warunki ustawione przez inną funkcję. Oto jak możemy zaimplementować funkcję filtrującą za pomocą read.
Scenariusz#!/kosz/bash
## filtr
## wersja 0.0.1 - początkowa
##################################################
filtr() { { lokalnynazwa_funkcji ;nazwa_funkcji='$ {1}';}
lokalnysamochód
lokalnycdr
lokalnyIFS
IFS='${indelimiter-}'
czytać -T 1samochód CDR|| powrót
test '$(deklaruj -f ${nazwa_funkcji} )' || powrót
test '${samochód}' || { prawda;powrót;}
${nazwa_funkcji} '${samochód}' || wyrzucił -n '${samochód}'
wyrzucił '${cdr}' | ${FUNCNAME} '${nazwa_funkcji}'
}
##################################################
## wygenerowane przez create-stub2.sh v0.1.2
## we wtorek, 18 cze 2019 13:19:54 +0900
## zobaczyć
##################################################
Źródło: filtr.sh
Polecenia
dziwne() { lokalny -i i=$ {1};test !$((i% 2 )) -równe 1;}wyrzucił {1...10} |filtruj nieparzyste
Wyjście
1 3 5 7 9Pętle używające odczytu
Pętle wykorzystujące odczyt pozwalają na iterację po wierszach pliku, który ma zostać wygenerowany lub już istnieje.
Podstawowa pętla podczas odczytu po lewej stronie (lewa oś)
Mamy polecenie lub funkcję (lhs), która może generować wiersze w pliku, które można zapętlić za pomocą pętli read i while.
Zbudowaćlhs| podczas czytać
robić
prawda
Gotowe
lewa jestKomendaktóra zwraca listę linii
Polecenia
następny 5 | podczas czytaćirobić
wyrzucił ${i}
Gotowe
Wyjście
12
3
4
5
Podstawowa pętla podczas odczytu po prawej stronie (prawa strona)
Mamy plik (rhs) z liniami, przez które można przejść za pomocą pętli read i while.
Zbudowaćpodczas czytać
robić
prawda
Gotowe <prawa strona
prawa strona jestplikzawierające wiersze
Polecenia
następny 5 >prawa stronapodczas czytaći
robić
wyrzucił ${i}
Gotowe <prawa strona
Wyjście
1
2
3
4
5
Niestandardowe lhs podczas pętli przy użyciu odczytu
Mamy strumień słów, przez które chcielibyśmy przejść za pomocą read.
Zbudować(
IFS=''
lhs| podczas czytać
robić
prawda
Gotowe
)
lhs to lista słów
Polecenia
(IFS=''
wyrzucił {1...5} | podczas czytaći
robić
wyrzucił '${i}
Gotowe
)
Wyjście
1 2 3 4 5Czytanie z dowolnego fd zamiast standardowego wejścia
Wbudowana opcja read, często pozostawiona bez zmian, to ta, która pozwala określić, z jakiego deskryptora pliku czytać, read -u FD. Domyślnie FD jest traktowane jako standardowe wejście.
Podstawowa koncepcja
Kiedy do otwartego pliku są przypisane deskryptory plików. Przekierowanie we/wy w bash pozwala na pozostawienie otwartego pliku z określonym deskryptorem pliku. Możemy zapisywać do pliku, czytać z niego i zamykać, kiedy skończymy.
_(){
Kot /dev/zero>myfifo;# puste myfifo
exec 3<myfifo;# otwórz plik myfifo jako fd 3
wyrzucił 'Witaj świecie! - od dd 3' >myfifo;# napisz do myfifo
czytać -u 3;# odczytaj linię z fd 3
exec 3> &-;# zamknij fd 3
wyrzucił ${ODPOWIEDŹ} # linia wyjściowa odczytana z fd 3 przed zamknięciem
}
_# Witaj świecie! od dd 3
Budowanie pociągu z deskryptorami plików i odczytem -u FD
Dla zabawy postanowiłem zbudować pociąg z deskryptorami plików i odczytać -u FD. Do każdego deskryptora pliku zapisany jest numer. Każdy deskryptor pliku odczytuje z deskryptora pliku 1 poniżej i dołącza się do siebie.
Wiersz poleceń
grzmotnąćlinuxhint.com/budować/test-read-fd.sh pociąg10Wyjście
inicjowanie plików fd...inicjowanie fd3...
fd3zainicjowany
inicjowanie fd4...
fd4zainicjowany
zainicjowano fds
czytanie z fd3oraz4...
4 3
fds przed czyszczeniem
0 1 2 3 4 5
sprzątanie ...
sprzątanie fds ...
Gotowesprzątanie fds
fds po oczyszczeniu
0 1 2 3
Funkcja pomijania przy użyciu read -u FD
Jeśli biegasz
unname -doMINGW64_NT-10,0DESKTOP-XVVVVVV 2.7.0(0,307/5/3)
2017.-02-17 14:20x86_64 Msys
grzmotnąć --wersja
GNU ANTYLOPAgrzmotnąć, wersja 4.4.12(1)-uwolnienie(x86_64-pc-msys)
ze względu na błąd może być możliwe zaimplementowanie funkcji pomijania, która pomija następujący wiersz w skrypcie bash poza funkcjami przed odczytaniem źródła skryptu. Zauważ, że nie działa na większości systemów. Na przykład,
unname -doLinux 4.9.0-8-amd64#1 Debian SMP 4.9.144-3.1 (19.02.2019) x86_64 GNU/Linux
grzmotnąć --wersja
GNU ANTYLOPAgrzmotnąć, wersja 4.4.12(1)-uwolnienie(x86_64-pc-linux-gnu)
przeskok nie lata.
Funkcjonować
pominąć() { czytać -u 31;}
Polecenia
pominąćwyrzuciłlinia pominięta
prawda
Wyjście
(pusty)Dolna linia
Wbudowane czytanie w bash nie tylko przechwytuje dane wprowadzane przez użytkownika. Może być używany w funkcjach, pętlach i wymianach między deskryptorami plików używanymi w skryptach bash. Czasami eksploracja przy użyciu deskryptorów do odczytu i plików może dać pisanki.