Comando Bash read

Bash Read Command



Leer o morir amigos. El comando de lectura es tan importante como los parámetros posicionales y el comando de eco. ¿De qué otra manera va a captar la entrada del usuario, aceptar contraseñas, escribir funciones, hacer bucles y echar un vistazo a los descriptores de archivos? Sigue leyendo.

¿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

echoa b| entrar

Producción

a.b

Línea de comando

echoa b| entrar | entrar. |

Producción

a|b

Funciones 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

NS() { local -I I=${1};echo$((I** 2 ));}
echo {1..10} |mapa de pow

Producción

1
4
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 9

Bucles 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.

Construir

lhs| tiempo leer
hacer
cierto
hecho
lhs es unmandoque devuelve una lista de líneas

Comandos

seq 5 | tiempo leerI
hacer
echo $ {i}
hecho

Producción

1
2
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.

Construir

tiempo leer
hacer
cierto
hecho <rhs

rhs es unexpedienteconteniendo líneas

Comandos

seq 5 >rhs
tiempo 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 5

Leyendo 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 tren10

Producció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 -a
MINGW64_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 -a
Linux 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

saltar
echolí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.