Las bases de la programación shell

1. Poner nombre a una variable

A continuación se muestran las reglas que hay que seguir para dar un nombre a las variables:

2. Definir una variable

Una variable está definida desde el momento en que ha sido inicializada. El contenido de una variable se considera por el shell como un conjunto de caracteres.

$ var1=palabra1  
$ echo $var1  
palabra1 
$ 

$ var1 = palabra1  
ksh: var1: not found 
$ 

$ var2='palabra1 palabra2 palabra3' #CORRECTO 
$ echo $var2  
palabra1 palabra2 palabra3 
$ var2=palabra1 palabra2 palabra3 #INCORRECTO 
ksh: palabra2: not found 
$ 

$ echo $vacia  
 
$ 

$ unset -v variable 

$ unset variable 

$ var=12  
$ echo $var  
12 

$ set | grep var  
var=12 

$ unset var 

$ echo $var  
 
$ set | grep var  
$ 

1. Los apóstrofes (comillas simples)

Los apóstrofes (o comillas simples) eliminan el significado a todos los caracteres especiales del shell. Los apóstrofes deben ser un número par en la línea de comandos.

Ejemplos

La variable $HOME se sustituye por su valor:

$ echo $HOME 
/home/cristina 

El carácter $ pierde su significado especial:

$ echo '$HOME' 
$HOME 

El carácter * se sustituye por los nombres de archivo del directorio actual:

$ echo * 
f1 f2 f3 

El carácter * pierde su significado especial:

$ echo '*' 
* 

El shell espera encontrar un nombre de archivo tras una redirección:

$ echo > 
bash: syntax error near unexpected token `>' 

El carácter > pierde su significado especial:

$ echo '>' 
> 

El shell ejecuta el comando logname y lo remplaza por su resultado:

$ echo Hola $(logname) 
Hola cristina 

La secuencia de caracteres $( ) pierde su significado especial:

$ echo 'Hola $(logname)' 
Hola $(logname) 
$ 

Protección de múltiples caracteres especiales:

$ echo '* ? > < >> << | $HOME $(logname)...

1. Definición

Un script en shell es un archivo de texto que contiene los comandos Unix internos o externos, así como palabras clave del shell.

No hay ningún convenio establecido para el nombre de scripts de shell. El nombre de un archivo script de shell puede tener extensión, pero no es obligatorio. Sin embargo, generalmente se usa la extensión ".sh" (incluso si el script no se interpreta con el ejecutable llamado "sh").

Para mejorar la legibilidad, los nombres de los scripts utilizados en este capítulo tendrán una extensión en relación con su compatibilidad: .bash, .ksh, .sh, .posix, .bourne, etc.

Ejemplo

A continuación se muestra el script primero.sh:

$ nl primero.sh 
     1 pwd 
     2 cd /tmp 
     3 pwd 
     4 ls 
$ 

Ejecución del script:

$ ksh primero.sh 
/home/cristina 
/tmp 
f1 f2 f3 
$ 

Los comandos se ejecutan secuencialmente.

2. Ejecución de un script por un shell hijo

En la mayoría de los casos, los scripts tienen que ejecutarse a través de un shell hijo como intermediario. Esto tiene como ventaja la no modificación del entorno del shell actual. Para ejecutar un script en shell, existen tres métodos que producen un resultado equivalente.

Primer método

$ ksh primero.sh 

Este ha sido el método usado anteriormente. Se invoca al comando ksh pidiéndole la interpretación del script primero.sh.

En este caso, el permiso de lectura sobre el archivo primero.sh es suficiente:

$ ls -l primero.sh  
-rw-r--r--    1 cristina curso       19 nov 15 19:16 primero.sh 

Segundo método

$ ksh < primero.sh 

El ksh es un programa que lee su entrada estándar; por tanto, es posible conectarle el archivo...

1. Los parámetros posicionales

Los scripts en shell son capaces de recuperar los argumentos pasados por línea de comandos con la ayuda de variables especiales, llamadas parámetros posicionales. 

Ejemplo

A continuación, un script que muestra el valor de cada parámetro posicional:

$ vi miscript.sh 
echo "Este script ha recibido $# argumentos" 
echo "El nombre del script es: $0" 
echo "Mi 1º argumento es     : $1" 
echo "Mi 2º argumento es     : $2" 
echo "Mi 3º argumento es     : $3" 
echo "La lista de todos mis argumentos: $*" 
$ chmod u+x miscript.sh 

Llamada de miscript.sh con seis argumentos (ver figura 4):

$ miscript.sh f1 f2 f3 f4 /tmp/fic.txt 123 
Este script ha recibido 6 argumentos 
El nombre del script es: miscript.sh 
Mi 1º argumento es     : f1 
Mi 2º argumento es     : f2 
Mi 3º argumento es     : f3 
La lista de todos mis argumentos: f1 f2 f3 f4 /tmp/fic.txt 123 

Figura 4: Pasar seis argumentos por línea de comandos

Llamada de miscript.sh con tres argumentos (ver figura 5):

$ miscript.sh 12 + 24 
Este script ha recibido 3 argumentos 
El nombre del script es: miscript.sh 
Mi 1º argumento es     : 12 
Mi 2º argumento es     : + 
Mi 3º argumento es     : 24 
La lista de todos mis argumentos: 12 + 24 

Figura 5: Pasar tres argumentos por línea...

1. Sintaxis

Primera sintaxis

read var1 
read var1 var2 ... 

Otras sintaxis

Estas sintaxis particulares (no portables) permiten visualizar un mensaje:

read var?"Introducir un valor: " 

read -p " Introducir un valor: " var 

2. Lecturas del teclado

El comando read lee su entrada estándar y asigna las palabras leídas en la(s) variable(s) cuyo nombre se pasa como argumento. La lista de caracteres separadores de palabras usados por read se almacenan en la variable de entorno IFS (contiene por defecto los caracteres espacio, tabulación (\t) y salto de línea (\n)).

Ejemplos

La palabra introducida se almacena en la variable var1:

$ read var1 
hola 
$ echo $var1 
hola 

Todas las palabras introducidas se almacenan en la variable var1:

$ read var1 
hola a todo el mundo 
$ echo $var1 
hola a todo el mundo 

La primera palabra se almacena en var1, la segunda en var2:

$ read var1 var2  
Hasta luego  
$ echo $var1  
Hasta 
$ echo $var2  
luego 

La primera palabra se almacena en var1 y el resto de la línea en var2:

$ read var1 var2  
Hasta luego a todo el mundo  
$ echo $var1  
Hasta 
$ echo $var2  
luego a todo el mundo 

La palabra se almacena en var1, y var2 se queda vacía:

$ read var1 var2  
Gracias 
$ echo $var1  
Gracias 
$ echo $var2  
 
$ 

Especificar un mensaje...

1. Introducción

Hay dos comandos que permiten efectuar las pruebas:

2. El comando [[ ]]

Este comando permite hacer verificaciones de archivos, de cadenas de caracteres y de números. Devuelve el código 0 o 1 (verdadero o falso), que el usuario puede consultar mostrando el valor de $? o explotar las estructuras de control if, while, until y los operadores lógicos del shell && y ||.

[[expresión]] 

[[ expresión ]] 

$ [[ -f  /etc/passwd ]]  
$ echo $?   
0 

if [[ -f  /etc/passwd ]]  
then  
  echo "El archivo /etc/passwd es un archivo ordinario"  
else  
  echo " El archivo /etc/passwd no es un archivo ordinario"  
fi 

1. Evaluación del operador &&

Sintaxis

comando1 && comando2 

Ejemplos

El directorio /tmp/svg no existe; por lo tanto, el comando cd no se ejecuta:

$ ls -d /tmp/svg 
/tmp/svg: No such file or directory 
$ pwd 
/export/home/cristina 
$ [[ -d /tmp/svg ]] && cd /tmp/svg 
 
$ echo $?        # Código del comando [[ ]]  
1 
$ pwd  
/export/home/cristina 

El directorio /tmp/svg existe; por lo tanto, el comando cd se ejecuta:

$ mkdir /tmp/svg  
$ [[ -d /tmp/svg ]] && cd /tmp/svg  
$ pwd  
/tmp/svg 
$ 

Estas acciones también pueden implementarse con la estructura de control if.

$ pwd  
/export/home/cristina ...

1. El comando (( ))

((expresión_aritmética)) 

(( expresión _aritmética )) 

$ x=10   
$ (( x = $x + 10 ))   
$ echo $x   
20 

$ x=10   
$ ((x=$x+10))   
$ echo $x   
20 

$ x=10   
$ ((x=x+10))   
$ echo $x   
20   
$ 

$ x=10   
$ ((x+=10))        # Equivalente a ((x=x+10))   
$ echo $x   
20   
$ 

$ nl egal.sh    
    1...

1. ksh93

El comando typeset permite declarar un número de punto flotante con la precisión deseada.

Sintaxis

typeset -Fprecisión  var1[=val1] [ var2=[val2] ... ] 

Ejemplo

$ typeset -F3 iva=0.21 
$ typeset -F2 noimp=153 
$ typeset -F2 monto Iva 
$ (( montoIva=$((noimp * $iva )) 
$ echo $monto Iva 
32.2                        # redondeo de 32.13 

2. Otros shells

El comando bc permite realizar cálculos y se comporta como un filtro. También es posible utilizar el comando awk (nawk en algunas plataformas), que puede efectuar cálculos sobre números de punto flotante.

Ejemplo

Envío de una expresión aritmética al comando bc:

$ noimp=153  
$ iva=0.21  
$ echo "$noimp * $iva" | bc  
32.13 

Envío de dos parámetros al comando awk (ver capítulo El lenguaje de programación awk):

$  echo "$noimp $iva" | awk '{ print $1 * $2 }' 
32.13 

La misma operación realizada con formato:

$  echo "$noimp $iva" | awk '{ printf("%.2f\n", $1 * $2) }' 
32.2 

1. Opción -x

La opción -x permite visualizar los comandos que son ejecutados, es decir, después del tratamiento de los caracteres especiales del shell.

Primera sintaxis

Activar la opción:

set -x 

Desactivar la opción:

set +x 

Segunda sintaxis

Activar la opción:

set -o xtrace 

Desactivar la opción:

set +o xtrace 

Tercera sintaxis

Invocar el shell intérprete con la opción -x:

$ bash -x script 

Ejemplo

He aquí, el script existe archivo.sh, en el cual se ha introducido un error. El desarrollador del script ha escrito, por descuido, arch en vez de $arch (línea 5):

$ nl existe_archivo.sh 
    1  #! /usr/bin/bash 
    2  # compatibilidad del script: bash 
 
    3  echo -n "Nombre del archivo a visualizar: " # específico bash 
    4  read arch 
    5  if [[ -f arch ]] ; then 
    6    echo "$arch existe" 
    7 else 
    8    echo "$arc no existe" 
    9  fi 

Ejecución del script sin corrección. ¡Parece sorprendente (¿o perturbador?) que el archivo /etc/passwd no se haya encontrado!...

1. if

La estructura de control if permite realizar verificaciones. El comando situado tras la palabra if se ejecuta. En función del código devuelto por este, el shell orienta el flujo de ejecución en la parte then si el comando ha devuelto verdadero ($? vale 0) y en la parte else si el comando ha devuelto falso ($? > 0). Si el comando ha devuelto falso y no tiene parte else, el flujo de ejecución continúa con el primer comando situado bajo fi.

Primera sintaxis

if comando1 
then 
  comando2 
  comando3 
  ... 
else  
  comando4 
  ... 
fi 

Segunda sintaxis

La parte else es opcional.

if comando1 
then 
  comando2 
  comando3 
  ... 
fi 

Tercera sintaxis

Es posible usar la palabra clave elif, que significa sino si.

if comando1 
then 
  comando2 
  ...  
elif comando3 
then  
  comando4 
  ... 
else  
  comando5 
  ... 
fi 

Otras sintaxis

La palabra clave then puede colocarse en la primera línea con la condición de usar un ; para poder separar el comando.

if comando1 ; then 
  comando2 
  ... 
fi 

También es posible anidar estructuras de control. La sintaxis mostrada a continuación es equivalente a la sintaxis elif presentada con anterioridad.

if comando1 
then  
  comando2 
  ... 
else  
  if comando3 
  then  
    comando4 
    ...  
  else  
    comando5 
    ... 
  fi 
fi 

Primer ejemplo

El script existe_usuario.sh recibe como argumento un nombre de usuario. El script muestra por pantalla si el usuario existe o no en el sistema:

$ nl existe_usuario.sh  
    1  #! /bin/bash  
 
    2  # compatibilidad del script: ksh, bash  
  
    3  if [[ $# -ne 1 ]] ; then   
    4    echo "Número incorrecto de argumentos"  ...

1. Variables, caracteres especiales

Hoy es jue 18 ago 14:32:22 CET 2022 

Hoy es 18/08/2022 

$ ls 
f1  f2  f3 

$ echo * 

$ echo \* 

$ echo "*" 

$ echo '*' 

$ edad=20   
$ echo $edad 

$ echo \$edad 

$ echo "$edad" 

$ echo '$edad' 

$ echo "Tú eres $(logname) y tienes -> $edad años" 

$ echo Tú eres $(logname) y tienes -> $edad años 

2. Variables, visualización y lectura del teclado

$ bash wcount.sh oso pájaro 
El nombre del script es: wcount.sh 
El primer argumento es: oso 
El segundo argumento es: pájaro 
Todos los argumentos: oso pájaro 
Número total de argumentos: 2 
El primer argumento contiene: 3 caracteres 
El segundo argumento contiene: 6 caracteres 

$ hello.sh 
Introduzca...