Los parámetros posicionales en un Shell Script.


Como ya se ha mencionado en entradas anteriores, las variables del shell son espacios de memoria que poseen nombre y guardan información. Ciertas variables son conocidas como variables de ambiente. Se les conoce así ya que sus valores pueden ser conocidos por los subprocesos del shell.

Las variables internas más importante del sistema son los parámetros posicionales. Estas variables guardan los valores de los argumentos que se envían a los scripts cuando son invocados.

Los parámetros posicionales son nombrados numéricamente a partir de 1 hasta N, donde N es el último argumento enviado al script. También existe el parámetro posicional 0, cuyo valor es el nombre del script invocado( o en defecto, la manera en que se invocó). Por ejemplo, suponga que posee el siguiente script de nombre prueba_posicional y lo invoca de la siguiente manera:

#! /bin/bash

# Script para probar parametros posicionales.El script desplegara los primeros tres parametros enviados por el usuario junto con el nombre del script.

echo "Nombre del script: $0"
echo "Primer argumento: $1"
echo "Segundo argumento: ${2}"
echo "Tercer argumento: ${3}"

usuario@Linux:~$ . prueba_posicional Uno Dos Tres

De la misma forma, existen dos variables especiales las cuales contienen a todos los parámetros posicionales (excepto por el parámetro 0). Por ejemplo, suponga que posee el script prueba_posicional2 y lo ejecuta de la siguiente manera:

#! /bin/bash

# Script para probar las variables especiales. Las variables $* y $@ desplegaran
 la lista de parametros pasados al script.

echo "Nombre del script: $0"
echo Argumentos: $*
echo Argumentos: $@

usuario@Linux:~$ . prueba_posicional2 1 a 3 b 5 c 7 e 9 f

La diferencia entre estas dos variables es poco importante y puede distinguirse cuando estas variables se encuentran entre dobles comillas la variable de IFS(Una variable de entorno que contiene una lista de caracteres para separar campos) está fijada a algún carácter visible.

$* contiene a los parámetros posicionales, comenzando por el uno. Cuando la variable $* se encuentra entre comillas dobles, todos los parámetros son tratados como una sola unidad, esto ya que cada uno de los valores de los parámetros es separado por el primer carácter de la variable especial IFS. Si la variable IFS no está establecida, los parámetros se separan con espacios. Si IFS es nulo, los parámetros se unen sin utilizar ningún tipo de separador.

$@ contiene a los parámetros posicionales, empezando por el uno. Cuando la variable $@ se encuentra entre comillas dobles cada parámetro es tratado como una unidad separada del resto. Por ejemplo, suponga que posee el siguiente script de nombre prueba_posicional3 y lo ejecuta de la siguiente manera:

#! /bin/bash

# Script para probar las variables especiales.

# Prueba utilizando el valor por defecto de variable IFS sin comillas dobles.

echo "Prueba utilizando el valor por defecto de variable IFS sin comillas dobles."
echo "==================================================="
echo "Valor de variables IFS: $IFS"
echo "Nombre del script: $0"
echo Argumentos: $*
echo Argumentos: $@
echo

# Prueba utilizando el valor por defecto variable IFS con comillas dobles.

echo "Prueba utilizando el valor por defecto de variable IFS con comillas dobles."
echo "==================================================="
echo "Valor de variable IFS: $IFS"
echo "Nombre del script: $0"
echo "Argumentos: $*"
echo "Argumentos: $@"
echo

# Prueba utilizando variable IFS sin comillas dobles.

IFS=#

echo "Prueba utilizando variable IFS sin comillas dobles."
echo "==================================================="
echo "Nombre del script: $0"
echo "Valor de variable IFS: $IFS"
echo Argumentos: $*
echo Argumentos: $@
echo

# Prueba utilizando variable IFS con comillas dobles.

IFS=$

echo "Prueba utilizando variable IFS con comillas dobles."
echo "==================================================="
echo "Nombre del script: $0"
echo "Valor de variable IFS: $IFS"
echo "Argumentos: $*"
echo "Argumentos: $@"

usuario@Linux:~$ . prueba_posicional3 1 2 3 4 a b c d

La variable especial # guarda el número de parámetros posicionales enviados al script. Ejemplo, suponga que posee el siguiente script de nombre prueba_posicional4 y lo ejecuta de la siguiente manera:

#! /bin/bash

# Script para probar parametros posicionales

echo "Nombre del script: $0"
echo "Numero de argumentos: $#"
usuario@Linux:~$ . prueba_posicional4 1 2 3 4

 

EJERCICIOS

  1. Cree un Shell Script el cual reciba 5 parámetros y los despliegue en pantalla.
  2. Cree un Shell Script el cual reciba(incluyendo las comillas) los siguientes parámetros:  “Primer Parametro” “Segundo Parametro” “Tercer Parametro”. ¿Qué valor muestra la variable #? ¿Qué se puede inducir de este ejercicio?
  3. Cree un Shell Script el cual reciba(incluyendo las comillas) los siguientes parámetros:  “Scooby Doo” ‘Shaggy’ Vilma Fred . ¿Qué valor muestra la variable #? ¿Qué se puede inducir de este ejercicio?
  4. Cree un Shell Script que despliegue el nombre del mismo.
  5. ¿Qué pasaría si un Shell script recibe 9 parámetros y se intenta imprimir el parámetro 10?
  6. Cree un Shell Script el cual despliegue en pantalla todos los valores de los parámetros enviados utilizando las dos variables especiales mencionadas.
  7. Cree un Shell Script el cual despliegue en pantalla todos los valores de los parámetros enviados,  separados por un guión.
  8. Cree un  Shell Script el cual cree un directorio a partir del primer parámetro recibido.
  9. Cree un  Shell Script el cual despliegue el contenido de un archivo a partir del segundo parámetro recibido.
  10. Realice diferentes pruebas con el script número 3 utilizando diferentes valores para la variable de entorno IFS. ¿ Cómo se comportan las variables $@ y $*?
Anuncios

¿Qué son las funciones?


Se puede decir que una función es un script dentro de otro script; se utilizan para definir y guardar código por nombre en la memoria del shell, para así,  ser invocado y ejecutado posteriormente.

Las funciones mejoran la programabilidad significativamente, por 2 razones principales:

  1. Cuando se invoca una función, esta ya se encuentra definida en memoria, por lo tanto se ejecuta de una manera más rápida.
  2. Las funciones son ideales para organizar a los scripts en pedazos modulares lo que hace que el código sea más fácil de desarrollar y mantener.

Se puede definir una función utilizando dos formatos:

1. Utilizando el estilo Bourne Shell. Ejemplo:

#####################################################################
#
#   DEFINICION DE FUNCION ESTILO BOURNE SHELL
#
#   function funcion
#   {
#      COMANDO_1
#      COMANDO_2
#      .
#      .
#      .
#      COMANDO_n
#   }
#
#####################################################################
#! /bin/bash

# Funcion que muestra el numero de argumentos que se le envien.

function escribeParametros
{
	# FUNCNAME es una variable de entorno que guarda el nombre de la funcion.
	printf "Hola, estoy en la funcion ${FUNCNAME}\n"

	# Despliega el contenido del archivo /etc/hosts.
	cat /etc/hosts

	# Termina funcion.
	exit 0
}

# Empieza cuerpo principal del script.

# Llamado a funcion.
escribeParametros

# Imprime el valor de terminacion de la funcion.
echo "Valor de terminacion: $?"

2. Utilizando el estilo C Shell. Ejemplo:

#####################################################################
#
#   DEFINICION DE FUNCION ESTILO BOURNE SHELL
#
#   function funcion
#   {
#      COMANDO_1
#      COMANDO_2
#      .
#      .
#      .
#      COMANDO_n
#   }
#
#####################################################################
#! /bin/bash

muestraInformacion()
{
	# Muestra información del usuario que ejecute el script a base de variables de entorno.
	echo "Usuario: $USER"
	printf "Shell: $SHELL \n"
	printf "Directorio Inicial: $HOME \n"
	echo "Host: $HOSTNAME"

	# Termina funcion.
	exit "$?"
}

# Inicia bloque principal del script.

# Llamado a funcion
muestraInformacion

# Imprime el valor de terminacion de la funcion
echo "Valor de terminacion $?"

Cuando se declara una función, el shell guarda su nombre y definición(es decir, los comandos que contiene) en memoria. Si se desea ejecutar la función después, solo hace falta escribir el nombre de la función seguida de sus argumentos, tal como si fuera un script. Ejemplo:

usuario@Linux:~$ escribeParametros "Este es un solo parametro" 

Se pueden visualizar las funciones(tanto como su definición) que se tienen guardadas dentro de una sesión utilizando el comando declare con la opción -f. Ejemplo:

usuario@Linux:~$ declare -f 

Si se requiere obtener solamente el nombre de las funciones, se puede utilizar el comando declare -F. Ejemplo:

usuario@Linux:~$ declare -F

De igual forma, una función también puede borrarse ejecutando el comando unset utilizando la opción -f seguido del nombre de la función. Ejemplo:

usuario@Linux:~$ unset -f escribeParametros

EJERCICIOS

  1. Cree un Shell Script utilizando la sintaxis Bourne Shell el cual contenga una función en la cual se cree el directorio directorioFuncion.
  2. Cree un Shell Script utilizando la sintaxis C Shell el cual contenga una funcion que despliegue en pantalla el contenido del archivo /etc/passwd.
  3. Cree un Shell Script utilizando la sintaxis Bourne Shell  el cual obtenga el nombre y directorio para la ruta estaRutaNoExiste.
  4. Cree un Shell Script utilizando la sintaxis C Shell el cual imprima el directorio actual de trabajo del usuario.
  5. Cree un Shell Script utilizando la sintaxis Bourne Shell  el cual muestre los primeros 76 caracteres del archivo /etc/shells.
  6. Cree un Shell Script utilizando la sintaxis C Shell el cual cambie su dirección actual por el diretorio raíz.
  7. Cree un Shell Script utilizando la sintaxis C Shell el cual visualice la página del manual del comando ls.

El comando exit.


El comando exit finaliza un script. Incluso, puede arrojar un valor de terminación, el cual estará disponible para su proceso padre.

Todo comando posee un estado de terminación(exit status). Un comando que se ejecutó satisfactoriamente arrojará un valor de 0, mientras que un comando que no se procesó de manera correcta, finalizará con un número diferente de 0.

Al igual que un comando, un script posee su propio estado de terminación, el cual será determinado por la última instrucción ejecutada por el script.

Dentro de un script, el comando exit puede arrojar un número dentro de un rango de 0 a 255. Ejemplo:

#! /bin/bash

############################
##
## Cuerpo Del script.
##
############################

COMANDO_1
COMANDO_2
.
.
.
COMANDO_n

exit 206

De no utilizar un parámetro en el comando exit, el script arrojará el valor de terminación de la última instrucción ejecutada. Ejemplo:

#! /bin/bash

############################
##
## Cuerpo Del script.
##
############################

COMANDO_1
COMANDO_2
.
.
.
echo "Terminando Script..."

# El programa finalizara con el estatus arojado por el comando echo

exit

Otra manera por la cual el script puede arrojar el valor de terminación de la última instrucción ejecutada es utilizando el comando exit  anteponiendo como parámetro la variable especial $? . Ejemplo:

#! /bin/bash

############################
##
## Cuerpo Del script.
##
############################

COMANDO_1
COMANDO_2
.
.
.
printf "Terminando Script..."

# El programa terminara con el estatus arojado por el comando printf

exit $? # Utilizacion de la variable $?

Una última forma por la cual el script puede arrojar el estado de terminación de la última sentencia ejecutada es evitando el uso del comando exit. Ejemplo:

#! /bin/bash

############################
##
## Cuerpo Del script.
##
############################

COMANDO_1
COMANDO_2
.
.
.
echo -n 'Terminando Script...'

# El programa finalizara con el valor arrojado por el último comando ejecutado.

La variable $? lee el valor de terminación del último comando ejecutado. De igual forma, cuando un script termina de ejecutarse, la variable $? guarda su valor de terminación.

EJERCICIOS

  1. Trate de revisar las páginas del manual para el comando esteComandoNoExiste. ¿Cuál es su valor de terminación?
  2. Utilice el comando pwd sobre su directorio actual. ¿Cuál es su valor de terminación?
  3. Visualice las últimas 5 líneas de /etc/hosts y /etc/archivoInexistente. ¿Cuál es su valor de terminación?
  4. Visualice el contenido del archivo /etc/hosts. ¿Cuál es su valor de terminación?
  5. Cree y ejecute un shell script cuyo valor de terminación sea 213.
  6. Cree y ejecute un shell script cuyo valor de terminación sea 0.
  7. Cree y ejecute shell script cuyo valor de terminación este basado en la instrucción ls -a /tmp. ¿Cuál es su valor de terminación?
  8. Cree y ejecute shell script cuyo valor de terminación este basado en la instrucción head archivoInexistente. ¿Cuál es su valor de terminación?

¿Qué es un Hashbang(#!)?


Un shell script no es más que un conjunto de comandos almacenados dentro de un archivo. Por lo regular, estos archivos sirven para automatizar tareas de uso diario. Ejemplo de un shell script:

#! /bin/bash

while :

do

who

sleep 600; # Parar por 5 minutos.

done

No existe nada inusual en este script, tan son sólo son un conjunto de comandos que podrían haber sido insertados uno a uno dentro de la línea de comandos. La ventaja de colocar comandos dentro del script van más allá de no tener que tipear los comandos una y otra vez. El script se vuelve una herramienta que puede ser modificada y personalizada fácilmente. Ejemplo del shell script mostrado anteriormente un poco más sofisticado:

#! /bin/bash

#Shell Script para mostrar los usuarios conectados al servidor en un intervalo de 5 minutos.

#Variables

SEGUNDOS=600 # Tiempo a esperar para mostrar usuarios.

while :

do

who

sleep $SEGUNDOS

done

Un Hashbang (#!), comunmente llamado She-Bang en la cabecera de un script, le indica al sistema que el fichero contiene un conjunto de comandos los cuales deberán ser ejecutados por el intérprete especificado. El símbolo #!, es lo que se conoce como un numero mágico de 2 bytes, es decir un marcador especial que define un tipo de archivo.

Seguido del Hashbang, se especifica una ruta. Esta es la ruta que apunta al programa que interpretará los comandos del script. Entonces, este intérprete de comandos ejecutará los comandos empezando desde el renglón que le sigue a la línea donde se especificó el hashbang e ignorando comentarios. Ejemplos:

#!/bin/sh
#!/bin/bash
#!/usr/bin/perl
#!/usr/bin/tcl
#!/bin/sed -f
#!/usr/awk -f

Cada una de las cabeceras mencionadas especifican un intérprete de comandos diferentes. Nótese que el hashbang especificado debe ser capaz de ejecutar los comandos contenidos en el script, ya que de otra forma no podrá ejecutar dichos comandos y desplegará el mensaje “Command not found”.

El símbolo #! puede ser omitido si el script consiste solamente de un conjunto de comandos genéricos del sistema y no de un grupo de directivas especificas de un shell en particular.

¿Qué son las variables?


Las variables son la manera en la cual los lenguajes de programación representan información. Una variable no es más que un nombre asignado a una ubicación o grupo de ubicaciones en memoria que guardan algún valor.

La sintáxis para definir una variable es la siguiente:

usuario@Linux:~$ nombreDeVariable=valor

Tal y como se muestra en el ejemplo, no deben existir espacios en ninguno de los dos lados de la igualación. En caso de que el valor para una variable necesite ser constituido por uno o más espacios, este debe estar entrecomillado. Ejemplos:

usuario@Linux:~$ variable2=”Hola Mundo,”
usuario@Linux:~$ variable3=’ ¿como te encuentras hoy?’

Para obtener el valor de una variable, se pueden utilizar los signos $ ó ${}. A este proceso de intercambiar el nombre de una variable por su valor se conoce como sustitución de variables. Ejemplo:

echo $variable2 ${variable3}

Arrojará como resultado:

Hola Mundo, ¿como te encuentras hoy?

La instrucción unset, se utiliza para eliminar el valor de alguna variable. Esto dejará a la variable sin valor alguno, es decir tendrá un valor nulo. Ejemplo:

usuario@Linux:~$ unset variable2

Arrojará como resultado: 


EJERCICIOS

  1. Asigne el valor 3 a la variable raton.
  2. Despliegue el valor de la variable raton en pantalla utilizando los operadores $ y ${}.
  3. Remueva el valor de la variable raton.
  4. Despliegue el valor de la variable raton. ¿Cuál es el resultado?
  5. Despliegue el valor de la variable gato. ¿Qué se puede deducir de este ejercicio?
  6. Asigne el valor de Miau Miau a la variable gato utilizando comillas dobles.
  7. Asigne el valor de Woof Woof a la variable perro utilizando comillas simples.
  8. Despliegue en pantalla el valor de las variables gato y variable perro utilizando los operadores $ y ${}.
  9. Borre los valores de las variables perro y gato.
  10. Intente eliminar el valor de la variable raton de nuevo. ¿Qué se puede deducir de este ejercicio?

¿Qué es un Shell Script?


Un shell script es un archivo que contiene uno más comandos del shell. Se puede crear un script a partir de un editor de textos.

FORMAS DE EJECUCIÓN

Una vez que se ha creado el fichero, existen varias maneras de ejecutarlo. Algunas son:

1. Utilizando la orden “.“. Ejemplo:

usuario@Linux:~$ . nombreDelFichero 

La orden interna “.” lee y ejecuta las órdenes del archivo en el shell actual, tal y como si los comandos fueran ingresados desde el teclado a la terminal. 

2. Ejecución como comando. Ejemplo:

usuario@Linux:~$ nombreDelFichero 

La ejecución de un script como comando se puede lograr siempre y cuando el script se guarde en una carpeta que este definida dentro de la variable de entorno PATH.

Existe una diferencia muy importante entre estas dos maneras de ejecutar un script. Mientras que el utilidad . corre el script como si fuera parte de la sesión actual, la ejecución como comando recorre una serie de pasos. Primero, crea una copia del shell como un subproceso(mejor conocido como subshell). Posteriormente, toma los comandos del script y los ejecuta, para finalmente terminar y pasar de nuevo el control al shell padre.

PERMISOS DE EJECUCIÓN

Antes de que se pueda ejecutar el script, se le deben dar permisos de ejecución. Cabe recordar que existen tres tipos de permiso para todo archivo(lectura, escritura y ejecución) y que estos permisos aplican para tres categorías de usuarios(usuario, grupos y otros) .

Por consiguiente, antes de ejecutar un shell script se le debe dar un permiso de ejecución, la manera mas sencilla de hacer esto es mediante el comando chmod. Ejemplo:

usuario@Linux:~$ chmod +x nombreDeScript

El editor preservará el permiso de ejecución aun y cuando el script sufra cambios. Si no se poseen permisos de ejecución sobre el script, el sistema responderá con alguna salida parecida a esta:

no se puede ejecutar el fichero binario 

¿ Qué son las Shells ?


Podríamos decir que el shell es un material duro que se halla entre el núcleo del sistema y el mundo exterior.

A pesar de que muchas usuarios piensan que un shell es solo un interprete de comandos interactivo, un shell es realmente un lenguaje de programación en el cual cada sentencia corre un comando.

Es un lenguaje fuera de lo común ya que debe satisfacer dos aspectos importantes:

  • Interactividad
  • Programación de la ejecución de un programa.

Estructura de Linux

PEQUEÑA HISTORIA SOBRE LAS SHELLS

Actualmente existen varios tipos de shell, sin embargo, la Bourne Shell fue la primer Shell usada para propósitos generales.

Al principio, era muy limitada, así que solo se usaba como una herramienta para correr otras herramientas. Existían las variables, ciclos, y sentencias condicionales, pero la mayoria del trabajo las realizaban las utilidades externas.

En la actualidad la mayoría de los sistemas Unix y sus derivados, incluyen la Bourne Shell. Y la mayoría de las Shells actuales, son derivadas de esta.

Steve Bourne, creador de la Bourne Shell

Steve Bourne, creador de la Bourne Shell

TIPOS DE SHELL

Al igual que las distribuciones Linux, existen varios tipos de Shells, cada una orientada a satisfacer diferentes necesidades que los diferentes tipos de usuario pudieran tener. Por mencionar algunas:

  • C Shell
  • Korn Shell
  • Bourne Again Shell

LA SHELL ES..

Un programa que actúa como interfaz entre el usuario y el sistema operativo.

Un software que atiende las ordenes tecleadas por el usuario y las traduce a instrucciones en la sintaxis interna del sistema.

Es afortunadamente algo mas que un interprete de comandos. Entre sus funciones destacan:

  • Interpretar y ejecutar ordenes y comandos.
  • Configurar el entorno.
  • Asignar valores a variables
  • Sustituir variables por su valor.
  • Redireccionar entradas y salidas.
  • Generar nombres de Archivo.
  • Encauzar listas de ordenes o tuberías.
  • Es un completo lenguaje-interprete de programación.