En este artículo, discutiremos cómo leer la entrada del usuario en BASH.
Entrada de usuario básica
Simplemente podemos obtener la entrada del usuario del comando de lectura en BASH. Proporciona muchas opciones y argumentos junto con él para un uso más flexible, pero los cubriremos en las próximas secciones. Por ahora, veamos cómo se puede usar un comando básico de lectura.
#!usr/bin/env bash read name echo "Hello, $name"
Entonces, en el script anterior, el «#!/usr/bin/env bash» es el operador shebang que indica al intérprete que ejecute el script en el entorno BASH. Hemos utilizado el comando de lectura para obtener la entrada del usuario en el nombre de la variable. El comando echo es un comando opcional para simplemente verificar que hemos almacenado la entrada en la variable de nombre. Usamos $delante del comando variable para buscar y analizar el valor literal de la variable.
Leer argumentos de comando
El comando de lectura proporciona una gran cantidad de argumentos que se le pueden pasar para obtener la entrada del usuario de una manera flexible. Algunos de los pocos argumentos se discuten aquí:
- String de solicitud (-p)
- Entrada de contraseña (-s)
- Cambiar el delimitador (IFS)
- Análisis de la array (-a)
- Limitación de la longitud de la entrada (-n)
- Entrada temporizada (-t)
String de solicitud
Usando este argumento, podemos solicitar una string antes de la entrada. Esto le permite al usuario tener una idea de qué ingresar sin usar el eco antes del comando de lectura. Echemos un vistazo a la demostración del argumento de solicitar una string al comando de lectura.
#!usr/bin/env bash read -p "Enter your name : " name echo "Hello, $name"
A partir de la demostración, podemos ver que había una solicitud de string antes de la entrada del usuario porque hemos usado el argumento «-p» antes de la variable de entrada, lo que da un argumento más, la string antes de la variable. Esto permite una mejor interfaz y legibilidad del programa. Podemos decir que este tipo de funcionalidad de eco incorporada se encuentra en el comando de lectura con el indicador de string.
Entrada de contraseña
Ahora suponga que queremos escribir la contraseña en la entrada y cuán inseguro sería mostrar mientras el usuario está escribiendo. Bueno, tenemos la solución para eso. Podemos usar el argumento -s para silenciar el eco de la entrada del usuario. Esto permite trabajar con el comando de lectura de forma segura.
#!usr/bin/env bash read -sp "Enter your password : " pswd echo -e "\nYour password is $pswd"
En la demostración anterior, la entrada se silencia, es decir, la interfaz no imprime lo que el usuario está escribiendo. Pero podemos ver que escribí 12345 y se almacena y recupera más tarde de la variable. Puede notar que anidamos los argumentos -s y -p como -sp para usar ambos argumentos juntos. Además, el comando echo se modifica cuando usamos el argumento -e para usar strings formateadas, es decir, usamos “ \n ” y otros caracteres especiales en la string.
Cambiar el delimitador
Usando este argumento, podemos cambiar la forma en que asignamos el valor a las variables, es decir, si queremos obtener las entradas múltiples usando un solo comando de lectura, podemos hacerlo usando valores separados por espacios.
#!usr/bin/env bash read -p "Enter name age and country : " name age country echo "Name : $name" echo "Age : $age" echo "Country : $country"
En el ejemplo anterior, podemos ver que inteligentemente asignó las variables a los valores proporcionados. Puede ver que la última variable tenía 3 espacios, por lo que, dado que fue la última entrada, se asignó todo, pero si no fue la última entrada, podría estropear el formato.
Si hubiéramos proporcionado cuatro entradas, la palabra «Unidos» habría sido la variable del país y el resto de las cosas en la última variable. Aquí comprendemos un poco los delimitadores, los delimitadores son los patrones o caracteres que se utilizan para distinguir diferentes conjuntos de entidades, en nuestro caso, las variables de entrada. Podemos cambiar los delimitadores, por defecto tenemos espacio como delimitadores en el comando de lectura . Veamos cómo podemos lograrlo.
#!usr/bin/env bash IFS="," read -p "Enter name, age, city and country : " name age city country echo "Name : $name" echo "Age : $age" echo "City : $city" echo "Country : $country"
En el siguiente ejemplo, hemos utilizado el IFS o el Separador de campo interno. Hemos configurado el IFS como «,» al comienzo del comando de lectura. Como puede ver, esto no cuenta el espacio como separador en la asignación de variables. Esto conduce a entradas adecuadas y formateadas como se desee, puede elegir IFS como el carácter que no se usa en las entradas internamente; de lo contrario, puede desorientar el formato como se esperaba. Podemos usar IFS como “ . “, “ , “, “ / “, “ \ “. “ ; “, etc. ya que esto no se usa comúnmente en la entrada y también depende del objetivo que esté tratando de lograr.
Análisis de una array
Podemos analizar la entrada directamente en una array a la vez. Podemos especificar el argumento -a para hacer lo mismo. Esto crea un elemento y asigna a los elementos de la array el valor de entrada. Veamos la demostración.
#!usr/bin/env bash
read -a array -p "Enter the elements of array : "
for n in ${array[*]};
do
echo "$n"
done
En este ejemplo, estamos ingresando los valores a la variable de array que es una lista/array. El nombre puede ser cualquier cosa relevante para su programa. El delimitador aquí es como dicho espacio por defecto, puede usar el argumento IFS al comienzo del comando de lectura para formatear la entrada como se dijo en la sección anterior. Pero aquí para la demostración, lo he mantenido por defecto en el espacio. Podemos agregar el argumento – a para agregar la entrada a una array proporcionada justo después de eso. Podemos verificar que el comando de lectura funcionó y almacenó todos los elementos iterando sobre la array.
Podemos usar los bucles for basados en rango para simplificar e imprimir el valor de cada elemento en la array. Podemos usar el “ {} ” para identificar la variable y [*] indicando todos los elementos en el arreglo , tenemos el iterador como “n” el cual imprimimos el valor después de cada iteración. Por lo tanto, en la salida, pudimos obtener todos los elementos de la array. Incluso podemos usar «[@]» en lugar de «[*]», ya que iteraría sobre la array de una manera un poco diferente pero tendría el mismo propósito.
Limitación de la longitud de la entrada
Incluso podemos limitar la longitud de la entrada en el comando de lectura. Si queremos que el usuario restrinja al usuario con ciertas limitaciones en la entrada, podemos hacerlo usando el argumento -n.
#!usr/bin/env bash read -n 6 -p "Enter the name : " name echo -e "\nName : $name"
En la demostración anterior, podemos ver que incluso si no presiono Retorno de carro/Intro/Nueva línea, el comando se detiene después de ingresar el sexto carácter en la entrada. Por lo tanto, esto se puede usar para limitar al usuario con algunas entradas confidenciales como nombre de usuario, contraseña, etc. Ingresamos el argumento -n seguido de la cantidad de caracteres a los que queremos limitar.
Entrada temporizada
Esto se hace a la entrada del usuario de una manera limitada en el tiempo. Podemos especificar el argumento como -t y la cantidad de segundos que queremos esperar hasta salir del indicador de entrada.
#!usr/bin/env bash read -p "Enter the name : " -t 8 name echo -e "\nName : $name"
Por lo tanto, podemos ver que el indicador esperó durante 8 segundos, pero no presionamos Enter y, por lo tanto, regresó sin ingresar las instrucciones adicionales en el script, si corresponde. Podemos pasar el argumento -t para establecer el tiempo de espera seguido de la cantidad de segundos de espera para que el usuario ingrese el valor requerido.