Ordre de lectura de Bash

Llegiu o moriu amics. L’ordre read és tan important com els paràmetres de posició i l’ordre echo. De quina altra manera podreu captar l'entrada de l'usuari, acceptar contrasenyes, escriure funcions, fer un bucle i mirar els descriptors de fitxers? Segueix llegint.

Què es llegeix?

Llegir és una ordre integrada bash que llegeix el contingut d’una línia en una variable. Permet la divisió de paraules lligada a la variable de shell especial IFS. S'utilitza principalment per captar l'entrada de l'usuari, però es pot utilitzar per implementar funcions que prenen l'entrada de l'entrada estàndard.

Bash llegeix l'ajuda de l'ordre integrada

Abans d’explorar com utilitzar l’ordre read en scripts bash, aquí teniu com obtenir ajuda. Allà hauríeu de veure totes les opcions disponibles per a l'ordre de lectura juntament amb les descripcions que intentarem cobrir als exemples.

Línia d’ordres

ajuda llegir

Sortida

llegir:llegir [-ers] [-una matriu] [-d compartir] [-i text] [-n nchars] [-N nchars]
[-p demana] [-t temps d'espera] [-u fd] [nom ...]

Llegiu una línia des de l'entrada estàndard idividiren camps.

Llegeix una sola línia des de l'entrada estàndard o des dedossierdescriptor FD
siel-uopció subministrada. La línia ésdividiren campscomamb paraula
es divideix i la primera paraula s’assigna al primer NOM, el segon
paraula al segon NOM, i així successivament, amb les paraules restants assignades a
elúltimNOM. Només els personatges trobatsdins $ IFSsón reconegutscomparaula
delimitadors.

Si no es proporcionen NAME, la líniallegirs’emmagatzemadinsla variable REPLY.

Opcions:
-aarray assigna les paraulesllegira índexs seqüencials de la matriu
variable ARRAY, començant per zero
-ddelimcontinuar finsel primer personatge de DELIM ésllegir, més aviat
que newline
-Feu servir Readline per obtenir la líniadinsun shell interactiu
-iús de text TEXTcomel text inicialperLínia de lectura
-nncharstornardesprés de llegir els personatges de NCHARS en lloc d’esperar
peruna línia nova, però respecta un delimitadorsimenys que

Els caràcters de NCHARS sónllegirabans del delimitador
-Nncharstornarnomés després de llegir exactament els caràcters NCHARS, tret que
Es troba EOF ollegir vegadesfora, ignorant qualsevol
delimitador
-psol·liciteu la sortida de la cadena PROMPT sense una línia nova final
intentantllegir
-rferno permetre que les barres invertides escapin de cap caràcter
-sfernotroboentrada provinent d’un terminal
-ttemps d'esperatempsfora itornarfracàssiacompletlínia de
l'entrada no ho ésllegird'aquí a TIMEOUT segons. El valor del fitxer
La variable TMOUT és el temps d'espera per defecte. TIMEOUT pot ser un
nombre fraccionari. Si és TIMEOUT0,llegirtorna
immediatament, sense intentar-hollegirqualsevol dada, retornant
només èxitsil'entrada està disponible a l'especificat
dossierdescriptor. Elsortirl'estat és superior a128
sies supera el temps d'espera
-ufdllegirdes dedossierdescriptor FD en lloc de l'entrada estàndard

Estat de sortida:
Eltornarel codi és zero, tret que es trobi el final del fitxer,llegir vegadesfora
(dins quin Caixaaixòés superior a 128), un error d'assignació variable

S'està capturant l'entrada de l'usuari

Els scripts bash interactius no són res sense captar les dades de l'usuari. La funció integrada de lectura proporciona mètodes que permeten capturar l'entrada de l'usuari dins d'un script bash.

Captura d'una línia d'entrada

Per llegir una línia d'entrada, no és necessari que NAME i les opcions siguin llegides. Quan no s'especifica NAME, s'utilitza una variable anomenada REPLY per emmagatzemar l'entrada de l'usuari.

Ordres

{
trobo -n 'Escriviu alguna cosa i premeu Retorn:';
llegir;
troboHas escrit$ {REPLY}
}

Sortida

Escriviu alguna cosa i premeu Intro: alguna cosa(línia nova)
Has escrit alguna cosa

Agafant una paraula d’entrada

Per agafar una paraula d’entrada, cal l’opció -d. En el cas d’una paraula, establiríem -d en un espai, llegiríem ‘-d’. És llavors quan l'usuari prem la barra espaiadora que es llegeix i carregarà REPLY amb la paraula.

Tingueu en compte que quan l'opció -d està configurada, el retrocés no funciona com s'esperava. Per retrocedir, mentre intenteu captar una paraula d’entrada, es pot utilitzar l’opció -e, llegiu -e ‘-d’.

Ordres

{
trobo -n 'Escriviu alguna cosa i premeu l'espai:';
llegir '-d';
trobo '';
trobo Heu escrit$ {REPLY}'
}

Sortida

Escriviu alguna cosa i premeu l'espai: alguna cosa(espai)
Has escrit alguna cosa

Usuari ràpid

En els scripts bash interactius que sol·liciten a un usuari pot requerir un missatge per dir-li a l'usuari quina entrada s'espera. Sempre ho podem aconseguir utilitzant el eco integrat. No obstant això, resulta que hi ha una opció que utilitza read.

Sol·liciteu una paraula a l'usuari

En capturar una paraula d’entrada, hem utilitzat eco per escriure Tipus de cosa i colpejar espai: a la sortida estàndard abans de llegir ‘-d’. L'opció -p permet mostrar un missatge abans de llegir-lo des de l'entrada estàndard.

Ordres

{
llegir -p 'Escriviu alguna cosa i premeu l'espai:' '-d';
trobo '';
trobo Heu escrit$ {REPLY}'
}

Sortida

Escriviu alguna cosa i premeu l'espai: alguna cosa(espai)
Has escrit alguna cosa

Demaneu a l'usuari un secret

Quan es capta l'entrada de l'usuari sense que aparegui al terminal, l'opció -s és útil. read -s -p us permet captar i amagar les dades de l'usuari de la següent manera.

Ordres

{
llegir -s -p 'Escriviu alguna cosa que prometo mantenir en secret:'
trobo '';
trobo 'El teu secret està segur amb mi';inestableRESPOSTA;
trobo '$ {REPLY}'
}

Sortida

Escriviu alguna cosa que prometo mantenir en secret:
El teu secret està segur amb mi

Funcions mitjançant lectura

A continuació, es mostren exemples de funcions en bash que fan servir lectura i entrada estàndard

Concepte bàsic

Les funcions que fan servir read fan ús d’entrada i paràmetres estàndard canalitzats. Les entrades principals que s’han de processar, com ara les línies d’un fitxer, es passen a través d’una entrada estàndard mitjançant una canonada. Es passen altres paràmetres si hi ha alguna entrada i opció.

llegir -t 1NOM1 NOM2 ...

llegirés unincorporat comandament

-t 1 impedeix que l'script bash esperi indefinidament que es retorni una línia mitjançant l'entrada estàndard. Si l’entrada estàndard està buida inicialment, la funció torna amb un codi de sortida de 142 que significa que no s’ha llegit cap data dins del període de temps d’espera definit.

NOM1 NOM2 són noms de variables

... es poden incloure molts noms de variables

Ara que es defineixen les bases, vegem quines funcions familiars semblen implementades mitjançant read.

Funció Join mitjançant read

Suposem que volem una funció d’unió que agafi una llista de paraules i retorni una altra llista de paraules unides per un delimitador. A continuació s'explica com podem implementar una funció d'unió mitjançant read.

Guió

#! / bin / bash
## unir-se
## versió 0.0.2: corregiu els paràmetres de recursió
##################################################
unir-se() { { locallimitador;limitador='$ {1-}';localoutdelimiter;
outdelimiter='$ {2-.}';}
localcotxe
localcdr
localIFS
IFS='$ {indelimiter}'
llegir -t 1cotxe cdr|| tornar
prova '$ {cdr}' || { trobo '$ {car}';tornar;}
trobo '$ {car}$ {outdelimiter}$ {cdr}' | $ {FUNCNAME} '$ {indelimiter}'
'$ {outdelimiter}'
}
##################################################
## generat per create-stub2.sh v0.1.2
## el dilluns, 17 de juny de 2019 12:24:59 +0900
## veure
##################################################

Font: join.sh
Línia d’ordres

troboa b| unir-se

Sortida

a.b

Línia d’ordres

troboa b| unir-se | unir-se. |

Sortida

a|b

Funcions de mapes mitjançant lectura

Suposem que volem una funció de mapa que prengui una llista i retorni una altra llista que contingui el mateix nombre d'elements que són modificats per una altra funció. A continuació s’explica com podem implementar una funció de mapa amb read.

Guió

#! / bin / bash
## mapa
## versió 0.0.1: inicial
##################################################
mapa() { { localnom_funció;nom_funció='$ {1}';}
localcotxe
localcdr
localIFS
IFS='$ {indelimiter-}'
llegir -t 1cotxe cdr|| tornar
prova '$ (declarar -f $ {nom_funció})' || tornar
prova '$ {car}' || { cert;tornar;}
$ {function_name} $ {car}
trobo '$ {cdr}' | $ {FUNCNAME} '$ {function_name}'
}
##################################################
## generat per create-stub2.sh v0.1.2
## el dimarts, 18 de juny de 2019 08:33:49 +0900
## veure
##################################################

Font: map.sh
Ordres

NS() { local -i jo=$ {1};trobo$((jo** 2 ));}
trobo {1..10} |mapa pow

Sortida

1
4
9
16
25
36
49
64
81
100

Funció de filtre mitjançant lectura

Suposem que volem una funció de filtre que prengui una llista i retorni una sublista d'elements que satisfan les condicions establertes per una altra funció. A continuació s’explica com podem implementar una funció de filtre mitjançant read.

Guió

#! / bin / bash
## filtre
## versió 0.0.1: inicial
##################################################
filtre() { { localnom_funció;nom_funció='$ {1}';}
localcotxe
localcdr
localIFS
IFS='$ {indelimiter-}'
llegir -t 1cotxe cdr|| tornar
prova '$ (declarar -f $ {nom_funció})' || tornar
prova '$ {car}' || { cert;tornar;}
$ {function_name} '$ {car}' || trobo -n '$ {car}'
trobo '$ {cdr}' | $ {FUNCNAME} '$ {function_name}'
}
##################################################
## generat per create-stub2.sh v0.1.2
## el dimarts, 18 de juny de 2019 13:19:54 +0900
## veure
##################################################

Font: filter.sh

Ordres

estrany() { local -i jo=$ {1};prova !$((jo% 2 )) -eq 1;}
trobo {1..10} |filtre senar

Sortida

1 3 5 7 9

Bucles mitjançant lectura

Els bucles que fan servir read us permeten recórrer les línies d’un fitxer que s’ha de generar o que ja existeix.

Bucle bàsic mentre es llegeix per al costat esquerre (lhs)

Tenim una ordre o una funció (lhs) que pot generar línies en un fitxer que es poden fer mitjançant un bucle mitjançant lectura i un bucle while.

Construeix

lhs| mentre llegir
fer
cert
fet
lhs és uncomandamentque retorna una llista de línies

Ordres

seq 5 | mentre llegirjo
fer
trobo $ {i}
fet

Sortida

1
2
3
4
5

Bucle bàsic mentre es llegeix per al costat dret (rhs)

Tenim un fitxer (rhs) amb línies que es poden recórrer en bucle mitjançant la lectura i un bucle while.

Construeix

mentre llegir
fer
cert
fet <rhs

rhs és undossierque conté línies

Ordres

seq 5 >rhs
mentre llegirjo
fer
trobo $ {i}
fet <rhs

Sortida

1
2
3
4
5

Personalitzeu lhs mentre utilitzeu bucle de lectura

Tenim un flux de paraules que ens agradaria fer un bucle mitjançant la lectura.

Construeix

(
IFS=''
lhs| mentre llegir
fer
cert
fet
)

lhs és una llista de paraules

Ordres

(
IFS=''
trobo {1..5} | mentre llegirjo
fer
trobo '$ {i}
fet
)

Sortida

1 2 3 4 5

Lectura des de qualsevol fd en lloc de l'entrada estàndard

L'opció integrada de lectura que sovint es deixa intacta és la que us permet especificar quin descriptor de fitxer voleu llegir, llegir -u FD. Per defecte, FD es considera una entrada estàndard.

Concepte bàsic

Quan s’assignen descriptors de fitxers oberts. La redirecció IO a bash permet deixar un fitxer obert amb un descriptor de fitxer específic. Se’ns permet escriure al fitxer, llegir-ne i tancar-lo quan hàgim acabat.

_()
{
gat /dev/nul>myfifo;# myfifo buit
exec 3<myfifo;# obre el fitxer myfifo com a fd 3
trobo 'Hola món! - a partir de fd 3 ' >myfifo;# escriu a myfifo
llegir -u 3;# llegir la línia del fd 3
exec 3> &-;# tancar fd 3
trobo $ {REPLY} # línia de sortida llegida des del fd 3 abans de tancar-la
}
_# Hola món! a partir de fd 3

Construir un tren amb descriptors de fitxers i llegir -u FD

Només per diversió, vaig decidir construir un tren amb descriptors de fitxers i llegir -u FD. A cada descriptor de fitxers s’escriu un número. Cada descriptor de fitxers llegeix des del descriptor de fitxers 1 que hi ha a continuació i s’hi afegeix.

Línia d’ordres

bashlinuxhint.com/construir/tren de prova-lectura-fd.sh10

Sortida

inicialitzant fds ...
inicialitzant fd3...
fd3intialitzat
inicialitzant fd4...
fd4intialitzat
fds intialitzat
lectura de fd3i4...
4 3
fds abans de netejar
0 1 2 3 4 5
neteja ...
netejant fds ...
fetneteja de fds
fds després de la neteja
0 1 2 3

Funció d'ometre mitjançant lectura -u FD

Si esteu corrent

uname -a
MINGW64_NT-10.0DESKTOP-XVVVVVV 2.7.0(0307/5/3)
2017-02-17 14:20x86_64 Msys
bash --versió
GNUbash, versió 4.4.12(1)-alliberament(x86_64-pc-msys)

pot ser possible a causa d'un error implementar una funció de salt que salti la línia següent en un script bash fora de les funcions abans de llegir el codi font. Tingueu en compte que no funciona a la majoria de sistemes. Per exemple,

uname -a
Linux 4.9.0-8-amd64# 1 Debian SMP 4.9.144-3.1 (2019-02-19) x86_64 GNU / Linux
bash --versió
GNUbash, versió 4.4.12(1)-alliberament(x86_64-pc-linux-gnu)

saltar no vola.

Funció

Omet() { llegir -u 31;}

Ordres

Omet
trobolínia saltada
cert

Sortida

(buit)

Linia inferior

La lectura integrada a bash fa molt més que captar l'entrada de l'usuari. Es pot utilitzar en funcions, bucles i intercanvis entre descriptors de fitxers utilitzats en scripts bash. De vegades, l'exploració mitjançant descriptors de fitxers i de lectura pot produir ous de Pasqua.

Ordre de lectura de Bash

Què es llegeix?

Bash llegeix l'ajuda de l'ordre integrada

S'està capturant l'entrada de l'usuari

Captura d'una línia d'entrada

Agafant una paraula d’entrada

Usuari ràpid

Sol·liciteu una paraula a l'usuari

Demaneu a l'usuari un secret

Funcions mitjançant lectura

Concepte bàsic

Funció Join mitjançant read

Funcions de mapes mitjançant lectura

Funció de filtre mitjançant lectura

Bucles mitjançant lectura

Bucle bàsic mentre es llegeix per al costat esquerre (lhs)

Bucle bàsic mentre es llegeix per al costat dret (rhs)

Personalitzeu lhs mentre utilitzeu bucle de lectura

Lectura des de qualsevol fd en lloc de l'entrada estàndard

Concepte bàsic

Construir un tren amb descriptors de fitxers i llegir -u FD

Funció d'ometre mitjançant lectura -u FD

Linia inferior

Categoria

Entrades Populars