Apuntes Bash 1-40

Índice de contenido
Ficheros BASH................................................................................................................................3
Caracteres Especiales.......................................................................................................................3
Variables..........................................................................................................................................5
Comillas...........................................................................................................................................5
Estado de salida (exit status)............................................................................................................6
Comparadores..................................................................................................................................6
Operaciones.....................................................................................................................................9
Variables........................................................................................................................................11
Internas......................................................................................................................................11
Parámetros posicionales............................................................................................................11
Otras variables...........................................................................................................................12
Manipulación de cadenas..........................................................................................................12
Evaluación de variables y parámetros.......................................................................................13
Tipado de variables...................................................................................................................14
Referencia indirecta..................................................................................................................14
Números Aleatorios..................................................................................................................15
Bucles y Saltos...............................................................................................................................16
for..............................................................................................................................................16
while..........................................................................................................................................16
until...........................................................................................................................................17
break, continue..........................................................................................................................17
case............................................................................................................................................17
select..........................................................................................................................................17
Redirecciones............................................................................................................................19
Redirección local (here documents)..........................................................................................20
Expresiones Regulares (RegExp)..................................................................................................21
Expansión de nombres de fichero (globbing)...........................................................................22
Sustitución de procesos.............................................................................................................22
Funciones..................................................................................................................................23
Arrays............................................................................................................................................24
Ficheros especiales: /dev/null y /dev/zeros....................................................................................25
sed y awk.......................................................................................................................................26
sed.............................................................................................................................................26
awk............................................................................................................................................26
Comandos Internos........................................................................................................................27
IO..............................................................................................................................................27
Sistema de Ficheros..................................................................................................................27
Variables...................................................................................................................................27
Comportamiento script..............................................................................................................28
Apuntes Bash 2-40

Comandos..................................................................................................................................29
Control de trabajos....................................................................................................................29
Filtros externos, programas y comandos.......................................................................................30
Básicos......................................................................................................................................30
Comandos complejos................................................................................................................31
Fecha y hora..............................................................................................................................31
Procesado de texto....................................................................................................................32
Archivadores.............................................................................................................................33
Compresión...............................................................................................................................34
Ficheros.....................................................................................................................................34
Comparar ficheros.....................................................................................................................34
Utilidades de ficheros................................................................................................................34
Comunicaciones........................................................................................................................35
Acceso Remoto.........................................................................................................................35
Varios........................................................................................................................................36
Comandos de Administración y Sistema.......................................................................................37
Usuarios y grupos.....................................................................................................................37
Terminales.................................................................................................................................37
Información y estadísticas.........................................................................................................38
Logs...........................................................................................................................................38
Procesos....................................................................................................................................38
Control de procesos...................................................................................................................39
Red............................................................................................................................................39
Sistema de ficheros...................................................................................................................39
Apuntes Bash 3-40

Ficheros BASH
Todo fichero bash debe comenzar en la primera línea con #!/bin/bash

Caracteres Especiales
# comentario
usado en eliminaciones ${...}
; separador comandos en misma línea
;; separador “case ... in”
. lee y ejecuta fichero script (como source)
en expresión regular, cualquier carácter
“ evita interpretación, salvo $ (cita parcial)
‘ evita interpretación (cita total)
, enlaza operaciones aritméticas (entre dobles paréntesis; el resultado es el de la última)
\ escape
misma línea dividida
/ separador en rutas fichero
división (aritmética)
` (backquote) ejecutar comando y sustituir por su salida (como $(...) )
: NOP (ejemplo     ‘: > fichero’  => crea o trunca fichero)
! negación
indirección de variables (ejemplo:   ${!indir}  evalúa la variable con nombre $indir)
invoca mecanismo de historia
* comodín en globbing (expansión de nombre de fichero): cualquier conjunto de caracteres
en expresiones regulares (regexp): repite expresión anterior 0 o n veces
multiplicación (aritmética)
** potencia (aritmética)
? en globbing: cualquier carácter
en regexp: 0 o 1 repetición de la expresión previa
$ evalúa variable
en regexp: fin de línea
${...} sustitución de expresión
$* todos los parámetros (como una sola cadena)
$@ todos los parámetros (como n cadenas)
$? exit status
$$ pid
(...) grupo de comandos en subshell
inicializador de arrays (con espacios como separador)
{expr1, expr2, expr3... } en globbing, conjunto de expresiones alternativas para coincidencia
{...} bloque de código (con posibilidad de redirigir IO)
{} nombre de cada fichero (con ruta completa) encontrado en find (para la opción ­exec)
Apuntes Bash 4-40

[...] devuelve ok si la expresión es cierta (equivale a /usr/bin/test, pero es comando interno)
índice elemento en arrays
en regexp, conjunto de caracteres alternativo
[[...]] test extendido (admite más flexibilidad que [...])
((...)) evaluación de enteros
> redirección de stdout
&> redirección de stdout y stderr
>&2 redirección de stdout a stderr
>> redirige y añade (sin truncar si ya existe)
<(...) sustitución de procesos
>(...) sustitución de procesos
> comparador cadenas y enteros
< comparador cadenas y enteros
<< redirección para procesos interactivos
\< en regexp, inicio de palabra
\> en regexp, fin de palabra
| pipe
>| fuerza la redirección
|| OR lógico
& ejecución en segundo plano
&& AND lógico
­ opción de comando
stdin/stdout en redirecciones
$OLDPWD (ej: ‘cd ­’ cambia al directorio anterior)
menos (aritmética)
= asignación
comparación
+ suma (aritmética)
en regexp, repetir una o más veces la expresión anterior
opción de comando
% módulo (aritmética)
usado en eliminaciones ${...}
~ $HOME
~+ $PWD
~­ $OLDPWD
^ en regexp, inicio línea. Negación dentro de []
en globbing, negación dentro de []
Apuntes Bash 5-40

Variables
Asignación:   = (sin espacios)
ej: variable=hola
variable2=”hola”
Evaluación: $    o     ${...} (éste evita ambigüedad)
ej. variable3=$variable2
variable4=${variable3}
Parámetros posicionales: los que se pasan al comando o función.
$0 nombre de comando
$1... $9 parámetros
${10}... parámetros
$*, $@    todos los parámetros en conjunto
$#  numero de parámetros (excluyendo el nombre de comando)
referencia indirecta: var=7
var2=${!var}    asigna a var2 el 7º parámetro
shift: sentencia que pasa $2 a $1, $3 a $2 y así sucesivamente, perdiéndose el primer 
parámetro

Comillas
Partial quoting (comilla doble): Mantienen los espacios. Interpretan $, ` (backquoting), \ (escape)
ej: #!/bin/bash
var=”a      b c”
echo $var # => a b c
echo “$var” # =>  a      b c
Full quoting (comilla simple): No interpreta símbolos
ej: var1=”hola”; var2=”$var1”;  var3=’$var1’
echo “$var1 $var2 $var3” #=> hola hola $var1
– con $ delante, interpreta caracteres de escape
ej: echo $’\a’ equivale a  echo ­e “\a”
Apuntes Bash 6-40

Estado de salida (exit status)

Comando exit nnn (0­255) ­> 0 ok, 1­255 error
El símbolo $? tiene el estado de salida de la última instrucción
El comando exit sin parámetros equivale a exit $?
El símbolo ‘!’ más espacio más comando invierte el estado de salida
ej: #!/bin/bash
! echo hola   # => hola
echo $?  # => 1 (error)
echo $?  # => 0 (ok)

Comparadores
Sentencia if ... then ... elif ... then ... else ... fi
if comprueba el estado de salida de la sentencia. Si ok ($? es 0), ejecuta then.
Ej: #!/bin/bash
if cmp a b &> /dev/null  # compara los ficheros a b con salida silenciosa
then # si son iguales
echo “a y b son iguales”
else
echo “a y b son distintos”
fi
Operadores para comparaciones
[ ... ] equivale a /usr/bin/test, salvo que es un comando interno (builtin)
[[ ... ]] extiende la funcionalidad del anterior. No es un comando, sino una palabra clave.
let evalúa expresiones aritméticas
(( ... )) evalúa expresiones aritméticas
Operadores sobre fichero: IMPORTANTE: todos deben ir precedidos y seguidos de ESPACIO
­e existe. Ej:  if [ ­e /etc/passwd ]; then cat /etc/passwd; else echo “no existe”; fi
­f es fichero regular
­s no tiene longitud 0
­d es directorio
Apuntes Bash 7-40

­b es dispositivo de bloque
­c es dispositivo de caracteres
­p es un pipe
­h, ­L es enlace simbólico
­S es un socket
­t es un terminal (va con descriptor, no con nombre)
­r tiene permiso de lectura para usuario efectivo
­w tiene permiso de escritura para usuario efectivo
­x tiene permiso de ejecución para usuario efectivo
­g tiene setgid activado (tiene permiso para cambiar el grupo efectivo a root)
­u tiene setuid activado (tiene permiso para cambiar el usuario efectivo a root)
­k tiene sticky bit activado (mantener en cache)
­O usuario efectivo es propietario
­G grupo efectivo igual al del fichero
­N fecha de última modificación posterior a la de último acceso
f1 ­nt f2 f1 posterior f2 (newer than)
f1 ­ot f2 f1 anterior f2
f1 ­ef f2 f1 y f2 son enlaces fuertes (hard links) al mismo fichero
! negación

Operadores de enteros:
Con corchete [ “$a” ­operador “$b” ]
­eq igual
­ne distinto
­gt mayor
­ge mayor o igual
­lt menor
­le menor o igual
Con doble paréntesis (( “$a” operador “$b” ))
< menor
<= menor o igual
Apuntes Bash 8-40

> mayor
>= mayor o igual

Operadores de cadenas: con corchete o doble corchete. 
=, == cadenas iguales. Con doble corchete, admite patrones
ej: var="hola"
if [ $var = h* ]; then echo sí; else echo no; fi # => no
if [[ $var = h* ]]; then echo sí; else echo no; fi # => sí
if [[ $var = “h*” ]]; then echo sí; else echo no; fi # => no (ajuste exacto)
Las comillas dobles son útiles para preservar espacios
ej: var1="a      b"; var2=”a b”
if [ $var1 = $var2 ]; then echo sí; else echo no; fi # => error (too many args)
if [[ $var1 = $var2 ]]; then echo sí; else echo no; fi # => no
if [ "$var1" = "$var2" ]; then echo sí; else echo no; fi # => no
!= cadenas distintas. Mismos comentarios que el anterior
>, < mayor, menor (alfabéticamente). Con corchete simple requiere \ (escape)
ej: var1=”a”; var2=”b”
if [ $var1 \< $var2 ]; then echo sí; fi  # => sí
if [[ $var1 < $var2 ]]; then echo sí; fi # => sí
­z cadena de longitud cero o sin declarar (null)
­n cadena de longitud mayor que cero

Operadores lógicos
­a AND
­o OR
En corchetes dobles o en listas de comandos
&& AND
|| OR
Listas de comandos: debido a la ejecución perezosa, el operador && puede encadenar 
comandos hasta el primer retorno de estado no ok. De la misma forma, || encadena 
comandos hasta el primer ok
Apuntes Bash 9-40

ejemplo: [ ­e “$fichero” ] && cat “$fichero”
equivale a if [ ­e “$fichero” ]; then cat “$fichero”; fi

Operaciones
Asignación de variables =
Aritmética entera
+, ­, *, /, **, %
+=, ­=, *=, /=, %=
Para evaluar expresiones aritméticas se ha de usar let, expr o (( ... ))
Ejemplo: #!/bin/bash
a=1;b=2
let a=a+b; echo $a               # 3
a=`expr $a + $b`; echo $a      # 5
((a=a+b)); echo $a               # 7
: $((a=a+b)); echo $a            # 9
Los enteros en bash suelen ser con signo de 4 bytes
Arimética de coma flotante: En bash no existen las variables de tipo coma flotante. Son cadenas. 
Para ejecutar este tipo de cálculos necesitamos el comando bc, habitualmente en pipe
ejemplo #!/bin/bash
a=0.16; b=15
c= `echo “scale=0; $b ^ $a” | bc` # backquote para ejecutar y dejar stdout 
#como parámetro del siguiente comando
variables para bc: 
scale indica el número de decimales
ibase, obase indican las bases en las que se representan los datos de entrada y 
de salida respectivamente (por defecto, 10)
last último número impreso
Operadores a nivel de bit: <<, >>, <<=, >>=, &, &=, |, |=,~, ~=, ^, ^=
Otros operadores ,  la coma entre doble paréntesis ejecuta varias operaciones aritméticas y 
devuelve el resultado de la última
Constantes numéricas
Apuntes Bash 10-40

decimal let “x=32”
octal let “oc=032”
hex let “hx=0x32Fa” #también se admite 0X
otras bases let “bin=2#0100101”
máxima base 64, que usa 10 dígitos, 26 minúsculas, 26 mayúsculas, @ y _
Apuntes Bash 11-40

Variables

Internas
$EUID usuario efectivo
$FUNCNAME nombre de la función actual (para depuración)
$GROUPS lista de grupos a la que el usuario pertenece
$HOME directorio de trabajo del usuario
$HOSTNAME análogo a ejecutar /bin/hostname
$IFS internal field separator. Las separaciones de palabras y campos se llevan a 
cabo usando los caracteres aquí definidos como límites. Se puede modificar 
con los testigos que nos interesen en cada caso para hacer división de 
cadenas.
$LINENO contiene la línea actual del script (para depuración ej. echo “voy por 
$LINENO”)
$OLDPWD penúltimo en el histórico de directorios actuales
$PATH conjunto de rutas (separadas por :) en las que se buscan ejecutables
ej: PATH=$PATH:/nuevodirectorio
$PPID pid del proceso padre
$PROMPT_COMMAND comando ejecutado antes de imprimir el prompt principal PS1
$PS1 prompt principal
$PS2 prompt secundario. Para líneas de entrada adicionales (normalmente ‘>’)
$PS3 mostrado en la sentencia select
$PS4 cuando se invoca un script con ­x, opción xtrace que imprime cada comando 
antes de ejecutarlo (normalmente ‘+’ )
$PWD directorio actual
$REPLY en read, cuando no hay variable como parámetro, contiene el dato leído
en menús select; contiene el número de item
$TMOUT tiempo para logout (útil para realizar lecturas read con tiempo limitado)
$UID usuario

Parámetros posicionales
$0 nombre del script
Apuntes Bash 12-40

$1, $2... $9 parámetros del 1 al 9
${10}, ${11}... a partir de dos cifras se exige ${}
$# número de parámetros (excluyendo el nombre de script)
$* todos los parámetros (como una cadena)
$@ todos los parámetros (como $# cadenas)

Otras variables
$­ conjunto de flags
$! PID del último trabajo en segundo plano
$_ último parámetro del último comando invocado
$? exit status del último comando
$$ PID del proceso actual (útil por ejemplo para construir nombre únicos 
temporales)

Manipulación de cadenas
Longitud de una cadena
${#cadena}
expr length $cadena
expr “$cadena” : '.*'
Longitud de coincidencia de expresiones regulares
expr match “$cadena” “$regexp”
expr “$cadena” : “$regexp”
Búsqueda de caracteres: encuentra la posición (índice base 1) del primer carácter que coincida
expr index “$cadena” “$conjuntoDeCaracteres”
Extracción de subcadenas
${*:posicion} # parámetros posicionales desde posicion en adelante
${@:posicion} # parámetros posicionales desde posicion en adelante
${cadena:posicion} # desde posición al final
${cadena:posicion:longitud} # desde posición, 'longitud' caracteres
${cadena: ­ longitud} # 'longitud' últimos caracteres
expr substr “$cadena” “$posic” “$longitud”
Apuntes Bash 13-40

expr match “$cadena” “\($regexp\)” # extracción desde el inicio
expr “$cadena” : “\($regexp\)” # extracción desde el inicio
Borrado
${cadena#regexp} #borra la primera coincidencia más corta
${cadena##regexp} #borra la primera coincidencia más larga
${cadena%regexp} #borra la última coincidencia más corta
${cadena%%regexp} #borra la última coincidencia más larga
Sustitución
${cadena/regexp/cadenaSustituye} #sustituye la primera coincidencia
${cadena//regexp/cadenaSustituye} #sustituye todas las coincidencias
${cadena/#regexp/cadenaSustituye} #sustituye si la coincidencia se produce 
#desde el primer carácter
${cadena/%regexp/cadenaSustituye} #sustituye si la coincidencia se produce 
# desde el último carácter

Evaluación de variables y parámetros

En todos los casos var puede ser una etiqueta alfanumérica o un número, indicando en este último 
caso un parámetro posicional.
$var devuelve valor de var
${var} devuelve valor de var

${var­defecto} devuelve valor de var. Si no definida (null), devuelve 'defecto'
${var:­defecto} devuelve valor de var. Si no definida (null), devuelve 'defecto'

${var=defecto} devuelve valor de var. Si no definida (null), devuelve 'defecto' y se lo asigna a 
var
${var:=defecto} devuelve valor de var. Si no definida (null), devuelve 'defecto' y se lo asigna a 
var

${var+otro} si var está definida, devuelve 'otro'. Si no, devuelve null
${var:+otro} si var está definida, devuelve 'otro'. Si no, devuelve null
Apuntes Bash 14-40

${var?mensajeError} si var está definida, devuelve su valor. Si no, imprime 'mensajeError'
${var:?mensajeError} si var está definida, devuelve su valor. Si no, imprime 'mensajeError'

Tipado de variables
Las variables no tienen tipado fuerte. Para definir una variable, simplemente se inicializa a un valor 
y actúa con el tipo de la constante asignada. Posteriormente se le puede asignar otra constante de 
otro tipo.
Ejemplo:
#!/bin/bash
a=123456
let “a=$a + 100000”
echo `expr $a : '\(.*3\)'` # => 223
En todo caso, se puede restringir su uso con typeset o declare (son sinónimos)
– Constantes: declare ­r var
readonly var
– Enteros: declare ­i var
– Arrays: declare ­a var
– Funciones: declare ­f nombreFuncion
declare ­f  lista las funciones definidas hasta el momento
– Para exportar: declare ­x var  permite inicializar en la misma línea de declaración

Referencia indirecta.
eval ... \$$varIndirecta
${!varIndirecta}
Ejemplo:
#!/bin/bash
cad=”hola”
indir=”cad”
eval echo \$$indir # => hola
Apuntes Bash 15-40

echo ${!indir} # => hola

Números Aleatorios
Variable RANDOM.
Inicializar la semilla aleatoria (p.ej. usar pid) RANDOM=$$
Evaluar $RANDOM da un entero entre 0 y 32767
Apuntes Bash 16-40

Bucles y Saltos

for
for var [in lista] #si se omite lista, se usa $@
do
cmd
cmd
...
done
o bien
for ((  a=1 ; a < 10 ; a++ ))
do
...
done
Útiles
– set ­­ $var divide var en palabras y las asigna a $1, $2...
– se puede usar expansión de nombres de fichero (globbing)
for fich in ./* # para cada fichero en el directorio actual

while
while condición # al igual que if, la condición es una sentencia y se mira su exit status
do
...
done [<fichEntrada] [>fichSalida]
Las redirecciones de entrada y salida son muy interesantes para hacer bucles de lectura con read.  
Ejemplo:
while read lineaFichero
do
echo “$lineaFichero”
done < fichero
Apuntes Bash 17-40

until
Análogo al anterior

break, continue
Sin parámetros funcionan como en C
break n sale de n niveles de anidamiento
continue n sale de n­1 niveles de anidamiento y continúa en el siguiente ciclo del bucle exterior

case
case “$var” in
$valor1[|$valor2...])
...
;;  # indica finalización este caso
... )
...
;;
*)  # caso por exclusión
...
;;
esac
Los valores pueden llevar comodines (*), pero entonces no deben llevar comillas. Las comillas no 
son necesarias porque no hay división de palabras.

select
select var [in lista]
do
cmd
...
break
done
Apuntes Bash 18-40

Presenta un menú con lista. Se elige mediante número, var se actualiza a ese valor y se ejecuta la 
secuencia de comandos.
Apuntes Bash 19-40

Redirecciones
Los descriptores de fichero son ficheros especiales en /dev/fd/<num>, siendo 0, 1, 2 
respectivamente asignados a stdin, stdout y stderr
:> fich trunca fichero fich (análogo a touch fich, pero no arranca un subproceso)
>> redirige para añadir (no trunca fich si existe)

> fich redirige stdout a fich (truncando fich si exite)
1> fich redirige stdout a fich (truncando fich si exite)

>> fich redirige stdout a fich  para añadir datos (no trunca fich si exite)
1>> fich redirige stdout a fich  para añadir datos (no trunca fich si exite)

2> redirige stderr
&> redirige stdout y stderr
2>&1 redirige stderr a stdout
num1>&num2 redirige el descriptor num1 al descriptor num2

0< fich redirige stdin a fich
< fich redirige stdin a fich

... num<> fich asigna el descriptor num al fichero fich para el comando actual
exec num<> fich asigna el descriptor num al fichero fich para el resto de las sentencias
exec num>&­ cierra el descriptor num

Bucle típico de lectura de líneas
while read var
do
echo $var
done < fichOrigen > fichDestino
Apuntes Bash 20-40

Redirección local (here documents)

El operador ‘<<’ redirige la entrada stdin para un comando interactivo a las líneas que se escriban a 
continuación, hasta una cadena que marca el fin de lectura
comandoInteractivo << cadenaLimite
línea1
línea2
línea3
...
cadenaLimite

Una utilidad de esto puede ser comentar varias líneas
ejemplo
: << comentario
comentario uno
Esto es otro comentario
comentario
Apuntes Bash 21-40

Expresiones Regulares (RegExp)

Para sed, grep y awk
* coincidencia 0­n del carácter o RE previa
. coincidencia para un carácter cualquiera (salva retorno de carro)
^ principio de línea
^ (dentro de corchetes) complemento de rango
$ fin de línea
[...] rango o conjunto para coincidencia de un carácter
\ marca de carácter de escape
\< ... \> límites de palabra

Conjunto extendido de expresiones (para egrep, sed y awk)
? coincidencia 0­1 del carácter o RE previa
+ coincidencia 1­n del carácter o RE previa
\{num\} coincidencia num del carácter o RE previa. Ej: [0­9]\{5\}  equivale a cinco dígitos
( ... | ... | ... ) grupos de RE alternativos

Clases POSIX (admitidas en expresiones regulares extendidas, aunque a veces hay que usar doble  
cochete)
[:alnum:] 0­9a­zA­Z
[:alpha:] a­zA­Z
[:blank:] \ \t (espacio y tabulador)
[:cntrl:] caracteres de control
[:digit:] 0­9
[:graph:] caracteres imprimibles y espacio
[:print:] caracteres imprimibles (excluyendo espacio)
[:lower:] a­z
[:space:] [:blank:]
[:upper:] A­Z
[:xdigit:] 0­9a­fA­F (dígitos para hexadecimal)
Apuntes Bash 22-40

Expansión de nombres de fichero (globbing)

Bash no interpreta por sí mismo expresiones regulares (se usan como parámetros para algunos 
comandos), aunque sí lleva a cabo expansión de nombres de fichero
* cualquier conjunto de caractéres (excluyendo comienzo por ‘.’)
? cualquier carácter
[ ... ] un conjunto para coincidencia de un carácter. 
Ejemplo: ls ­ld [a­em]* lista todos los ficheros y directorios que comienzan por a, b, c, 
d, e, m
^ complemento de un rango
{patron1, patron2,...} conjunto alternativo de patrones
Ejemplo: ls ­ld {h?h, a*}.c lista todos los ficheros que finalicen por ‘.c’ y que, o bien 
comiencen por ‘a’, o bien tengan dos ‘h’ y en medio cualquier 
carácter

Sustitución de procesos
En los siguientes casos, cmd se ejecuta primero, redirigiendo su salida como parámetro de 
sentencia, que se ejecuata a continuación
sentencia `cmd`
sentencia $(cmd)
Ejemplo:
var=`ls` #$var contiene los ficheros y directorios del directorio actual

Cuando se tiene como parámetro un fichero, se pueden usar las expresiones <(cmd) o >(cmd), 
dependiendo si el fichero es un parametro de lectura o escritura. 
sentencia <(cmd)
sentencia >(cmd)
Ejemplo: Comparar los directorios /home/pepe y /home/manolo con diff
diff <(ls /home/pepe) <(ls /home/manolo)
Ejemplo: Imprimir selectivamente la tabla de enrutamiento
while read des what mask iface; do
Apuntes Bash 23-40

  echo $des $what $mask $iface
done < <(route −n)

Funciones
function nombreFuncion {
<cuerpo>
}
o bien
nombreFuncion() {
<cuerpo>
}
Los parámetros no se definen entre los paréntesis. En el cuerpo se invocan por $1, $2... (parámetros 
posicionales), y son siempre de tipo global. Para invocar la función los parámetros se colocan a 
continuación separados por espacios (sin paréntesis).
Ejemplo:
#!/bin/bash
miFun(){
var2=”adios”
         eval $1="pepe";
}
var="hola"
miFun var
echo $var2 $var # => adios pepe
Se pueden definir variables locales con la palabra reservada local.
La palabra reservada return <num> modifica $? (estado de retorno), que puede ser consultado por 
el script que invoca la función.
Apuntes Bash 24-40

Arrays
Los arrays tienen como primer índice el 0 (como en C)
Declaración: <nombre>[<tamano>]
o bien
declare ­a <nombre>
Invocación: ${<nombre>[<índice>]}  (operador ${...})
Asignación: <nombre>[<índice>]=valor
Inicialización: <nombre>=(valor1 valor2 ... ) (paréntesis y valores separados por espacios)
o bien
<nombre>=([2]=valor1 [7]=valor2 ... ) (inicialización selectiva por índices)
Longitud: ${#<nombre>[@]}
o bien
${#<nombre>[*]}
NOTA: ${#<nombre>} es la longitud del primer elemento del array!
Extracción de elementos:
${<nombre>[@]:<indiceInicial>}
${<nombre>[@]:<indiceInicial>:<numeroElementos>}
Operaciones:
read ­a nombreVector lee una línea de stin, la divide en palabras según IFS y cada una se la 
asigna al elemento correspondiente del vector nombreVector

Ejemplos: 
Sustituir último elemento
miVector=( a b )
miVector[ ${#miVector[@]} ­ 1 ]="hola"  # obsérvese que no necesita ((...)) para cálculo
echo ${miVector[@]} # => a hola
Eliminar último elemento
miVector=( a b )
unset miVector[ ${#miVector[@]} ­ 1 ] # obsérvese que no necesita ((...)) para cálculo
echo ${miVector[@]} # => a
Apuntes Bash 25-40

Ficheros especiales: /dev/null y /dev/zeros

/dev/null actúa como “agujero negro”
Ejemplo: eliminar la salida error.
comando ... 2> /dev/null
/dev/zeros actúa igualmente, pero también sirve para inicializar a 0 binario
Ejemplo: creación de un área de intercambio inicializada a 0 binario
dd if=/dev/zero of=$fich bs=1024 count=4096
mkswap $fich 4096
swapon $fich
Apuntes Bash 26-40

sed y awk

sed
Editor no interactivo de línea. Lee cada línea de stdin, la procesa y la escribe en stdout.
Se definen rangos con un parámetro o dos separados por una coma. El parámetro puede ser un 
número (de línea) o un patrón de coincidencia (expresión regular).
Si sólo hay un parámetro, se ejecutará el comando sobre todas las líneas coincidentes (sólo una si es 
un número de línea o todas las que contengan la expresión regular)
Si hay dos parámetros, el rango queda definido por la primera coincidencia del primer parámetro y, 
a partir de ese punto, la primera coincidencia del segundo.
Para realizar varias operaciones sobre un rango (o definir subrangos) se usan llaves. Ejemplo: 
Imprimir, de entre los cuatro primero archivos, aquellos que comiencen por ‘a’, ‘b’ o ’c’.
ls ­1| sed ­n 1,4{/[a­c].*/p}
(NOTA: ls ­1 (número ‘1’, no letra ‘l’) imprime usando una columna)
(NOTA2: sed imprime por defecto todas las líneas a stdout, con independencia de la 
instrucción que se ejecute. ­n se usa para eliminar esta salida)
Operaciones
[rango]/d no imprime las líneas coincidentes en rango
[rango]/p no imprime las líneas coincidentes en rango
[rango]s/regexp/cadena/ sustituye la primera coincidencia de regexp por cadena
[rango]s/regexp/cadena/g sustituye todas las coincidencias de regexp por cadena
[rango]y/conjunto1/conjunto2/ sustituye la primera coincidencia de caracteres del primer 
conjunto por el correspondiente en el segundo conjunto 
(análogo a tr)
[rango]y/conjunto1/conjunto2/g sustituye todas las coincidencias de caracteres del primer 
conjunto por los correspondientes en el segundo conjunto.

awk
Nos vamos a limitar a la funcionalidad de cortar en campos (más versátil que cut).
Ejemplo: Imprimir los campos 1 y 3 del fichero fichero
cat fichero | awk ­F ‘\t’ ‘{print $1 “\t” $3}’
Si se omite la especificación de delimitador (­F), el delimitador será el espacio
Apuntes Bash 27-40

Comandos Internos
Un comando interno (builtin) de bash no requiere arrancar un subproceso.

IO
echo imprime texto en stdout
­e reconoce caracteres de escape
­n no imprime retorno de carro al finalizar
printf cadenaFormato param1 param2 ... análogo en C
read [var [, var2...]] lee una línea de stdin y la asigna a var.
si var se omite, el valor queda en $REPLY.
si se redirige la entrada, se lee la primera línea.
si hay varias variables, se lleva a cabo la división de la línea según IFS y cada 
campo se le asigna a cada variable. A la última se le asigna el resto.
­a divide la línea y la asigna a un array
­s no hay eco en stdout
­nNN lee máximo NN caracteres
­p escribe texto de pregunta
­t secs establece un tiempo de espera de secs segundos

Sistema de Ficheros
cd nuevoDirectorio cambia pwd a nuevoDirectorio
cd ­ cambia a $OLDPWD
pwd imprime $PWD (directorio actual)

Variables
let  expresiones aritméticas
eval expansión y conversión a comando
ej: a=”echo hola”; eval “$a” # => hola
set sin parámetros lista las variables de entorno
­­ $var establece parámetros posicionales según la división de $var
­­ borra los parámetros posicionales
Apuntes Bash 28-40

`comandos` ejecuta comandos y redirige su salida para establecer los 
parámetros posicionales
ej: set `echo hola`; echo $1 # => hola
unset var borra var (pasa a valer null)
export var establece var como variable de entorno para procesos hijos
declare/typeset establece tipo de variable
readonly establece tipo constante
getopts para leer opciones (flags seguidos de guiones)
$OPTIND indica el parámetro posicional donde se encuentra la siguiente 
opción
$OPTARG para las opciones que requieren ir seguidas de un parámetro, el 
valor de dicho parámetro
Ejemplo:
while getopts “:abc:d” opcion # los dos puntos tras c indican que esa 
# opción requiere parámetro
do
case $opcion in
a) echo “$opcion”  # a
   ;;
b) echo “$opcion”  # b
   ;;
c) echo “$opcion $OPTARG” # c <valorParámetro>
   ;;
d) echo “$opcion”  # d
   ;;
esac
done

Comportamiento script
. (punto) | source el punto y la palabra reservada source son sinónimos. Son análogos a 
#include en C
exit n finaliza con exit status n
Apuntes Bash 29-40

exec cmd finaliza el script actual y lanza en su lugar cmd
shopt cambia opciones shell

Comandos
true pone $? a 0 (ok)
false pone $? a 1 (error)
type [cmd] ruta completa del comando (si es externo)
­a describe si es keyword (palabra clave) o builtin (comando interno) o si 
comando externo (describe la ruta completa)

Control de trabajos
fg trae proceso en segundo plano a primer plano
bg reinicia un proceso bloqueado en segundo plano
wait espera a todos los procesos hijos lanzados en segundo plano
pid espera al hijo con el pid indicado
%job espera al hijo con el número de tarea indicado
kill  ­l imprime la lista de señales.
  [­num] pid manda la señal num (por defecto, SIGTERM) al proceso con pid 
indicado
%job manda la señal num (por defecto, SIGTERM) al proceso con número 
de tarea indicado.
Apuntes Bash 30-40

Filtros externos, programas y comandos.

Básicos.
ls [patrón] lista ficheros y directorios ordenados alfabéticamente
­a incluye ficheros que comienzan por .
­l información completa
­R lista directorios recursivamente
­S ordenados por tamaño
­t ordenados por tiempo
­i muestra inodes
­F muestra etiqueta con tipo de fichero
cat fich [fich2...] imprime el contenido de los ficheros consecutivamente en stdout
­n incluye número de línea
­b no imprime líneas blancas
­v muestra caracteres no imprimibles con ^
­s si hay varias líneas blancas consecutivas, sólo imprime una
tac análogo a cat, pero imprime desde la última línea a la primera
rev imprime línea a línea desde el principio, pero invierte cada línea (hola­>aloh)
cp orig dest copia el fichero orig en dest, truncando caso de que exista este último
­d copia los enlaces simbólicos como tal (no los ficheros a los que apunta)
­p preserva permisos tanto como sea posible
­r copia directorios recursivamente (copia mal FIFOs y ficheros especiales!)
­R copia directorios recursivamente
­a equivale ­dpR (copia recursiva respetuosa con enlaces y permisos)
rm fich borra fichero fich
­f no pregunta confirmación (bueno para script)
­r directorios recursivamente (bueno para borrar árboles completos)
rmdir dir borra directorio vacío
mkdir dir crea directorio
chmod numOctal fich cambia los permisos de fich. Tres dígitos en octal indican rwx de propietario, 
grupo y resto 
Apuntes Bash 31-40

{u,g,o,a}{+,­}{r,w,x} fich ejemplo: chmod u+w fich añade permisos de escritura para el 
propietario
­R recursivamente
ln fichero enlace crea enlace para fichero
­s enlace simbólico

Comandos complejos
find <dir> [­name <patrón>] [­type <tipo>] [­exec <comando> \;]
busca coincidencias patrón recursivamente en dir, ficheros de tipo tipo, y 
ejecuta con cada uno comando (se le puede pasar ‘{}’ como argumento 
equivalente al nombre de fichero encontrado). Por defecto, lo imprime.
ejemplo: find “$dir” ­type f ­atime +5 ­exec rm {} \; 
esto borra los ficheros regulares (f) en el directorio $dir con tiempo de acceso mayor 
que cinco días de diferencia con la fecha actual
xargs cmd ejecuta cmd con los parámetros que se indican en stdin
­n N número de parámetros que se pasarán al comando (si sobran, se ejecuta de 
nuevo)
ejemplo: ls | xargs ­n 1 echo lista el directorio en una columna
expr véase en Manipulación de Cadenas

Fecha y hora
date fecha
­u UTC
+<formato> ejemplo: date +”%Y %m” # => 05 12
touch fich crea fich con longitud 0
at <fecha> [­f <ficheroListaTrabajos>]  si se omite ­f, se espera la lista de trabajos de stdin
ejecuta una lista de tareas en la fecha indicada (mejor usar cron)
sleep num bloquea el proceso num segundos
usleep num bloquea el proceso num microsegundos
hwclock, clock reloj hw (acceso y modificación)
Apuntes Bash 32-40

Procesado de texto
sort [fich[ fich2] ordena líneas ficheros e imprime stdout (si se omiten ficheros, stdin)
uniq borra líneas duplicadas
­c incluye el número de apariciones de cada línea
expand, unexpand convierten tabuladores a espacios y a la inversa
cut extracción de campos (mejor usar awk)
­f num campo num
­d “$delimitadores” especifica delimitadores de separación de campos
­c num1­num2 extrae caracteres entre las columnas num1 y num2 (se ignora 
la separación por delimitadores)
paste fich1 fich2... imprime cada línea consistente en la línea correspondiente de cada fichero 
separadas por tabuladores
join fich1 fich2 une líneas según el primer campo de línea igual (el primer campo actúa a 
modo de clave primaria en un join natural)
head [­n num] fich imprime num líneas iniciales de fich (10 por defecto)
­c num imprime num caracteres
tail fich análogo a head, pero del final
­f va imprimiendo el final a medida que va creciendo el fichero (muy bueno 
para observar ficheros log).
grep regexp ficheros extrae las líneas donde existe alguna coincidencia de regexp en ficheros
­i ignora caso
­w coincidencia palabras completas
­l sólo lista los archivos donde hay coincidencias, no las líneas.
­r recursivamente los directorios
­n imprime números de línea
­v inversión: imprime donde NO hay coincidencia
­c sólo imprime el número de coincidencias
­E equivale a egrep: admite expresiones regulares extendidas
­F equivale a fgrep: no se admiten expresiones regulares, sólo coincidencias 
exactas
para ficheros comprimidos
zgrep, zegrep, zfgrep versiones para fichero gzip
Apuntes Bash 33-40

bzgrep versión para ficheros bzip, bzip2
sed ver apartado Sed y Awk
awk ver apartado Sed y Awk
wc cuenta líneas, palabras y caracteres
­w sólo palabras
­l sólo líneas
­c sólo caracteres
­L longitud de la línea más larga
tr rango1 rango2 sustituye los caracteres de rango1 por los correspondientes de rango2, 
leyendo de stdin e imprimiendo en stdout
ejemplo: tr A­Z a­z < fichero imprime fichero todo minúsculas
­d rango1 no imprime los caracteres en rango1
­c rango rango se convierte en su complementario (ej. ‘­c a’ sería ‘todo excepto a’)
nl equivale a cat ­n (pinta con números de línea) salvo que no imprime líneas en 
blanco

Archivadores
tar para archivos tarball
­c crear archivo
­x extraer archivo
­­delete fich eliminar fich del archivo
­r fich añadir fich en el archivo
­A arch  añadir archivo tar arch al archivo
­t lista los ficheros del archivo
­u actualiza
­d compara el contenido del archivo con el de un sistema de ficheros
­z fichero gzip (con ­c comprime, con ­x descomprime)
­j fichero bzip
rpm Red Hat Package Manager. Para instalar paquetes Red Hat
­i instalar
Apuntes Bash 34-40

­qa lista paquetes instalados

Compresión
gzip, gunzip (equivale gzip ­d)
bzip2, bunzip
compress, uncompress
sq, unsq
zip, unzip  maneja los ficheros MS­DOS zip generados por pkzip
unarc, unarj, unrar descomprimen los ficheros correpondientes MS­DOS

Ficheros
file <fich> muestra el tipo de fichero
which <fich> muestra la ruta completa del fichero
whereis <fich> muestra la ruta completa del fichero y la correspondiente página del manual 
whatis <fich> muestra ayuda sobre el fichero
vdir ls ­l
locate, slocate busca la ruta en una base de datos del sistema actualizada periódicamente
readlink muestra a qué fichero apunta un enlace
strings busca cadenas de texto en archivos binarios, de datos, dumps...

Comparar ficheros
diff f1 f2 compara línea a línea y pinta la líneas distintas
cmp f1 f2 informa del primer punto (línea y byte) donde ambos difieren
­s no imprime nada. Sólo modifica $?

Utilidades de ficheros
basename fich elimina del nombre la ruta, dejando únicamente el nombre
dirname fich elimina el nombre del fichero,  dejando únicamente la ruta
Apuntes Bash 35-40

sum, cksum, md5sum generadores de resumen (digest) de fichero
md5sum: 128bit Message Digest checkSUM. 
Este programa imprime los 128bit en hexadecimal y el nombre del fichero al que se 
le ha realizado el resumen
shed borrado seguro de fichero (imprime varias veces encima de forma aleatoria)

Comunicaciones
host nombreDNS devuelve dirección IP
host dirIP devuelve el nombre DNS (resolución inversa)
ipcalc  ­h dirIP devuelve el nombre DNS (resolución inversa)
­m dirIP máscara de subred por defecto para dirIP
­n dirIP red (aplicando la máscara por defecto)
nslookup resolución DNS
dig resolución DNS
­x resolución inversa
traceroute traza de los saltos de red
ping prueba de eco de conexión a un equipo
whois resolución DNS
finger usuarios conectados al sistema

Acceso Remoto
ssh, scp terminal remoto seguro, copia de archivos segura
wget descarga no interactiva
­c continuar si existe una porción del archivo (se interrumpió el proceso)
­r descargas recursivas
­l nivel de profundidad en la descarga (siguiendo enlaces)
ftp transferencia de ficheros
telnet terminal remoto (no seguro, mejor ssh)
Apuntes Bash 36-40

Varios
jot, seq [<inicio>] <fin> [<incremento>] 
devuelve una secuencia (por defecto, inicio e incremento valen 1
­s sep separa la secuencia con sep
run­parts ejecuta los scripts de un directorio en orden alfabético
yes imprime una secuencia ilimitada de cadenas (“yes” por defecto). Es útil para 
programas interactivos donde se quiera aceptar todas las preguntas
tee <fich> usado en pipe. Imprime stdin en fich además de en stdout
dd transferencias entre ficheros
if input file
of output file
bs block size
count números de bloques
ejemplo: dd if=~/ficheroImagen of=/dev/fd0 bs=1024 count=1440; sync
genera un floppy a partir de un fichero de imagen
sync libera (flush) los buffers
Apuntes Bash 37-40

Comandos de Administración y Sistema

Usuarios y grupos
users equivale a who ­q (lista los usuarios conectados)
groups equivale a $GROUPS: grupos a los que pertenece el usuario actual
chown, chgrp cambian el propietario o grupo de un fichero
useradd, userdel, usermod crea, borra y modifica un usuario
groupmod modifica un grupo
id lista el uid, gid y euid del proceso actual
who lista de usuarios conectados
w lista de usuarios conectados y procesos asociados
logame equivale a whoami (nombre usuario actual)
su <usuario> cambia usuario efectivo (por defecto, root)
sudo <cmd> ejecuta cmd como root (en /etc/sudoers se encuentran los usuarios con este 
privilegio)
passwd cambia la contraseña de un usuario
ac estadísticas de tiempo de conexión del usuario

Terminales
tty muestra el fichero al que está conectado stdin
stty configurar terminal
ejemplo: detectar pulsación sin necesidad de pulsar ENTER
old=$(stty ­g)  #guardar los valores actuales
stty ­icanon   #dehabilita el modo canónico (pasa a modo raw)
pulsacion=$(dd bs=1 count=1 2>/dev/null)
stty “$old”
setterm atributos de terminal
­bold on/off
­cursor off
dmesg lista de mensajes de arranque
Apuntes Bash 38-40

Información y estadísticas
uname tipo de sistema (habitualmente “Linux”)
­a información extendida sobre el sistema
strace <cmd> traza de las señales y llamadas al sistema de cmd
nmap <host>|<red> busca puertos abiertos en un host o una red
du espacio usado por ficheros (por defecto, sólo directorios)
­a incluye ficheros en la lista
­c totaliza al final
df información de uso de sistemas de ficheros
netstat información sobre la red
­r equivale a route. Tabla de enrutamiento
uptime tiempo de conexión del usuario actual
hostname $HOSTNAME
hostid identificador de 32bit de la máquina

Logs
logger añade un mensaje a /var/log/messages

Procesos
ps procesos con euid (usuario efectivo) igual al usuario actual
ax todos los procesos
u formato orientado al usuario
pstree todos los procesos en árbol padre­hijos (todos penden de init)
top lista de procesos por orden de carga de CPU, actualizada periódicamente
­b no actualizaciones (para script)
nice valor de cortesía de un proceso
nohup proceso continúa aunque el usuario que lo inició se desconecte
pidof <nomProg> pids de procesos asociados a un programa con nombre nomProg
fuser <fich> procesos que acceden a un fichero en un momento
Apuntes Bash 39-40

­k [­señal] enviarles señal (por defecto, SIGKILL)
cron, crond ejecuta tareas según la temporización establecida en /etc/crontab

Control de procesos
runlevel indica el nivel de ejecución del sistema
0 parado
1 usuario único
2­3 multiusuario
5 X­windows
6 reboot

Red
ifconfig <interface> información sobre interface de red (por defecto, todas)
iwconfig configuración para wireless
route equivale a netstat ­r. Tabla de enrutamiento
chkconfig consulta y actualiza información sobre los niveles de ejecución
­­list enumera los servicios arrancados
­­add <nomServicio> añade nomServicio para ser arrancado en todos los 
niveles
­­del <nomServicio> borra nomServicio para no ser arrancado en ningún 
nivel de ejecución
tcpdump sniffer de red. Muestra en stdout información acerca de los paquetes de red 
observados

Sistema de ficheros
mount <dispositivo> <sistemaFicheros> monta un dispositivo sobre un sistema de ficheros
­a monta todos los indicados en /etc/fstab
­t establece el tipo de sistema de fichero
­r sólo lectura
­o loop usa dispositivos loopback (por ejemplo para montar archivos sobre 
sistemas de ficheros)
Apuntes Bash 40-40

ejemplo: montar el directorio /home de la máquina academia.org compartido mediante nfs 
en mi directorio /compartidoAcademia
mount ­t nfs academia.org:/home /compartidoAcademia
ejemplo: montar archivo iso (imagen de cd) como directorio
mount ­t iso9660 ­o loop ~/miImagenCd.iso /mnt/cdVirtual
mkfs [­t tipo] crea un sistema de ficheros
mke2fs [­j] crea un sistema de ficheros ext2 (si se le añade ­j (journaling), es ext3)
mkswap crea un sistema de ficheros swap
swapon, swapoff activa un sistema de ficheros swap