Scripts Bash en Rhel

Vicerrectoría Académica
Dirección de Servicios Académicos

Subdirección de Servicios a Escuelas
Programación de Scripts BASH en RHEL 6
Objetivos:
• Programar scripts Bash para automatizar y apoyar el proceso de
administración del sistema de acuerdo a las necesidades y/o requerimientos
de la organización.
Beneficios:
Se podrán elaborar scripts que permitan automatizar y encadenar tareas
relacionadas con la administración del sistema, tareas repetitivas y generalmente
tediosas, etc.
Índice
Programación de Scripts BASH en RHEL 6 ............................................................... 1
1.- ¿Qué es un SHELL? .................................................................................................. 4
1.1 Los SHELLs de LINUX ................................................................................................... 5
2.- ¿Qué es el BASH? ..................................................................................................... 6
2.1 Características de BASH ............................................................................................... 7
2.2 Archivos de arranque del BASH ................................................................................... 7
2.3 Ayudas interactivas de BASH ....................................................................................... 8
2.4 Gestión del histórico de comandos .............................................................................. 8
3.- SHELL Scripts .......................................................................................................... 10
3.1 SHELL SCRIPTS en BASH ......................................................................................... 11
3.2 Variables en BASH ....................................................................................................... 12
3.3 Variables de Ambiente ................................................................................................. 13
3.4 Entrada/Salida en BASH .............................................................................................. 14
3.5 Operaciones con variables en BASH......................................................................... 15
3.6 Operaciones aritméticas con BASH ........................................................................... 17
4.- Control del flujo en BASH ..................................................................................... 20
4.1 “Condiciones” en el control del flujo en BASH.......................................................... 21
4.2 Sentencia condicional IF .............................................................................................. 22
4.3 Sentencia condicional CASE....................................................................................... 25
4.4 Sentencia iterativa WHILE ........................................................................................... 28
4.5 Sentencias true y false ................................................................................................. 32
4.6 Sentencias break y continue ....................................................................................... 33

4.7 Sentencia iterativa FOR ............................................................................................... 34
4.8 Sentencia iterativa UNTIL ............................................................................................ 38
4.9 Sentencia SELECT ....................................................................................................... 39
5.- Funciones en BASH ................................................................................................ 41
5.1 Uso de funciones en SCRIPTS BASH....................................................................... 41
5.2 Los PARÁMETROS POSICIONALES ....................................................................... 46
5.3 Variables locales y globales ........................................................................................ 47
5.4 Las variables $*, $@ y $# ............................................................................................ 49
5.5 Librería de FUNCIONES .............................................................................................. 50
6.- Resumen .................................................................................................................... 51
6.- Bibliografía ................................................................................................................ 54

1.- ¿Qué es un SHELL?
El SHELL es el intérprete de comandos de un sistema UNIX/LINUX.

El SHELL es una interfaz que nos proporciona utilidades de trabajo y permite
establecer una relación con el kernel (o núcleo) del sistema operativo. Es decir, el
SHELL reconoce una serie de órdenes o comandos, los interpreta y lanza los
procesos necesarios para su realización.
En la siguiente figura se muestra la típica visión del SHELL en el sistema:
Figura Nº 1: Visión del Shell en el sistema
En definitiva, el SHELL es un programa que nos permite interactuar con el sistema

operativo.
La “línea de comandos” es la entrada del usuario para el SHELL. El SHELL
examina la línea de comandos, verifica que lo que se ha escrito es correcto,
determina si se ha digitado el nombre de un programa (ya sea binario o
compilado), y de ser así envía dicho programa al núcleo (kernel) para su
ejecución.
1.1 Los SHELLs de LINUX
En GNU/LINUX hay varios tipos de SHELLS, ver la Figura Nº 2, cada una con sus
características propias, entre los más conocidos podemos nombrar:
 BASH (/bin/bash) - El BASH es el SHELL por defecto en la mayoría de las
distribuciones de GNU/LINUX disponibles en la actualidad.
 KORN SHELL (/bin/ksh) – Desarrollado por David Korn de los Laboratorios
AT&T Bell en el comienzo de la década del 80.
 C SHELL (/bin/csh) – Desarrollado por Bill Joy en la Universidad de
Berkeley, California.
Figura Nº 2: SHELLS de Linux

2.- ¿Qué es el BASH?
El BASH es un intérprete de comandos o SHELL desarrollado para el proyecto

“GNU operating system”.
El nombre BASH es un acrónimo de bourne-again shell (otro shell bourne) -
haciendo un juego de palabras (born-again significa renacimiento) sobre el
BOURNE SHELL (sh), que fue uno de los primeros intérpretes de comandos
importantes de UNIX.
El BASH Potencia la interactividad, soportando edición en línea de comandos,
capacidad de completar automáticamente un comando, etc. También soporta
prompts configurables.
El BASH de GNU/LINUX es tanto un intérprete de comandos o SHELL, como un

lenguaje de programación de alto nivel. Como intérprete de comandos, procesa
las órdenes introducidas en respuesta a su indicación. Utilizado como lenguaje de
programación, el BASH procesa grupos de órdenes almacenados en archivos
llamados SCRIPTS.
El BASH es ampliamente compatible con el BOURNE SHELL sh e incorpora

algunas características del KORN SHELL ksh y el C SHELL csh.
El BASH está llamado a ser la implementación de la “IEEE POSIX Shell and

Tools” proyecto incluido en el estándar de la especificación IEEE POSIX (IEEE
Standard 1003.1).
2.1 Características de BASH
BASH incluye, entre otras, las siguientes características:

 Edición y completación de comandos.
 Histórico de comandos.
 Control de procesos.
 Funciones SHELL y alias.
 Manipulación de arreglos.
 Operaciones aritméticas.
 Capacidades de E/S expandidas.
 Facilidades de ayuda.
 Prompts personalizados.
 Seguridad.
 Modo POSIX.
 Timing de comandos, etc.
2.2 Archivos de arranque del BASH
Cuando el BASH es invocado de manera interactiva, primero lee y ejecuta

comandos desde el archivo /etc/profile, si es que existe.
Una vez leído este archivo, BASH ejecuta comandos del primer archivo que exista
y que BASH pueda leer de entre los siguientes archivos: ~/.bash_profile,
~/.bash_login, y ~/.profile, en ese orden.
Cuando salimos de una “sesión de login”, BASH lee y ejecuta comandos desde el
archivo ~/.bash_logout, si es que este archivo existe.
http://dghubble.com/blog/posts/.bashprofile-.profile-and-.bashrc-conventions/
2.3 Ayudas interactivas de BASH
Para recibir información del usuario, BASH y otros programas emplean las
librerías readline e history. readline brinda facilidades para escribir comandos
con un teclado e history almacena los últimos comandos que el usuario haya
dado para facilitar su reutilización.
Algunas de las posibilidades que estas librerías ofrecen son:
 Flechas o Control-p, Control-n - Para "navegar" sobre la historia de
comandos.
 Completación con <TAB> - Se puede emplear la tecla <TAB> para
completar nombres de programas, de máquinas o de usuarios. Si hay
varias posibles completaciones un segundo <TAB> presentará la lista de
posibilidades.
 Buscar comandos en la historia de comandos.
2.4 Gestión del histórico de comandos
El BASH (y otros shells también) mantiene una historia de comandos.

El histórico de comandos se guarda en el archivo .bash_history, donde están
guardados todos los comandos escritos.
Al editar el archivo .bash_history se presenta una lista numerada de comandos,
incluidos los introducidos en entradas anteriores al sistema.
El histórico de comandos se accede a través del comando history, y tiene varias

opciones que se pueden cambiar para tener un mejor control del mismo:
Control del tamaño del archivo de histórico: Se cuenta con dos variables de
entorno para ello, HISTSIZE y HISTFILESIZE, que indican el tamaño del archivo.
En el siguiente ejemplo podemos ver el uso de estas variables:
HISTSIZE=1000
HISTFILESIZE=1000
Con esto hacemos que el tamaño máximo del archivo de histórico sea de 1000
comandos o líneas.
Si ponemos el tamaño de la variable HISTSIZE a cero hacemos que no se guarde

nada en el histórico:
export HISTSIZE=0
Control de duplicados en el histórico: En el histórico se van guardando TODOS

los comandos que se van introduciendo, aunque repitamos 20 veces el mismo
comando, este se guardará 20 veces en el histórico.
Es posible utilizar la variable HISTCONTROL para hacer dos cosas: eliminar los
duplicados consecutivos con ignoredups y eliminar los duplicados sean o no
consecutivos con erasedups; tal como se muestra en los siguientes ejemplos:
export HISTCONTROL=ignoredups
o bien
export HISTCONTROL=erasedups
Donde guardar el histórico: por defecto el histórico se guarda en

~/.bash_history pero podemos indicar donde guardarlo con la variable HISTFILE,
tal como se muestra en el siguiente ejemplo:
HISTFILE=~/.agenda
Formatear la salida del histórico: la variable de entorno HISTTIMEFORMAT nos

permite formatear la salida de history, agregando especificaciones de fecha y
hora, por ejemplo:
[alumno@localhost ~]$ export HISTTIMEFORMAT='- %F %T - '
[alumno@localhost ~]$ history
1 - 2009-02-14 00:56:49 - ls /
2 - 2009-02-14 00:56:59 - cd ~
3 - 2009-02-14 00:57:01 – history
Recordar que todas estas variables debemos ponerlas en un archivo donde se

activen al arranque, por ejemplo, podría ser el archivo ~/.bash_profile.
3.- SHELL Scripts
Un SCRIPT o procedimiento SHELL es un archivo con órdenes o comandos BASH

ejecutables. La potencia de los SHELL SCRIPTS reside en la combinación y
utilización de los comandos del sistema sumada a las características incorporadas
al SHELL que se está utilizando.
Un archivo de SHELL SCRIPT es un grupo de comandos, funciones y variables,

reconocidos por LINUX o bien ser parte del juego de instrucciones del SHELL que
se esté utilizando.
Puede ser una línea de comandos que preferimos no escribir o un complejo

programa que puede incluir ciclos, sentencias condicionales, operaciones
matemáticas, operaciones sobre archivos y estructuras de control, entre otros.
Un archivo de SHELL SCRIPT es una forma de agrupar secuencias de comandos
que corren sin tener que ser escritos en el prompt del sistema operativo en uso.
Los archivos de arranque del BASH, como son ~/.bash_profile o ~/.bashrc, son
ejemplos de SCRIPTS.
Hay dos tipos de archivos de SHELL SCRIPTS: los basados en BASH y los
derivados de C. Ambos tipos de SHELL SCRIPT se escriben en un archivo de
texto al que se le otorgan permisos de ejecución. Una vez realizado este proceso
se podrá escribir en la consola o terminal el nombre del archivo y éste se ejecutará
como un comando.
3.1 SHELL SCRIPTS en BASH
En BASH los SHELL SCRIPTS deben comenzar con la siguiente línea:

#!/bin/bash
#Resto del SCRIPT
…..
Luego de esta línea se escribirán los comandos que queremos que ejecute
nuestro SCRIPT.
Los caracteres #! de la primera línea de un SCRIPT, indican al sistema que el

primer argumento que sigue en la línea es el programa a utilizar para ejecutar este
script. En este caso usamos el SHELL /bin/bash. Esto quiere decir que se
invocará al SHELL BASH para interpretar estos comandos y ejecutarlos.
3.2 Variables en BASH
En un SHELL SCRIPT se pueden utilizar variables.

Una variable puede contener un número, un carácter o una cadena de caracteres.
En BASH una variable NO necesita ser declarada. En BASH, por defecto, todas
las variables son tratadas como cadenas de caracteres.
En BASH La asignación de variables se realiza simplemente indicando su nombre,

un signo =, y el valor, tal como en el siguiente ejemplo:
[alumno@localhost ~]$ msg=“Alumno DUOC”
Notar que NO hay espacios antes ni después del = en la asignación en BASH.

En este ejemplo se crea la variable msg que contiene la cadena “Alumno DUOC”.
En el ejemplo anterior son necesarias las " ", pues hay un carácter de espacio
dentro de la cadena.
El valor de una variable se toma anteponiendo un signo $ al nombre, así si

queremos imprimir en pantalla el valor de la variable msg que creamos antes, se
debe escribir:
[alumno@localhost ~]$ echo $msg
Para borrar el contenido de una variable en BASH utilizaremos el comando unset:

Alumno DUOC
[alumno@localhost ~]$ unset msg
[alumno@localhost ~]$
3.3 Variables de Ambiente
Normalmente existen variables ya definidas por el SHELL BASH.

Usualmente se cuenta con un conjunto de variables definidas cuando iniciamos
una sesión de SHELL, algunas definidas por el sistema operativo, otras por las
aplicaciones lanzadas y otras asignadas en nuestro archivo de configuración del
SHELL.
Tabla con variables de ambiente
Existen dos áreas de memoria en los SHELLS para almacenar variables: el área
local de datos y el entorno o ambiente. Podemos visualizar el contenido de ambas
áreas a través del comando set.
[alumno@localhost ~]$ set
BASH=/bin/bash
BASH_VERSINFO=([0]="2" [1]="05a" [2]="0" [3]="1“…
BASH_VERSION='2.05a.0(1)-release'
COLUMNS=95
...
Por defecto, las variables utilizadas en un SHELL son locales, es decir, son
conocidas solo por ese SHELL.
Pero si se abre otro SHELL a partir del que estamos, estos nuevos “SUBSHELLS“
desconocen el valor de las variables que hemos asignado anteriormente. En
cambio, las VARIABLES DE AMBIENTE están disponibles para todos los

“SUBSHELLS“, es decir, los valores de estas variables son conocidos también por
los procesos hijos del SHELL.
La lista de TODAS las VARIABLES DE AMBIENTE y sus valores se puede

obtener por medio del comando env.
Para exportar una variable y lograr así que forme parte del ambiente de procesos
creados por su sesión, se pueden emplear los comandos declare –x o export,
seguidos del nombre de la variable que se desea exportar. Empleando sólo export
o sólo declare -x puede ver los nombres y valores de variables exportables.
Además de las variables de SHELL propias del entorno o ambiente, las definidas
por el usuario y los parámetros posicionales en un SHELL existen otra serie de
variables cuyo nombre está formado por un carácter especial, precedido por el
habitual símbolo $. Estas variables reciben el nombre de VARIABLES
PREDEFINIDAS.
Tabla de variables predefinidas
3.4 Entrada/Salida en BASH
En BASH la entrada/salida puede manejarse a través de los comandos echo y

read.
Con estas órdenes el SCRIPT podrá interactuar con el usuario, recibiendo datos
desde el exterior por medio del teclado (read) y mostrando en pantalla los
resultados (echo).
Por ejemplo, consideremos el siguiente SCRIPT:
#!/bin/bash
clear
echo -e “Ingresar su nombre: \c”
read nombre
echo -e “hola $nombre\n”
Los argumentos “\c” y “\n” son interpretados por la opción -e de echo: “\n”
corresponde a un salto de línea y “\c” suprime el carácter salto de línea.
La orden read permite leer valores desde la entrada estándar y asignarlos a las
variables definidas en el SHELL. La instrucción read también puede leer
simultáneamente varias variables, tal como se muestra en el siguiente ejemplo:
read var1 var2 var3 …
La cadena suministrada por el usuario empieza por el primer carácter tecleado

hasta el salto de línea final. Esta línea se supone dividida en campos por el
separador de campos definido por la VARIABLE DE AMBIENTE IFS (Internal Field
Separator) que de forma predeterminada es una secuencia de espacios y
tabuladores. El primer campo tecleado por el usuario será asignado a var1, el
segundo a var2, etc. Si el número de campos es mayor que el de variables,
entonces la última variable contiene los campos que sobran. Si por el contrario el
número de campos es mayor que el de variables las variables que sobran tendrán
un valor nulo.
3.5 Operaciones con variables en BASH
Ciertos SHELL, entre ellos el BASH, proporcionan algunas facilidades que

pueden ser útiles para ahorrar código en la programación de SCRIPTS de SHELL,
como son la eliminación o extracción de subcadenas desde una variable.
La orden ${variable:inicio:longitud} extrae una subcadena de variable, partiendo

de inicio y de tamaño indicado por longitud. Si se omite longitud toma hasta el fin
de la cadena original.
[alumno@localhost ~]$ A=abcdef
[alumno@localhost ~]$ echo ${A:3:2}
de
[alumno@localhost ~]$ echo ${A:1:4}
bcde
[alumno@localhost ~]$ echo ${A:2}
cdef
La orden ${variable#texto} corta texto de variable si variable comienza por texto.

Si variable no comienza por texto variable se usa inalterada.
[alumno@localhost ~]$ echo ${A#ab}
cdef
[alumno@localhost ~]$ echo ${A#$B}
cdef
[alumno@localhost ~]$ B=abc
[alumno@localhost ~]$ echo ${A#$B}
def
[alumno@localhost ~]$ echo ${A#cd}
abcdef
La orden ${variable%texto} corta texto de variable si variable termina por texto. Si

variable no termina por texto variable se usa inalterada.
[alumno@localhost ~]$ echo ${A%def}

abc
[alumno@localhost ~]$ B=cdef
[alumno@localhost ~]$ echo ${A%$B}
ab
Los comandos ${variable/texto1/texto2} y ${variable//texto1/texto2} sustituyen

texto1 por texto2 en variable. En la primera forma, sólo se reemplaza la primera
aparición. La segunda forma hace que se sustituyan todas las apariciones de
texto1 por texto2.
[alumno@localhost ~]$ echo ${A/abc/x}
xdef
[alumno@localhost ~]$ echo ${A/de/x}
abcxf
3.6 Operaciones aritméticas con BASH
Para realizar operaciones aritméticas en BASH se utiliza el comando expr, cuya

sintaxis es la siguiente:
expr argumento1 operación argumento2
Las operaciones especificadas en el formato anterior pueden ser las habituales +,

-, * y / (división), además de % (módulo o resto de una división entre enteros).
En el siguiente ejemplo se muestra el uso de expr para realizar una suma en la

línea de comandos:
[alumno@localhost ~]$ expr 15 + 10
25
Observar que en la multiplicación se debe anteponer al signo asterisco (*), una

barra invertida (carácter de arranque) para que BASH no realice sustitución de
nombres de archivo, tal como se muestra en el siguiente ejemplo:
[alumno@localhost ~]$ expr 15 \* 10
150
El resultado del comando expr es enviado a la salida estándar (pantalla). Para

hacer que el resultado de una operación aritmética se almacene en una variable
debemos usar una orden de la forma: variable=$(expr arg1 operación arg2).
[alumno@localhost ~]$ resto=$(expr 17 % 2)

[alumno@localhost ~]$ echo $resto
1
Existen varias formas alternativas de realizar OPERACIONES ARITMÉTICAS en

BASH, por ejemplo, considere:
[alumno@localhost ~]$ echo $((1 + 1))
2
[alumno@localhost ~]$ echo $[1+1]
2
[alumno@localhost ~]$ echo $[3/4]
0
El último resultado del ejemplo anterior se debe a que BASH sólo utiliza enteros
en sus respuestas.
Para operaciones con reales se debe usar el programa bc; a modo de ejemplo
considere:
[alumno@localhost ~]$ echo 3/4 | bc -l
0.75
bc se incluye con todas las distribuciones LINUX como estándar, así como en casi
todas las UNIX.
Los resultados de cálculos en algunos formatos propietarios de bc tienen hasta 99
dígitos decimales antes y después del punto decimal. Este límite se ha superado
mucho en GNU bc, en al menos varias decenas de miles!!!.
bc acepta entrada de datos desde archivos y desde la entrada estándar, esto nos
permite dirigir los datos para hacer cálculos muy rápidamente.
Veamos algunos ejemplos de uso de bc:

[alumno@localhost ~]$ echo " 57+43 " | bc
100
[alumno@localhost ~]$ echo " 57*43 " | bc
2451
La variable scale determina el número de dígitos que siguen al punto decimal en

el resultado presentado por bc. Por defecto, el valor de la variable scale es cero,
salvo que usemos la opción -l en cuyo caso por defecto vale 20 posiciones
decimales.
Esto se puede configurar declarando scale antes de hacer los cálculos, tal como
se muestra en el siguiente ejemplo de división:
[alumno@localhost ~]$ echo "scale=25;57/43" | bc
1.3255813953488372093023255
En resumen, bc puede efectuar cálculos estándar en la línea de comandos

incluyendo suma, resta, multiplicación, división, raíz cuadrada, potencias,
conversión de decimal a hexadecimal, decimal a binario, hexadecimal a decimal,
binario a decimal, entre otros.
4.- Control del flujo en BASH
El CONTROL DEL FLUJO es la manera que poseen los lenguajes de

programación de provocar que el flujo de la ejecución avance y se ramifique en
función de los cambios de estado de los datos.
La ramificación, iteración, selección y llamadas a subrutinas son formas de

CONTROL DE FLUJO implementadas en prácticamente todos los lenguajes de
programación.
El BASH de GNU/LINUX soporta dos tipos de sentencias de CONTROL DEL

FLUJO:
 SENTENCIAS CONDICIONALES, como por ejemplo: if-then,if-then-else,
case.
 SENTENCIAS ITERATIVAS, como por ejemplo: while, for, until.
Las SENTENCIAS CONDICIONALES (también llamadas ESTRUCTURAS DE

DECISIÓN) son las que nos permiten decidir por un camino, entre dos ó más
posibles, dada una condición.
Si la condición se evalúa como “verdadera”, se cumplirá el camino inmediato de

secuencias, en caso de ser evaluada la condición como “falsa”, se ejecutará el
bloque de secuencias alternativas.
 If-then, if-then-else – Permiten ejecutar una serie de comandos

dependiendo si una cierta condición se cumple o no.
 Case – Permite ejecutar una o varias listas de comandos dependiendo del
valor de una variable.
Las SENTENCIAS ITERATIVAS (también denominadas ESTRUCTURAS

CICLICAS) se utilizan para ejecutar un bloque de instrucciones un número dado ó
un número de veces hasta que una condición se cumpla.
Llamaremos CICLO (o BUCLE) a todo proceso que se repite un cierto número de

veces dentro de un archivo de SHELL SCRIPT o programa.
 while – Permite ejecutar una serie de comandos mientras que una

determinada condición se cumpla.
 for – Permite ejecutar una serie de comandos un número determinado de
veces.
 until – Permite ejecutar una serie de comandos hasta que una determinada
condición se cumpla.
4.1 “Condiciones” en el control del flujo en BASH
La mayoría de las condiciones utilizadas con estas sentencias son principalmente:

 Comparaciones de cadenas alfanuméricas o numéricas.
 Valores de terminación de comandos.
 Comprobaciones de atributos de archivos.
Tabla comparación de valores numérico

Para realizar comparaciones entre valores o cadenas alfanuméricas test adopta

las siguientes formas:
 test cadena1 operador cadena2
 test operador cadena
Tabla comparación de cadenas alfanuméricas
Tabla comprobación de atributos de archivos
Hay que notar que las condiciones en BASH se pueden comprobar con test, tal
como hemos visto anteriormente, y también usando [ ].
Así, “test condición” será equivalente a [ condición ], por ejemplo:
test –f archivo será equivalente a [ –f archivo ].
4.2 Sentencia condicional IF
La sintaxis de la SENTENCIA CONDICIONAL IF es la siguiente:
if test condición
then
sentencias_1
else
sentencias_2
fi
Si test evalúa la condición como “verdadera” se ejecutan las sentencias del IF, es
decir, el grupo de ordenes sentencias_1. Si test determina que la condición es
“falsa” se ejecutan las sentencias del ELSE, es decir, el grupo de ordenes
sentencias_2; tal como se muestra en la Figura Nº 3.
En una sentencia IF el ELSE es opcional; con esto IF puede adoptar la siguiente

forma:
if test condición
then
sentencias
fi
Figura Nº 3: Sentencia Condicional IF
Veamos algunos ejemplos de uso de la SENTENCIA CONDICIONAL IF:
#!/bin/bash
clear
echo –e “Ingresar un numero: \c”
read num
if test $num –gt 0
then
echo –e “$num es positivo\n”
else
echo –e “$num es negativo\n”
fi
#!/bin/bash
clear
echo –e “Ingresar nombre de archivo: \c”
read arch
if test –f $arch
then
more $arch
else
echo –e “$arch no es archivo regular\n”
fi
4.3 Sentencia condicional CASE
La sintaxis de la SENTENCIA CONDICIONAL CASE es la siguiente:
case $opción in
opc_1) comandos;;
opc_2) comandos;;
…..
*) comandos;;
esac
La SENTENCIA CONDICIONAL CASE evalúa el valor de una variable y ejecuta

varias instrucciones en función de su valor. Es similar a usar varios IF anidados.
Si la variable NO es igual a ninguno de los valores especificados como opciones,

se ejecutan las instrucciones especificadas en el asterisco.
Veamos un ejemplo de uso de la SENTENCIA CONDICIONAL CASE:
#!/bin/bash
clear
echo –e “ingresar un número: \c”
read num
resto=$(expr $num % 2)
case $resto in
0) echo –e “$num es par\n”;;
1) echo –e “$num es impar\n”;;
esac
El final de cada acción a tomar en una opción de la SENTENCIA CONDICIONAL

CASE, o conjunto de órdenes a ejecutar, se indica con un doble punto y coma, ";;".
Esto se hace para evitar que una vez se haya ejecutado un conjunto de órdenes,
se continúe con la ejecución de las órdenes de las siguientes opciones.
En el siguiente ejemplo se comprueba si el archivo ingresado encaja con los

patrones dados en la primera opción del CASE. En el caso de tener extensión .c
se compila a través del programa GCC.
En el caso por defecto, es decir, si no encaja con los patrones de la primera

opción, se da un mensaje informando de tal situación.
#!/bin/bash
clear
echo –e “ingrese nombre archivo: \c”
read arch
case $arch in
*.c) echo compilando $arch
gcc $arch;;
*) echo $arch no es un fichero c;;
esac
El siguiente SCRIPT muestra un menú para ejecutar, mediante un CASE, el

escritorio que queramos.
#!/bin/bash
clear
echo –e “\n\n\t\t\tMENU\n”
echo –e “\t\t1) Iniciar KDE”
echo –e “\t\t2) Iniciar GNOME”
echo –e “\t\t3) Terminar ejecución”
echo –e “\t\tElegir opción [_]\b\b\c”
read opc
case $opc in
1) startx kde;;
2) startx gnome;;
3) exit;;
esac
Notar que la sentencia exit termina la ejecución del SCRIPT.
4.4 Sentencia iterativa WHILE
La sintaxis de la SENTENCIA ITERATIVA WHILE es la siguiente:

while test condición
do
sentencias
done
Las sentencias del WHILE se ejecutarán mientras la condición evaluada con test
se mantenga en “verdadero”; cuando la condición alcance el valor de verdad
“falso” el ciclo WHILE dejará de ejecutarse. Una vez finalizado el ciclo WHILE, el
control de la ejecución del SCRIPT es pasado a la siguiente instrucción después
del bloque del WHILE. Ver Figura Nº 1.
Veamos un ejemplo de uso de WHILE:

#!/bin/bash
echo –e “Ingrese un número: \c”
read num
i=1
sum=0
while test $i –le $num
do
sum=$(expr $sum + $i)
i=$(expr $i + 1)
done
echo –e “La suma de 1 a $num es: $sum\n”
En el ejemplo anterior se obtiene la suma de los números entre 1 y un número

(positivo) leído desde el teclado.
En el siguiente ejemplo, se imprimen en pantalla todos los divisores de un número

(positivo) leído desde teclado:
#!/bin/bash
echo –e “Ingrese un número: \c”
read num
i=1
while test $i –le $num
do
resto=$(expr $num % $i)
if test $resto –eq 0
then
echo –e “$i”
fi
i=$(expr $i + 1)
done
Figura Nº 1: Sentencia iterativa WHILE
En el siguiente SCRIPT de ejemplo utilizaremos la sentencia WHILE para

examinar la variable de ambiente PATH y mostrar los directorios que componen
dicha variable. Aprovecharemos el hecho de que una cadena en un test de
condición evalúa como “verdadero” cuando NO está vacía y evalúa como “falso”
cuando está vacía.
#!/bin/bash
path=$PATH
while [ $path ]
do
echo ${path%%:*}
if [ ${path#*:} = $path ]
then
path=
else
path=${path#*:}
fi
done
En la solución propuesta al ejercicio planteado, la comprobación

[ ${path#*:} = $path ] se hace para que cuando quede un solo directorio sin dos
puntos pongamos la variable path a vacía, ya que el patrón del operador de
búsqueda de patrones no se cumple si la cadena no tiene el símbolo de dos
puntos (:).
Podemos usar el ciclo WHILE para leer todas las líneas de archivo.txt, tal como se
muestra en el siguiente ejemplo:
#!/bin/bash
while read línea
do
echo –e "$línea\n"
done < archivo.txt
Este método de lectura del archivo tiene el inconveniente de eliminar el

formateado de las líneas y especialmente los espacios y tabulaciones.
4.5 Sentencias true y false
Dos órdenes sencillas que pueden ser utilizadas, por ejemplo dentro de los ciclos,
son true y false. Como sus nombres lo indican, true siempre devuelve un valor
cierto (cero), y false siempre devuelve un valor falso (distinto de cero).
La sentencia true usualmente se utiliza junto con WHILE para construir ciclos
infinitos, por ejemplo, en la implementación de un menú de opciones:
#!/bin/bash
clear
while true
do
clear
echo “\t\tMENU PRINCIPAL”
echo “\t\t**********************\n\n”
echo “\t\t1) Ver un archivo”
echo “\t\t2) Listar un directorio”
echo “\t\t5) Listar usuarios activos”
echo “\t\t6) Salir\n\n\n”
echo ““\t\tIngresar Opción: \c”
read opc
done
4.6 Sentencias break y continue
Las sentencias break y continue tiene el mismo comportamiento que sus

respectivas contrapartes en los lenguajes como C y PERL. La ejecución de un
break dentro de un ciclo WHILE o FOR hace que la ejecución de dicho ciclo
finalice. Por otro lado, la ejecución de un continue dentro de un ciclo hace que se
descarte la iteración en curso y el flujo de programa “salte” a la siguiente iteración.
#!/bin/bash
while true
do
clear
echo –e “Número: \c”
read num
if test $num –eq 0
then
break
fi
done
En el ejemplo anterior, se ingresan números (TODOS los que uno quiera, pero no
nulos) hasta cuando se ingresa cero, en ese instante el ciclo infinito termina de
ejecutarse, pues se ejecuta la sentencia break.
Si existen varios ciclos anidados, break terminará la ejecución del último que se
ha abierto. Es posible salir de n niveles de ciclo mediante la instrucción break n.
La instrucción continue reinicia el bucle con la próxima iteración dejando de
ejecutar cualquier orden posterior en la iteración en curso.
4.7 Sentencia iterativa FOR
La sintaxis de la SENTENCIA ITERATIVA FOR es la siguiente:
for variable [ in lista_de_valores ]
do
sentencias
done
En el ciclo FOR, variable va tomando de uno en uno los valores de la

lista_de_valores, el primer valor de la lista será tomado en la primera iteración, el
segundo valor de la lista será tomando en la segunda iteración,…, así
sucesivamente hasta tomar TODOS los valores de la lista. Ver Figura Nº 2.
Notar que en cada iteración se ejecutarán las sentencias que componen el cuerpo
del FOR.
En resumen, el ciclo FOR no se repite un número fijo de veces (comportamiento

por defecto), sino que se repite de acuerdo con la cantidad de palabras o
argumentos que compongan la lista_de_valores especificada en la sentencia.
En el formato anterior, in lista_de_valores es opcional, si se omite, el FOR

recorrerá el contenido de $@.
Veamos un ejemplo sencillo de uso de FOR:
#!/bin/bash
for nombre in María Juan Luis
do
echo –e “Hola $nombre”
done
Aquí, claramente el FOR se ejecutará 3 veces, pues en la lista_de_valores

aparecen 3 nombres.
El delimitador que usa el ciclo FOR para lista_de_valores es el que se especifique

en la variable de ambiente IFS, y por defecto es el “espacio”.
La lista_de_valores del ciclo FOR también puede contener comodines (como por
ejemplo, el “*”). A modo de ejemplo, el siguiente SCRIPT muestra en pantalla la
lista de los archivos del directorio actual:
#!/bin/bash
for archivo in *
do
echo –e $archivo
done
Notar que para recorrer los argumentos recibidos por el SCRIPT, lo adecuado es
utilizar $@ entre comillas, es decir, usar “$@”.
Figura Nº 2: Sentencia iterativa FOR
En el siguiente ejemplo de uso del ciclo FOR, se imprimirá en pantalla la lista de

todos los archivos ejecutables que fueron pasados como parámetros al SCRIPT:
#!/bin/bash
for archivo in “$@”
do
if [ -x $archivo ]; then
echo –e $archivo
fi
done
Mediante el uso de la sentencia seq, podemos hacer que el comportamiento del

ciclo FOR sea más parecido al FOR de C y PERL:
#!/bin/bash
for i in $(seq 1 10)
do
echo –e $i
done
Por último, podemos usar el ciclo FOR para leer todas las líneas de un archivo, tal
como se muestra en el siguiente ejemplo:
#!/bin/bash
oldIFS=$IFS
IFS=$'\n'
for línea in $(cat archivo)
do
echo –e "$línea\n"
done
IFS=$old_IFS
El ciclo FOR asociado a un cambio de IFS, a diferencia del WHILE, permite

conservar la estructura del documento en la salida.
4.8 Sentencia iterativa UNTIL
La sintaxis de la SENTENCIA ITERATIVA UNTIL es la siguiente:
until test condición
do
sentencias
done
El ciclo UNTIL se ejecuta hasta que la evaluación de la condición con test alcance
“verdadero”. Según esto último, UNTIL se puede interpretar como ejecutar varias
veces un comando hasta que tenga éxito.
Veamos un ejemplo sencillo de uso de UNTIL:

#!/bin/bash
num=0
until test $num –gt 0
do
echo –e “Ingresar un número positivo: \n”
read num
done
En este ejemplo, el UNTIL se repetirá hasta que el usuario ingrese un número

positivo.
Veamos otro ejemplo de uso de UNTIL:
#!/bin/bash
cont=10
until test $cont -lt 0
do
cont=$(expr $cont - 1)
echo –e $cont
done
echo –e “Valor final del contador: $cont\n”
4.9 Sentencia SELECT
Otra sentencia bastante útil al momento de definir SCRIPTS de menú y sus

opciones es la sentencia SELECT.
La sintaxis de la sentencia SELECT es la siguiente:

select variable in lista
do
sentencias
done
Mediante SELECT podemos crea menús de selección de manera muy cómoda;

podemos definir un arreglo con todas las opciones y SELECT las mostrará en
pantalla por nosotros.
Veamos un ejemplo de implementación de un SCRIPT de menú y sus opciones
con la sentencia SELECT:
#!/bin/bash
PS3="Ingresar Opción: "
opciones="opción1 opción2 salir"
echo opciones $opciones
select opt in $opciones
do
echo $opt
if test $opt = "salir"
then
exit
fi
done
Notar que en el ejemplo anterior se ha utilizado la sentencia PS3=“Ingresar

Opción: “ para que este “prompt” aparezca una vez se ejecute el SCRIPT. La línea
leída se almacena en la variable REPLY, y obviamente puede ser desplegada
usando echo $REPLY.
Veamos un ejemplo de SCRIPT con SELECT usando estas características:
#!/bin/bash
PS3="Elegir el archivo a proteger: "
Salir="Salir de este programa"
touch "$Salir"
select archivo in *; do
case $archivo in
"$Salir") exit;;
*) echo "$archivo ($REPLY)"
chmod go-rwx "$archivo";;
esac
done
rm –f "$Salir"
5.- Funciones en BASH
Como en prácticamente todos los lenguajes de programación, en el BASH de

GNU/LINUX se pueden utilizar funciones para agrupar trozos de código o rutinas
de una manera más lógica.
5.1 Uso de funciones en SCRIPTS BASH

Esto permitirá organizar un SCRIPT en unidades lógicas de manera que sea más
fácil mantenerlo y programarlo (y entenderlo), sin necesidad de estar repitiendo
múltiples veces una misma porción de código.
El uso de FUNCIONES en BASH, nos va a ayudar en:

 Tareas en las que debamos repetir cierto número de veces lo mismo, sin
necesidad de duplicar líneas.
 Desglosar todo lo que vayamos a hacer, en conjuntos de acciones,
resolviendo cada problema individualmente (programación modular).
Las FUNCIONES, a diferencia de los SCRIPTS, se ejecutan dentro de la memoria

del propio proceso BASH, por lo que resultan más eficientes que ejecutar
SCRIPTS separados, pero tienen el inconveniente de que tienen que estar
siempre cargadas en la memoria del proceso BASH para poder utilizarse.
Actualmente, debido a la gran cantidad de memoria que tienen los computadores,

el tener FUNCIONES cargadas en la memoria de BASH tiene un costo
insignificante.
Las funciones de BASH son una extensión de las funciones que existen desde el
BOURNE SHELL.
Así, en BASH las funciones se pueden definir básicamente de dos maneras:

Al estilo del BOURNE SHELL:
function nombre_de_función(){
comandos_de_la_función
…..
}
O bien, al estilo del C SHELL:
nombre_de_función(){
comandos_de_la_función
…..
NO existe diferencia entre ellos, y se utilizarán indistintamente ambos formatos.
Para ejecutar una FUNCIÓN simplemente basta escribir su nombre seguido de

argumentos, tal como si se tratará de un comando. Los argumentos actúan como
PARÁMETROS DE LA FUNCIÓN. En caso de que sea necesario pasar varios
parámetros a la función, se especificaran uno detrás de otro separados por
espacios.
Veamos el siguiente ejemplo del uso de funciones en BASH:

#!/bin/bash
#función para listar el directorio
function Listar(){
if test –d $1
then
ls –l $1
fi
#PRINCIPAL
clear
echo –e “Ingresar un Directorio: \c”
read dir
Listar $dir #Llamada a la función Listar
Veamos otro ejemplo del uso de funciones:
#!/bin/bash
function Salir(){
exit
function Saludo(){
echo –e “Hola Mundo!!!…\n”
#PRINCIPAL
clear
Saludo #Llamada a la función Saludo
Salir #Llamada a la función Salir
Las funciones en BASH, al igual que un SCRIPT devuelven un valor, el que

podemos establecer con la sentencia exit.
Las funciones en BASH pueden “retornar” un valor por medio de la sentencia

return, que se usa de la misma manera que exit. La sentencia return solo sirve
para retornar enteros entre 0 y 255.
Veamos un ejemplo de FUNCIÓN que retorna un valor:

#!/bin/bash
function suma(){
c=$(expr $1 + $2)
return $c
#PRINCIPAL
suma 100 150
echo –e “suma=$?\n”
Podemos definir funciones en la línea de órdenes, de la siguiente manera:
[alumno@localhost ~]$ function saludo(){
> echo hola
>}
[alumno@localhost ~]$ function salir(){
> exit
>}
[alumno@localhost ~]$ declare –f
declare –f salir
declare –f saludo
Notar que para “entrar” las líneas de la función se debe presionar <CTRL> +
<RETURN>.
Podemos ver que funciones tenemos definidas en una sesión usando el comando
declare –f. El SHELL imprime las funciones, y su definición, ordenadas
alfabéticamente. Si preferimos sólo el nombre de las funciones podemos usar el
comando declare –F. Si una función tiene el mismo nombre que un SCRIPT o
ejecutable, la FUNCIÓN tiene preferencia. Para borrar una FUNCIÓN podemos
usar el comando unset –f nombre_función.
5.2 Los PARÁMETROS POSICIONALES
Los PARÁMETROS POSICIONALES son los encargados de recibir los

argumentos de un SCRIPT y los PARÁMETROS DE UNA FUNCIÓN.
Los nombres de los PARÁMETROS POSICIONALES son 1, 2, 3, etc. por lo que

para acceder a ellos utilizaremos $1, $2, $3, etc. Ver el siguiente ejemplo:
#!/bin/bash
function impParam(){
echo –e “Nombre del SCRIPT : $0”
echo –e “Primer parámetro : $1”
echo –e “Segundo parámetro : $2”
echo –e “TODOS los parámetros : $*”
#PRINCIPAL
clear
impParam hola a todo el mundo
Además, se tiene el PARÁMETRO POSICIONAL 0 que almacena el nombre del

SCRIPT donde se ejecuta.
Los valores de los PARÁMETROS POSICIONALES no es posible modificarlos,

sólo se pueden leer, si se intenta asignarles un valor se produce un error.
5.3 Variables locales y globales
Por defecto, los PARÁMETROS POSICIONALES son locales al SCRIPT o

FUNCIÓN y no se pueden acceder o modificar desde otra FUNCIÓN.
A diferencia de los PARÁMETROS POSICIONALES, el resto de variables que

definimos en un SCRIPT o FUNCIÓN son globales, es decir, una vez definidas en
el SCRIPT son accesibles (y modificables) desde cualquier FUNCIÓN.
#!/bin/bash
#PRINCIPAL
clear
$1=hola 
En el ejemplo anterior la sentencia marcada da el siguiente mensaje de error:
./parametros: line 10: =hola: commnad not found
Las variables por defecto son globales en BASH, por lo que si queremos que una
variable sea local, tenemos que definirla como local dentro de la función:
func(){
var1=2 #Variable global
local var2=23 #define una variable local
El modificador local sólo se puede usar dentro de las funciones, NO en los

SCRIPTS.
Por último, las variables globales también se pueden definir dentro de una
FUNCIÓN.
#!/bin/bash
function f1(){
v1=25
local v2=57
function f2(){
echo –e “v1=$v1”
#PRINCIPAL
f1
f2
5.4 Las variables $*, $@ y $#
La variable $# almacena el número de argumentos o parámetros recibidos por el

SCRIPT o la FUNCIÓN.
El valor almacenado en $# es de tipo cadena de caracteres.
Tanto $* como $@ nos devuelven los argumentos recibidos por el SCRIPT o

FUNCIÓN.
#!/bin/bash
echo –e “Cantidad de parámetros : $#”
}
#PRINCIPAL
clear
5.5 Librería de FUNCIONES
A la hora de programar SCRIPTS de SHELL no es que existan herramientas para

declarar librerías, pero se pueden simular de cierta manera colocando el código de
FUNCIONES en archivos de SCRIPTS separados.
El siguiente ejemplo corresponde a un ejemplo de uso de librerías, usando un

archivo con las funciones que queremos “exportar”:
Se graban en el archivo librería.sh las FUNCIONES que se desean “exportar”.

[alumno@localhost ~]$ vi librería.sh
function saludar(){
echo –e “Hola\n”
function salir(){
exit
Se incluye el archivo librería.sh en el SCRIPT en donde deseemos ocupar las

FUNCIONES “importadas”.
#!/bin/bash
#libreria.sh contiene las funciones a ser utilizadas
source librería.sh
…..
6.- Resumen
 El BASH es un intérprete de comandos o SHELL desarrollado para el

proyecto “GNU operating system” y es el SHELL por defecto en la mayoría
de las distribuciones de GNU/LINUX disponibles en la actualidad.
 El BASH de GNU/LINUX es tanto un intérprete de comandos o SHELL,

como un lenguaje de programación de alto nivel.
 El SHELL reconoce una serie de órdenes o comandos, los interpreta y

lanza los procesos necesarios para su realización.
 Además de BASH, en GNU/LINUX hay varios tipos de SHELLS, entre

estos: ksh o KORN SHELL y el csh o C SHELL.
 Un SCRIPT o procedimiento SHELL es un archivo con órdenes o comandos

BASH ejecutables.
 En un SHELL SCRIPT se pueden utilizar variables, estas NO necesitan ser

declaradas.
 En BASH la E/S puede manejarse a través de los comandos echo y read:

echo permite desplegar o imprimir en pantalla, y read, leer desde teclado.
 Para realizar operaciones aritméticas en BASH se utiliza el comando expr.

Los LINUX actuales ofrecen varias formas de realizar operaciones
aritméticas.
 El BASH de GNU/LINUX soporta dos tipos de sentencias de control del

flujo: SENTENCIAS CONDICIONALES (if, case) y SENTENCIAS
ITERATIVAS (while, for).
 Las SENTENCIAS CONDICIONALES son las que nos permiten decidir por
un camino, entre dos ó más posibles, dada una condición.
 If-then, if-then-else – Permiten ejecutar una serie de comandos

dependiendo si una cierta condición se cumple o no.
 Case – Permite ejecutar una o varias listas de comandos dependiendo del

valor de una variable.
 while – Permite ejecutar una serie de comandos mientras que una

determinada condición se cumpla.
 for – Permite ejecutar una serie de comandos un número determinado de

veces.
 until – Permite ejecutar una serie de comandos hasta que una determinada
condición se cumpla.
 select – Permite crear menús de selección de manera muy rápida y

cómoda.
 Como en prácticamente todos los lenguajes de programación, en el BASH

de GNU/LINUX se pueden utilizar funciones para agrupar trozos de código
o rutinas de una manera más lógica, de manera que sea más fácil
mantenerlo, programarlo y entenderlo, sin necesidad de estar repitiendo
múltiples veces una misma porción de código.
 En BASH las funciones se pueden definir básicamente de dos maneras: al

estilo del BOURNE SHELL o bien al estilo del C SHELL.
 Las funciones en BASH, al igual que un SCRIPT devuelven un valor, el que

podemos establecer con la sentencia exit, y también pueden “retornar” un
valor por medio de la sentencia return, que se usa de la misma manera que
exit.
6.- Bibliografía
[1] Jang, Michael; RHCSA/RHCE Red Hat Linux Certification Study Guide, 6th
Ed.; McGraw-Hill, 2011.
[2] Van Vugt, Sander; Red Hat Enterprise Linux 6 Administration: Real World
Skills for Red Hat Administrators; John Wiley & Sons, 2013.
[3] Ghori, Asghar; Red Hat certified system administrator & Engineer: Training
guide and a quick deskside reference, Exams EX200 & EX300; Endeavor
Technologies Inc.; 1 edition, 2012.
[4] Red Hat Enterprise Linux 6 Essentials; Disponible online en:

http://www.techotopia.com/index.php/Red_Hat_Enterprise_Linux_6_Essenti
als
[5] Mike G Mikkey; BASH Programming – Introduction HOW-TO. Disponible

online en: http://www.linuxdoc.org/HOWTO/Bash-Prog-Intro-HOWTO.html
[6] Garrels, Machtelt; Bash Guide for Begginers. Disponible online en:
http://linux.die.net/Bash-Beginners-Guide/
[7] Hill, Roger; Bash scripting for beginning system administrators. Disponible
online en: http://www.ibm.com/developerworks/aix/library/au-getstartedbash/

Scripts Bash en Rhel

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Scripts Bash en Rhel

Diunggah oleh

Hak Cipta:

Format Tersedia

Vicerrectoría Académica

Dirección de Servicios Académicos

Programación de Scripts BASH en RHEL 6

Programación de Scripts BASH en RHEL 6 ............................................................... 1

1.- ¿Qué es un SHELL? .................................................................................................. 4

1.1 Los SHELLs de LINUX ................................................................................................... 5

2.- ¿Qué es el BASH? ..................................................................................................... 6

2.1 Características de BASH ............................................................................................... 7

2.2 Archivos de arranque del BASH ................................................................................... 7

2.3 Ayudas interactivas de BASH ....................................................................................... 8

2.4 Gestión del histórico de comandos .............................................................................. 8

3.- SHELL Scripts .......................................................................................................... 10

3.1 SHELL SCRIPTS en BASH ......................................................................................... 11

3.2 Variables en BASH ....................................................................................................... 12

3.3 Variables de Ambiente ................................................................................................. 13

3.4 Entrada/Salida en BASH .............................................................................................. 14

3.5 Operaciones con variables en BASH......................................................................... 15

3.6 Operaciones aritméticas con BASH ........................................................................... 17

4.- Control del flujo en BASH ..................................................................................... 20

4.1 “Condiciones” en el control del flujo en BASH.......................................................... 21

4.2 Sentencia condicional IF .............................................................................................. 22

4.3 Sentencia condicional CASE....................................................................................... 25

4.4 Sentencia iterativa WHILE ........................................................................................... 28

4.5 Sentencias true y false ................................................................................................. 32

4.6 Sentencias break y continue ....................................................................................... 33

4.7 Sentencia iterativa FOR ............................................................................................... 34

4.8 Sentencia iterativa UNTIL ............................................................................................ 38

4.9 Sentencia SELECT ....................................................................................................... 39

5.- Funciones en BASH ................................................................................................ 41

5.1 Uso de funciones en SCRIPTS BASH....................................................................... 41

5.2 Los PARÁMETROS POSICIONALES ....................................................................... 46

5.3 Variables locales y globales ........................................................................................ 47

5.4 Las variables $*, $@ y $# ............................................................................................ 49

5.5 Librería de FUNCIONES .............................................................................................. 50

6.- Resumen .................................................................................................................... 51

6.- Bibliografía ................................................................................................................ 54

1.- ¿Qué es un SHELL?

El SHELL es el intérprete de comandos de un sistema UNIX/LINUX.

En la siguiente figura se muestra la típica visión del SHELL en el sistema:

Figura Nº 1: Visión del Shell en el sistema

En definitiva, el SHELL es un programa que nos permite interactuar con el sistema

1.1 Los SHELLs de LINUX

Figura Nº 2: SHELLS de Linux

2.- ¿Qué es el BASH?

El BASH es un intérprete de comandos o SHELL desarrollado para el proyecto

El BASH de GNU/LINUX es tanto un intérprete de comandos o SHELL, como un

El BASH es ampliamente compatible con el BOURNE SHELL sh e incorpora

El BASH está llamado a ser la implementación de la “IEEE POSIX Shell and

2.1 Características de BASH

BASH incluye, entre otras, las siguientes características:

2.2 Archivos de arranque del BASH

Cuando el BASH es invocado de manera interactiva, primero lee y ejecuta

2.3 Ayudas interactivas de BASH

2.4 Gestión del histórico de comandos

El BASH (y otros shells también) mantiene una historia de comandos.

El histórico de comandos se accede a través del comando history, y tiene varias

Si ponemos el tamaño de la variable HISTSIZE a cero hacemos que no se guarde

Control de duplicados en el histórico: En el histórico se van guardando TODOS

Donde guardar el histórico: por defecto el histórico se guarda en

Formatear la salida del histórico: la variable de entorno HISTTIMEFORMAT nos

Recordar que todas estas variables debemos ponerlas en un archivo donde se

3.- SHELL Scripts

Un SCRIPT o procedimiento SHELL es un archivo con órdenes o comandos BASH

Un archivo de SHELL SCRIPT es un grupo de comandos, funciones y variables,