2.1 Lección 2

Certificación:

Linux Essentials

Versión:

1.6

Tema:

2 Encontrando tu camino en el sistema Linux

Objetivo:

2.1 Conceptos básicos de la línea de comandos

Lección:

2 de 2

Introducción

Todas las shells administran información del estado de sus sesiones. La información del tiempo de ejecución(runtime) puede cambiar durante la sesión e influir en el comportamiento del shell. Estos datos también son utilizados por los programas para determinar aspectos de la configuración del sistema. La mayoría de estos datos se almacenan en las denominadas variables, las cuales cubriremos en esta lección.

Variables

Las variables son piezas de almacenamiento de datos, como texto o números; una vez establecidas, se puede acceder al valor asignado. Ellas tienen un nombre que permite acceder a una variable específica, incluso cuando el contenido de la variable cambia. Las variables son una herramienta muy común en la mayoría de los lenguajes de programación.

En la mayoría de las shells de Linux, hay dos tipos de variables:

Variables locales: Estas variables están disponibles solo para el proceso de shell actual. Si crea una variable local y luego inicia otro programa desde la misma shell, la variable ya no estará disponible para ese programa, debido a que no son heredadas por subprocesos. Este tipo de variables se denominan variables locales.
Variables de entorno (Environment): Estas variables están disponibles tanto en una sesión de shell específica como en subprocesos generados a partir de esa misma sesión. Estas variables se pueden usar para pasar datos de configuración a comandos cuando se ejecuten. Debido a que estos programas pueden acceder a estas variables, se denominan variables de entorno. La mayoría de estas variables están en mayúsculas (por ejemplo, PATH, DATE, USER). Algunas variables de entorno proporcionan información como el directorio de inicio del usuario o el tipo de terminal. En ocasiones, el conjunto completo de todas las variables de entorno se conoce como environment.

Estos tipos de variables también se conocen como variables de ámbito (variable scope).

Note

Las variables no son persistentes. Cuando se cierra la shell donde se establecieron, se pierden todas las variables y su contenido. La mayoría de las shells proporcionan archivos de configuración que contienen variables que se establecen cada vez que se inicia una nueva shell. Las variables que deben establecerse permanentemente, deben agregarse a uno de estos archivos de configuración.

Manipulando Variables

Como administrador del sistema, deberá crear, modificar o eliminar variables locales y de entorno.

Trabajando con variables locales

Puede configurar una variable local utilizando el operador = (igual). Está asignación simple creará una variable local:

$ greeting=hello

Note	No agregue ningún espacio antes o después del operador `=`.

Puede mostrar cualquier variable usando el comando echo. El comando generalmente muestra el texto en la sección de argumentos:

$ echo greeting
greeting

Para acceder al valor de la variable, deberá usar $ (signo de dólar) antes del nombre de la variable.

$ echo $greeting
hello

Como puede ver, la variable ha sido creada. Ahora abra otro shell e intente mostrar el contenido de esa variable.

$ echo $greeting

No se muestra nada. Esto significa que las variables siempre existen en una sola shell específica.

Para verificar que la variable es en realidad una variable local, intente generar un nuevo proceso y verifique si este proceso puede acceder a esa variable. Podemos hacerlo iniciando otra shell y dejar que este ejecute el comando echo. Como la nueva shell se ejecuta en un nuevo proceso, no heredará variables locales de su proceso padre:

$ echo $greeting world
hello world
$ bash -c 'echo $greeting world'
world

Note	Como en el ejemplo anterior, asegúrese de usar comillas simples.

Para eliminar una variable, deberá usar el comando unset:

$ echo $greeting
hey
$ unset greeting
$ echo $greeting

Note	`unset` requiere el nombre de la variable como argumento. Por lo tanto, no puede agregar `$` al nombre, ya que pasaría el valor de la variable a `unset` en lugar del nombre de la variable.

Trabajando con variables globales

Para que una variable esté disponible para los subprocesos, tiene que convertir una variable local a una variable de entorno. Esto se hace con el comando export. Cuando se invoca con el nombre de la variable, esta se agrega al entorno de shell:

$ greeting=hello
$ export greeting

Note	Asegúrese de no usar `$` cuando ejecute `export`, ya que lo que se debe pasar es el nombre de la variable y no su contenido.

Una forma más fácil de crear la variable de entorno es combinar ambos métodos anteriores, asignando el valor de la variable en el argumento del comando.

$ export greeting=hey

Verifiquemos nuevamente si la variable es accesible para los subprocesos:

$ export greeting=hey
$ echo $greeting world
hey world
$ bash -c 'echo $greeting world'
hey world

Otra forma de usar variables de entorno es mediante los comandos. Podemos probar esto con la variable de entorno TZ que contiene la zona horaria. El comando date usa esta variable para determinar la hora de la zona horaria que se mostrará:

$ TZ=EST date
Thu 31 Jan 10:07:35 EST 2019
$ TZ=GMT date
Thu 31 Jan 15:07:35 GMT 2019

Puede mostrar todas las variables de entorno utilizando el comando env.

La variable `PATH`

La variable PATH es una de las variables de entorno más importantes en un sistema Linux. Almacena una lista de directorios separados por dos puntos que contienen programas ejecutables elegibles como comandos de la shell de Linux.

$ echo $PATH
/home/user/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

Para agregar un nuevo directorio a la variable deberá usar el signo de dos puntos (:).

$ PATH=$PATH:new_directory

Aquí un ejemplo:

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
$ PATH=$PATH:/home/user/bin
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/home/user/bin

Como puede observar, $PATH se ve como nuevo valor asignado a PATH. Esta variable se resuelve durante la ejecución del comando y se asegura de que se conserve el contenido original de la variable. Por supuesto, en la asignación también puede usar otras variables:

$ mybin=/opt/bin
$ PATH=$PATH:$mybin
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/home/user/bin:/opt/bin

La variable PATH debe manejarse con precaución, ya que es crucial para trabajar en línea de comandos. Consideremos la siguiente variable PATH:

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Para descubrir cómo el shell invoca un comando específico, puede utilizar el comando which con el nombre del comando como argumento. Por ejemplo, podemos tratar de averiguar dónde se almacena nano:

$ which nano
/usr/bin/nano

Como podemos observar, el ejecutable nano se encuentra dentro del directorio /usr/bin. Eliminemos el directorio de la variable y verifiquemos si el comando aún funciona:

$ PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/sbin:/bin:/usr/games
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/sbin:/bin:/usr/games

Busquemos el comando nano nuevamente:

$ which nano
which: no nano in (/usr/local/sbin:/usr/local/bin:/usr/sbin:/sbin:/bin:/usr/games)

Como podemos observar, el comando no se encuentra, por lo tanto, no se ejecuta. El mensaje de error también explica la razón por la cual no se encontró y en qué ubicaciones se buscó.

Volvamos a agregar los directorios e intentemos ejecutar el comando nuevamente.

$ PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
$ which nano
/usr/bin/nano

Ahora nuestro comando funciona de nuevo.

Tip	El orden de los elementos en `PATH` también define el orden de búsqueda. La primera coincidencia encontrada al recorrer el PATH se ejecutará.

Ejercicios guiados

Cree una variable local number.
Cree una variable de entorno ORDER, utilizando uno de los métodos anteriores.
Muestre los nombres de las variables y sus contenidos.
¿Cuáles son los ámbitos de las variables creadas previamente?

Ejercicios exploratorios

Cree una variable local nr_files y asignele el número de líneas encontradas en el archivo /etc/passwd. Sugerencia: mire el comando wc y la sustitución de comandos, tampoco se olvide de las comillas.
Crea una variable de entorno ME. Asigna el valor de la variable USER a la misma.
Agregue el valor de la variable HOME a ME usando el delimitador :. Luego muestre el contenido de la variable ME.
Usando el ejemplo de fecha anterior, cree una variable llamada today y asignele la fecha para una de las zonas horarias.
Cree otra variable llamada today1 y asígnele la fecha del sistema.

Resumen

En esta lección, usted aprendió:

Tipos de variables
Crear variables
Manipular variables

Comandos utilizados en los ejercicios:

env: Muestra las variables de entorno actual.
echo: Salida de texto.
export: Hace que las variables locales estén disponibles para los subprocesos.
unset: Elimina una variable.

Respuestas a los ejercicios guiados

Cree una variable local number.
```
$ number=5
```
Cree una variable de entorno ORDER, utilizando uno de los métodos anteriores.
```
$ export ORDER=desc
```

Muestre los nombres de las variables y sus contenidos.

$ echo number
number
$ echo ORDER
ORDER
$ echo $number
5
$ echo $ORDER
desc

¿Cuáles son los ámbitos de las variables creadas previamente?
- El alcance de la variable number es la subshell actual.
- El alcance de la variable ORDER es el sistema actual.

Respuestas a los ejercicios exploratorios

Cree una variable local nr_files y asignele el número de líneas encontradas en el archivo /etc/passwd. Sugerencia: mire el comando wc y la sustitución de comandos, tampoco se olvide de las comillas.
```
$ nr_files=`wc -l /etc/passwd`
```
Crea una variable de entorno ME. Asigna el valor de la variable USER a la misma.
```
$ export ME=$USER
```
Agregue el valor de la variable HOME a ME usando el delimitador :. Luego muestre el contenido de la variable ME.
```
$ ME=$ME:$HOME
$ echo $ME
user:/home/user
```
Utilizando el ejemplo de la fecha anterior, cree una variable llamada today y asigne la fecha de una de las zonas horarias.

Se utilizan las zonas horarias GMT y EST como ejemplo, pero cualquier selección de zona horaria es válida.
```
$ today=$(TZ=GMT date)
$ echo $today
Thu 31 Jan 15:07:35 GMT 2019
```
or
```
$ today=$(TZ=EST date)
$ echo $today
Thu 31 Jan 10:07:35 EST 2019
```
Cree otra variable llamada today1 y asígnele la fecha del sistema.

Asumiendo que estás en GMT:
```
$ today1=$(date)
$ echo $today1
Thu 31 Jan 10:07:35 EST 2019
```