105.1 Lección 2

Certificación:

LPIC-1

Versión:

5.0

Tema:

105 Shells y shell scripting

Objetivo:

105.1 Personalizando y utilizando el entorno de shell

Lección:

2 de 3

Introducción

Piense en una variable como una caja imaginaria en la que coloca temporalmente una información. Al igual que los scripts de inicialización, Bash clasifica las variables como shell/local (las que se ubican sólo dentro de los límites del shell en el que fueron creadas) o entorno/global (las que son heredadas por shells y/o procesos hijos). De hecho, en la lección anterior hemos echado un vistazo a las shell y sus scripts de configuración o inicialización. Ahora es conveniente señalar el poder de estos archivos de inicio, el cual radica en el hecho de que nos permiten utilizar variables — así como alias y funciones — que nos ayudan a crear y personalizar el entorno de shell como queramos.

Variables: Asignación y referencia

Una variable puede definirse como un nombre que contiene un valor.

En Bash, dar un valor a un nombre se llama asignación de variables y es la forma en que creamos o establecemos las variables. Por otro lado, el proceso de acceder al valor contenido en el nombre se llama variable referenciada.

La sintaxis para la asignación de variables es:

<variable_name>=<variable_value>

Por ejemplo:

$ distro=zorinos

La variable distro es igual a zorinos, es decir, hay una porción de memoria que contiene el valor zorinos — con distro siendo el puntero hacia este.

Tenga en cuenta, que no puede haber ningún espacio a ambos lados del signo igual cuando se asigna una variable:

$ distro =zorinos
-bash: distro: command not found
$ distro= zorinos
-bash: zorinos: command not found

A causa de nuestro error, Bash leyó distro y zorinos como órdenes.

Para referenciar una variable (es decir, para comprobar su valor) utilizamos el comando echo que precede al nombre de la variable con un signo $:

$ echo $distro
zorinos

Nombres de variables

Al elegir el nombre de las variables, hay ciertas reglas que debemos tener en cuenta.

El nombre de una variable puede contener letras (a-z,A-Z), números (0-9) y guiones bajos (_):

$ distro=zorinos
$ echo $distro
zorinos
$ DISTRO=zorinos
$ echo $DISTRO
zorinos
$ distro_1=zorinos
$ echo $distro_1
zorinos
$ _distro=zorinos
$ echo $_distro
zorinos

No puede empezar con un numero o Bash se confundira:

$ 1distro=zorinos
-bash: 1distro=zorinos: command not found

No puede contener espacios (ni siquiera usando comillas); por convención, se usan los guiones bajos en su lugar:

$ "my distro"=zorinos
-bash: my: command not found
$ my_distro=zorinos
$ echo $my_distro
zorinos

Valores de las variables

En lo que respecta a la referencia o el valor de las variables, también es importante considerar una serie de reglas.

Las variables pueden contener cualquier carácter alfanumérico (a-z,A-Z,0-9) así como la mayoría de los caracteres (?,!,*,.,/, etc.):

$ distro=zorin12.4?
$ echo $distro
zorin12.4?

Los valores de las variables deben ser encerrados entre comillas si contienen espacios simples:

$ distro=zorin 12.4
-bash: 12.4: command not found
$ distro="zorin 12.4"
$ echo $distro
zorin 12.4
$ distro='zorin 12.4'
$ echo $distro
zorin 12.4

Los valores de las variables también deben ser encerrados entre comillas si contienen caracteres como los utilizados para la redirección (<,>) o el símbolo de "pipe" (|). Lo único que hace el siguiente comando es crear un archivo vacío llamado zorin:

$ distro=>zorin
$ echo $distro

$ ls zorin
zorin

Esto funciona, siempre y cuando usemos las comillas:

$ distro=">zorin"
$ echo $distro
>zorin

Sin embargo, las comillas simples y dobles no siempre son intercambiables. Según lo que hagamos con una variable (asignación o referencia), el uso de una u otra tiene implicaciones y dará resultados diferentes. En el contexto de la asignación de variables, las comillas simples toman todos los caracteres del valor de la variable literalmente, mientras que las comillas dobles permiten la sustitución de la variable:

$ lizard=uromastyx
$ animal='My $lizard'
$ echo $animal
My $lizard
$ animal="My $lizard"
$ echo $animal
My uromastyx

Por otra parte, cuando se hace referencia a una variable cuyo valor incluye algunos espacios iniciales (o adicionales) — a veces combinados con asteriscos — es obligatorio utilizar comillas dobles después del comando echo para evitar la división de campos y la expansión de nombres:

$ lizard="   genus   |   uromastyx"
$ echo $lizard
genus | uromastyx
$ echo "$lizard"
   genus   |   uromastyx

Si la referencia de la variable contiene un signo de exclamación de cierre, éste debe ser el último carácter de la cadena (ya que de lo contrario Bash pensará que nos referimos a un evento histórico):

$ distro=zorin.?/!os
-bash: !os: event not found
$ distro=zorin.?/!
$ echo $distro
zorin.?/!

Cualquier "backslash" debe escapar por otro. Además, si una barra invertida es el último caracter de la cadena (string) y no escapa, Bash interpretará que queremos un salto de línea y nos dará una nueva línea:

$ distro=zorinos\
>
$ distro=zorinos\\
$ echo $distro
zorinos\

En las próximas dos secciones resumiremos las principales diferencias entre las variables locales y de entorno.

Variables locales o de Shell

Las variables locales o de shell existen sólo en el shell en el que se crean. Por convención, las variables locales se escriben en minúsculas.

Con el fin de realizar algunas pruebas, vamos a crear una variable local. Como se ha explicado anteriormente, elegimos un nombre apropiado para la variable y la equiparamos a un valor apropiado. Por ejemplo:

$ reptile=tortoise

Usemos ahora el comando echo para referirnos a nuestra variable y comprobar que todo ha ido como se esperaba:

$ echo $reptile
tortoise

En ciertos escenarios — cuando se escriben los scripts — la inmutabilidad puede ser una característica interesante de las variables. Si queremos que nuestras variables sean inmutables, podemos crearlas en modo sólo lectura (readonly):

$ readonly reptile=tortoise

Otra opción es convertirlas después de haberlas creado:

$ reptile=tortoise
$ readonly reptile

Ahora, si intentamos cambiar el valor de reptile, Bash lo negará:

$ reptile=lizard
-bash: distro: readonly variable

Note	Para listar todas las variables de sólo lectura en nuestra sesión actual, escriba `readonly` o `readonly -p` en la terminal.

Un comando útil cuando se trata de variables locales es set.

set da salida a todas las variables y funciones de shell que se encuentran actualmente asignadas. Dado que pueden ser muchas líneas (¡pruébalo tú mismo!), se recomienda usarlo en combinación con un buscador como less:

$ set | less
BASH=/bin/bash
BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath
BASH_ALIASES=()
BASH_ARGC=()
BASH_ARGV=()
BASH_CMDS=()
BASH_COMPLETION_COMPAT_DIR=/etc/bash_completion.d
BASH_LINENO=()
BASH_SOURCE=()
BASH_VERSINFO=([0]="4" [1]="4" [2]="12" [3]="1" [4]="release" [5]="x86_64-pc-linux-gnu")
BASH_VERSION='4.4.12(1)-release'
(...)

¿Se encuentra nuestra variable reptile?

$ set | grep reptile
reptile=tortoise

¡Sí, ahí está!

Sin embargo, reptile — siendo una variable local — no será heredado por ningún proceso hijo generado desde el shell actual:

$ bash
$ set | grep reptile
$

Y por supuesto, tampoco podemos ejecutar el comando echo para revisar su valor:

$ echo $reptile
$

Note	Al teclear el comando `bash` en la terminal abrimos un nuevo shell (hijo).

Para remover cualquier variable (ya sea local o global), usamos el comando unset:

$ echo $reptile
tortoise
$ unset reptile
$ echo $reptile
$

Note	`unset` debe ser seguido por el nombre de la variable solamente (no precedido por el símbolo `$`).

Variables globales o de entorno

Existen variables globales o de entorno para el shell actual, así como para todos los procesos subsecuentes que se derivan de este. Por convención, las variables de entorno se escriben en mayúsculas:

$ echo $SHELL
/bin/bash

Podemos pasar recursivamente el valor de estas variables a otras variables y el valor de estas últimas se expandirá finalmente a las primeras:

$ my_shell=$SHELL
$ echo $my_shell
/bin/bash
$ your_shell=$my_shell
$ echo $your_shell
/bin/bash
$ our_shell=$your_shell
$ echo $our_shell
/bin/bash

Para que una variable de shell local se convierta en una variable de entorno, se debe utilizar el comando export:

$ export reptile

Con export reptile hemos convertido nuestra variable local en una variable de entorno para que los shells hijos puedan reconocerla y usarla:

$ bash
$ echo $reptile
tortoise

De la misma manera, export puede ser usado para asignar y exportar una variable, todo a la vez:

$ export amphibian=frog

Ahora podemos abrir una nueva instancia de Bash y referirnos con éxito a la nueva variable:

$ bash
$ echo $amphibian
frog

Note	Con `export -n <VARIABLE-NAME>` la variable se convertirá de nuevo en una variable de la shell local.

El comando export también nos dará una lista de todas las variables de entorno existentes o cuando se digita con la opción -p:

$ export
declare -x HOME="/home/user2"
declare -x LANG="en_GB.UTF-8"
declare -x LOGNAME="user2"
(...)
declare -x PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
declare -x PWD="/home/user2"
declare -x SHELL="/bin/bash"
declare -x SHLVL="1"
declare -x SSH_CLIENT="192.168.1.10 49330 22"
declare -x SSH_CONNECTION="192.168.1.10 49330 192.168.1.7 22"
declare -x SSH_TTY="/dev/pts/0"
declare -x TERM="xterm-256color"
declare -x USER="user2"
declare -x XDG_RUNTIME_DIR="/run/user/1001"
declare -x XDG_SESSION_ID="8"
declare -x reptile="tortoise"

Note	El comando `declare -x` es equivalente a `export`.

Dos comandos más que pueden ser usados para imprimir una lista de todas las variables de entorno son env y printenv:

$ env
SSH_CONNECTION=192.168.1.10 48678 192.168.1.7 22
LANG=en_GB.UTF-8
XDG_SESSION_ID=3
USER=user2
PWD=/home/user2
HOME=/home/user2
SSH_CLIENT=192.168.1.10 48678 22
SSH_TTY=/dev/pts/0
MAIL=/var/mail/user2
TERM=xterm-256color
SHELL=/bin/bash
SHLVL=1
LOGNAME=user2
XDG_RUNTIME_DIR=/run/user/1001
PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
_=/usr/bin/env

Además de ser un sinónimo de env, a veces podemos usar printenv de forma similar a como usamos el comando echo para comprobar el valor de una variable:

$ echo $PWD
/home/user2
$ printenv PWD
/home/user2

Sin embargo, con printenv el nombre de la variable no está precedido por $.

Note	`PWD` almacena la ruta del directorio de trabajo actual. Aprenderemos sobre esta y otras variables de entorno más adelante.

Ejecución de un programa en un entorno modificado

El comando env puede ser usado para modificar el entorno del shell en el momento de la ejecución de un programa.

Para iniciar una nueva sesión de Bash con un entorno tan vacío como sea posible — despejando la mayoría de las variables (así como las funciones y alias) — usaremos env con la opción -i:

$ env -i bash

Ahora la mayoría de las variables de nuestro entorno han desaparecido:

$ echo $USER
$

Y sólo quedan unas pocas:

$ env
LS_COLORS=
PWD=/home/user2
SHLVL=1
_=/usr/bin/printenv

También podemos usar env para establecer una variable particular para un programa particular.

En nuestra lección anterior, cuando hablamos de los shells no interactivos sin inicio de sesión, observamos como los scripts no leen ningún archivo de inicio estándar sino que buscan el valor de la variable BASH_ENV y lo usan como su archivo de inicio si existe.

Demostrémos este proceso:

Creamos nuestro propio archivo de inicio llamado .startup_script con el siguiente contenido:
```
CROCODILIAN=caiman
```
Escribimos un script Bash llamado test_env.sh con el siguiente contenido:
```
#!/bin/bash

echo $CROCODILIAN
```
Establecemos el bit ejecutable para nuestro script test_env.sh:
```
$ chmod +x test_env.sh
```
Por último, usamos env para establecer BASH_ENV en startup_script para test_env.sh:
```
$ env BASH_ENV=/home/user2/.startup_script ./test_env.sh
caiman
```
El comando env está implícito incluso si nos deshacemos de este:
```
$ BASH_ENV=/home/user2/.startup_script ./test_env.sh
caiman
```

Note	Si no comprendes la línea `#!/bin/bash` o el comando `chmod +x`, ¡no te asustes! Aprenderemos todo lo necesario acerca de los scripts de shell en futuras lecciones. Por ahora, sólo recuerda que para ejecutar un script desde su propio directorio usamos `./some_script`.

Variables comunes de entorno

Es hora de revisar algunas de las variables de entorno más relevantes que se establecen en los archivos de configuración de Bash.

DISPLAY

En relación con el servidor X, el valor de esta variable se compone normalmente de tres elementos:

El hostname (la ausencia de este significa localhost) donde se ejecuta el servidor X.
Dos puntos como delimitador.
Un número (normalmente es 0 y se refiere a la pantalla de la computadora).
```
$ printenv DISPLAY
:0
```
Un valor vacío para esta variable significa un servidor sin un sistema X WIndow. Un número extra — como en mi.xserver:0:1 — se referiría al número de pantalla (si existe más de uno).

HISTCONTROL

Esta variable controla qué comandos se guardan en HISTFILE (ver abajo). Hay tres valores posibles:

ignorespace

Los comandos que empiecen con un espacio no se guardarán.

ignoredups

Un comando que es el mismo que el anterior no se guardará.

ignoreboth

Los comandos que caen en cualquiera de las dos categorías anteriores no se guardarán.

$ echo $HISTCONTROL
ignoreboth

HISTSIZE

Esto establece el número de comandos que se almacenarán en la memoria mientras dure la sesión de shell.

$ echo $HISTSIZE
1000

HISTFILESIZE

Esto establece el número de comandos que se guardarán en HISTFILE tanto al principio como al final de la sesión:

$ echo $HISTFILESIZE
2000

HISTFILE

El nombre del archivo que almacena todos los comandos a medida que se escriben. Por defecto este archivo se encuentra en ~/.bash_history:

$ echo $HISTFILE
/home/user2/.bash_history

Note	Para ver el contenido de `HISTFILE`, simplemente escribimos `history`. Alternativamente, podemos especificar el número de comandos que queremos ver pasando un argumento (el número de los comandos más recientes) a `history`, ejemplo: `history 3`.

HOME

Esta variable almacena la ruta absoluta del directorio principal del usuario y se establece cuando el usuario se conecta.

Esta parte del código — de ~/.profile — se explica por sí mismo (tiene como origen "$HOME/.bashrc" si existe):

    # include .bashrc if it exists
    if [ -f "$HOME/.bashrc" ]; then
	. "$HOME/.bashrc"
    fi

Note	Si no comprende bien la afirmación `if`, no te preocupes: sólo consulta las lecciones sobre shell scripting.

Recuerda que ~ es equivalente a $HOME:

$ echo ~; echo $HOME
/home/carol
/home/carol

Note	Los comandos pueden ser concatenados con un punto y coma (`;`).

También podemos probar esto con una declaración de if.

$ if [ ~ == "$HOME" ]; then echo "true"; else "false"; fi
true

Note	Recuerde: El signo de igualdad `=` se utiliza para la asignación de variables. Y el signo "==" se usa para probar la igualdad.

HOSTNAME

Variable que almacena nombre del computador en la red:

$ echo $HOSTNAME
debian

HOSTTYPE

Esto almacena la arquitectura de la unidad central de procesamiento (CPU) del computador:

$ echo $HOSTTYPE
x86_64

LANG

Esta variable guarda la información de localización que utiliza el sistema:

$ echo $LANG
en_UK.UTF-8

LD_LIBRARY_PATH

Esta variable consiste en un conjunto de directorios separados por dos puntos donde las bibliotecas compartidas (shared libraries) son compartidas por los programas:

$ echo $LD_LIBRARY_PATH
/usr/local/lib

MAIL

Esta variable almacena el archivo en el que Bash revisa el correo electrónico:

$ echo $MAIL
/var/mail/carol

Otro valor común para esta variable es /var/spool/mail/$USER.

MAILCHECK

Esta variable almacena un valor numérico que indica en segundos la frecuencia con la que Bash comprueba si hay correo nuevo:

$ echo $MAILCHECK
60

PATH

Esta variable de entorno almacena la lista de directorios donde Bash busca los archivos ejecutables cuando se le indica que ejecute cualquier programa. En nuestra máquina de ejemplo, esta variable se establece a través del archivo /etc/profile de todo el sistema:

if [ "`id -u`" -eq 0 ]; then
  PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
else
  PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
fi
export PATH

A través de la declaración if se comprueba la identidad del usuario y — dependiendo del resultado de la prueba (root o de otra manera) — obtendremos un PATH u otro. Finalmente, el PATH elegido se propaga invocando el comando export.

Observe dos cosas con respecto al valor de PATH:

Los nombres de los directorios se escriben usando rutas absolutas.

Los dos puntos se usan como delimitador.

Si quisiéramos incluir la carpeta /usr/local/sbin en el PATH para usuarios habituales, modificaremos la línea para que se vea así:

(...)
else
  PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/local/sbin"
fi
export PATH

Ahora podemos ver cómo cambia el valor de la variable cuando entramos como usuario regular:

# su - carol
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/local/sbin

Note

También podríamos haber añadido /usr/local/sbin al PATH del usuario en la línea de comandos o bien PATH=/usr/local/sbin:$PATH o PATH=$PATH:/usr/local/sbin — el primero hace que /usr/local/sbin sea el primer directorio en el que se busquen archivos ejecutables; el segundo hace que sea el último.

PS1

Esta variable almacena el valor del indicador Bash. En la siguiente parte de código (también de /etc/profile), la sentencia if comprueba la identidad del usuario y en consecuencia brinda un indicador muy discreto ( # para root o $ para usuarios regulares):

if [ "`id -u`" -eq 0 ]; then
  PS1='# '
else
  PS1='$ '
fi

Note	El `id` de `root` es `0`. Conviértete en `root` y compruébalo tú mismo con `id -u`.

Otras variables de aviso incluyen:

PS2: Normalmente se establece en > y se usa como un mensaje de continuidad para comandos largos de varias líneas.
PS3: Usado como el indicador para el comando select.
PS4: Normalmente se establece en + y se usa para la depuración.

SHELL

Esta variable almacena la ruta absoluta del shell actual:

$ echo $SHELL
/bin/bash

USER

Esto almacena el nombre del usuario actual:

$ echo $USER
carol

Ejercicios guiados

Observe la asignación de la variable en la columna “Comando(s)” e indique si la variable resultante es “Local” o “Global”:

Comando(s) Local Global

debian=mother

ubuntu=deb-based

mint=ubuntu-based; export mint

export suse=rpm-based

zorin=ubuntu-based
Estudie el “Comando” y la “Salida” y explica el significado:

Comando Salida Signficado

echo $HISTCONTROL

ignoreboth

echo ~

/home/carol

echo $DISPLAY

reptilium:0:2

echo $MAILCHECK

60

echo $HISTFILE

/home/carol/.bash_history

Las variables están siendo puestas incorrectamente en la columna “Comando erróneo”. Proporcione la información que falta en “Comando correcto” y “Referencia de la variable” para que obtengamos la “Salida esperada”:

Comando erróneo Comando correcto Referencia de la variable Salida esperada

lizard =chameleon

chameleon

cool lizard=chameleon

chameleon

lizard=cha|me|leon

cha|me|leon

lizard=/** chameleon **/

/** chamelon **/

win_path=C:\path\to\dir\

C:\path\to\dir\

Considere el propósito y escriba el comando apropiado:

Propósito Comando

Establecer el lenguaje del actual shell al español UTF-8 (es_ES.UTF-8).

Imprime el nombre del directorio actual.

Referencia a la variable de entorno que almacena la información sobre las conexiones ssh.

Establecer el PATH para incluir /home/carol/scripts como el último directorio para buscar ejecutables.

Establecer el valor de`my_path` en PATH.

Establecer el valor de my_path en el de PATH.

Crear una variable local llamada "mammal" y asígnale el valor gnu:
Usando la sustitución de variables, cree otra variable local llamada var_sub con el valor apropiado para que cuando se haga referencia a través de echo $var_sub obtengamos: The value of mammal is gnu:
Convierte a mammal en una variable de entorno:
Búscalo con set y grep:
Búscalo con env y grep:
Crear, en dos comandos consecutivos, una variable de entorno llamada BIRD cuyo valor es penguin:
Crear en dos comandos consecutivos, una variable de entorno llamada NEW_BIRD cuyo valor es yellow-eyed penguin:
Asumiendo que eres user2, cree una carpeta llamada bin en tu directorio principal:
Escriba el comando para agregar la carpeta ~/bin a su PATH para que sea la primera carpeta en la que bash busque binarios:
Para garantizar que el valor de PATH permanezca inalterado en los reinicios, ¿Qué parte del código — en forma de una declaración if — agregarías en el ~/.profile?

Ejercicios de exploración

let: más que la evaluación de la expresión aritmética::
- Haz una búsqueda en la página web de let y sus implicaciones al establecer las variables y crea una nueva variable local llamada my_val cuyo valor es 10 — como resultado de sumar 5 + 5:
- Ahora crea otra variable llamada your_val, cuyo valor es 5 — como resultado de dividir el valor de my_val entre 2:
¿El resultado de un comando en una variable? Por supuesto, eso es posible; se llama sustitución de comandos. Investiga y estudia la siguiente función llamada music_info:
```
music_info(){
latest_music=`ls -l1t ~/Music | head -n 6`
echo -e "Your latest 5 music files:\n$latest_music"
}
```
El resultado del comando ls -l1t ~/Music | head -n 6 se convierte en el valor de la variable latest_music. Luego, se hace referencia a la variable latest_music en el comando echo (que genera el número total de bytes ocupados por la carpeta Music y los últimos cinco archivos de música almacenados en la carpeta Music — uno por línea).

¿Cuál de los siguientes es un sinónimo válido?
```
latest_music=`ls -l1t ~/Music | head -n 6`
```
Opción A:
```
latest_music=$(ls -l1t ~/Music| head -n 6)
```
Opción B:
```
latest_music="(ls -l1t ~/Music| head -n 6)"
```
Opción C:
```
latest_music=((ls -l1t ~/Music| head -n 6))
```

Resumen

En esta lección aprendimos:

Las variables son una parte muy importante del entorno del shell ya que son utilizadas por el propio shell así como por otros programas.
Como asignar y referenciar las variables.
Las diferencias entre las variables local y globlal (o entorno).
Como hacer variables sólo lectura.
Como convertir una variable local en una variable de entorno con el comando export.
Como listar todas las variables de entorno.
Como ejecutar un programa en un entorno modificado.
Como hacer que las variables sean persistentes con la ayuda de los scripts de inicio.
Algunas variables de entorno comunes: DISPLAY, HISTCONTROL, HISTSIZE, HISTFILESIZE, HISTFILE, HOME, HOSTNAME, HOSTTYPE, LANG, LD_LIBRARY_PATH, MAIL, MAILCHECK, PATH, PS1 (y otras variables), SHELL y USER.
El significado de la tilde (~).
Lo básico de las declaraciones de if.

Comandos usados en esta lección:

echo: Referencia a una variable.
ls: Lista el contenido de un directorio.
readonly: Hacer que las variables sean inmutables. Listar todas las variables de sólo lectura en la sesión actual.
set: Enumera todas las variables y funciones de la sesión actual.
grep: Imprime líneas que coincidan con un patrón.
bash: Crear un nuevo shell.
unset: Remover variables.
export: Convierte una variable local en una variable de entorno. Enumera las variables de entorno
env: Enumera las variables de entorno. Ejecuta un programa en un entorno modificado.
printenv: Enumera las variables de entorno. Refiere a una variable.
chmod: Cambiar permisos de un archivo, por ejemplo hacerlo ejecutable.
history: Enumera los comandos anteriores.
su: Cambia la identificación de usuario o lo convierte en superusuario.
id: Imprime la identificación de usuario.

Respuestas a los ejercicios guiados

Observe la asignación de la variable en la columna “Comando(s)” e indique si la variable resultante es “Local” o “Global”:

Comando(s) Local Global

debian=mother

Si

No

ubuntu=deb-based

Si

No

mint=ubuntu-based; export mint

No

Si

export suse=rpm-based

No

Si

zorin=ubuntu-based

Si

No

Estudie el “Comando” y la “Salida” y explica el significado:

Comando Salida Signficado

echo $HISTCONTROL

ignoreboth

Tanto los comandos duplicados como los que empiezan con un espacio no se guardarán en la historia.

echo ~

/home/carol

El HOME de carol is /home/carol.

echo $DISPLAY

reptilium:0:2

reptilium la máquina tiene un servidor X funcionando y estamos usando la segunda pantalla de la pantalla.

echo $MAILCHECK

60

El correo será revisado cada 60 segundos.

echo $HISTFILE

/home/carol/.bash_history

history se guardará en /home/carol/.bash_history.

Comando erróneo Comando correcto Referencia de la variable Salida esperada

lizard =chameleon

lizard=chameleon

echo $lizard

chameleon

cool lizard=chameleon

cool_lizard=chameleon (Por ejemplo)

echo $cool_lizard

chameleon

lizard=cha|me|leon

lizard="cha|me|leon" o lizard='cha|me|leon'

echo $lizard

cha|me|leon

lizard=/** chameleon **/

lizard="/** chameleon **/" o lizard='/** chameleon **/'

echo "$lizard"

/** chamelon **/

win_path=C:\path\to\dir\

win_path=C:\\path\\to\\dir\\

echo $win_path

C:\path\to\dir\

Considere el propósito y escriba el comando apropiado:

Propósito Comando

Establecer el lenguaje del actual shell al español UTF-8 (es_ES.UTF-8).

LANG=es_ES.UTF-8

Imprime el nombre del directorio actual.

echo $PWD or pwd

Referencia a la variable de entorno que almacena la información sobre las conexiones ssh.

echo $SSH_CONNECTION

Establecer el PATH para incluir /home/carol/scripts como el último directorio para buscar ejecutables.

PATH=$PATH:/home/carol/scripts

Establecer el valor de`my_path` en PATH.

my_path=PATH

Establecer el valor de my_path en el de PATH.

my_path=$PATH

Crear una variable local llamada "mammal" y asígnale el valor gnu:
```
mammal=gnu
```
Usando la sustitución de variables, cree otra variable local llamada var_sub con el valor apropiado para que cuando se haga referencia a través de echo $var_sub obtengamos: The value of mammal is gnu:
```
var_sub="The value of mammal is $mammal"
```
Convierte a mammal en una variable de entorno:
```
export mammal
```
Búscalo con set y grep:
```
set | grep mammal
```
Búscalo con set y grep:
```
env | grep mammal
```
Crear, en dos comandos consecutivos, una variable de entorno llamada BIRD cuyo valor es penguin:
```
BIRD=penguin; export BIRD
```
Crear en dos comandos consecutivos, una variable de entorno llamada NEW_BIRD cuyo valor es yellow-eyed penguin:
```
export NEW_BIRD="yellow-eyed penguin"
```
o
```
export NEW_BIRD='yellow-eyed penguin'
```
Asumiendo que eres user2, cree una carpeta llamada bin en tu directorio principal:
```
mkdir ~/bin
```
o
```
mkdir /home/user2/bin
```
o
```
mkdir $HOME/bin
```
Escriba el comando para agregar la carpeta ~/bin a su PATH para que sea la primera carpeta en la que bash busque binarios:
```
PATH="$HOME/bin:$PATH"
```
PATH=~/bin:$PATH o PATH=/home/user2/bin:$PATH son igualmente válidas.
Para garantizar que el valor de PATH permanezca inalterado en los reinicios, ¿Qué parte del código — en forma de una declaración if — agregarías en el ~/.profile?
```
if [ -d "$HOME/bin" ] ; then
    PATH="$HOME/bin:$PATH"
fi
```

Respuestas a los ejercicios de exploración

let: más que la evaluación de la expresión aritmética:
- Haz una búsqueda en la página web de let y sus implicaciones al establecer las variables y crea una nueva variable local llamada my_val cuyo valor es 10 — como resultado de sumar 5 + 5:
  let "my_val = 5 + 5"
  o
  let 'my_val = 5 + 5'
- Ahora crea otra variable llamada your_val, cuyo valor es 5 — como resultado de dividir el valor de my_val entre 2:
  let "your_val = $my_val / 2"
  o
  let 'your_val = $my_val / 2'
¿El resultado de un comando en una variable? Por supuesto, eso es posible; se llama sustitución de comandos. Investiga y estudia la siguiente función llamada music_info:
```
music_info(){
latest_music=`ls -l1t ~/Music | head -n 6`
echo -e "Your latest 5 music files:\n$latest_music"
}
```
El resultado del comando ls -l1t ~/Music | head -n 6 se convierte en el valor de la variable latest_music. Luego, se hace referencia a la variable latest_music en el comando echo (que genera el número total de bytes ocupados por la carpeta Music y los últimos cinco archivos de música almacenados en la carpeta Music — uno por línea).

¿Cuál de los siguientes es un sinónimo válido?
```
latest_music=`ls -l1t ~/Music | head -n 6`
```
Es la opción A:
```
latest_music=$(ls -l1t ~/Music| head -n 6)
```