Temporalmente Cerrado


Por causas de fuerza mayor, no he podido seguir escribiendo en este blog durante hace ya algún tiempo. Espero que mis posts puedan serles utiles, ya que es este es el objetivo de esta página: El poder brindar información para quien desee fortalecer su conocimiento. Sin embargo, espero regresar a escribir más mini guías para ustedes pronto ;).

Siempre puedes contactarme por medio de:

LinkedIn: http://www.linkedin.com/profile/view?id=74846985&trk=hb_tab_pro_top

root@Linux:~# shutdown -h now Hasta pronto 

El comando echo.


Versión para imprimir: El comando echo.


El comando interno echo es una de las instrucciones más simples de la shell. Se encarga de repetir o desplegar en la salida estándr cualquier argumento que se le indíque(inclusive comodínes), para posteriormente saltar una línea. Ejemplos: 

usuario@Linux:~$ echo Hola Mundo!

Hola Mundo!

usuario@Linux:~$ echo /etc/sh*

/etc/shadow /etc/shadow- /etc/shells

SEQUENCIAS DE ESCAPE

El comando echo puede interpretar varias secuencias de escape. Para que estas secuencias de escape puedan ser intepretadas, deben ser encerradas entre comillas dobles o simples y el comando deberá utilizar la opción -e, ya que si no el carácter de escape es interpretado por el shell y no por el comando. Lista de sequencias de escape más relevantes: 

Ejemplos:

usuario@Linux:~$ echo -e "Campana el Sistema: \a Ding Dong!"
usuario@Linux:~$ echo -e "Borra Caracteress\b hacia atras"
usuario@Linux:~$ echo -e "Suprime \c Lo siguiente"
usuario@Linux:~$ echo -e "Retorno de carro. \r"
usuario@Linux:~$ echo -e "Este es un\t tabulador"

OPCIONES

-e: Habilita la interpretación de las sequencias de escape.

 usuario@Linux:~$ echo -e "\a \b \r \t \n \c"

-n: Evitar el brinco de línea que posee el comando por defecto.

 usuario@Linux:~$ echo -n "Evita el brinco de Linea"

-E: Explícitamente suprime la interpretación de las sequencias de escape.

 usuario@Linux:~$ echo -E "Evita el uso de \a \b \r \n, etc."

EJERCICIOS

  1. Despliege en pantalla el mensaje “Esta es una nueva linea”
  2. Haga timbrar la campana del sistema.
  3. ¿Qué ocurre cuando se utiliza el parámetro “Mensaje de prueba\b” utilizando las opciones -en?
  4. ¿Qué ocurre cuando se utiliza el parámetro “Mensaje de prueba\b” utilizando solamente la opcion -e?
  5. Imprima tres líneas en blanco en pantalla utilizando sequencias de escape.
  6. ¿Qué ocurre cuando se utiliza el parámetro “Mensaje de prueba\c” utilizando solamente la opcion -e?
  7. ¿Qué ocurre cuando se utiliza el parámetro “Mensaje de prueba\c” utilizando solamente la opcion -en?
  8. Imprima el mensaje “No se generan Lineas Nuevas” Utilizando la opcion -n.
  9. Imprima en pantalla mensaje “No \a \b \n” especificando explícitamente que no se tomarán en cuenta las sequencias de escape.

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 $*?

¿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.

Creador de Linux recibe el “Nobel” de Tecnología.


Los dos científicos galardonados.

El programador finlandés Linus Torvalds, creador del sistema operativo de código abierto Linux, y el médico japonés Shinya Yamanaka recibieron en Helsinki el Premio Millennium de Tecnología, el galardón más importante del mundo en este campo y considerado el “Nobel” de tecnología.

 El presidente de Finlandia, Sauli Niinistö, fue el encargado de hacer entrega del premio a Torvalds y Yamanaka, quienes se repartirán a partes iguales los 1,2 millones de euros (1,5 millones de dólares) del galardón, durante una ceremonia celebrada en la Ópera Nacional de Helsinki.

Torvalds, informático de 42 años, fue distinguido por crear el kernel (núcleo) del sistema operativo de código abierto Linux y por su trabajo en favor del software libre, según la academia.

“La labor de Linus Torvalds ha mantenido la web abierta a la búsqueda del conocimiento y para el beneficio de la humanidad, no simplemente por intereses económicos”, señaló la presidenta de la Academia Finlandesa de Tecnología, Ainomaija Haarla.

Torvalds creó Linux en 1991 cuando era estudiante de la Universidad de Helsinki y lo desarrolló con las aportaciones de miles de internautas voluntarios, hasta convertirse en el exponente más conocido del software libre.

Veinte años después, este informático finlandés sigue supervisando la evolución de Linux desde su casa de Portland (EE.UU.), para garantizar que se mantenga como un sistema operativo libre de código abierto, en contraste con el Windows de Microsoft y el iOS de Apple.

Linus Torvalds recibiendo el galardón.

“El código abierto es muy importante, es como aplicar al software el enfoque científico de construir a partir del trabajo publicado abiertamente por los demás. Y el software es demasiado importante en el mundo moderno como para que no sea desarrollado de esa forma”, declaró Torvalds.

Millones de personas utilizan ordenadores, teléfonos inteligentes y videocámaras digitales equipados con Linux, un sistema operativo que ha servido también para desarrollar el software que emplean gigantes tecnológicos como Google, Amazon y Facebook.

Torvalds compartirá este galardón con el médico japonés Shinya Yamanaka, inventor de un nuevo método para producir en el laboratorio células madre de pluripotencia inducida (iPS, por sus siglas en inglés).

La Pila de Directorios(Directory Stack).


La pila de directorios es una lista que contiene los directorios visitados recientemente. Los comandos pushd y popd implementan esta pila permitiendo que el usuario pueda moverse entre los directorios utilizados recientemente y la shell pueda recordar tales rutas.

El comando pushd añade directorios a la pila y cambia al directorio actual de trabajo por el último directorio añadido a la pila. El comando popd remueve los directorios de la cima de la pila y cambia la ruta actual por el último directorio eliminado.

El comando dirs muestra el contenido de la pila de directorios. El contenido de la pila también puede ser consultado desde la variable de entorno DIRSTACK.

EL COMANDO PUSHD

La instrucción pushd guarda al directorio especificado en la cima de la pila de directorios y lo convierte en el directorio actual de trabajo. De no especificarse algún argumento, el comando intercambiará los dos directorios que se encuentren más arriba en la pila. Ejemplo:

usuario@Linux:~$ pushd /tmp

OPCIONES

+N: Lleva al n-ésimo directorio(contando de izquierda a derecha de la lista impresa por el comando dirs, empezando por 0) a la cima de la pila. Ejemplo:

usuario@Linux:~$ pushd +0 /etc

-N: Lleva al n-ésimo directorio(contando de derecha a izquierda de la lista impresa por el comando dirs, empezando por 0) a la cima de la pila. Ejemplo:

usuario@Linux:~$ pushd -0 /lib

dir: Hace que el directorio especificado se convierta en la cima de la pila y por lo tanto se convierta en el directorio actual de trabajo. Ejemplo:

usuario@Linux:~$ pushd /bin

EL COMANDO POPD

Elimina al directorio que se encuentra en la cima de la pila y convierte al nuevo directorio del tope de la pila en el directorio actual de trabajo.

OPCIONES

+N: Elimina el n-ésimo directorio(contando de izquierda a derecha de la lista de directorios impresa por el comando dirs), comenzando con cero. Ejemplo:

usuario@Linux:~$: popd +1

-N: Elimina el n-ésimo directorio(contando de derecha a izquierda de la lista de directorios impresa por el comando dirs), comenzando con cero. Ejemplo:

usuario@Linux:~$: popd -0

EL COMANDO DIRS

La instrucción dirs, permite visualizar los directorios almacenados actualmente en la pila de directorios. Ejemplo:

usuario@Linux:$~ dirs

OPCIONES

+N: Muestra el n-ésimo directorio(contando de izquierda a derecha de la lista de directorios impresa por el comando dirs), comenzando con cero. Ejemplo:

usuario@Linux:~$ dirs +3

-N: Muestra el n-ésimo directorio(contando de derecha a izquierda de la lista de directorios impresa por el comando dirs), comenzando con cero. Ejemplo:

usuario@Linux:~$ dirs -1

-c: Limpia la pila de directorios. Ejemplo:

usuario@Linux:~$ dirs -c

-v: Muestra los directorios enumerados. Ejemplo:

usuario@Linux:~$ dirs -v

EJERCICIOS

  1. Agregue el directorio /tmp a su pila de directorios. ¿Qué ocurre?
  2. ¿Qué directorios se encuentran en su stack de directorios?
  3. Agregue a los directorios /bin, /lib, /usr y /etc a su pila de directorios.
  4. Muestre su pila de directorios enumerada.
  5. Ejecute al comando pushd sin argumentos. ¿Qué ocurre?
  6. Muestre su pila de directorios para corroborar al ejercicio anterior.
  7. Lleve al directorio que se encuentra más a la izquierda de su pila de directorios a la cima de la pila.
  8. Remueva el directorio que se encuentre en la cima de la pila.
  9. Muestre su pila de directorios para corroborar al ejercicio anterior.
  10. Remueve al directorio que se encuentre más a la derecha en la cima de la pila.
  11. Limpie su pila de directorios.

El comando exit.


Versión para imprimir: 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?