Shell

El shell es un programa que provee una interfaz de usuario para acceder a los servicios del Sistema Operativo o ejecutar los diferentes programas. Este puede ser de varios tipos:

• Texto: Command Line Interface (CLI)
• Gráfica: Graphical User Interface (GUI)
• Lenguaje natural: Natural User Interface (NUI). Interfaz de usuario en el que se utilizan gestos corporales o la voz, sin el uso del ratón, teclado, panel táctil, etc.

En este artículo se hablará de los shells CLI, dado que los otros se han diseñado para que sean intuitivos y sencillos de usar.

Puedes ver una comparativa en Wikipedia. Nótese que en Unix, el shell no está integrado en el kernel, por tanto el usuario puede utilizar otros o escribir el suyo propio.

En Linux, el archivo /etc/shells contiene las rutas a las shells conocidas por el sistema y el archivo /etc/passwd especifica la shell por defecto de cada usuario (también se puede ver en la variable $SHELL). Se puede cambiar con el el comando chsh.

Línea de comandos

Nos centraremos en Bash, que cumple con la especificación POSIX y es la shell por defecto en muchos sistemas (no solo Linux). Actualmente, algunos prefieren zsh, pero todo lo que vamos a ver también se le puede aplicar.

bash se ejecuta como si fuese un comando más:

bash

Y para salir puedes ejecutar exit o Ctrl-D.

Funcionamiento de Bash

El shell es un proceso interactivo que ejecuta comandos, de los que se distinguen dos tipos:

• Comando externo: se crea un proceso hijo que ejecute el comando y el shell espera a que este termine (fork execv).
  Ejemplos: cp, cat, grep, mkdir…

• Comando interno: se ejecuta en el mismo proceso.
  Ejemplos: cd, bg, alias, eval, pwd, echo…

Nótese que los comandos externos son ajenos al shell, almacenados como archivos ejecutables en algún lugar del sistema. Para encontrar estos comandos externos, se busca en las rutas que contenga la variable PATH. Esta es una lista de rutas separadas normalmente por :.

PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin:/opt/bin

Tenga en cuenta que se busca de forma lineal, por lo que conviene que las rutas más usadas se coloquen al inicio.

Se puede comprobar rápidamente si un comando es interno o externo de la siguiente forma:

type comando

Componentes de un comando y orden de evaluación

Cada comando tiene 3 componentes:

• Nombre del comando
• Opciones
• Parámetros

Nótese que en programas más complejos se puede distinguir otro componente, el subcomando, por ejemplo git clone.

ls -l /tmp

Desde que introducimos un comando hasta que se ejecuta, el shell realiza los siguientes pasos en orden:

1. Redirección E/S
2. Sustitución de variables
3. Sustitución de nombres de ficheros

star=\*
ls -l $star

pipe=\|
cat archivo.txt $pipe more
# Error: no existe el archivo "|"
# Error: no existe el archivo "more"

Pero este comportamiento se modifica al usar eval:

1. Primero se realizan todas las sustituciones
2. Luego se ejecuta el comando

Ejecución en segundo plano

Varias formas de ejecutar un comando:

• Primer plano: el shell hace waitpid (se bloquea y espera) a que termine el comando. Este es el comportamiento por defecto.
• Segundo plano: lanza el comando pero permite al usuario realizar otros.

sleep 10     # Espera 10 segundos
sleep 10 &   # Lanza el mismo comando pero en segundo plano
             # Se puede lanzar otro comando

A mayores, para manejar un proceso en primer plano se puede usar Ctrl-C para matarlo y Ctrl-Z para detener su ejecución.

Tabulador y edición de comandos

Uso de tabulador para completar comandos y rutas a archivos. Dando dos veces al tabulador se pueden listar todas las posibilidades.

Durante la edición de comandos en Bash, permite algunos atajos de teclado de Emacs por defecto. Puede usar set -o vim para usar los atajos de Vi.

Expansiones

Más información en man 7 glob

Una expansión en Bash es una secuencia que este interpreta y expande antes de ejecutar el comando. También se les llaman comodines o globbing. Su uso principal es para sustituir nombres de archivos (wildcards):

ls -l *.html  # Lista todos los archivos html

Nótese que si la expansión falla (no hay archivos que coincidan), el argumento se dejará como está.

Bash tiene algunos conjuntos de caracteres predeterminados:

• [[:lower:]]: cualquier carácter en minúsculas. Equivalente a [a-z].
• [[:upper:]]: cualquier carácter en mayúsculas. Equivalente a [A-Z].
• [[:digit:]]: cualquier carácter numérico. Equivalente a [0-9].
• [[:alpha:]]: cualquier carácter alfanumérico. Equivalente a [a-zA-Z0-9].

echo date    # Muestra "date"
echo `date`  # Muestra "lun 12 feb 2024 14:14:54 CET"
echo "Num lineas: $(wc -l fichero)"  # Muestra "Num lineas: 130"

Historial de comandos

Bash mantiene una lista de los comandos previamente usados. Esta tiene un tamaño definido por HISTSIZE, por defecto 1000, y se almacena por defecto en el archivo ~/.bash_history.

Los parámetros que denoto entre corchetes pueden ser:

• El índice en el historial
• Un número negativo, siendo -1 el último, -2 el penúltimo, etc
• Una cadena que sea el inicio del comando

Variables

Bash permite la creación de variables. Se distinguen dos tipos:

• Locales (minúsculas): solo están presentes en el shell actual
• Globales/Entorno (mayúsculas): los procesos hijos (comandos externos) heredan también estas variables. Nótese que es solo una copia, si el proceso modifica la variable, el shell no se verá afectado.

El comando declare permite declarar variables con determinadas características, además de mostrar información sobre las variables existentes.

Si se usa readonly sin parámetros, se mostrará una lista con todas las variables de solo lectura. Si se usa printenv o env se mostrarán todas las variables de entorno.

una_variable = hola

Redirecciones

Recuerde que cada proceso tiene asociados 3 archivos especiales para su Entrada/Salida (toda la E/S se hace a través de archivos en Linux):

• stdin (0): entrada del teclado
• stdout (1): salida estándar
• stderr (2): error estándar

El comando recibe datos del stdin y luego escribe en stdout o stderr, dependiendo del caso. Pues el usuario puede redirigir estos datos a otro archivo.

Un lugar muy común para redirigir la salida de un comando es /dev/null, la basura, lo que evita que se muestre nada en la consola.

Es importante que al combinar varias redirecciones de distintos descriptores, 2>&1 o análogos vaya siempre al final del comando a redirigir. Es decir, si quieres redirigir stderr a stdout para pasarselo a grep, debes hacer esto:

params2stderr prueba test prueba 2>&1 | grep "p"

En lugar de:

params2stderr prueba test prueba | grep "p" 2>&1

En este último intentas redirigir la salida de grep, en lugar de la salida del primer comando.

Caracteres especiales

La siguiente lista de caracteres reciben un tratamiento especial por parte de bash:

    Globbing:               * ? [ ] [! ]
    Variables:              $
    Redirección:            < > << >> ` |
    Terminador de comando:  & ;

Por tanto, si quieren utilizar como caracteres literales (no con el significado que les da Bash), será necesario escaparlos.

$ echo '$HOME'
$HOME
$ echo "$HOME"
/home/magno
$ echo

Algunos comandos

Documentación

El número potencial de comandos es muy grande, y cada uno tiene sus propios subcomandos, con opciones y diferentes parámetros; por lo que resulta muy difícil aprenderlos todos.

Normalmente, los programas disponen de una opción que muestran alguna ayuda básica, comúnmente --help o -h. Para comandos internos se puede usar help <comando>.

$ fdisk --help
Usage:
 fdisk [options] <disk>         change partition table
 fdisk [options] -l [<disk>...] list partition table(s)

Display or manipulate a disk partition table.

Options:
 -b, --sector-size <size>      physical and logical sector size
 [...]
 -h, --help                    display this help
 -V, --version                 display version

For more details see fdisk(8).

Pero el mejor lugar para buscar información concreta es el manual (man).

man fdisk

El comando whatis mantiene una base de datos para rápidamente realizar búsquedas. Se construye con diferentes comandos, dependiendo de la distribución:

1makewhatis
2catman
3mandb

Otro comando interesante puede ser info, que es el sistema de manuales de GNU. Por lo general es más flexible y completo que man.

Útiles con pipes y redirecciones

ls -l /bin | tee archivos.txt | less

locate README | xargs cat

locate README | xargs -I % 'cat %; cp % /tmp'

Procesado de texto

patron { accion1; accion2; }

1sed 's/regex/replace' < archivo.txt

Otros comandos:

• grep: busca una expresión regular. Usar -E para expresiones regulares extendidas y -o para solo mostrar el match. También se puede usar -v para invertir el resultado (mostrar las líneas que no hacen match).
• diff: muestra la diferencia entre dos archivos. Recomiendo -u --color para hacerlo más legible.
• sort: ordena alfabéticamente. Usar -n para ordenar numéricamente o -u para eliminar duplicados. -r si quieres invertir el orden.
• paste: unir línea a línea dos archivos.
• tac: imprime un archivo al revés, la primera línea es ahora la última.
• rev: le da la vuelta a los caracteres de cada línea.
• wc: con -l puedes contar líneas de un archivo, con -w palabras, -c el número de bytes y -L la longitud de la línea más larga.
• head: imprime las primeras líneas de un archivo. -n especifica la cantidad.
• tail: lo mismo que head, pero imprime las últimas líneas.

Scripting

La Bourne Shell, aunque se use como intérprete de comandos, también se pensó para que se utilizase como un lenguaje de scripting.

La idea es básicamente tomar los comandos que estábamos ejecutando en la línea de comandos y guardarlos en un archivos para reutilizar luego. La extensión típica para los scripts de Bash es .sh, pero técnicamente solo son archivos de texto plano.

Para ejecutar el archivo se puede le puede pasar a Bash directamente: bash script.sh. Otra alternativa es ejecutarlo como un programa normal, pero es necesario asignar permisos adecuadamente:

1chmod u+x script.sh
2./script.sh

Como existen otros lenguajes de scripting que se pueden utilizar (Python, Perl…) con este método es necesario indicar el intérprete a utilizar en la primera línea con un shebang:

1#!/bin/bash

Aquí tienes una cheatsheet bastante útil.

Variables útiles

Estructuras de control

Para los condicionales solo se chechea el código de retorno del comando $?.

En los bucles también se pueden usar break y continue (se les puede pasar un número para salir de ese número de bucles).

1if cmd1
2then
3    cmd2
4elif cmd3
5then
6    cmd4
7else
8    cmd5
9fi

 1case valor in
 2    patron1)
 3        cmd
 4        ;;
 5
 6    patron2)
 7        cmd
 8        ;;
 9
10    *)      # Caso por defecto
11        cmd;
12        ;;
13esac

1for variable in lista
2do
3    cmd $variable
4done

Lista debe ser texto, cada elemento estará separado por espacios. Por tanto, es posible usar las expansiones de Bash vistas anteriormente.

1for ((i=0; i < 5; i++))
2do
3    cmd $i
4done

1while cmd
2do
3    cmd $i
4done

1until cmd
2do
3    cmd $i
4done

Checks

Comando read

El comando read se puede utilizar para bastantes cosas. Por ejemplo, leer de teclado a una variable:

1read -p "Introduzca un dato: " res
2printf "Ha instroducido: \"$res\""

Leer la primera línea de un fichero (dado que el delimitador es \n. Esto se puede cambiar con -d):

1read linea < archivo.txt

También se puede iterar sobre un archivo:

1i=1
2while read buff
3do
4    printf "$i: $buff\n"
5    i=$[$i+1]
6done < archivo.txt

Funciones

1nombre() {
2    cmd
3    return 0
4}

Para pasar parámetros se usa la misma sintaxis que con los parámetros de un script: $1 ... $9 ${10} ..., $* o $@. Para obtener el nombre de la función debes usar ${FUNCNAME[0]}, dado que $0 siempre es el nombre del script.

Rendimiento

• El shell no es eficiente a la hora de ejecutar trabajos pesados
• Es mejor dejar que los procesos hagan todo el trabajo: evitar expr, usar $[] o $(()).
• El uso de lazos con ficheros es muy ineficiente. Mejor usar comandos que operen con ellos (internamente tienen lazos eficientes escritos en C).
• Usar comandos internos cuando sea posible.
• Useless use of any comand (UUC):

  1cat /etc/passwd | grep root
  2# es equivalente a
  3grep root /etc/passwd
  

• Disminuir redirecciones a fichero de tipo > y >>. Los pipes | suelen ser bastantes eficientes