Escribir guiones en Bash. Escribiendo Scripts en Linux (Aprendiendo con el Ejemplo) Lo que necesita saber desde el principio

Escribir scripts en Linux (aprender con ejemplos)

———————————————————————————-

1. Introducción

Lo que necesitas para escribir guiones
Propiedad de la herramienta línea de comando y sus opciones requeridas.
Conocimiento básico en Inglés el nivel de la escuela primaria no interferirá.

Por qué se necesitan guiones
En primer lugar, la administración de un servidor Linux, en un grado u otro, se reduce a la ejecución sistemática de los mismos comandos. Además, no es necesario que estos comandos sean ejecutados por una persona. Se pueden programar para ser ejecutados por una máquina.
En segundo lugar, incluso hacer una tarea normal que (de repente) asciende a 20-1000... las operaciones repetitivas son MUCHO más fáciles de implementar en un script.

que es un guion
Un script es un conjunto de instrucciones que deben estar en un cierto orden y en tiempo específico ejecutar computadora. Las instrucciones pueden ser comandos internos shells (bucles, condiciones, procesamiento información de texto, trabajar con Variables de entorno etc.), así como cualquier programa que ejecutemos en la consola con los parámetros necesarios.

Cómo escribir un guión
En nuestro caso, el script será Archivo de texto con atributos de ejecución. Si un archivo de script comienza con #!, que se llama sha-bang en el mundo UNIX, esto le dice al sistema qué intérprete usar para ejecutar el script. Si esto es difícil de entender, entonces recuerde que comenzaremos a escribir todos los scripts con la línea #!/bin/bash o #!/bin/sh, y luego irán los comandos y los comentarios.

palabra de despedida
Le aconsejo sinceramente que escriba tantos comentarios como sea posible en casi todas las líneas del guión. Pasará el tiempo y deberá cambiar o modernizar el guión escrito una vez. Si no recuerda o no comprende lo que está escrito en el guión, se vuelve difícil cambiarlo, es más fácil escribir desde cero.

Qué scripts podríamos necesitar:

establecer reglas de cortafuegos cuando se inicia el sistema.

realizar una copia de seguridad de la configuración y los datos.

agregando buzones V servidor de correo(más precisamente, en la base de datos mysql)

lanzando en un momento determinado (preferiblemente todas las noches) un programa que escanea los registros del servidor proxy y emite un informe web conveniente sobre la cantidad de tráfico descargado.

enviándonos por correo información de que alguien ha accedido a nuestro servidor vía ssh, tiempo de conexión y dirección del cliente.

Sobre la técnica de scripting
Creamos un archivo de texto, lo editamos, establecemos derechos de ejecución, lo ejecutamos, comprobamos errores, lo arreglamos, lo ejecutamos, comprobamos errores...
Cuando todo está lamido y funciona correctamente, lo ponemos en autocarga o en el programador durante un tiempo determinado.

———————————————————————————-

2. Aprender a escribir scripts en el lenguaje BASH interno
original: https://www.linuxconfig.org/Bash_scripting_Tutorial

Esta guía no asume ningún conocimiento previo de cómo escribir scripts (en adelante, scripts) utilizando lenguaje interno intento. Con la ayuda de esta guía, pronto descubrirá que las secuencias de comandos son muy Tarea simple. Comencemos nuestro tutorial con un script simple que imprime la cadena "¡Hola mundo!" (traducido del inglés - ¡Hola a todos!)

1. Escenario "Hola a todos"
Aquí está su primer ejemplo de secuencia de comandos bash:

#!/bin/bash
eco "Hola mundo"

Cambie al directorio que contiene nuestro archivo hello_world.sh y hágalo ejecutable:

Código: Seleccionar todo $ chmod +x hello_world.sh

Ejecute el script para su ejecución.

Código: Seleccionar todo $ ./hello_world.sh

2. Un script bash de archivo simple

#!/bin/bash
tar -czf midirectorio_principal.tar.gz /home/usuario

Código: Seleccionar todo $ ./backup.sh

$ du -sh midirectorio_principal.tar.gz
41M myhome_directory.tar.gz

3. Trabajar con variables
En este ejemplo, declaramos una variable simple y la mostramos en la pantalla usando el comando echo.

#!/bin/bash
STRING="HOLA MUNDO!!!"
eco $CADENA

Código: Seleccionar todo $ ./hello_world.sh
¡¡¡HOLA MUNDO!!!

Nuestro script de archivo con variables:

#!/bin/bash
OF=midirectorio_principal_$(fecha +%Y%m%d).tar.gz
IF=/inicio/usuario
tar -czf $DE $SI

Código: Seleccionar todo $ ./backup.sh
tar: eliminando la "\" inicial de los nombres de los miembros
$ du -sh *tar.gz
41M myhome_directory_20100123.tar.gz

3.1 Variables globales y locales

#!/bin/bash
# Declarar una variable global
# Esta variable se puede usar en cualquier parte de este script
VAR="variable global"
golpe de función (
# Declarar una variable local
# Tal variable es válida solo para la función en la que se declara
VAR local="variables locales"
eco $VAR
}
eco $VAR
intento
# Tenga en cuenta que la variable global no ha cambiado
eco $VAR

Código: Seleccionar todo $ ./variables.sh
variables globales
variable local
variables globales

4. Pasar Argumentos al Script

#!/bin/bash
# Usar variables predefinidas para acceder a argumentos
# Imprimir argumentos en la pantalla
eco $1 $2 $3 ‘ -> eco $1 $2 $3’

#También podemos acceder a los argumentos a través de un arreglo especial args=("$@")
# Imprimir argumentos en la pantalla
echo $(argumentos) $(argumentos) $(argumentos) ‘ -> argumentos=("$@"); echo $(argumentos) $(argumentos) $(argumentos)'

# Use la variable $@ para mostrar todos los argumentos a la vez
eco $@ ‘ -> eco $@’

Utilice la variable $# para mostrar el número de argumentos pasados ​​al script
echo Número de argumentos pasados: $# ‘ -> echo Número de argumentos pasados: $#’

Código: seleccione todo $ ./arguments.sh Bash Scripting Tutorial
Tutorial de secuencias de comandos de Bash -> echo $1 $2 $3
Tutorial de scripting de Bash -> args=("$@"); echo $(argumentos) $(argumentos) $(argumentos)
Tutorial de secuencias de comandos de Bash -> echo $@
Número de argumentos pasados: 3 -> echo Número de argumentos pasados: $#

5. Ejecutar comandos de Shell en un script

#!/bin/bash
# usar comillas traseras» ` ` » para ejecutar un comando de shell
echo `uname -o`
# ahora probemos sin comillas
echo uname -o

Código: Seleccionar todo $ uname -o
GNU/Linux
$ ./bash_backtricks.sh
GNU/Linux
uname-o

Como puede ver, en el segundo caso, se mostraba el comando en sí, y no el resultado de su ejecución.

6. Leer la entrada del usuario (interactividad)

#!/bin/bash
echo -e "Hola, escribe la palabra: \c"
leer palabra
echo "La palabra que ingresó es: $palabra"
echo -e "¿Puedes ingresar dos palabras? »
leer palabra1 palabra2
echo "Aquí está su entrada: \"$palabra1\" \"$palabra2\""
echo -e "¿Cómo te sientes acerca de bash scripting? »
# El comando de lectura ahora almacena una respuesta en la variable incorporada predeterminada $REPLY
leer
echo "Dijiste $RESPONDER, ¡me alegra escuchar eso! »
echo -e "¿Cuáles son tus colores favoritos? »
# -a hace que el comando de lectura lea en una matriz
leer -a colores
echo "Mis colores favoritos también son $(colores), $(colores) y $(colores):-)"

Código: Seleccionar todo $ ./read.sh
Hola, por favor escriba la palabra: algo
La palabra que ingresaste es: algo
¿Puedes introducir dos palabras?
DebianLinux
Aquí está su entrada: "Debian" "Linux"
¿Cómo te sientes acerca de bash scripting?
bien
¡Dijiste bien, me alegra escuchar eso!
¿Cuáles son tus colores favoritos?
azul verde negro
Mis colores favoritos también son el azul, el verde y el negro :-)

7. Usando la trampa

#!/bin/bash
# declarar una trampa
trampa bashtrap INT
# limpiar la pantalla
claro;
# la función gancho se ejecuta cuando el usuario presiona CTRL-C:
# Mostrará => ¡Ejecutando la subrutina bash trap!
# pero el script continuará ejecutándose
bashtrap()
{
echo "¡CTRL+C detectado!... ¡ejecutando bash trap!"
}
# el script contará hasta 10
para a en `seq 1 10`; hacer
echo "$a/10 para salir".
dormir1;
hecho
echo "¡¡Salir del ejemplo de Bash Trap!!!"

Código: Seleccionar todo $ ./trap.sh
1/10
2/10
3/10
4/10
5/10
6/10

7/10
8/10
9/10
CTRL+C ¡Detectado!...ejecutando bash trap!
10/10
¡¡¡Ejemplo de Salir de Bash Trap!!!

Como puede ver, la combinación de teclas Ctrl-C no detuvo la ejecución del script.

8. Matrices
8.1 Declarar una matriz simple

#!/bin/bash
# Declarar una matriz simple con 4 elementos
ARRAY=('Debian Linux' 'Red Hat Linux' ubuntu linux)
# Obtener el número de elementos en la matriz
ELEMENTOS=$(#ARRAY[@])

# recorrer cada elemento de la matriz
para ((i=0;i<$ELEMENTS;i++)); do
echo $(ARRAY[$(i)])
hecho

Código: Seleccionar todo $./arrays.sh
DebianLinux
red hat linux
ubuntu
linux

8.2 Llenar una matriz con valores de un archivo

#!/bin/bash
# Declarar una matriz
declarar -a ARRAY
# comando ejecutivo # stdin (generalmente el teclado) se generará a partir de este archivo. Esto hace posible leer
# el contenido del archivo, línea por línea, y analice cada línea ingresada con sed y/o awk.
ejecutivo 10 letcount=0

mientras lee LINE<&10; do

ARRAY[$recuento]=$LINEA
((cuenta++))
hecho

echo Número de elementos: $(#ARRAY[@])
# Mostrar valores de matriz
echo $(ARRAY[@])
# cerrar el archivo
ejecutivo 10>&-

Código: Seleccionar todo $ cat bash.txt
DebianLinux
red hat linux
ubuntu
linux
$ ./matrices.sh
Número de elementos: 4
Debian Linux Redhat Linux Ubuntu Linux

9. Condiciones si-entonces-si no
9.1. Uso simple de condiciones "if-else"
Preste atención a los espacios entre corchetes, sin los cuales la condición no funcionará.

#!/bin/bash
directorio="./BashScripting"

# comprobar si existe el directorio
if [ -d $directorio ]; entonces
echo "El directorio existe"
demás
echo "El directorio no existe"
fi

Código: Seleccionar todo $ ./if_else.sh
directorio no existe
$ mkdir BashScripting
$ ./if_else.sh
El directorio existe

9.2 Condiciones if-else anidadas

#!/bin/bash
# Declarar una variable con valor 4
elección = 4
# Mostrar
eco "1. intento"
eco "2. Secuencias de comandos»
eco "3. Tutorial"

# Ejecutar mientras la variable sea igual a cuatro
# bucle
while [ $elección -eq 4 ]; hacer

# leer la entrada del usuario
elección de lectura
# condición "if-else" anidada
si [ $ elección -eq 1 ] ; entonces

echo "Has elegido la palabra: Bash"

si [ $ elección -eq 2 ] ; entonces
echo "Ha elegido la palabra: Scripting"
demás

si [ $ elección -eq 3 ] ; entonces
echo "Has elegido la palabra: Tutorial"
demás
echo "¡Elige entre 1 y 3!"
eco "1. intento"
eco "2. Secuencias de comandos»
eco "3. Tutorial"
echo -n "¿Por favor elige una palabra? »
elección = 4
fi
fi
fi
hecho

Código: Seleccionar todo $ ./nested.sh
1. golpe
2. Secuencias de comandos
3. Tutoría

5

1. golpe
2. Secuencias de comandos
3. Tutoría
Por favor elige una palabra
4
¡Elige entre 1 y 3!
1. golpe
2. Secuencias de comandos
3. Tutoría
Por favor elige una palabra
3
Has elegido la palabra: Tutorial

Por lo tanto, primero se ejecuta el cuerpo del bucle "while", porque la variable de elección se establece inicialmente en cuatro. Luego, leemos la entrada del usuario, y si la entrada no es igual a 1.2 o 3, entonces hacemos que nuestra variable sea igual a 4 nuevamente, en relación con lo cual se repite el cuerpo del ciclo (debe ingresar 1.2 o 3 nuevamente).

10. Comparaciones
10.1 Comparaciones aritméticas

Teniente<
-gt>
-le<=
-ge >=
-equivalente ==
-ne !=

#!/bin/bash

NÚM1=2
NÚM2=2
si [ $NUM1 -eq $NUM2 ]; entonces
echo "Ambos valores son iguales"
demás
echo "Los valores NO son iguales"
fi

Código: Seleccionar todo $ ./equals.sh
Ambos valores son iguales

#!/bin/bash
# Declarar variables con valores enteros
NÚM1=2
NÚM2=3
si [ $NUM1 -eq $NUM2 ]; entonces
echo "Ambos valores son iguales"
demás
echo "Los valores NO son iguales"
fi

Código: Seleccionar todo $ ./equals.sh
Los valores NO son iguales

#!/bin/bash
# Declarar variables con valores enteros
NÚM1=2
NÚM2=1
si [ $NUM1 -eq $NUM2 ]; entonces
echo "Ambos valores son iguales"
elif [ $NUM1 -gt $NUM2 ]; entonces
echo "$NUM1 es mayor que $NUM2"
demás
echo "$NUM2 es mayor que $NUM1"
fi

Código: Seleccionar todo $ ./equals.sh
2 es mayor que 1

10.2 Comparaciones de caracteres y texto

Lo mismo
!= no es lo mismo
< меньще чем
> más que
-n s1 la variable s1 no está vacía
-z s1 la variable s1 está vacía

#!/bin/bash

S1="Golpe"

S2="Secuencias de comandos"
si [ $S1 = $S2 ]; entonces

demás
echo "Las cadenas NO son iguales"
fi

Código: Seleccionar todo $ ./statement.sh
Las cadenas NO son iguales

#!/bin/bash
# Declarar la variable simbólica S1
S1="Golpe"
# Declarar la variable simbólica S2
S2="Golpear"
si [ $S1 = $S2 ]; entonces
echo "Ambas cadenas son iguales"
demás
echo "Las cadenas NO son iguales"
fi

Código: Seleccionar todo $ ./statement.sh
Ambas cadenas son iguales

11. Comprobación de archivos

B nombre de archivo Bloquear archivo especial
-c nombre de archivo Archivo de caracteres especiales
-d nombredirectorio Comprobar la existencia del directorio
-e nombre de archivo Comprobar la existencia del archivo
-f nombre de archivo Verifica la existencia regular de un archivo, no un directorio
-G nombre de archivo Verifica si el archivo existe y es propiedad del ID de grupo efectivo.
-g nombre de archivo verdadero si el archivo existe y es set-group-id.
-k nombre de archivo Sticky bit
-L nombre de archivo Enlace simbólico
-O nombre de archivo Verdadero si el archivo existe y es propiedad del ID de usuario efectivo.
-r nombre de archivo Comprobar si el archivo es legible
-S nombre de archivo Comprobar si el archivo es socket
-s nombre de archivo Comprueba si el archivo tiene un tamaño distinto de cero
-u nombre de archivo Comprueba si el bit set-ser-id del archivo está establecido
-w nombre de archivo Comprobar si el archivo es escribible
-x nombre de archivo Comprobar si el archivo es ejecutable

#!/bin/bash
archivo="./archivo"
if [ -e $archivo ]; entonces
echo "El archivo existe"
demás
echo "El archivo no existe"
fi

Código: Seleccionar todo $ ls
archivo.sh
$ ./archivo.sh
El archivo no existe
$ tocar archivo
$ls
archivo archivo.sh
$ ./archivo.sh
El archivo existe

De manera similar, para el ejemplo, podemos usar bucles "while" para verificar si el archivo no existe. Este script dormirá hasta que exista el archivo. Tenga en cuenta el Bash negativo "!" que niega (invierte) la opción -e.

12. Ciclos
12.1. En bucle

#!/bin/bash
# en bucle
para f en $(ls /var/); hacer
eco $f
hecho

Ejecutando un bucle for desde la línea de comandos de bash:

Código: seleccione todos los $ para f en $(ls /var/); hacer eco $f; hecho Código: Seleccione todos los $ para f en $(ls /var/); hacer eco $f; hecho
copias de seguridad
cache
chocar
juegos
liberación
local
cerrar
registro
correo
optar
correr
carrete
tmp
www

12.2. mientras bucle

#!/bin/bash
CONTAR=6
# mientras bucle
while [ $CONTAR -gt 0 ]; hacer

sea ​​CONTAR=CONTAR-1
hecho

Código: Seleccionar todo $ ./while_loop.sh
El valor de la cuenta es: 6
El valor de la cuenta es: 5
El valor de la cuenta es: 4
El valor de la cuenta es: 3
El valor de la cuenta es: 2
El valor de la cuenta es: 1

12.3. hasta bucle

#!/bin/bash
CONTAR=0
#hasta bucle
hasta [ $COUNT -gt 5 ]; hacer
echo El valor de la cuenta es: $COUNT
sea ​​CONTAR=CONTAR+1
hecho

Código: Seleccionar todo $ ./until_loop.sh
El valor de la cuenta es: 0
El valor de la cuenta es: 1
El valor de la cuenta es: 2
El valor de la cuenta es: 3
El valor de la cuenta es: 4
El valor de la cuenta es: 5

12.4. Bucles con condiciones implícitas
En el siguiente ejemplo, la condición del ciclo while es la presencia de una entrada estándar.
El cuerpo del bucle se ejecutará siempre que haya algo que se redirija desde la salida estándar al comando de lectura.

#!/bin/bash
# Este script encontrará y eliminará espacios
# en archivos, reemplazándolos con guiones bajos
DIR="."
Controlar el bucle con el comando de lectura redirigiendo la salida en el bucle.
encontrar $DIR -tipo f | mientras lee el archivo; hacer
# usar la clase POSIX [:space:] para encontrar espacios en los nombres de archivos
if [[ "$archivo" = *[[:espacio:]]* ]]; entonces
# reemplazar espacios con guiones bajos
mv "$archivo" `echo $archivo | tr ' '_'`
fi;
hecho

Código: Seleccionar todo $ ls -1
script.sh
$ toque "archivo con espacios"
$ ls -1
archivo con espacios
script.sh
$ ./script.sh
$ ls -1
archivo_con_espacios
script.sh

13. Funciones

#!/bin/bash
# Las funciones se pueden declarar en cualquier orden
función función_B(
Función de eco B.
}
función función_A(
eco $1
}
función función_D(
Función de eco D.
}
funcion_C(
eco $1
}
# Funciones de llamada
# pasar el parámetro a la función A
function_A "Función A".
función_B
# pasar el parámetro a la función función C
function_C "Función C."
función_D

Código: Seleccione todo $ ./functions.sh
función a
Función B.
función c
funcion d

14. Seleccionar operador - Seleccionar

#!/bin/bash
PS3='Elige una palabra:'
# seleccionar
seleccione la palabra en "linux" "bash" "scripting" "tutorial"
hacer
echo "La palabra que ha seleccionado es: $palabra"
# Break, de lo contrario el bucle será infinito.
romper
hecho
salida 0

Código: Seleccionar todo $ ./select.sh
1) Linux
2) golpe
3) secuencias de comandos
4) tutoría
Elige una palabra: 4
La palabra que has seleccionado es: tutorial

15. Operador de selección - Caso

#!/bin/bash
echo "¿Cuál es su lenguaje de programación / secuencias de comandos preferido"
echo "1) bash"
echo "2) perla"
echo "3) fitón"
eco "4) c++"
echo "5) ¡No lo sé!"
leer caso;
# una estructura simple de elección de casos
# tenga en cuenta que en este ejemplo $case es solo una variable
# y no tiene que llamarse así. esto es solo un ejemplo
$caso en
1) echo "Usted seleccionó bash";;
2) echo "Usted seleccionó perl";;
3) echo "Usted seleccionó phyton";;
4) echo "Usted seleccionó c++";;
5) salir
esac

Código: Seleccionar todo $ ./case.sh
¿Cuál es su lenguaje de programación / secuencias de comandos preferido?
1) golpe
2) perlas
3) fitón
4) C++
5) ¡No sé!
4
Usted seleccionó c++

———————————————————————————-

Se puede obtener información más detallada de varias fuentes, por ejemplo aquí
original: https://www.linuxconfig.org/Bash_scripting_Tutorial
https://ruslandh.narod.ru/howto_ru/Bash-Prog-Intro/
https://bug.cf1.ru/2005-03-17/programmin … -libro.html

https://ubuntologia.ru/forum/viewtopic.php?f=109&t=2296

Para escribir un script bash simple tenemos que hacer los siguientes pasos simples:

Cómo funciona todo:

La primera línea de nuestro script #!/bin/bash es esencial para que nuestro script se ejecute correctamente.

la segunda línea mkdir testdir crea el directorio testdir

la tercera línea cd testdir le permite cambiar al directorio creado testdir

equipo tocar en la siguiente línea toque archivo1 archivo2 archivo3 crea tres archivos

y el último comando en la línea de nuestro script ls -al nos permite mostrar el contenido del directorio actual, en el que, gracias a la línea anterior, aparecieron tres archivos vacíos.

Como podemos ver, en nuestro guion sencillo todos los comandos comienzan en una nueva línea. Cada línea, cuando se inicia el script, realiza secuencialmente su trabajo, realizando ciertas acciones.

Si ejecuta una cadena de algunos comandos idénticos (con parámetros constantes) en Linux todos los días, entonces podría tener sentido que escriba el mismo secuencia de comandos bash simple, que te permitirá ahorrar tiempo y automatizar tu trabajo.

Hoy hablaremos de scripts bash. Estos son scripts de línea de comando escritos para el shell bash. Hay otros shells, como zsh, tcsh, ksh, pero nos centraremos en bash. Este material está destinado a todos, la única condición es la capacidad de trabajar en la línea de comandos de Linux.

Los scripts de línea de comandos son conjuntos de los mismos comandos que se pueden ingresar desde el teclado, recopilados en archivos y unidos por algún propósito común. Al mismo tiempo, los resultados del trabajo de los equipos pueden tener un valor independiente o servir como aporte para otros equipos. Los scripts son una forma poderosa de automatizar acciones que se realizan con frecuencia.

Entonces, si hablamos de la línea de comandos, te permite ejecutar varios comandos a la vez, ingresándolos con un punto y coma:

pwd; quién soy
De hecho, si ha probado esto en su terminal, su primer script bash que usa dos comandos ya ha sido escrito. Funciona así. El comando pwd primero muestra información sobre el directorio de trabajo actual, luego el comando whoami muestra información sobre el usuario con el que inició sesión.

Usando un enfoque similar, puede combinar tantos comandos como desee en una línea, el límite es solo la cantidad máxima de argumentos que se pueden pasar al programa. Puede definir este límite con el siguiente comando:

Obtenerconf ARG_MAX
La línea de comandos es una gran herramienta, pero debe ingresar comandos cada vez que los necesite. ¿Qué pasa si escribimos un conjunto de comandos en un archivo y simplemente llamamos a ese archivo para ejecutarlos? De hecho, el archivo del que estamos hablando se llama script de línea de comando.

Cómo funcionan los scripts de bash

Cree un archivo vacío usando el comando táctil. En su primera línea, debe especificar qué shell vamos a usar. Estamos interesados ​​en bash, por lo que la primera línea del archivo será:

#!/bin/bash
En otras partes de este archivo, el símbolo hash se usa para indicar comentarios que el shell no procesa. Sin embargo, la primera línea es un caso especial, donde un signo de almohadilla seguido de un signo de exclamación (llamado shebang) y la ruta a bash le dice al sistema que el script fue escrito específicamente para bash.

Los comandos de Shell están separados por un avance de línea, los comentarios están separados por un signo de libra. Esto es lo que parece:

#!/bin/bash # Este es un comentario pwd whoami
Aquí, al igual que en la línea de comandos, puede escribir comandos en una línea, separándolos con un punto y coma. Sin embargo, si escribe comandos en diferentes líneas, el archivo es más fácil de leer. En cualquier caso, el shell los procesará.

Configuración de permisos en un archivo de script

Guarde el archivo, asígnele el nombre myscript y casi habrá terminado con el script bash. Ahora lo único que queda por hacer es hacer que este archivo sea ejecutable, de lo contrario, cuando intente ejecutarlo, encontrará un error de Permiso denegado.

Intentar ejecutar un archivo de secuencia de comandos con permisos configurados incorrectamente

Hagamos el archivo ejecutable:

Chmod +x ./miscript
Ahora intentemos ejecutarlo:

./miscript
Después de configurar los permisos, todo funciona como debería.

Ejecute con éxito el script bash

Salida de mensaje

El comando echo se usa para imprimir texto en la consola de Linux. Usemos el conocimiento de este hecho y editemos nuestro script, agregando explicaciones a los datos que generan los comandos que ya están en él:

#!/bin/bash # nuestro comentario está aquí echo "El directorio actual es:" pwd echo "El usuario conectado es:" whoami
Esto es lo que sucede después de ejecutar el script actualizado.

Salida de mensajes desde un script

Ahora podemos mostrar etiquetas explicativas usando el comando echo. Si no sabe cómo editar un archivo con las herramientas de Linux, o no ha encontrado el comando echo antes, consulte este artículo.

Uso de variables

Las variables le permiten almacenar información en el archivo de script, por ejemplo, los resultados de los comandos para que los usen otros comandos.

No hay nada de malo en ejecutar comandos individuales sin almacenar los resultados de su trabajo, pero las posibilidades de este enfoque son muy limitadas.

Hay dos tipos de variables que se pueden usar en scripts bash:

• Variables de entorno
• Variables de usuario

Variables de entorno

A veces, los comandos de shell necesitan funcionar con algunos datos del sistema. Por ejemplo, así es como se muestra el directorio de inicio del usuario actual:

#!/bin/bash # muestra la casa del usuario echo "La casa del usuario actual es: $HOME"
Tenga en cuenta que podemos usar la variable de sistema $HOME entre comillas dobles, esto no evitará que el sistema la reconozca. Esto es lo que sucede si ejecuta el script anterior.

Uso de una variable de entorno en un script

Pero, ¿y si quieres mostrar un signo de dólar? Intentemos esto:

Echo "Tengo $1 en mi bolsillo"
El sistema detectará un signo de dólar en una cadena delimitada por comillas y asumirá que hemos referenciado una variable. El script intentará mostrar el valor de la variable no definida $1. Esto no es lo que necesitamos. ¿Qué hacer?

En una situación como esta, usar el carácter de control de barra invertida antes del signo de dólar ayuda:

Echo "Tengo \$1 en mi bolsillo"
El script ahora generará exactamente lo que se espera.

Uso de una secuencia de escape para generar un signo de dólar

Variables de usuario

Además de las variables de entorno, los scripts bash le permiten establecer y utilizar sus propias variables en el script. Tales variables mantienen un valor hasta que finaliza el script.

Al igual que con las variables del sistema, se puede acceder a las variables de usuario usando el signo de dólar:
TNW-CUS-FMP - código de promoción para un 10 % de descuento en nuestros servicios, disponible para activación dentro de 7 días
#!/bin/bash # testing variables grade=5 person="Adam" echo "$person es un buen chico, está en grado $grade"
Esto es lo que sucede después de ejecutar dicho script.

Variables personalizadas en script

Sustitución de comandos

Una de las funciones más útiles de los scripts de bash es la capacidad de extraer información de la salida de los comandos y asignarla a variables, lo que le permite utilizar esta información en cualquier parte del archivo de script.

Esto se puede hacer de dos formas.

• Con el carácter de acento grave "`"
• Con la construcción $()

Cuando utilice el primer enfoque, tenga cuidado de no utilizar una comilla simple en lugar de un acento grave. El comando debe estar encerrado en dos de estos iconos:

midir=`contraseña`
En el segundo enfoque, el mismo se escribe así:

midir=$(contraseña)
Y el guión, al final, podría verse así:

#!/bin/bash midir=$(pwd) echo $midir
En el curso de su trabajo, la salida del comando pwd se almacenará en la variable mydir, cuyo contenido, usando el comando echo, caerá en la consola.

Script que guarda los resultados del comando en una variable

Operaciones matemáticas

Para realizar operaciones matemáticas en un archivo de script, puede usar una construcción como $((a+b)) :

#!/bin/bash var1=$((5 + 5)) echo $var1 var2=$(($var1 * 2)) echo $var2

Operaciones matemáticas en un script

estructura de control si-entonces

En algunos escenarios, es necesario controlar el flujo de ejecución de comandos. Por ejemplo, si un determinado valor es mayor a cinco, se debe realizar una acción, en caso contrario otra. Esto es aplicable en muchas situaciones, y la construcción de control si-entonces nos ayudará aquí. En su forma más simple, se ve así:

Si comando entonces comandos fi
Y aquí hay un ejemplo de trabajo:

#!/bin/bash si pwd entonces repite "Funciona" fi
En este caso, si el comando pwd se completa con éxito, el texto "funciona" se imprimirá en la consola.

Usemos el conocimiento que tenemos y escribamos un escenario más complejo. Digamos que desea encontrar un usuario en /etc/passwd y, si puede encontrarlo, informe que existe.

#!/bin/bash user=likegeeks if grep $user /etc/passwd luego echo "The user $user Exists" fi
Esto es lo que sucede después de ejecutar este script.

Búsqueda de usuarios

Aquí hemos usado el comando grep para encontrar al usuario en el archivo /etc/passwd. Si el comando grep no le resulta familiar, puede encontrar su descripción aquí.

En este ejemplo, si se encuentra el usuario, el script mostrará un mensaje apropiado. ¿Qué pasa si no se puede encontrar al usuario? En este caso, el script simplemente completará la ejecución sin decirnos nada. Me gustaría que nos hablara de esto también, así que mejoremos el código.

La construcción de control if-then-else

Para que el programa pueda informar tanto de los resultados de una búsqueda exitosa como de una falla, usaremos la construcción if-then-else. Así es como está configurado:

si comando entonces comandos else comandos fi
Si el primer comando devuelve cero, lo que significa que tuvo éxito, la condición será verdadera y la ejecución no descenderá por la rama else. De lo contrario, si se devuelve algo distinto de cero, lo que significa una falla o un resultado falso, se ejecutarán los comandos después del else.

Escribamos el siguiente script:

#!/bin/bash usuario=otroUsuario if grep $usuario /etc/passwd luego echo "El usuario $usuario existe" else echo "El usuario $usuario no existe" fi
Su ejecución fue a lo largo de la rama else.

Ejecutar un script con una construcción if-then-else

Bueno, sigamos adelante y preguntémonos por condiciones más difíciles. ¿Qué sucede si necesita verificar no una condición, sino varias? Por ejemplo, si se encuentra el usuario requerido, se debe mostrar un mensaje, si se cumple alguna otra condición, se debe mostrar otro mensaje, y así sucesivamente. En tal situación, las condiciones anidadas nos ayudarán. Se parece a esto:

Si comando1 entonces ordena elif comando2 entonces ordena fi
Si el primer comando devuelve cero, lo que indica éxito, se ejecutarán los comandos del primer bloque, de lo contrario, si la primera condición es falsa y el segundo comando devuelve cero, se ejecutará el segundo bloque de código.

#!/bin/bash usuario=otroUsuario if grep $usuario /etc/passwd luego echo "El usuario $usuario Existe" elif ls /home luego echo "El usuario no existe pero de todos modos hay un directorio bajo /home" fi
En dicho script, puede, por ejemplo, crear un nuevo usuario usando el comando useradd si la búsqueda no arroja resultados, o hacer otra cosa útil.

Comparación de números

En los scripts, puede comparar valores numéricos. A continuación se muestra una lista de comandos relevantes.

n1 -eq n2 Devuelve verdadero si n1 es igual a n2.
n1 -ge n2 Devuelve verdadero si n1 es mayor o igual que n2 .
n1 -gt n2 Devuelve verdadero si n1 es mayor que n2.
n1 -le n2 Devuelve verdadero si n1 es menor o igual que n2 .
n1 -lt n2 Devuelve verdadero si n1 es menor que n2.
n1 -ne n2 Devuelve verdadero si n1 no es igual a n2 .

Como ejemplo, probemos uno de los operadores de comparación. Tenga en cuenta que la expresión está encerrada entre corchetes.

#!/bin/bash val1=6 if [ $val1 -gt 5 ] then echo "El valor de prueba $val1 es mayor que 5" else echo "El valor de prueba $val1 no es mayor que 5" fi
Esto es lo que generará este comando.

Comparar números en guiones

El valor de la variable val1 es mayor a 5, por lo que se ejecuta la rama entonces del operador de comparación y se muestra el mensaje correspondiente en la consola.

Comparación de cadenas

Los scripts también pueden comparar valores de cadena. Los operadores de comparación parecen bastante simples, pero los operadores de comparación de cadenas tienen ciertas peculiaridades, que veremos a continuación. Aquí hay una lista de operadores.

str1 = str2 Prueba la igualdad de las cadenas, devuelve verdadero si las cadenas son idénticas.
s tr1 != str2 Devuelve verdadero si las cadenas no son idénticas.
str1< str2 Возвращает истину, если str1 меньше, чем str2 .
str1 > str2 Devuelve verdadero si str1 es mayor que str2.
-n str1 Devuelve verdadero si la longitud de str1 es mayor que cero.
-z str1 Devuelve verdadero si la longitud de str1 es cero.

Aquí hay un ejemplo de una comparación de cadenas en un script:

#!/bin/bash usuario ="likegeeks" si [$usuario = $USUARIO] luego echo "El usuario $usuario es el usuario conectado actualmente" fi
Como resultado de la ejecución del script, obtenemos lo siguiente.

Comparación de cadenas en scripts

Aquí hay una característica de la comparación de cadenas que vale la pena mencionar. A saber, los operadores ">" y "<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>' como un comando de redirección de salida.

Así es como se ve trabajar con estos operadores en el código:

#!/bin/bash val1=texto val2="otro texto" si [ $val1 \>
Aquí están los resultados del script.

Comparación de cadenas, advertencia lanzada

Tenga en cuenta que el script, aunque se está ejecutando, da una advertencia:

./myscript: línea 5: [: demasiados argumentos
Para deshacerse de esta advertencia, ajuste $val2 en doble comillas:

#!/bin/bash val1=text val2="otro texto" if [ $val1 \> "$val2" ] then echo "$val1 es mayor que $val2" else echo "$val1 es menor que $val2" fi
Ahora todo funciona como debería.

Comparación de cadenas

Otra característica de los ">" y "<» заключается в том, как они работают с символами в верхнем и нижнем регистрах. Для того, чтобы понять эту особенность, подготовим текстовый файл с таким содержимым:

como los geeks como los geeks
Guárdelo con el nombre myfile y luego ejecute el siguiente comando en la terminal:

Ordenar mi archivo
Ordenará las líneas del archivo de la siguiente manera:

Likegeeks Likegeeks
El comando ordenar, por defecto, ordena las cadenas en orden ascendente, es decir, la letra minúscula en nuestro ejemplo es menor que la letra mayúscula. Ahora preparemos un script que compare las mismas cadenas:

#!/bin/bash val1=Likegeeks val2=likegeeks if [ $val1 \> $val2 ] then echo "$val1 es mayor que $val2" else echo "$val1 es menor que $val2" fi
Si lo ejecuta, resulta que ocurre lo contrario: la letra minúscula ahora es más grande que la mayúscula.

comando de clasificación y comparación de cadenas en el archivo de script

En los comandos de comparación, las letras mayúsculas son más pequeñas que las letras minúsculas. La comparación de cadenas aquí se realiza comparando los códigos de caracteres ASCII, por lo que el orden de clasificación depende de los códigos de caracteres.

El comando de clasificación, a su vez, utiliza el orden de clasificación especificado en la configuración de idioma del sistema.

Comprobaciones de archivos

Quizás los siguientes comandos se usan con mayor frecuencia en scripts de bash. Te permiten comprobar varias condiciones concerniente a archivos. Aquí hay una lista de estos comandos.

-d archivo Comprueba si el archivo existe y es un directorio.
-e archivo Comprueba si existe un archivo.
-f archivo Comprueba si un archivo existe y es un archivo.
-r archivo Comprueba si el archivo existe y es legible.
-s archivo Comprueba si el archivo existe y no está vacío.
-w archivo Comprueba si el archivo existe y se puede escribir.
-x archivo Comprueba si el archivo existe y es ejecutable.
archivo1 -nt archivo2 Comprueba si el archivo1 es más nuevo que el archivo2.
archivo1 -ot archivo2 Comprueba si el archivo1 es más antiguo que el archivo2.
-O archivo Comprueba si el archivo existe y es propiedad del usuario actual.
-G archivo Comprueba si el archivo existe y si su ID de grupo coincide con la ID de grupo del usuario actual.

Estos comandos, así como muchos otros discutidos hoy, son fáciles de recordar. Sus nombres, que son abreviaturas de varias palabras, indican directamente los controles que realizan.

Probemos uno de los comandos en la práctica:

#!/bin/bash mydir=/home/likegeeks if [ -d $mydir ] then echo "El directorio $mydir existe" cd $ mydir ls else echo "El directorio $mydir no existe" fi
Este script, para un directorio existente, mostrará su contenido.

Listado del contenido de un directorio

Creemos que puedes experimentar con el resto de los comandos por tu cuenta, todos se aplican según el mismo principio.

Resultados

Hoy hablamos sobre cómo comenzar a escribir scripts bash y cubrimos algunas cosas básicas. De hecho, el tema de la programación bash es enorme. Este artículo es una traducción de la primera parte de una gran serie de 11 materiales. Si desea continuar ahora mismo, aquí hay una lista de los originales de estos materiales. Para mayor comodidad, se incluye aquí aquel cuya traducción acabas de leer.

Por supuesto, todos aquellos que se comunican con el sistema operativo Linux al menos una vez han tratado (al menos lo escucharon con seguridad) con el shell de comandos BASH. Pero BASH no es solo un shell de comandos, también es un excelente lenguaje de programación de secuencias de comandos.
El propósito de este artículo es acercar a los usuarios a bash, hablar sobre la sintaxis, las técnicas básicas y las características del lenguaje, con el fin de usuario ordinario Pude escribir rápidamente una secuencia de comandos simple para realizar el trabajo de rutina diario (-semanal, -mensual) o, digamos, "sobre mi rodilla" para hacer una secuencia de comandos para la copia de seguridad del directorio.

Introducción

BASH - Bourne-Again SHell (que se puede traducir como "reborn shell" o "Bourne-Again SHell otra vez"), el intérprete de comandos más popular en sistemas tipo Unix, especialmente en GNU/Linux. A continuación hay una serie de comandos integrados que usaremos para crear nuestros scripts.

romper la salida en bucle, mientras o hasta
continuar ejecuta la siguiente iteración del bucle for, while o till
echo imprimir argumentos separados por espacios a la salida estándar
salir salir de la concha
export marca los argumentos como variables para pasar a los procesos secundarios en el entorno
hash recuerda los nombres de ruta completos de los comandos proporcionados como argumentos para que no se busquen la próxima vez que se llamen
kill envía una señal de terminación a un proceso
pwd muestra el directorio de trabajo actual
read lee una línea de la entrada del shell y la usa para asignar valores a las variables especificadas.\
return hace que la función de shell salga con el valor especificado
shift mueve los parámetros posicionales a la izquierda
prueba evalúa la expresión condicional
times imprime el nombre de usuario y la hora del sistema utilizados por el shell y sus descendientes
trap especifica los comandos que se ejecutarán cuando el shell reciba una señal
unset hace que las variables de shell se destruyan
wait espera a que el proceso secundario finalice e informa el estado de salida.

Y, por supuesto, además de los comandos incorporados, usaremos un montón de comandos de programa separados y externos, que ya conoceremos en el proceso.

Lo que necesitas saber desde el principio

1. Cualquier script bash debe comenzar con la línea:

#!/bin/bash
en esta línea después de #! se especifica la ruta al intérprete de bash, por lo que si lo tiene instalado en otro lugar (donde puede averiguarlo escribiendo whereis bash) cámbielo a su ruta.
2. Los comentarios comienzan con el símbolo # (excepto en la primera línea).
3. En bash, las variables no tienen un tipo (se discutirán más adelante)

Variables y parámetros del script

Déjame darte un pequeño ejemplo que analizaremos:

#!/bin/bash
# especificar dónde almacenamos el intérprete de bash
parametr1=$1 #establecer la variable parametr1 al valor del primer parámetro del script
script_name=$0 #establecer la variable script_name al valor del nombre del script
echo "Ha ejecutado un script con el nombre $script_name y el parámetro $parametr1" # el comando echo genera una determinada cadena, se accede a las variables a través de $variable_name.
echo "Ha ejecutado un script llamado $script_name con el parámetro $parametr1" # aquí vemos otras comillas, la diferencia es que no hay sustitución de variables entre comillas simples.
exit 0 #Salir con el código 0 (finalización exitosa del script)

[correo electrónico protegido]:~$ ./prueba.sh qwerty
Ha ejecutado un script llamado ./test.sh con el parámetro qwerty
Ha ejecutado un script con el nombre $script_name y el parámetro $parametr1

Ahora que hemos visto cómo usar variables y pasar parámetros a un script, es hora de familiarizarse con las variables reservadas:

$DIRSTACK - el contenido de la parte superior de la pila de directorios
$EDITOR- editor de texto por defecto
$EUID - UID efectivo. Si usó el programa su para ejecutar comandos como otro usuario, entonces esta variable contiene el UID de ese usuario, mientras que...
$UID - ... contiene identificación real, que se establece solo al iniciar sesión.
$FUNCNAME: el nombre de la función actual en el script.
$GROUPS - matriz de grupos a los que pertenece el usuario actual
$HOME - directorio de inicio del usuario
$HOSTNAME - su nombre de host
$HOSTTYPE - arquitectura de host.
$LC_CTYPE - variable interna que determina la codificación de caracteres
$OLDPWD - antiguo directorio de trabajo
$OSTYPE - tipo de sistema operativo
$PATH - ruta de búsqueda del programa
$PPID - ID de proceso principal
$SECONDS - tiempo de ejecución del script (en segundos)
$# - número total de parámetros pasados ​​al script
$*: todos los argumentos pasados ​​al script (se muestran en una cadena)
$@ - igual que el anterior, pero los parámetros se muestran en una columna
ps - PID del último proceso ejecutándose en segundo plano
$$ - PID del propio script

Condiciones

Creo que los operadores condicionales son familiares para casi todos los que alguna vez han tratado de escribir programas en algo. En bash, las condiciones se escriben de la siguiente manera. manera (como es habitual en el ejemplo):
#!/bin/bash
source=$1 # poner el primer parámetro del script en la variable fuente
dest=$2 #poner el segundo parámetro del script en la variable dest

Si [[ "$fuente" -eq "$destino" ]] # cite los nombres de las variables para comparar. -eq - comparación lógica que denota "igual"
entonces # si son realmente iguales, entonces
echo "¡Destino $destino y fuente $fuente son el mismo archivo!" #mostrar un mensaje de error, porque $origen y $destino son iguales
salir 1 # salir con un error (1 - código de error)
else # si no son iguales
cp $fuente $destino # luego ejecute el comando cp: copie la fuente al destino
echo "¡Copia exitosa!"
fi #que indica el final de la condición.

Resultado de la ejecución del script:
[correo electrónico protegido]:~$ ./primer2.sh 1 1
¡El solicitante 1 y la fuente 1 son el mismo archivo!
[correo electrónico protegido]:~$ ./primer2.sh 1 2
¡Feliz copia!

La estructura if-then-else se usa así:
si<команда или набор команд возвращающих код возврата(0 или 1)>
entonces
<если выражение после if истино, то выполняется этот блок>
demás
<если выражение после if ложно, тот этот>
Las estructuras [[ , [ , test, (()) o cualquier otro (o varios) comandos de Linux pueden actuar como comandos que devuelven un código de retorno.
prueba: se utiliza para la comparación lógica. después de la expresión, se requiere un corchete de cierre "]"
[ es un sinónimo del comando de prueba
[[ - versión extendida de "[" (desde la versión 2.02) (como en el ejemplo), dentro de la cual || (o y). Debe tener un corchete de cierre "]]"
(()) - comparación matemática.
para construir condiciones multinivel de la forma:
si ...
entonces ....
demás
si ....
entonces....
demás ....

Para brevedad y legibilidad del código, puede usar la estructura:
si..
entonces...
elif...
entonces...
elif...

Condiciones. Opción multiple

Si necesita comparar cualquier variable con gran cantidad parámetros, es más conveniente utilizar la sentencia case.
#!/bin/bash
echo "Seleccione un editor para ejecutar:"
echo "1 Ejecutando nano"
echo "2 Ejecutar programa vi"
echo "3 Iniciar programa emacs"
echo "4 Salir"
leer haciendo #aquí leemos en la variable $haciendo de la entrada estándar

Caso $ haciendo en
1)
/usr/bin/nano # si $haciendo es 1 entonces ejecute nano
;;
2)
/usr/bin/vi # si $hacer contiene 2, entonces inicie vi
;;
3)
/usr/bin/emacs # si $haciendo contiene 3 entonces inicie emacs
;;
4)
salida 0
;;
*) #si se ingresa algo desde el teclado que no se describe en el caso, haga lo siguiente:
echo "Se ingresó una acción no válida"

Declaración de Esac #endcase.

Resultado del trabajo:
[correo electrónico protegido]:~$ ./menu2.sh
Seleccione un editor para iniciar:
1 Lanzamiento nano
2 Iniciando vi
3 Inicie emacs
4 Salir

Después de seleccionar un número y presionar Enter, se iniciará el editor que haya elegido (a menos, por supuesto, que todas las rutas sean correctas y tenga estos editores instalados :))
Aquí hay una lista de operadores lógicos que se usan para la construcción if-then-else-fi:
-z # la línea está vacía
-n # cadena no está vacía
=, (==) # cadenas son iguales
!= # cadenas no son iguales
-eq # es igual
-ne # desigual
-lt,(<) # меньше
-le,(<=) # меньше или равно
-gt,(>) #más
-ge,(>=) #mayor o igual que
! #negación de expresión booleana
-a,(&&) #lógico Y
-o,(||) # lógico "O"

Descubrimos los conceptos básicos del idioma y las condiciones para no sobrecargar el artículo, lo dividiré en varias partes (digamos 3). En la segunda parte, analizaremos los operadores de bucle y el rendimiento de las operaciones matemáticas.

UPD: Se corrigieron algunos errores
UPD: Se actualizó la parte sobre las condiciones if-then-else

Todo el mundo sabe que el shell Bash tiene comandos integrados que no se encuentran en las carpetas /bin o /usr/bin. Están integrados en el shell y se ejecutan como funciones. En uno de los artículos anteriores, consideramos. Discutimos casi todo allí, cómo deberían verse los scripts, el uso de condiciones, bucles, variables, pero no nos detuvimos en las funciones.

En el artículo de hoy, corregiremos esta deficiencia. Como todo lenguaje de programación, Bash tiene funciones que pueden ser muy útiles de usar. Veremos el uso de funciones bash, cómo escribirlas e incluso cómo crear bibliotecas a partir de estas funciones.

Primero necesitamos entender qué es una función en nuestro contexto. Una función es un conjunto de comandos, unidos por un nombre, que realizan una tarea específica. La función se llama por su nombre, puede tomar parámetros y devolver el resultado del trabajo. En resumen, las funciones de Bash funcionan igual que en otros lenguajes de programación.

La sintaxis para crear una función es muy simple:

nombre_función() (lista de comandos)

El nombre de la función no debe coincidir con ninguno de los comandos o funciones existentes, y todos los comandos en el cuerpo de la función se escriben en una línea nueva.

función sencilla

Escribamos una pequeña función que imprimirá una cadena en la pantalla:

$ función vi.sh

#!/bin/bash
printstr()(
echo "hola mundo"
}
printstr

Llamar bash funciones se hace especificando su nombre, como para cualquier otro comando. Ejecute nuestro script para su ejecución, no olvide que antes de eso debe otorgarle los derechos de ejecución:

chmod u+x función.sh

Todo funciona, ahora compliquemos la tarea, intentemos pasar argumentos a la función.

Argumentos de función

Los argumentos de la función se deben pasar al llamar y se leen de la misma manera que los argumentos del script. La sintaxis para llamar a una función con parámetros bash es:

nombre de la función argumento1 argumento2 ... argumentoN

Como puedes ver, todo es bastante simple. Los parámetros están separados por un espacio. Ahora mejoremos nuestra función para que genere la cadena que especificamos:

!/bin/bash
printstr()(
eco $1
}
printstr "Hola mundo"

Puedes tener múltiples opciones:

!/bin/bash
printstr()(
eco $1
eco $2
eco $3
eco $5
}
printstr "arg1" "arg2" "arg3" "arg4" "arg5"

Hay otra forma de extraer argumentos, como en C, usando la pila. Obtenemos el primer argumento, luego avanzamos el puntero de la pila de argumentos en uno y volvemos a obtener el primer argumento. Etcétera:

!/bin/bash
printstr()(
eco $1
cambio
eco $1
cambio
eco $1
cambio
eco $1
}
printstr "arg1" "arg2" "arg3" "arg4"

Devolver el resultado de una función

No solo puede usar funciones con parámetros bash, sino también obtener el resultado del trabajo. El comando de retorno se utiliza para esto. Termina la función y devuelve el valor numérico del código de retorno. Puede ser de 0 a 255:

!/bin/bash
printstr()(
volver 134;
}
printstr
eco $?

Si necesita usar el valor de retorno de una función bash en lugar del código de estado, use echo. La cadena no se envía inmediatamente a la terminal, sino que se devuelve como resultado de la función y se puede escribir en una variable y luego usar:

!/bin/bash
printstr()(
eco "prueba"
}
VAR=$(printstr)
eco $VAR

Funciones de exportación

Puede hacer que una función esté disponible fuera de un script con el comando declare:

!/bin/bash
printstr()(
echo "hola mundo"
}
declarar -x -f printstr

Luego ejecute el script con el comando fuente:

función fuente.sh
$printstr

recursión

Puede llamar a una función desde dentro de sí misma para hacer la recursión:

!/bin/bash
printstr()(
echo "hola mundo"
printstr
}
printstr

Puede experimentar con el uso de la recursión, puede ser útil en muchos casos, solo recuerde hacer la primera llamada a la función Bash.

Variables locales en una función

Si declara una variable ordinaria en una función, estará disponible en todo el script, esto es conveniente para devolver un valor de función, pero a veces puede ser necesario crear una variable local. Hay un comando local para esto:

!/bin/bash
printstr()(
VAR local=$1
eco $(var)
}
printstr "Hola mundo"

Bibliotecas de funciones

Podemos tomar algunas funciones bash y combinarlas en una biblioteca para que podamos importar estas funciones con un solo comando. Esto se hace de manera similar a las funciones de exportación. Primero, vamos a crear un archivo de biblioteca:

prueba1()(
echo "Hola Mundo desde 1";
}
prueba2()(
echo "Hola mundo de 2";
}
prueba3()(
echo "Hola mundo de 3";
}

Ahora vamos a crear un script que usará nuestras funciones. Puede importar la biblioteca usando el comando fuente o simplemente especificando el nombre del script:

!/bin/bash
fuente lib.sh
prueba1
prueba2
prueba3

conclusiones

En este artículo, analizamos las funciones bash, cómo escribirlas, aplicarlas y combinarlas en bibliotecas. Si suele escribir scripts en Bash, esta información le resultará útil. Puede crear su propio conjunto de funciones para usar en cada script y así facilitar su trabajo.