¿Qué se lee?
Read es un comando integrado de bash que lee el contenido de una línea en una variable. Permite la división de palabras que está ligada a la variable especial de shell IFS. Se usa principalmente para capturar la entrada del usuario, pero se puede usar para implementar funciones que toman la entrada de la entrada estándar.
Ayuda de comando incorporado de lectura de bash
Antes de sumergirnos en cómo usar el comando de lectura en scripts bash, aquí es cómo obtenemos ayuda. Allí debería ver todas las opciones disponibles para el comando de lectura junto con descripciones que intentaremos cubrir en los ejemplos.
Línea de comando
ayuda leer
Producción
leer:leer [-ers] [-una matriz] [-d compartir] [-yo texteo] [-n nchars] [-N nchars]
[-p mensaje] [-t tiempo de espera] [-u fd] [nombre ...]
Lea una línea de la entrada estándar ysepararen los campos.
Lee una sola línea de la entrada estándar o deexpedientedescriptor FD
silos-use suministra la opción. La linea essepararen los camposcomocon palabra
dividiendo, y la primera palabra se asigna al primer NOMBRE, la segunda
palabra al segundo NOMBRE, y así sucesivamente, con las palabras sobrantes asignadas a
losúltimoNOMBRE. Solo los personajes encontradosen $ IFSson reconocidoscomopalabra
delimitadores.
Si no se proporcionan NAME, la línealeerestá almacenadoenla variable REPLY.
Opciones:
-amatriz asignar las palabrasleera índices secuenciales de la matriz
variable ARRAY, comenzando en cero
-DdelimitarSeguir Hasta queel primer carácter de DELIM esleer, bastante
que nueva línea
-Utilizamos Readline para obtener la líneaenun caparazón interactivo
-Itexto usar TEXTcomoel texto inicialporReadline
-nortencharsregresodespués de leer los personajes de NCHARS en lugar de esperar
poruna nueva línea, pero respeta un delimitadorsimenos que
Los personajes de NCHARS sonleerantes del delimitador
-NORTEncharsregresosolo después de leer exactamente los caracteres NCHARS, a menos que
EOF se encuentra oleer vecesfuera, ignorando cualquier
delimitador
-pagIndique la salida de la cadena PROMPT sin una nueva línea al final antes
intentandoleer
-rhacerno permitir que las barras invertidas escapen de ningún carácter
-shacernoechoentrada procedente de un terminal
-tse acabó el tiempotiempoFuera yregresofallasiacompletolinea de
la entrada no esleerdentro de TIMEOUT segundos. El valor de la
La variable TMOUT es el tiempo de espera predeterminado. TIMEOUT puede ser un
numero fraccional. Si TIMEOUT es0,leerdevoluciones
inmediatamente, sin intentarleercualquier dato, devolviendo
solo éxitosila entrada está disponible en el especificado
expedientedescriptor. losSalidael estado es mayor que128
sise excede el tiempo de espera
-ufdleerdeexpedientedescriptor FD en lugar de la entrada estándar
Estado de salida:
losregresoel código es cero, a menos que se encuentre el final del archivo,leer vecesfuera
(en cuales casoesoes mayor que 128), un error de asignación de variable
Captando la entrada del usuario
Los scripts de bash interactivos no son nada sin captar la entrada del usuario. La lectura incorporada proporciona métodos que la entrada del usuario puede ser capturada dentro de un script bash.
Captando una línea de entrada
Para capturar una línea de NAME de entrada y las opciones no son requeridas por read. Cuando no se especifica NAME, se usa una variable llamada REPLY para almacenar la entrada del usuario.
Comandos
{echo -norte 'Escribe algo y presiona enter:';
leer;
echoTu escribiste$ {RESPUESTA}
}
Producción
Escribe algo y presiona enter: algo(nueva línea)Escribiste algo
Captar una palabra de entrada
Para captar una palabra de entrada, se requiere la opción -d. En el caso de una palabra, pondríamos -d en un espacio, leeríamos '-d'. Es entonces cuando el usuario presiona la barra espaciadora read cargará RESPUESTA con la palabra.
Tenga en cuenta que cuando se establece la opción -d, el retroceso no funciona como se esperaba. Para retroceder, mientras intenta captar una palabra de entrada, se puede usar la opción -e, lea -e '-d'.
Comandos
echo -norte 'Escribe algo y pulsa espacio:';
leer '-D ';
echo '';
echo 'Escribiste$ {RESPUESTA}'
}
Producción
Escribe algo y pulsa espacio: algo(espacio)Escribiste algo
Preguntar al usuario
En los scripts de bash interactivos, el usuario puede requerir un mensaje para indicarle qué entrada se espera. Siempre podemos lograr esto usando el eco incorporado. Sin embargo, resulta que hay una opción que usa read.
Solicitar al usuario una palabra
Al capturar una palabra de entrada, usamos echo para escribir algo y presionar espacio: a la salida estándar antes de leer '-d'. La opción -p permite que se muestre un mensaje antes de leerlo desde la entrada estándar.
Comandos
{leer -pag 'Escribe algo y pulsa espacio:' '-D ';
echo '';
echo 'Escribiste$ {RESPUESTA}'
}
Producción
Escribe algo y pulsa espacio: algo(espacio)Escribiste algo
Solicitar al usuario un secreto
Cuando se captura la entrada del usuario sin que aparezca en la terminal, la opción -s es útil. read -s -p le permite capturar y ocultar la entrada del usuario de la siguiente manera.
Comandos
{leer -s -pag 'Escriba algo, prometo mantenerlo en secreto:'
echo '';
echo 'Tu secreto está a salvo conmigo';desarmadoRESPUESTA ;
echo '$ {RESPUESTA}'
}
Producción
Escriba algo que prometo mantenerlo en secreto:Tu secreto está a salvo conmigo
Funciones usando read
Aquí hay ejemplos de funciones en bash que usan lectura y entrada estándar
Concepto principal
Las funciones que utilizan lectura hacen uso de parámetros y entradas estándar por canalización. La entrada principal que se va a procesar, como las líneas de un archivo, se pasa a través de la entrada estándar a través de una tubería. Otras entradas, si las hay, y las opciones se pasan como parámetros.
leer -t 1NAME1 NAME2 ...leeres unincorporado mando
-t 1 evita que el script bash espere indefinidamente a que se devuelva una línea a través de la entrada estándar. Si la entrada estándar está inicialmente vacía, la función regresa con un código de salida de 142, lo que significa que no se leyó ninguna fecha dentro del período de tiempo de espera establecido.
NAME1 NAME2 son nombres de variables... se pueden enumerar muchos nombres de variables
Ahora que las bases están establecidas, veamos cómo se ven las funciones familiares implementadas usando read.
Unirse a la función usando read
Supongamos que queremos una función de combinación que toma una lista de palabras y devuelve otra lista de palabras unidas por un delimitador. Así es como podemos implementar una función de unión usando read.
Texto#! / bin / bash
## entrar
## versión 0.0.2 - corregir parámetros de recursividad
##################################################
entrar() { { locallimitadorlimitador='${1- }';localoutdelimiter;
outdelimiter='${2-.}';}
localcoche
localcdr
localIFS
IFS='$ {indelimiter}'
leer -t 1coche cdr|| regreso
prueba '$ {cdr}' || { echo '$ {coche}';regreso;}
echo '$ {coche}$ {outdelimiter}$ {cdr}' | $ {FUNCNAME} '$ {indelimiter}'
'$ {outdelimiter}'
}
##################################################
## generado por create-stub2.sh v0.1.2
## el Lun, 17 de junio de 2019 12:24:59 +0900
## ver
##################################################
Fuente: join.sh
Línea de comando
Producción
a.bLínea de comando
echoa b| entrar | entrar. |Producción
a|bFunciones de mapa usando read
Supongamos que queremos una función de mapa que toma una lista y devuelve otra lista que contiene el mismo número de elementos que son modificados por otra función. Así es como podemos implementar una función de mapa usando read.
Texto#! / bin / bash
## mapa
## versión 0.0.1 - inicial
##################################################
mapa() { { localnombre de la función ;nombre de la función='${1}';}
localcoche
localcdr
localIFS
IFS='$ {indelimiter-}'
leer -t 1coche cdr|| regreso
prueba '$ (declare -f $ {nombre_función})' || regreso
prueba '$ {coche}' || { cierto;regreso;}
$ {function_name} $ {coche}
echo '$ {cdr}' | $ {FUNCNAME} '$ {function_name}'
}
##################################################
## generado por create-stub2.sh v0.1.2
## el martes, 18 de junio de 2019 08:33:49 +0900
## ver
##################################################
Fuente: map.sh
Comandos
echo {1..10} |mapa de pow
Producción
14
9
16
25
36
49
64
81
100
Función de filtro mediante lectura
Supongamos que queremos una función de filtro que toma una lista y devuelve una sublista de elementos que satisfacen las condiciones establecidas por otra función. Así es como podemos implementar una función de filtro usando read.
Texto#! / bin / bash
## filtro
## versión 0.0.1 - inicial
##################################################
filtrar() { { localnombre de la función ;nombre de la función='${1}';}
localcoche
localcdr
localIFS
IFS='$ {indelimiter-}'
leer -t 1coche cdr|| regreso
prueba '$ (declare -f $ {nombre_función})' || regreso
prueba '$ {coche}' || { cierto;regreso;}
$ {function_name} '$ {coche}' || echo -norte '$ {coche}'
echo '$ {cdr}' | $ {FUNCNAME} '$ {function_name}'
}
##################################################
## generado por create-stub2.sh v0.1.2
## el martes 18 de junio de 2019 13:19:54 +0900
## ver
##################################################
Fuente: filter.sh
Comandos
impar() { local -I I=${1};prueba !$((I% 2 )) -eq 1;}echo {1..10} |filtro impar
Producción
1 3 5 7 9Bucles usando lectura
Los bucles que usan lectura le permiten iterar a través de las líneas de un archivo que se va a generar o que ya existe.
Bucle de lectura while básico para el lado izquierdo (izq.)
Tenemos un comando o función (lhs) que puede generar líneas en un archivo que se pueden recorrer usando read y un bucle while.
Construirlhs| tiempo leer
hacer
cierto
hecho
lhs es unmandoque devuelve una lista de líneas
Comandos
seq 5 | tiempo leerIhacer
echo $ {i}
hecho
Producción
12
3
4
5
Bucle de lectura while básico para el lado derecho (dcha.)
Tenemos un archivo (rhs) con líneas que se pueden recorrer usando read y un bucle while.
Construirtiempo leer
hacer
cierto
hecho <rhs
rhs es unexpedienteconteniendo líneas
Comandos
seq 5 >rhstiempo leerI
hacer
echo $ {i}
hecho <rhs
Producción
1
2
3
4
5
Custom lhs while loop usando read
Tenemos un flujo de palabras que nos gustaría recorrer usando read.
Construir(
IFS=' '
lhs| tiempo leer
hacer
cierto
hecho
)
lhs es una lista de palabras
Comandos
(IFS=' '
echo {1..5} | tiempo leerI
hacer
echo '$ {i}
hecho
)
Producción
1 2 3 4 5Leyendo desde cualquier fd en lugar de la entrada estándar
La opción de lectura incorporada que a menudo se deja intacta es la que le permite especificar qué descriptor de archivo leer, leer -u FD. Por defecto, FD se toma como entrada estándar.
Concepto principal
Cuando se abre un archivo, se asignan descriptores de archivo. La redirección de IO en bash permite dejar un archivo abierto con un descriptor de archivo específico. Se nos permite escribir en el archivo, leerlo y cerrarlo cuando hayamos terminado.
_(){
gato /dev/nulo>myfifo;# myfifo vacío
ejecutivo 3<myfifo;# abre el archivo myfifo como fd 3
echo '¡Hola Mundo! - desde fd 3 ' >myfifo;# escribir a myfifo
leer -u 3;# leer línea de fd 3
ejecutivo 3>&-;# cerrar fd 3
echo $ {RESPUESTA} # línea de salida leída de fd 3 antes de cerrar
}
_# ¡Hola Mundo! desde fd 3
Construyendo un tren con descriptores de archivos y lectura -u FD
Simplemente por diversión, decidí construir un tren con descriptores de archivo y leer -u FD. En cada descriptor de archivo se escribe un número. Cada descriptor de archivo lee el descriptor de archivo 1 a continuación y se agrega a sí mismo.
Línea de comando
intentolinuxhint.com/construir/test-read-fd.sh tren10Producción
inicializando fds ...inicializando fd3...
fd3inicializado
inicializando fd4...
fd4inicializado
fds inicializado
leyendo de fd3y4...
4 3
fds antes de limpiar
0 1 2 3 4 5
limpiar ...
limpiando fds ...
hecholimpiando fds
fds después de limpiar
0 1 2 3
Función de salto usando read -u FD
Si estas corriendo
tu nombre -aMINGW64_NT-10.0ESCRITORIO-XVVVVVV 2.7.0(0.307/5/3)
2017-02-17 14:20x86_64 Msys
intento --versión
ÑUintento, versión 4.4.12(1)-liberación(x86_64-pc-msys)
puede ser posible debido a un error implementar una función de omisión que omita la siguiente línea en un script bash fuera de las funciones antes de que se lea el código fuente del script. Tenga en cuenta que no funciona en la mayoría de los sistemas. Por ejemplo,
tu nombre -aLinux 4.9.0-8-amd64# 1 Debian SMP 4.9.144-3.1 (2019-02-19) x86_64 GNU / Linux
intento --versión
ÑUintento, versión 4.4.12(1)-liberación(x86_64-pc-linux-gnu)
saltar no vuela.
Función
saltar() { leer -u 31;}
Comandos
saltarecholínea omitida
cierto
Producción
(vacío)Línea de fondo
La lectura incorporada en bash hace más que capturar la entrada del usuario. Se puede utilizar en funciones, bucles e intercambios entre descriptores de archivo utilizados en scripts bash. En ocasiones, la exploración con descriptores de archivos y de lectura puede generar huevos de Pascua.