# Tutorial Bash I


## ¡Hola, internauta! {#hola-internauta}

Hoy te quiero traer una breve introducción a **Bash**, que no solo es un [shell](https://es.wikipedia.org/wiki/Shell_(inform%C3%A1tica)), sino también un lenguaje de scripting (!loco, ¿no?¡). Personalmente, yo siempre me confundo cuando hablo de esto con amistades: suelo pensar en Bash solo como un lenguaje de scripting… pero sí, también es una shell. Así de versátil es el asunto.

Y ahora te preguntarás: ¿por qué dejo enlaces directos a Wikipedia?
La respuesta es simple. En mis inicio en este mundo del la informática y desarrollo de software, aveces perdía horas (¡horas!) leyendo la Wikipedia. Estudiando, curioseando y aprendiendo. Por pura añoranza no quiero perder eso... y tampoco quiero tú lo pierdas. Así que ya sabes: aprende a indagar, a buscar y a leer por gusto.

> La curiosidad no mata al gato, ¡lo vuelve un hacker! 😼
>
> {{< style "text-align: right;" >}}_Raksodiano_{{< /style >}}


## ¿Qué es _Bash_? {#qué-es-bash}

**Bash** es un intérprete de comandos para sistemas **Unix/Linux**, así como un lenguaje de scripting que te permite interactuar con el sistema operativo mediante instrucciones escritas en la terminal, **Bash** fue escrito por [Brian Fox](https://es.wikipedia.org/wiki/Brian_Fox_(programador)) para el sistema operativo [GNU](https://es.wikipedia.org/wiki/Proyecto_GNU), con la intención de reemplazar el clásico shell [Bourne](https://es.wikipedia.org/wiki/Bourne_Shell).

Su nombre es un acrónimo de _Bourne-again shell_, un juego de palabras que hace referencia tanto al shell que reemplaza como a la idea de "renacer" con "Born-again" (un juego de palabras en inglés). Mmmmm sí, hasta los intérpretes de comandos tienen su lado «poético».

**Bash** ha sido utilizado ampliamente como el intérprete predeterminado en la mayoría de las distribuciones GNU/Linux, Además ofrece un montón de funcionalidades útiles, como por ejemplo:

-   Compatible con el shell tradicional [Bourne](https://es.wikipedia.org/wiki/Bourne_Shell) (sh).
-   Posibilidad de ejecutar comandos, escribir scripts, gestionar procesos y personalizar el entorno de trabajo.
-   Características avanzadas como autocompletado, historial de comandos, variables, funciones y control de jobs.


## Entrando en _Bash_ {#entrando-en-bash}

Ahora bien, podemos dar a entender que tenemos dos modos en **Bash**, el modo `interactivo` y el `no interactivo`;


### El modo interactivo {#el-modo-interactivo}

Este es el que usamos cuando ejecutamos comandos manualmente desde la terminal, uno por uno, como buenos artesanos del teclado. Por ejemplo:

```bash
[usuario@localhost ~]$ ls -la
```


### El modo no interactivo {#el-modo-no-interactivo}

Este es el modo donde ejecutamos los scripts, nosotros tuvimos que haber escrito el código para que este se pueda ejecutar solo y sin nuestra intervención (o algo, dependiendo de tú programa 🤪), por ejemplo;

```bash
[usuario@localhost ~]$ ./mi_script_super_elegante.sh
```


## Tus primeros pasitos en _Bash_ {#tus-primeros-pasitos-en-bash}

Vamos a escribir nuestro primer script en **Bash**. Para ello, primero debemos tener a la mano nuestro editor favorito para empezar con la codificación, ese que te hace sentir como un verdadero hacker en la terminal. Ya sea (super) **Emacs**, Micro, mg, Jed, Zilde, Vi, Vim, Nvim, Nano, ed, elvis, micro o cualquier otro editor que te haga sentir en control del universo:

{{< admonition tip "Tip" false >}}
Te recomiendo crear primero el archivo con el nombre que quieras usar y con la extensión *.sh*

Esto es con el propósito siempre pero importante: ayudarte a mantener un entorno de trabajo ordenado desde un principio. Un entorno limpio y organizado no solo mejora tu productividad, sino que también te ahorra dolores de cabeza más adelante, como desorde u pérdida de tiempo innecesaria solo porque no encuentras un archivo.

Ejemplo;

```sh
mkdir Workspace/scripts/bash    # Creamos una carpetita
cd Workspace/scripts/bash       # Nos movemos a la carpetita
touch mi_fantabuloso_script.sh  # Creamos un archivo con un nombre fabuloso
```
{{< /admonition >}}

{{< admonition info "Información" false >}}
¡Fíjate hasta dónde has llegado! Leyendo tips pro, como todo un «juacker»
{{< /admonition >}}

{{< admonition note "Notita" false >}}
Para poder ejecutar ese script vamos a darle permisos de ejecución y ejecutarlo

```sh
chmod +x mi_fantabuloso_script.sh       # Permisito de ejecución
./mi_fantabuloso_script.sh              # Así lo ejecutamos
```
{{< /admonition >}}

Primeramente tenemos que decirle al script el interprete a utilizar para ello comenzamos con el **shebang** ( `#!` ) seguido de la ruta donde se encuentra el interprete;

```bash
#!/bin/bash
```

{{< admonition note "Notita" false >}}
Todos los scripts que crees **deben comenzar** con una línea shebang (`#!`) que especifique el intérprete. Aunque existen alternativas como:

```sh
#!/bin/sh    # Bourne Shell (más limitado)
#!/bin/zsh   # Z Shell (extiende bash)
#!/bin/csh   # C Shell (sintaxis diferente)
```

Algunos tienen compatibilidad entre ellos y otros no (looking at you, **csh** 👀), así que, para evitar un `segmentation fault` mental, nos quedaremos con Bash: porque en este post, o es Bash… o es bash.
{{< /admonition >}}

Ahora solo vamos a dale un saludable `¡Hola mundo!` pero yo soy más original porque vine a brillar 💅;

```bash
#!/bin/bash

echo "¡Aloha Mundirijillo!"

# Output: ¡Aloha Mundirijillo!
```

> Si fuera por mí, les enseñaría el todopoderoso *Emacs* pero mejor lo dejamos para otra entrega. <br>
> Y sí, tú el que estas diciendo que es un sistema operativo... cuidadito, te vigilo de cerca: ¡es un editor! >:V

> Espero que [San Ignucio](https://es.wikipedia.org/wiki/Richard_Stallman#San_Ignucio) se apiade de sus unidades de almacenamiento y no caigan en el mal… con *VIVIVI*.
>
> {{< style "text-align: right;" >}}_Raksodiano_{{< /style >}}


## Subimos el nivel de _Bash_ {#subimos-el-nivel-de-bash}

Siempre he sido de los que piensan de que puedes aprender un lenguaje de programación en pocas horas. Pero ojo: una cosa es aprenderlo y otra es dominarlo.
Así que vamos a tratar de llegar a sus mentes con la finalidad de poder hacer crecerlas y que digan con orgullo; "¡Mi mente es superior a la de los demás!" (Sheldon, si estas leyendo esto... soy tu fan 🫣)

Ahora bien, lo que necesitamos conocer son los conceptos básicos para empezar con buen pie 🦶:


### Comentarios {#comentarios}

Los comentarios son de las cosas más importantes en el mundo del desarrollo.
No se ejecutan cuando el programa corre, ya que el intérprete los ignora por completo (sí, completamente en serio).

Su función es otra: nos permiten dejar anotaciones o documentación dentro del código, lo cual hace mucho más fácil entender qué hace cada parte… especialmente cuando vuelves al script tres meses después sin recordar nada.

Porque claro, como dicen por ahí:

> Antes, San Ignucio y yo sabíamos lo que hacía este código. Ahora, solo San Ignucio lo sabe.

Para dejar comentarios en nuestro código tenemos


#### Una linea {#una-linea}

Basta con colocar una `#` (numeral, almohadilla, hastag, gato... o como le llames)

```bash
# Este es un comentario de una linea que no se va a ejecutar

#!/bin/bash

# Este es un otros comentario de una linea que no se va a ejecutar
echo "¡Aloha Mundirijillo!" # Otro comentario al lado, sí al lado se puede 😺

# Output: ¡Aloha Mundirijillo!
```


#### Multilíneas {#multilíneas}

Esto, más que comentarios... son una aberración a la naturaleza.

```bash
<< COMENTARIO-MULTILINEA
    Pero que ven mis ojos
    qué aberración multilineal es esto
    hola mamá, estoy en un código
COMENTARIO-MULTILINEA

#!/bin/bash

echo "¡Aloha Mundirijillo!"

# Output: ¡Aloha Mundirijillo!
```

Este método no suele usarse mucho, pero para que lo entiendas mejor: es solo un truquito que un loquito se inventó, usando el famoso **HereDoc** (`<<`). El cual es un tipo de redirección que permite pasar múltiples lineas a un comando, pero este puede servir para comentarios ya que no hay comando que reciba las lineas.

Lo que hacemos es usar la sintaxis del **HereDoc** y definimos un delimitador, el nombre queda a tú gusto. En el ejemplo que dejo arriba su nombre es `COMENTARIO-MULTILINEA`, el delimitador siempre debe de ser en mayúsculas y usualmente se usa por estándar el delimitador `EOF`.


### Variables {#variables}

Las variables son meras cajitas 📦 donde tu guardas la información (es la forma más fácil de explicar, no me funen puritas del código :'v soy buena persona, en serio), estas variables pueden almacenar toda la información que puedas necesitar a lo largo del script.

Y para estas cajitas hay algo muy importantemente importante que aclarar:

1.  Los nombres no pueden empezar por caracteres especiales y por números: así que olvida esas variables feas de `1variable` y de `&variable`, estas solo deben de empezar por una **letra**. Solo letras. Fin.

2.  Son "Case Sensitive": ¿No sabes inglés? calmese joven y yo le explico, quiere decir que distinguen entre mayúsculas y minúsculas, así que para **Bash** estas `variablesensual` y `VariableSensual` son totalmente distintas.

Un ejemplo de uso podría ser este;

```bash
#!/bin/bash

# Aquí declaramos una variable y le asignamos el valor "Aloha"
variable_sensual="Aloha"

# Aquí imprimimos la variable sabrosona
echo $variable_sensual

# Output: Aloha
```

Sí pudiste percatarte, para poder hacer uso de la variable, hay que agregarle un `$` delante de la misma para que esta pueda ser usada, pero para una asignación no es necesario, aparte de ello, no puedes darle un espacio entre el signo de asignación, el nombre de la variable y el valor a asignar.
A **Bash** le gusta que todo esté bien juntito, bien pegadito 💞.

{{< admonition note "Notita" false >}}
Puedes colocar siempre los nombres como tu quieras a las variables, siempre y cuando respetes lo que previamente he comentado con respecto a los nombres. Ahora bien, aunque técnicamente puedes llamarla como se te antoje, si quieres volver a entender tu script algún día y no depender solo de **San Ignucio**, ponle nombres claros. No te ahogues en un vaso de agua...

Por eso existen algunos estándares para nombrar variables, y acá te muestro cómo se suelen usar en Bash:

```bash
# 📌 Variables de entorno (por convención en MAYÚSCULAS)
USER_NAME="TuMamaEnTangas"
HOME_DIR="/home/tumamaentangas"

# 🧪 Variable local (snake_case)
file_name="reporte_final_version_final_final.txt"
user_age=69
is_logged_in=true

# 🧩 Variable de configuración (prefijo CFG_)
CFG_THEME_SUCULENTO="dark"
CFG_TIMEOUT_GAME_OVER=30

# 🔁 Variables para iteraciones y scripts (letras o prefijo tmp_)
i=0
tmp_counter=1
line=""

# 📦 Variables especiales del sistema (ya definidas por Bash)
echo "Nombre del tu primer script: $0"
echo "Número de tu primer script verdadero: $#"
echo "Todos los argumentos son permitidos: $@"

# 🧾 Variables posicionales
primerito_arg=$1
segundito_arg=$2

# 🔒 Constantes simuladas (readonly)
readonly APP_VERSION="1.13.69"
readonly MAX_USERS=69

# 🐚 Exportando variables para subprocesos
export DB_USER="admin"
export DB_PASS="secretoSecretito"
```

{{< /admonition >}}

{{< admonition note "Notita" false >}}
Las variables pueden almacenar cualquier tipo de dato, por ello podría ocurrir que agregues algo como no debes, ejemplo;

```bash
# Variable de tipo String (cadena de caracteres)
saludo="hola"
echo $saludo
# Output: hola

# Variable de tipo numerica
saludo=5
echo $saludo
# Output: 5

# Variable de tipo booleana
saludo=true
echo $saludo
# Output: true
```

Aunque en **Bash** es totalmente valido, ya que es de tipado dinámico esto puede llevarte a errores, así que te recomiendo que no lo hagas, y evites hacer ese tipo de cambios dentro de tus variables, ya que puede ocacionarte errores durante la ejecución del script.

{{< /admonition >}}


### Imprimir y guardar información {#imprimir-y-guardar-información}

Ya hemos usado herramientas básicas, pero ahora toca el momento en que puedas meterle... y sacarle... la información a tu script. ¡Vamos al grano!


#### Imprimir información {#imprimir-información}

Ya vimos que podemos mostrar cosas al usuario usando `echo` para mostrar en pantalla, pero vamos a "extendernos" un poquito, porque mostrar información es fundamental:

```bash
#!/bin/bash

# Imprimimos un escrito pequeño
echo "Mostrandosela al usuario (la información, malpensado)"
# Output: Mostrandosela al usuario (la información, malpensado)

# Podemos imprimir variables de entorno como las siguientes (también vale para las locales)
echo "Tu usuario es: $USER"
echo "Directorio actual: $PWD"

# Imprimirmos sin saltan una linea al final
echo -n "Hola, " # con -n le decimos que no haga un salto de linea
echo "¿cómo estás?"
# Output: Hola, ¿cómo estás?

# De esta forma, le damos caracteristicas "espaciales"
# con \n agregamos un salto de linea
# con \t agregamos una tabulación
echo -e "Línea 1\nLínea 2\tTabulación"

# También le podemos poner colorsitos
echo -e "\e[31mTexto en rojo\e[0m"
echo -e "\e[42mFondo verde 420\e[0m"

# Con \ podemos "escapar" y de estar forma mostrar las comillas al imprimir el texto
echo "Texto entre \"comillas\""
```

{{< admonition tip "Tip" false >}}
Siempre que quieras saber más del comando `echo` puedes leer el manual, donde solo tienes que ejecutar el manual de la terminal;

```sh
man echo
```
{{< /admonition >}}


#### Guardar información {#guardar-información}

En **Bash** también puedes interactuar con el usuario y meterle datos al script. Esto te sirve para hacer menús, recibir opciones, parámetros… ¡lo que se te ocurra!

```bash
#!/bin/bash

read variable_sensual

echo $variable_sensual
```

Con el comando `read` le dices a **Bash** que le meta toda la información a la variable. Así de directo.

Lo que hace esto es decirle al script que va a recibir la información y la va a almacenar dentro de la variable.

{{< admonition tip "Tip" false >}}
Siempre que quieras saber más del comando `read` puedes leer el manual, donde solo tienes que ejecutar el manual de la terminal;

```sh
man read
```
{{< /admonition >}}


## echo "Bye bye" {#echo-bye-bye}

Bueno, como palabras finales, quiero dejar en claro que este post está escrito con un tono de humor algo curioso y raro, pero con la alegría genuina de poder enseñarte de una forma más amena. Así fue como yo aprendí.

En la universidad tuve una profesora que nos enseñaba con chistes de doble sentido, y gracias a ella puedo decir que comprendí muchas cosas. A veces, este tipo de contenido puede ser denso y agotador, así que mi intención es ofrecerte un camino más suave, digerible y ¿por qué no? divertido.

Faltan muchas cosas por explicar, y aún estoy pensando cómo transmitir algunas ideas de la mejor manera. Este contenido no está ni cerca de estar completo ni terminado; es más bien un abrebocas de todo lo que **Bash** tiene por ofrecer.

Solo espero que este tipo de contenido te resulte agradable, que lo disfrutes tanto como yo disfruto escribirlo, y que puedas aprender de forma entretenida.
Tal vez no sea la forma más “académica”, pero fue la forma en la que me enseñaron algoritmia… y con la que he estudiado la mayoría de los lenguajes de programación que conozco.

Así que nada… vamos improvisando sobre la marcha.

>🙏 *Pensamiento final*
>
>Que **San Ignucio** te proteja del ~software privativo~, <br>
>que tus scripts corran sin errores, <br>
>y que nunca te falte un buen `man` a tu lado. <br>
>
>**Recuerda**: <br>
>*"Benditos sean los que comparten su `código`,
>porque de ellos será el reino del `software libre`"*
>
>¡Nos leemos pronto, con terminal abierta y corazón libre! 🐧✨