Shell Scripting

Conceptos de BASH y Características.

Bash (Bourne-Again Shell) es un intérprete de comandos de Unix. Este lee los comandos
del shell e interactúa con el sistema operativo para ejecutarlos.

En términos básicos, Bash es un intérprete de línea de comandos que generalmente se

ejecuta en una ventana de texto donde el usuario puede interpretar comandos para realizar varias
acciones. La combinación de estos comandos como una serie dentro de un archivo se conoce
como Shell Script. Bash puede leer y ejecutar los comandos desde un Shell Script. (Velazquez,
2023)

Para entender completamente el scripting shell bash, necesitas conocer dos conceptos:
shell y scripting.

Shell es un macroprocesador que utiliza comandos para interactuar con el sistema

operativo. Esto significa que puede recuperar, procesar y almacenar información en un
ordenador.

Por su parte, el scripting es el proceso de compilar comandos del shell en un nuevo

archivo utilizando un editor de texto.

Cuando escribes bash en un editor de texto, estás compilando comandos bash o funciones
bash, los cuales son un conjunto de comandos que pueden ser llamados numerosas veces tan solo
usando el nombre de la función. El texto se guarda entonces como un archivo de script bash
ejecutable con la extensión .sh. (B., 2023)
¿Qué puedo hacer con BASH?
Los scripts Bash pueden ayudarte con tu flujo de trabajo, ya que compilan muchos
comandos largos en un único archivo de script ejecutable.

Por ejemplo, si tienes múltiples comandos que tienes que ejecutar en un intervalo de
tiempo específico, puedes compilar un script bash, en lugar de escribir y ejecutar los comandos
manualmente uno por uno. Sólo tendrás que ejecutar el archivo de script cuando sea necesario.
(B., 2023)

Aquí otras ventajas de utilizar scripts bash:

 Comandos bien estructurados. Estructura los comandos en una secuencia para que
cada vez que ejecutes el script, se ejecute en el orden correcto.
 Automatización de tareas. Automatiza la ejecución de secuencias de comandos en
cualquier momento definido mediante el programador cron basado en el tiempo.
 Transparencia. La gente puede comprobar el contenido de un script ya que está en
un archivo de texto legible. Sin embargo, si ejecutas los comandos utilizando otro
programa escrito en un lenguaje de programación diferente, como C++, tendrás
que acceder al código fuente.
 Transferible. Si transfieres un script a otras distribuciones de Linux, seguirá
funcionando, siempre que los comandos del shell estén disponibles en ese sistema
operativo específico.

Historia y versiones
Bash es un programa shell escrito por Brian Fox como una versión mejorada del
programa ‘sh’ de Bourne Shell. Es un proyecto GNU de código abierto. Fue lanzado en 1989
como una de las distribuciones shell más populares de los sistemas operativos GNU/Linux.
Proporciona mejoras funcionales sobre Bourne Shell tanto para programación como para usos
interactivos. Incluye edición de línea de comandos, combinación de teclas, historial de comandos
con tamaño ilimitado, etc. (Velazquez, 2023)
 Brian Fox fué quien programó las primeras versiones de Bash y continuó actualizándolo
hasta 1993. A principios de 1989, Chet Ramey empezó a ayudar a Brian y fué el responsable de
muchos arreglos en el código y nuevas características.

Chet Ramey es ahora el mantenedor oficial del shell bash sindo la última versión la 2.x.

Diferencia entre Bash y otras shells.

Bash (una abreviatura de "Bourne-again shell") es el shell predeterminado para muchos
sistemas operativos similares a Unix.

Los ejemplos comunes de sistemas operativos similares a Unix incluyen GNU/Linux y

macOS. Aunque existen muchos otros shells para la terminal, uno de los shells más populares es
zsh o el "shell Z". (Frisina, 2023)

Si bien bash y zsh son shells poderosos y comparten muchas características destacadas,
también poseen distinciones por las cuales los usuarios pueden tener diferentes preferencias.

Concepto de Scripting.
Según (Gonzàlez, 2011) un script es un conjunto de órdenes y llamadas a programas que,
junto a una serie de estructuras de control básicas, se utiliza para automatizar tareas en un
sistema operativo, podríamos definirlo también de la siguiente manera un script hace referencia a
una secuencia de comandos o “guion” que indica al ordenador las instrucciones que debe
realizar.

Un lenguaje de scripting es un lenguaje interpretado que se traduce a lenguaje de

máquina solo cuando se ejecuta. A través de un programa, llamado intérprete, los comandos se
traducen e interpretan directamente desde el código fuente y, por lo tanto, no es necesaria la
compilación. Los lenguajes compilados, por el contrario, deben implementarse utilizando un
compilador que traduzca los comandos a lenguaje de máquina antes de que se ejecuten.

Todos los lenguajes de scripting son, por lo tanto, lenguajes de programación, mientras
que lo contrario no es cierto.
 La diferencia entre lo que es un lenguaje de programación y un lenguaje de scripting
radica principalmente en cómo se utilizan. Los primeros son útiles para crear nuevos programas,
mientras que los segundos permiten proporcionar instrucciones a los programas existentes.

- Sintaxis de un script de BASH. – Hola Mundo en BASH.

Variables en BASH.
Las variables de entorno se utilizan para almacenar algunos valores que pueden ser
utilizados por los scripts desde el shell. No estás limitado a las variables de entorno del shell,
puedes crear las tuyas propias.

El shell de bash tiene dos tipos de variables de entorno:

 Variables globales

 Variables locales

La variable local es visible solo en el shell donde definió, mientras que la variable global
es visible para cualquier proceso en ejecución o que se ejecute desde el shell.

Variables globales

El sistema Linux establece algunas variables de entorno globales cuando inicias sesión en
tu sistema y siempre son en LETRAS MAYÚSCULAS para diferenciarlas de las variables de
entorno definidas por el usuario.

Si queremos ver las variables de entorno que estamos usando y que estan cargadas en
nuestra sesión, escribe el comando printenv o env:

~$ printenv

...

USER=JECD

CONDA_EXE=/anaconda2/bin/conda

SSH_AUTH_SOCK=/private/tmp/com.apple.launchd.JeacBiHuQB/
Listeners
 _CE_CONDA= LSCOLORS=ExFxBxDxCxegedabagacad

PATH=/Users/JECD/edirect:/anaconda2/bin:/anaconda2/
condabin:/Users/JECD/.rbenv/shims:/usr/local/kSNP3:/Users/JECD/
Documents/SPAdes-3.13.0
Darwin/bin:/Applications/sratoolkit.2.9.2/bin:/Users/JECD/mview-
1.64/bin:/Users/JECD/Documents/bioinformaticsbinaries:/Users/
JECD/Documents/HTSeq-0.8.0/scripts:/Library/Python/2.7/site-
packages/ete3/tools:/Users/JECD/anaconda_ete/bin:/usr/local/
bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/usr/local/git/
bin:/Users/JECD/Documents/ncbi-blast-2.6.0+/bin

CONDA_PREFIX=/anaconda2

PWD=/Users/JECD/Dropbox/informatica/BASH_scripting/if_loops

XPC_FLAGS=0x0

PS1=(base) \[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\
033[33;1m\]\w\[\033[m\]$

RBENV_SHELL=bash

...

Hay muchas variables de entorno globales, para imprimir solo una de ellas, escribe el
comando echo seguido de $NombreDeVariable. Ej: para imprimir la variable HOME escribe
echo $HOME

~$ echo $HOME

/Users/JECD

Podemos configurar las variables de entorno modificando los archivos de configuración

de la shell. En nuestro caso la shell por defecto que usamos es bash, por lo tanto el fichero de
configuración que debemos usar es: $HOME/.bashrc, en caso de usar
MAC: $HOME/.bash_profile
 Dentro de nuestro .bashrc podemos modificar las variables que se inicializaran en nuestra
shell con nuestro usuarios ademas de almacenar alias, o cambiar la configuración de de aspecto
de la shell entre otros.

Variables locales

En realidad, el sistema Linux también define algunas variables de entorno locales

estándar de forma predeterminada.

Para ver las variables globales y locales del shell que está ejecutando y las que están
disponible para ese shell, escribe el comando set.

Para declarar una variable en Shell escribe el nombreDeLaVariable que desees, seguido
de un signo igual y el valor SIN espacios:

~$ myName='Jesus'

~$ echo $myName

~$ Jesus

Una vez que hayas establecido tu variable local, será visible en el alcance del shell
actualmente en ejecución, esto significa que, si inicias otra ventana del shell, la variable no estará
disponible en esa nueva ventana.

Declarar variables globales

Para declarar una variable de entorno global, debes declarar una variable de entorno local
y luego utilizar el comando export de la siguiente manera directamente en la shell:

~$ myvar='soy una variable global'

~$ echo $myvar

~$ export myvar
 Ahora, mientras tengamos abierta la terminal donde se exportó la variable myvar,
cualquier nueva ventana de terminal que abra tendrá acceso a dicha variable global.

variable global persistente

¿Como podemos entonces generar variables que persistan en el sistema?

Simplemente tendremos que cambiar la sintaxis a la hora de exportar la variable:

~$ export my_var='soy una variable global'

~$ echo $myvar

eliminar variable global

Si queremos eliminar una variable global solo tendremos que utilizar el comando unset:

~$ unset myvar

~$ echo $myvar

Variables de entorno predeterminadas

Como hemos visto anteriormente, el sistema define algunas variables de forma

predeterminada para nosotros, una de esas es la variable PATH, que contiene algunas rutas de
ejecución importantes. Estas rutas son las predeterminadas que utiliza el shell para buscar un
comando cuando se escribe en el terminal.

echémosle un vistazo:

$ echo $PATH

/Users/JECD/edirect:/anaconda2/bin:/anaconda2/condabin:/
Users/JECD/.rbenv/shims:/usr/local/kSNP3:/Users/JECD/Documents/
SPAdes-3.13.0-Darwin/bin:/Applications/sratoolkit.2.9.2/bin:/
Users/JECD/mview
1.64/bin:/Users/JECD/Documents/bioinformaticsbinaries:/Users/JEC
D/Documents/HTSeq-0.8.0/scripts:/Library/Python/2.7/site
packages/ete3/tools:/Users/JECD/anaconda_ete/bin:/usr/local/bin:
/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/usr/local/git/bin:/
Users/JECD/Documents/ncbi-blast-2.6.0+/bin

Asi es un poco engorroso, que tal si aplicamos lo aprendido en los bucles For

$ for line in $(echo $PATH); do echo "$line" ;done

:/Users/JECD/edirect

:/anaconda2/bin

:/anaconda2/condabin

:/Users/JECD/.rbenv/shim

:/usr/local/kSNP3

:/Users/JECD/mview-1.64/bin

:/Users/JECD/Documents/bioinformaticsbinaries

:/Users/JECD/Documents/HTSeq-0.8.0/scripts

:/Library/Python/2.7/site-packages/ete3/tools

:/Users/JECD/anaconda_ete/bin

:/usr/local/bin

:/usr/bin

:/bin

:/usr/sbin

:/sbin
 :/opt/X11/bin

:/usr/local/git/bin

:/Users/JECD/Documents/ncbi-blast-2.6.0+/bin

Como podeis observar hay un total de 8 entradas con los path de programas que puedo
ejecutar directamente en la shell, como blast, kSNP3 o HTSeq.

Modificando la variable de entorno PATH

Si agregas una ruta de carpeta a la variable PATH, el shell buscará en esa carpeta
cualquier ejecutable que se ejecute cuando escribas cualquier comando.

Simplemente agrega la variable de ruta seguida de dos puntos y el nuevo directorio como
se muestra a continuación:

PATH=$PATH:/path/to/directory

aqui un ejemplo

~$ PATH=$PATH:/Users

~$ for line in $(echo $PATH); do echo "$line" ;done

:/Users

:/Users/JECD/edirect

:/anaconda2/bin

:/anaconda2/condabin

:/Users/JECD/.rbenv/shim

:/usr/local/kSNP3

:/Users/JECD/mview-1.64/bin

:/Users/JECD/Documents/bioinformaticsbinaries
 :/Users/JECD/Documents/HTSeq-0.8.0/scripts

:/Library/Python/2.7/site-packages/ete3/tools

...

si queremos que la variable sea persistente tenemos que editar el archivo .bashrc
o .bash_profile en mac y añadirlo de la siguiente manera:

export PATH=$PATH:/path/to/directory

Almacenando comandos en una variable

Para almacenar en una variable la salida (stdout) de un comando en la Shell, podemos

utilizar la sustitución de comandos. Para ello existen dos métodos:

Encapsular el comando dentro de la estructura $(comando) :

~$ mycurrentdir=$(pwd)

~$ echo $mycurrentdir

/Users/JECD

Encapsular con el carácter comilla simple invertida (`):

~$ mycurrentdir=`pwd`

~$ echo $mycurrentdir

/Users/JECD

Depuración.

La depuración es el proceso de encontrar y solucionar errores en el código fuente de

cualquier software. Cuando un software no funciona tal y como se espera, los programadores de
computadoras estudian el código para determinar por qué ocurren algunos errores. Con este
objetivo, los programadores utilizan herramientas de depuración para ejecutar el software en un
entorno controlado, comprobar el código paso a paso y analizar y solucionar el error.

El término “depuración” se remonta a la almirante Grace Hopper, quien trabajó en la

Universidad de Harvard en la década de 1940. Cuando uno de sus colegas encontró una polilla
que impedía el funcionamiento de uno de las computadoras de la universidad, les dijo que
estaban depurando el sistema. Se registró por primera el uso de los términos errores y depuración
por parte de los programadores de computadoras en la década de 1950 y, a principios de la
década de 1960, el término depuración se aceptaba comúnmente en la comunidad de
programación.

Depurar en Bash

Como te indicaba en la introducción es posible depurar en Bash. Para ello, Bash te

proporciona una serie de opciones que te ayudarán a depurar tus scripts.

Para utilizar estas opciones que te ofrece Bash para depurar tus scripts, es necesario
que modifiques la primera línea de tu script, incluyendo una o mas de las opciones que Bash te
ofrece.

La opción de depuración -x

La primera de las opciones que te ofrece Bash para depurar tus scripts es -x. Esta opción
la puedes incluir en la cabecera de tu script de la siguiente forma,

!#/bin/bash -x

También puedes ejecutar los scripts incluyendo la opción -x de la siguiente forma,

bash -x tu_script.sh

O también puedes utilizar la combinación set -x y set +x . De esta forma cuando

utilices la primera instrucción comenzará la depuración y cuando utilices la segunda se detendrá.

Pero ¿que hace la opción -x ? La opción -x lo que hace, básicamente, es imprimir cada
una de las instrucciones que se ejecutan en el script. De esta manera, puedes seguir de forma
sencilla la ejecución de tu script.
 Podemos apreciarlo en un ejemplo, que siempre es mucho mas sencillo de entender. A
este ejemplo le llamaremos ejemplo.sh , y le daremos permisos de ejecución, chmod +x
ejemplo.sh .

#!/bin/bash -x

echo "Esto es un ejemplo donde operamos 2+2=$((2+2))"

Fíjate que en la primera línea he incluido la opción -x . Si ahora ejecutas el script

con ./ejemplo.sh , verás lo siguiente,

+ echo 'Esto es un ejemplo donde operamos 2+2=4'

Esto es un ejemplo donde operamos 2+2=4

Si ejecutamos bash ejemplo.sh , como podemos imaginar, no se realiza la depuración.

Si lo quieremos hacer así tenemos que incluir directamente la opción -x , como se ha indicado
anteriormente, es decir, bash -x ejemplo.sh .

Si apreciamos mejor, antes de ejecutarse la primera línea del script este la imprime. De
esta manera podemos saber exactamente lo que estamos ejecutado. Para distinguirlo incluye
un + al comienzo de la línea.

Hemos modificado ligeramente el ejemplo anterior para que podamos ver el uso de set
-x y set +x . Fíjate,

#!/bin/bash

set -x

operacion=$((2+2))

set +x

echo "Esto es un ejemplo donde operamos 2+2=$operacion"

 Si ahora ejecutamos el script con ./ejemplo.sh podemos ver el siguiente resultado,

+ operacion=4

+ set +x

Esto es un ejemplo donde operamos 2+2=4

¿Te has dado cuenta? Desde el momento que has establecido set -x se imprimen todas
las instrucciones hasta set +x inclusive.

La siguiente de las opciones que tenemos para depurar en Bash es -e . Esta opción lo que
hace es que cuando en nuestro script alguna instrucción de como resultado un valor distinto de
cero detendrá el script, es decir, directamente se saldrá del script sin continuar.

Se trata de una forma bastante sencilla de localizar donde se puede encontrar el error en
el script. Nuevamente mostramos un ejemplo para que podamos ver su utilidad. Primero, lo
haremos sin la opción -e .

#!/bin/bash -x

file=/no/existe

ls $file

echo $file

Si ejecutamos este script como bash -x otro_ejemplo.sh , el resultado es el siguiente,

+ file=/no/existe

+ ls /no/existe

ls: no se puede acceder a '/no/existe': No existe el archivo o el directorio

+ echo /no/existe

/no/existe
 Sin embargo, si ejecutamos el script con bash -xe otro_ejemplo.sh el resultado es
significativamente distinto,

+ file=/no/existe

+ ls /no/existe

ls: no se puede acceder a '/no/existe': No existe el archivo o el directorio

Como podemos apreciar al ejecutar ls $file y no existir el archivo por el que preguntas,
directamente termina la ejecución del script. Ya hemos localizado el error.

Indicarte que puedes utilizar bash -x -e o bash -xe o bash -ex es completamente
indistinto y el funcionamiento resultará ser exactamente igual.

Así como la opción para depurar en Bash -x expande los valores, la opción de
depuración -v imprime cada línea conforme la lee en el script, sin expandirla. Así, si ejecutas el
último de los ejemplos que has visto bash -xv otro_ejemplo.sh, el resultado será el siguiente,

#!/bin/bash -x

file=/no/existe

+ file=/no/existe

ls $file

+ ls /no/existe

ls: no se puede acceder a '/no/existe': No existe el archivo o el directorio

echo $file

+ echo /no/existe

/no/existe

De esta forma podemos ver como escribimos cada una de las líneas del script y
exactamente como es interpretada.
 Generando un número aleatorio y enviándolo a una variable.
Puedes generar un número aleatorio en Bash utilizando el comando `shuf` o `od`
combinado con `/dev/urandom`. Aquí tienes un ejemplo de cómo hacerlo y almacenarlo en una
variable:

```bash
# Generar un número aleatorio entre 1 y 100
numero=$(( (RANDOM % 100) + 1 ))
# Imprimir el número aleatorio
echo "Número aleatorio: $numero"
```
En este ejemplo, `(RANDOM % 100) + 1` genera un número aleatorio entre 1 y 100.
Luego, este número se asigna a la variable `numero`. Puedes ajustar el rango según tus
necesidades.

Si prefieres usar `shuf` o `od` para generar números aleatorios, aquí tienes otro ejemplo:

```bash
# Generar un número aleatorio entre 1 y 100
numero=$(shuf -i 1-100 -n 1)
# Imprimir el número aleatorio
echo "Número aleatorio: $numero"
```
O usando `od`:

```bash
# Generar un número aleatorio entre 1 y 100
numero=$(od -A n -N 2 -t d -An /dev/urandom | tr -d ' ')
# Asegurarse de que el número está dentro del rango deseado
 numero=$(( numero % 100 + 1 ))
# Imprimir el número aleatorio
echo "Número aleatorio: $numero"
```
Cualquiera de estos métodos generará un número aleatorio y lo almacenará en la variable
`numero`.

Comandos básicos de una Shell.

Los comandos básicos de una shell varían según el sistema operativo y la shell específica
que estés utilizando. Sin embargo, aquí hay una lista de algunos comandos básicos que son
comunes en la mayoría de las shells tipo Unix/Linux, como Bash:

1. **cd**: Cambiar el directorio actual.

```bash

cd directorio

```

2. **ls**: Listar archivos y directorios en el directorio actual.

```bash

ls

```

3. **pwd**: Mostrar la ruta del directorio actual.

```bash

pwd
 ```

4. **mkdir**: Crear un nuevo directorio.

```bash

mkdir nombre_directorio

```

5. **rm**: Eliminar archivos o directorios.

```bash

rm archivo

rm -r directorio

```

6. **cp**: Copiar archivos o directorios.

```bash

cp origen destino

```

7. **mv**: Mover o renombrar archivos o directorios.

```bash

mv origen destino

```

8. **cat**: Mostrar el contenido de un archivo.

```bash

cat archivo

```
9. **echo**: Imprimir texto en la pantalla.

```bash

echo "texto"

```

10. **grep**: Buscar texto dentro de archivos.

```bash

grep "texto" archivo

```

11. **chmod**: Cambiar los permisos de un archivo o directorio.

```bash

chmod permisos archivo

```

12. **chown**: Cambiar el propietario y el grupo de un archivo o directorio.

```bash

chown usuario:grupo archivo

```

13. **ps**: Mostrar procesos en ejecución.

```bash

ps

```

14. **kill**: Terminar un proceso.

```bash
 kill PID

```

15. **man**: Mostrar el manual de un comando.

```bash

man comando

```

Estos son solo algunos de los comandos básicos disponibles en una shell. Hay muchos
más comandos y opciones que pueden ser útiles dependiendo de tus necesidades y del entorno en
el que estés trabajando.

Condicionales y ciclos
En el scripting de shell (como en Bash), los condicionales y los bucles son fundamentales
para controlar el flujo de ejecución del programa. Aquí te muestro cómo puedes usar
condicionales y bucles en Bash:

Condicionales:

1. If-else:

```bash
if [ condición ]; then
# Código si la condición es verdadera
else
# Código si la condición es falsa
fi
```
Ejemplo:

```bash
edad=18
if [ "$edad" -ge 18 ]; then
 echo "Eres mayor de edad"
else
echo "Eres menor de edad"
fi
```
2. If-elif-else:

```bash
if [ condición1 ]; then
# Código si la condición1 es verdadera
elif [ condición2 ]; then
# Código si la condición2 es verdadera
else
# Código si todas las condiciones son falsas
fi
```
Bucles:

1. For loop:

```bash
for variable in lista_de_elementos; do
# Código a ejecutar
done
```
Ejemplo:

```bash
for archivo in *.txt; do
echo "Procesando archivo: $archivo"
done
```
2. While loop:

```bash
while [ condición ]; do
# Código a ejecutar mientras la condición sea verdadera
done
```
Ejemplo:

```bash
contador=1
while [ $contador -le 5 ]; do
echo "Contador: $contador"
contador=$((contador+1))
done
```
3. Until loop:

```bash
until [ condición ]; do
# Código a ejecutar mientras la condición sea falsa
done
```
Ejemplo:

```bash
contador=1
until [ $contador -gt 5 ]; do
echo "Contador: $contador"
contador=$((contador+1))
done
```
 Estos son solo algunos ejemplos básicos de cómo usar condicionales y bucles en Bash.
Puedes combinarlos y anidarlos según sea necesario para construir scripts más complejos y
funcionales.

Estructuras de control
En Bash, al igual que en otros lenguajes de programación, las estructuras de control
permiten controlar el flujo de ejecución de un script. Las principales estructuras de control en
Bash son los condicionales (`if-else`), los bucles (`for`, `while`, `until`) y la instrucción `case`.
Aquí tienes una descripción de cada una:

1. Condicionales (if-else):

El condicional `if-else` se usa para tomar decisiones basadas en el resultado de una

condición.

```bash
if [ condición ]; then
# Código a ejecutar si la condición es verdadera
else
# Código a ejecutar si la condición es falsa
fi
```
2. Bucles:

a. For loop:

El bucle `for` se utiliza para iterar sobre una lista de elementos.

```bash
for variable in lista_de_elementos; do
# Código a ejecutar en cada iteración
done
```
 b. While loop:

El bucle `while` se utiliza para ejecutar repetidamente un conjunto de instrucciones

mientras una condición dada sea verdadera.

```bash
while [ condición ]; do
# Código a ejecutar mientras la condición sea verdadera
done
```
c. Until loop:

El bucle `until` es similar al bucle `while`, pero se ejecuta mientras la condición sea falsa.

```bash
until [ condición ]; do
# Código a ejecutar mientras la condición sea falsa
done
```
3. Instrucción case:

La instrucción `case` se utiliza para realizar diferentes acciones dependiendo del valor de
una variable.

```bash
case $variable in
valor1)
# Código a ejecutar si la variable es igual a
valor1
;;
valor2)
# Código a ejecutar si la variable es igual a
valor2
;;
 *)
# Código a ejecutar si la variable no coincide con
ninguno de los valores anteriores
;;
esac
```
Ejemplo combinando varias estructuras de control:

```bash
#!/bin/bash
# Estructura de control combinando condicional y bucle
contador=1
while [ $contador -le 5 ]; do
if [ $contador -eq 3 ]; then
echo "El contador es igual a 3"
else
echo "El contador no es igual a 3"
fi
contador=$((contador+1))
done
```
Estas son las principales estructuras de control en Bash que te permiten escribir scripts
poderosos y flexibles para automatizar tareas en sistemas Unix/Linux.

Operaciones algebraicas
Puedes realizar operaciones algebraicas en Bash utilizando la herramienta `bc`
(calculadora de precisión arbitraria). `bc` es una calculadora de precisión arbitraria que permite
realizar cálculos matemáticos básicos y avanzados en la línea de comandos. Aquí tienes un
ejemplo de cómo realizar operaciones algebraicas básicas en Bash utilizando `bc`:
```bash
#!/bin/bash
# Operaciones algebraicas en Bash utilizando bc

# Suma
echo "Suma:"
echo "5 + 3" | bc

# Resta
echo "Resta:"
echo "8 - 2" | bc

# Multiplicación
echo "Multiplicación:"
echo "4 * 6" | bc

# División
echo "División:"
echo "12 / 4" | bc

# Potencia
echo "Potencia:"
echo "2 ^ 3" | bc

# Raíz cuadrada
echo "Raíz cuadrada:"
echo "sqrt(16)" | bc
 # Operaciones con decimales
echo "Operaciones con decimales:"
echo "scale=2; 5 / 3" | bc
```

Este script realizará varias operaciones algebraicas básicas utilizando `bc`. Puedes
ejecutarlo en la línea de comandos de tu terminal Bash y verás los resultados. Además, puedes
ajustar la precisión decimal con `scale=n` donde `n` es el número de decimales que deseas
mostrar en el resultado.

Argumentos de los scripts

En Bash, puedes pasar argumentos a un script al ejecutarlo desde la línea de comandos.
Estos argumentos pueden ser valores simples o cadenas de texto que el script puede usar durante
su ejecución. Los argumentos se pasan al script como variables especiales llamadas `$1`, `$2`,
`$3`, y así sucesivamente, dependiendo del número de argumentos que se pasen. Aquí tienes un
ejemplo de cómo puedes usar argumentos en un script de Bash:

Supongamos que tienes un script llamado `mi_script.sh`:

```bash
#!/bin/bash

# Este es un ejemplo de cómo usar argumentos en un script

de Bash

# Imprimir el primer argumento

echo "El primer argumento es: $1"
 # Imprimir el segundo argumento
echo "El segundo argumento es: $2"

# Imprimir todos los argumentos

echo "Todos los argumentos son: $@"
```

Luego, puedes ejecutar este script desde la línea de comandos y pasarle argumentos como
sigue:

```bash
./mi_script.sh argumento1 argumento2
```
En este ejemplo:

- `$1` contendrá "argumento1"

- `$2` contendrá "argumento2"
- `$@` contendrá todos los argumentos pasados al script ("argumento1", "argumento2")

Puedes usar `$#` para obtener el número total de argumentos pasados al script. Por
ejemplo:

```bash
echo "Número total de argumentos: $#"
```

Este comando imprimirá el número total de argumentos pasados al script.

Valor de retorno
En Bash, al final de un script o de un comando ejecutado dentro de un script, puedes
especificar un valor de retorno utilizando la palabra clave `return`. El valor de retorno es un
número entero que indica si la ejecución del script o del comando fue exitosa o no. Por
convención, un valor de retorno de `0` indica éxito, mientras que cualquier otro valor distinto de
`0` indica algún tipo de error.

Aquí hay un ejemplo simple de cómo puedes usar `return` en un script de Bash:

```bash
#!/bin/bash

# Este es un ejemplo de cómo usar el valor de retorno en un

script de Bash

# Función que comprueba si un número es par

es_par() {
if (( $1 % 2 == 0 )); then
return 0 # Retorna 0 si el número es par (éxito)
else
return 1 # Retorna 1 si el número no es par
(error)
fi
}

# Llamada a la función y verificación del valor de retorno

numero=10
es_par $numero
if [ $? -eq 0 ]; then
echo "$numero es un número par."
else
echo "$numero no es un número par."
fi
```
En este ejemplo:
 - La función `es_par` verifica si un número pasado como argumento es par o no. Si es
par, retorna `0` indicando éxito, de lo contrario, retorna `1` indicando un error.
- Después de llamar a la función `es_par`, se verifica el valor de retorno usando `$?`.
Este es un valor especial en Bash que contiene el valor de retorno del comando
anterior. Se compara con `0` para determinar si la función tuvo éxito o no.
- Dependiendo del valor de retorno, se imprime un mensaje apropiado.

En este caso, el script imprimirá "10 es un número par." porque `10` es un número par y
la función `es_par` devuelve `0`, indicando éxito.

Evaluar expresiones
En Bash, puedes evaluar expresiones aritméticas utilizando el comando `expr` o la doble
paréntesis `(( ... ))`. Aquí te muestro ambos métodos:

1. **Usando `expr`**:

```bash
#!/bin/bash
# Evaluar expresiones aritméticas con expr
# Definir las expresiones
expresion1="3 + 5"
expresion2="10 - 2"
expresion3="2 * 4"
expresion4="20 / 5"

# Evaluar y mostrar resultados

echo "Resultado de $expresion1: $(expr $expresion1)"
echo "Resultado de $expresion2: $(expr $expresion2)"
echo "Resultado de $expresion3: $(expr $expresion3)"
echo "Resultado de $expresion4: $(expr $expresion4)"
```
 2. **Usando doble paréntesis `(( ... ))`**:

```bash
#!/bin/bash

# Evaluar expresiones aritméticas con doble paréntesis

(( ... ))

# Definir las expresiones

expresion1=$((3 + 5))
expresion2=$((10 - 2))
expresion3=$((2 * 4))
expresion4=$((20 / 5))

# Mostrar resultados
echo "Resultado de 3 + 5: $expresion1"
echo "Resultado de 10 - 2: $expresion2"
echo "Resultado de 2 * 4: $expresion3"
echo "Resultado de 20 / 5: $expresion4"
```
Ambos métodos funcionan para evaluar expresiones aritméticas en Bash. Sin embargo,
ten en cuenta que `(( ... ))` es más flexible y puede manejar expresiones más complejas, además
de admitir asignaciones y comparaciones.

Tipos de datos manejados en BASH

Bash, como muchos otros lenguajes de scripting, es bastante flexible en cuanto a los tipos
de datos que maneja. Aquí hay una descripción general de los tipos de datos comunes que se
pueden manejar en Bash:

1. **Cadenas (Strings)**:
 Las cadenas son secuencias de caracteres. En Bash, las cadenas pueden ser definidas
utilizando comillas simples (`'...'`) o comillas dobles (`"..."`). Las comillas dobles permiten la
expansión de variables y caracteres de escape, mientras que las comillas simples no.

Ejemplo:

```bash

cadena1="Hola, mundo!"

cadena2='Este es un ejemplo'

```

2. **Números (Numbers)**:

Los números en Bash son tratados como cadenas por defecto, pero pueden ser
interpretados como enteros o números de punto flotante en contextos aritméticos utilizando la
expresión `(( ... ))` o la herramienta `expr`.

Ejemplo:

```bash
numero1=10
numero2="20"
```
3. **Arreglos (Arrays)**:

Los arreglos en Bash permiten almacenar múltiples valores en una sola variable. Se
definen utilizando paréntesis `(...)` y los elementos se separan por espacios.

Ejemplo:

```bash
 mi_array=("valor1" "valor2" "valor3")
```
4. **Variables Especiales**:

Bash tiene varias variables especiales que almacenan información útil. Algunas de estas
incluyen:

- `$0`: El nombre del script.

- `$1`, `$2`, `$3`, ...: Los argumentos pasados al script o a una función.
- `$#`: El número de argumentos pasados al script o a una función.
- `$@`: Todos los argumentos pasados al script o a una función como una lista.
- `$?`: El valor de retorno del último comando ejecutado.

5. **Booleanos (Booleans)**:

Bash no tiene un tipo de dato booleano nativo, pero los valores `true` y `false` se
pueden representar usando convenciones numéricas. Por ejemplo, `0` puede representar `false` y
cualquier otro valor puede representar `true`.

Ejemplo:

```bash
verdadero=1
falso=0
```

6. **Nulo (Null)**:

No existe un tipo de dato `null` específico en Bash. Sin embargo, una variable no
inicializada o vacía puede considerarse nula.

Es importante tener en cuenta que en Bash, las variables no tienen un tipo de dato fijo; el
tipo de dato de una variable puede cambiar dinámicamente según el contexto en el que se utilice.
Esto permite una gran flexibilidad pero también puede llevar a comportamientos inesperados si
no se tiene cuidado.

Operadores booleanos
En Bash, puedes utilizar operadores booleanos para realizar comparaciones y
evaluaciones lógicas en tus scripts. Aquí tienes una lista de los operadores booleanos más
comunes en Bash:

1. **Operador de Igualdad (`==`)**:

Este operador se utiliza para verificar si dos cadenas son iguales.

```bash
if [ "$cadena1" == "$cadena2" ]; then
echo "Las cadenas son iguales."
fi
```
2. **Operador de No igual (`!=`)**:

Este operador se utiliza para verificar si dos cadenas son diferentes.

```bash
if [ "$cadena1" != "$cadena2" ]; then
echo "Las cadenas son diferentes."
fi
```

3. **Operadores de Comparación Numérica**:

- ` -eq`: Igual que

- ` -ne`: No igual que
 - ` -lt`: Menor que
- ` -le`: Menor o igual que
- ` -gt`: Mayor que
- ` -ge`: Mayor o igual que

```bash
if [ "$numero1" -eq "$numero2" ]; then
echo "Los números son iguales."
fi
```
4. **Operadores Lógicos**:

- `&&`: Y lógico (AND)

- `||`: O lógico (OR)
- `!`: Negación lógica (NOT)

```bash
if [ "$condicion1" -eq 1 ] && [ "$condicion2" -eq 2 ];
then
echo "Ambas condiciones son verdaderas."
fi

if [ "$condicion1" -eq 1 ] || [ "$condicion2" -eq 2 ];

then
echo "Al menos una de las condiciones es verdadera."
fi

if ! [ "$condicion" -eq 1 ]; then

echo "La condición es falsa."
fi
```
 Recuerda que los corchetes `[` y `]` son necesarios alrededor de las expresiones para
realizar las comparaciones y evaluaciones lógicas en Bash. Además, es importante usar comillas
alrededor de las variables para evitar errores de expansión de parámetros cuando las cadenas
contienen espacios u otros caracteres especiales.

Debugging y errores comunes

El proceso de debugging en Bash puede ser un poco diferente al de otros lenguajes de
programación más tradicionales, pero sigue siendo crucial para identificar y corregir errores en
tus scripts. Aquí hay algunos consejos sobre debugging y algunos errores comunes en Bash:

1. Habilita el Modo de Depuración

Puedes habilitar el modo de depuración agregando `set -x` al principio de tu script. Esto
mostrará cada línea de tu script mientras se ejecuta, lo que puede ayudarte a identificar dónde
ocurren los errores.

```bash
#!/bin/bash
set -x
# Resto de tu script aquí
```
2. Agrega `echo` Statements

Coloca declaraciones `echo` estratégicamente dentro de tu script para imprimir valores

de variables o mensajes de estado en puntos clave. Esto te ayudará a entender qué está
sucediendo en diferentes partes del script.

```bash
#!/bin/bash
echo "Iniciando ejecución del script..."
 # Resto de tu script aquí

echo "Fin del script."

```
3. Usa `set -e` para Terminar en Errores

Agregar `set -e` al principio de tu script hará que se detenga automáticamente si se

encuentra un error, lo que puede ayudarte a detectar problemas más rápidamente.

```bash
#!/bin/bash
set -e
# Resto de tu script aquí
```
4. Maneja Errores con `if` Statements y `exit`

Utiliza declaraciones `if` para verificar el resultado de los comandos críticos y usa
`exit` para salir del script si es necesario.

```bash
if ! [ -f "$archivo" ]; then
echo "Error: El archivo no existe."
exit 1
fi
```
Errores Comunes en Bash:

1. **Errores de Sintaxis**:

Olvidar comillas, paréntesis o corchetes puede provocar errores de sintaxis.

2. **Referencias a Variables No Definidas**:

 Utilizar una variable que no ha sido definida previamente puede causar errores. Es
importante asegurarse de que todas las variables estén inicializadas correctamente.

3. **Ejecución de Comandos con Permisos Insuficientes**:

Intentar ejecutar un comando que requiere permisos especiales sin tenerlos puede
causar errores.

4. **Errores de Expansión de Parámetros**:

No usar comillas alrededor de las variables puede causar problemas de expansión de

parámetros, especialmente si las variables contienen espacios u otros caracteres especiales.

5. **Errores Lógicos**:

Asegúrate de que tus declaraciones lógicas y condicionales estén correctamente

formuladas para evitar resultados inesperados.

Al depurar scripts Bash, ten en cuenta que los mensajes de error a menudo pueden ser
crípticos, así que no dudes en experimentar con diferentes técnicas de debugging y buscar ayuda
en la documentación y en línea.

“Bachismos” y compatibilidad con POSIX

"Bashismos" se refiere a características o construcciones específicas de Bash que no son
compatibles con el estándar POSIX (Portable Operating System Interface) o no están presentes
en otros shells de Unix. Estas características pueden hacer que los scripts sean menos portables
entre diferentes sistemas Unix o que no funcionen correctamente en shells que no sean Bash.

Aquí hay algunos ejemplos de "Bashismos" comunes y cómo podrían no ser compatibles
con POSIX:
 1. Construcciones de Arreglos Asociativos:

Bash admite arreglos asociativos, que permiten asociar claves de cadena con valores.
Este es un Bashismo porque no está presente en otros shells de Unix y no es parte del estándar
POSIX.

2. Redirecciones de Proceso y Subproceso:

Bash permite redirecciones de entrada y salida en procesos y subprocesos, como

`<(comando)` o `>(comando)`. Estas construcciones pueden no ser compatibles con otros shells.

3. `[[ ... ]]` para Pruebas de Condición:

Bash admite `[[ ... ]]` para pruebas de condición más avanzadas y flexibles, pero esto no
es parte del estándar POSIX. Para scripts portables, es mejor usar `[ ... ]` para pruebas de
condición.

4. `$((...))` para Expresiones Aritméticas:

Bash admite la sintaxis `$((...))` para evaluar expresiones aritméticas, lo cual es

Bashismo. Para scripts compatibles con POSIX, es mejor usar `expr` o doble paréntesis `((...))`.

5. `$RANDOM` para Números Aleatorios:

Bash tiene la variable especial `$RANDOM` para generar números aleatorios, pero esta
funcionalidad no está garantizada en otros shells de Unix.

Es importante tener en cuenta la compatibilidad con POSIX al escribir scripts Bash si la

portabilidad es una preocupación. Aunque Bash es ampliamente utilizado y potente, no todas sus
características son compatibles con todos los sistemas Unix y shells disponibles. Algunas
distribuciones de Unix pueden usar shells diferentes por defecto (por ejemplo, Dash en sistemas
Debian), lo que puede afectar la portabilidad de los scripts. Por lo tanto, es una buena práctica
evitar los "Bashismos" en scripts destinados a ejecutarse en un entorno más amplio.

Privacidad del código BASH

La privacidad del código Bash, al igual que cualquier otro tipo de código, depende de
cómo se maneje y dónde se almacene. Aquí hay algunas consideraciones sobre la privacidad del
código Bash:

1. Almacenamiento Seguro: Si deseas mantener tu código Bash privado, asegúrate de

almacenarlo en un lugar seguro. Esto podría ser en tu propio sistema, en un
repositorio privado de control de versiones (como GitLab o Bitbucket), o en un
servidor seguro.
2. Acceso a los Archivos: Controla quién tiene acceso a los archivos que contienen tu
código Bash. Asegúrate de establecer los permisos adecuados en el sistema de
archivos para que solo las personas autorizadas puedan ver o modificar los archivos.
3. Compartir Selectivamente: Si necesitas compartir tu código Bash con otros
colaboradores, asegúrate de compartirlo solo con las personas de confianza y que
tengan una necesidad legítima de acceder al código. Puedes utilizar herramientas de
control de versiones que admitan repositorios privados para compartir el código de
manera segura.
4. Eliminar Información Sensible: Antes de compartir tu código Bash, asegúrate de
eliminar cualquier información sensible, como contraseñas, tokens de autenticación u
otra información confidencial que no deba estar expuesta.
5. Consideraciones de Seguridad: Asegúrate de que tu código Bash esté escrito de
manera segura para evitar vulnerabilidades de seguridad. Esto incluye la validación
adecuada de las entradas del usuario, la sanitización de datos y el manejo seguro de
contraseñas y otros datos sensibles.
6. Auditorías Regulares: Realiza auditorías regulares de tu código Bash para
identificar posibles problemas de privacidad o seguridad. Esto te ayudará a mantener
tu código seguro y protegido.
 En resumen, la privacidad del código Bash se puede mantener utilizando prácticas
estándar de seguridad de la información, como controlar el acceso a los archivos, compartir
selectivamente y eliminar información sensible antes de compartir. Además, es importante seguir
buenas prácticas de seguridad y realizar auditorías regulares del código para identificar posibles
problemas de privacidad o seguridad.

Usando SHC
`SHC` es una utilidad de línea de comandos que se utiliza para compilar scripts de shell
(como scripts Bash) en binarios ejecutables. Esto puede ser útil para proteger el código fuente del
script y para distribuirlo en entornos donde no deseas que el código sea fácilmente legible o
editable.

Aquí podemos ver una breve guía sobre cómo usar `SHC`:

1. Instalación:

Primero, necesitas instalar `SHC`. Puedes hacerlo mediante la instalación de paquetes

en tu sistema operativo o descargando e instalando el código fuente de `SHC` desde su sitio web
oficial.

2. Compilación del Script:

Después de instalar `SHC`, puedes compilar tu script de shell utilizando el comando

`shc`. Por ejemplo, si tienes un script Bash llamado `mi_script.sh`, puedes compilarlo de la
siguiente manera:

```bash
shc -f mi_script.sh
```
Esto generará un archivo ejecutable llamado `mi_script.sh.x`. Este archivo es el binario
compilado del script original.

3. Ejecución del Binario Compilado:

 Puedes ejecutar el binario compilado como cualquier otro archivo ejecutable. Por
ejemplo:

```bash

./mi_script.sh.x

```

El script se ejecutará como lo haría normalmente, pero ahora está compilado en forma
binaria.

Es importante tener en cuenta que `SHC` no proporciona una seguridad completa para tu
código fuente, ya que el binario compilado aún puede ser descompilado. Sin embargo, puede
dificultar la edición casual del script y puede proporcionar cierta protección contra la
visualización del código fuente a simple vista.

Además, ten en cuenta que `SHC` tiene algunas limitaciones y puede no ser compatible
con todos los scripts de shell, especialmente aquellos que utilizan características avanzadas de
Bash o dependencias externas. Es recomendable realizar pruebas exhaustivas después de
compilar un script con `SHC` para asegurarse de que funcione como se espera.

Combinar Bash con otros programas de Scripting

Combinar Bash con otros programas de scripting es una práctica común y puede ser muy
útil para aprovechar las fortalezas de diferentes lenguajes de programación en tus proyectos.
Aquí hay algunas formas de combinar Bash con otros programas de scripting:

1. Bash con Python:

Python es un lenguaje de programación versátil y potente que se integra bien con Bash.
Puedes ejecutar comandos de Python directamente desde un script de Bash utilizando el
intérprete de Python. Esto te permite aprovechar las bibliotecas y capacidades avanzadas de
Python mientras mantienes la flexibilidad de Bash para realizar tareas de administración del
sistema.

```bash
#!/bin/bash
 # Ejecutar un script de Python desde Bash
python3 mi_script.py
```
2. Bash con Perl:

Perl es otro lenguaje de scripting popular que se puede combinar fácilmente con Bash.
Al igual que con Python, puedes ejecutar scripts de Perl directamente desde un script de Bash.

```bash
#!/bin/bash

# Ejecutar un script de Perl desde Bash

perl mi_script.pl
```
3. Bash con Ruby:

Ruby es otro lenguaje de scripting que se puede integrar con Bash. Puedes ejecutar
scripts de Ruby desde un script de Bash de manera similar a Python y Perl.

```bash
#!/bin/bash

# Ejecutar un script de Ruby desde Bash

ruby mi_script.rb
```
4. Bash con Awk:

Awk es un potente lenguaje de programación para el procesamiento de texto que se

integra bien con Bash. Puedes usar Awk directamente desde un script de Bash para manipular y
procesar datos de texto.
 ```bash
#!/bin/bash

# Utilizar Awk desde Bash para procesamiento de texto

awk '{print $1}' archivo.txt
```
5. Bash con Sed:

Sed es otra herramienta útil para el procesamiento de texto que se puede integrar con
Bash. Puedes usar Sed directamente desde un script de Bash para realizar sustituciones de texto y
otras manipulaciones.

```bash
#!/bin/bash

# Utilizar Sed desde Bash para realizar sustituciones de

texto
sed 's/busqueda/reemplazo/g' archivo.txt
```
Al combinar Bash con otros programas de scripting, puedes aprovechar las fortalezas de
diferentes lenguajes de programación para realizar una amplia gama de tareas de manera
eficiente y efectiva. Es importante familiarizarse con la sintaxis y las capacidades de los
diferentes lenguajes para poder utilizarlos de manera efectiva en tus proyectos.

¿Qué es Power Shell?

PowerShell, llamado Windows PowerShell originariamente, es una interfaz de línea de
comandos o CLI (Command-Line Interface) que tiene la posibilidad de ejecutar Scripts (unión de
comandos) y que facilita la configuración, administración y automatización de tareas
multiplataforma, ademas dispone de un lenguaje de scripting. Powershell tiene una salida basada
en objetos por lo que acepta y devuelve objetos de .NET ya que está basado en .NET CLR
(Commond Language Runtime) esto es ideal para automatización de procesos. (Soto, 2020)
 La principal diferencia de PowerShell respecto a otras interfaces de línea de comandos es
que PowerShell puede tratar con objetos, algo mas que un simple comando de otros CLI que solo
devuelve texto. Estos comandos, llamados cmdlet, devuelven una instancia de un objeto que da
lugar a una información de salida mucho más completa que los demás intérpretes de comandos,
además los otros CLI necesitan de este para poder obtener la información de salida, mientras que
un cmdlet obtiene la información de salida por si mismo. (Soto, 2020)

PowerShell permite un conjunto de comandos extensible a diferencia de otros CLI que su

conjunto de comandos está integrado, se pueden crear nuevos cmdlet a partir de scrpit o código
compilado, si necesitamos nuestro propio cmdlet podemos crearlo. También trabaja con alias de
comandos para facilitar su manejo, un alias es un nombre que designa a un comando, así si
estamos acostumbrados a trabajar con otros CLI, podemos asignar alias a los comandos de
PowerShell y seguir usando los mismos comandos. Por ejemplo, podemos asignar el alias listar-
directorios al comando dir que nos mostrará una lista de directorios, cuando ejecutemos uno u
otro nombre, siempre mostrará el mismo resultado. (Soto, 2020)

El código fuente de PowerShell se liberó el 15 de agosto de 2016 y Microsoft, que es su

desarrollador, lo publico en GitHub, que ahora le pertenece al haberlo comprarlo un par de años
más tarde. La versión inicial de PowerShell fue lanzada en noviembre de 2006 para Windows XP
Service Pack 2, Windows Vista y Windows Server 2003 Servide Pack 1, la versión actual,
después de algunos cambios de nombre intermedios, es la PowerShell 7.0 que está construido
sobre .NET Core 3.1. (Soto, 2020)

Aquí podemos conocer algunas características clave de PowerShell:

1. Shell Interactivo: PowerShell proporciona un shell interactivo similar a la línea de

comandos de Unix, donde los usuarios pueden ejecutar comandos y scripts en tiempo
real.
2. Lenguaje de Scripting: PowerShell es un lenguaje de scripting completo con
características como variables, bucles, estructuras de control, funciones y manejo de
errores. Está basado en el marco de .NET, lo que le proporciona acceso a una amplia
variedad de bibliotecas y funciones del sistema operativo.
 3. Cmdlets: PowerShell utiliza cmdlets (pronunciado "command-lets"), que son
pequeños programas modulares diseñados para realizar tareas específicas. Los
cmdlets siguen un formato de verbo-sustantivo, como `Get-Process`, `Stop-Service`,
`New-Item`, etc.
4. Pipeline: PowerShell permite encadenar cmdlets en una tubería (pipeline), donde la
salida de un cmdlet se pasa como entrada al siguiente. Esto permite realizar
operaciones complejas y encadenadas con una sola línea de comando.
5. Extensibilidad: PowerShell es altamente extensible y permite a los usuarios escribir
sus propios cmdlets, funciones y módulos para ampliar su funcionalidad.
6. Administración Remota: PowerShell incluye capacidades integradas para administrar
sistemas de forma remota a través de protocolos como WinRM (Windows Remote
Management) y SSH (desde PowerShell 7).
7. Integración con el Ecosistema de Windows: PowerShell está estrechamente integrado
con el ecosistema de Windows y proporciona acceso completo a las API de Windows,
lo que lo hace ideal para la administración de sistemas en entornos basados en
Windows.

PowerShell se ha convertido en una herramienta ampliamente utilizada en el mundo de la

administración de sistemas de Windows, ya que proporciona una manera poderosa y flexible de
automatizar tareas, administrar sistemas y realizar análisis de datos en entornos Windows.

Fundamentos de PowerShell y GetHelp.

PowerShell es un entorno de línea de comandos y un lenguaje de scripting para la
administración de sistemas, automatización de tareas y análisis de datos en entornos basados en
Windows. Aquí tienes una introducción a los fundamentos de PowerShell y cómo utilizar `Get-
Help` para obtener información sobre los cmdlets y funciones disponibles:

1. Ejecución de Comandos y Scripts:

En PowerShell, puedes ejecutar comandos directamente desde el shell o escribir scripts

para realizar tareas más complejas. Los scripts de PowerShell tienen la extensión `.ps1`.
 ```powershell
# Ejemplo de comando en PowerShell
Get-Process

# Ejemplo de ejecución de un script de PowerShell

.\mi_script.ps1
```
2. Cmdlets:

PowerShell utiliza cmdlets (command-lets) para realizar tareas específicas. Los cmdlets
siguen un formato de verbo-sustantivo y proporcionan una funcionalidad modular y reutilizable.

```powershell

# Ejemplo de uso de un cmdlet para obtener información

sobre procesos en ejecución

Get-Process

```

3. Parámetros de Cmdlets:

Los cmdlets pueden aceptar parámetros para personalizar su comportamiento. Puedes

usar `Get-Help` para obtener información sobre los parámetros admitidos por un cmdlet
específico.

```powershell

# Obtener ayuda sobre el cmdlet Get-Process

Get-Help Get-Process

```

4. `Get-Help`:
 `Get-Help` es un cmdlet en PowerShell que te proporciona información detallada sobre
otros cmdlets, funciones, módulos y scripts disponibles en PowerShell. Puedes usar `Get-Help`
para obtener descripciones, ejemplos de uso, sintaxis de comando y más.

```powershell
# Obtener ayuda sobre un cmdlet específico
Get-Help Get-Process

# Obtener ayuda sobre todos los cmdlets disponibles

Get-Help *

# Obtener ayuda sobre un tema específico (por ejemplo,

variables)
Get-Help about_Variables
```
5. Alias de Comandos:

PowerShell admite alias de comandos, que son abreviaturas o nombres alternativos para
cmdlets, funciones y scripts. Puedes usar `Get-Alias` para obtener una lista de alias definidos en
PowerShell.

```powershell
# Obtener una lista de alias definidos en PowerShell
Get-Alias
```
6. Tab Completions:

PowerShell admite la finalización de pestañas, que te permite presionar la tecla de

tabulación para completar automáticamente nombres de cmdlets, parámetros y rutas de archivos
mientras escribes en el shell.

```powershell
# Presionar la tecla de tabulación para completar
automáticamente nombres de cmdlets, parámetros, etc.
 Get-P<tab>
```
`Get-Help` es una herramienta muy útil en PowerShell para familiarizarse con los
cmdlets disponibles, aprender sobre sus funcionalidades y obtener ayuda en tiempo real mientras
trabajas en el shell. Es una práctica recomendada consultar la ayuda antes de utilizar nuevos
cmdlets para comprender mejor su uso y funcionalidad.

Set-ExecutionPolicy.
`Set-ExecutionPolicy` es un cmdlet de PowerShell que se utiliza para establecer la
política de ejecución de scripts en un entorno de PowerShell. Esta política determina qué scripts
pueden ejecutarse en el sistema y puede ayudar a prevenir la ejecución no autorizada de scripts
maliciosos.

La sintaxis básica de `Set-ExecutionPolicy` es la siguiente:

```powershell
Set-ExecutionPolicy <Policy>
```
Donde `<Policy>` puede ser uno de los siguientes valores:

- `Restricted`: No se permite la ejecución de ningún script. Este es el valor

predeterminado.
- `AllSigned`: Se permiten la ejecución de scripts, pero solo si están firmados
digitalmente por un editor de confianza.
- `RemoteSigned`: Se permiten la ejecución de scripts locales sin firma, pero los
scripts descargados de Internet deben estar firmados digitalmente por un editor de
confianza.
- `Unrestricted`: Se permite la ejecución de todos los scripts sin restricciones.
Advertencia: Esto puede ser peligroso, ya que permite la ejecución de scripts sin
firma desde Internet.
- `Bypass`: No se aplican restricciones de ejecución. Esta opción es adecuada para
situaciones en las que necesitas ejecutar scripts sin restricciones temporales.

Por ejemplo, para establecer la política de ejecución en `RemoteSigned`, puedes ejecutar:

 ```powershell
Set-ExecutionPolicy RemoteSigned
```
Es importante tener en cuenta que necesitas permisos de administrador para cambiar la
política de ejecución de PowerShell. Si no tienes permisos de administrador, es posible que
necesites ejecutar PowerShell como administrador utilizando la opción "Ejecutar como
administrador" al abrir PowerShell desde el menú Inicio.

Es recomendable establecer la política de ejecución en un nivel que equilibre la seguridad

y la funcionalidad según tus necesidades. En entornos de producción, es común utilizar
`AllSigned` o `RemoteSigned` para garantizar que solo se ejecuten scripts firmados digitalmente
por editores de confianza.

¿Qué es el Pipeline?
El "pipeline" en PowerShell se refiere a la capacidad de encadenar múltiples cmdlets
(comandos) juntos, donde la salida de uno se convierte automáticamente en la entrada del
siguiente. Esto permite realizar operaciones complejas y encadenadas de manera eficiente con
una sola línea de comando.

En el contexto de PowerShell, el pipeline se representa mediante el operador `|` (tubo),

que se coloca entre dos cmdlets. Cuando se utiliza el operador `|`, la salida del primer cmdlet se
pasa automáticamente como entrada al segundo cmdlet. Esto permite que los cmdlets trabajen
juntos de manera sinérgica, realizando una serie de operaciones en los datos de entrada.

Por ejemplo, supongamos que queremos obtener una lista de los procesos en ejecución
que están utilizando más memoria en el sistema y luego ordenarlos por la cantidad de memoria
utilizada. Podemos hacerlo utilizando el pipeline en PowerShell de la siguiente manera:

```powershell
Get-Process | Sort-Object -Property WS | Select-Object -
Last 10
```
En este ejemplo:
 - `Get-Process` obtiene una lista de todos los procesos en ejecución en el sistema.
- La salida de `Get-Process` se pasa automáticamente al cmdlet `Sort-Object`, que
ordena los procesos en función de la cantidad de memoria que están utilizando (`WS`
representa la propiedad de memoria de trabajo).
- La salida de `Sort-Object` se pasa al cmdlet `Select-Object`, que selecciona los
últimos 10 procesos de la lista ordenada.

El resultado final es una lista de los 10 procesos que están utilizando más memoria en el
sistema, ordenados de mayor a menor.

El uso del pipeline en PowerShell es una característica poderosa que permite realizar
tareas complejas y realizar análisis de datos de manera eficiente y concisa. Permite a los usuarios
combinar y manipular datos de manera flexible para obtener los resultados deseados.

Importar datos en PowerShell.

En PowerShell, puedes importar datos desde una variedad de fuentes, como archivos de
texto, archivos CSV (valores separados por comas), bases de datos, servicios web, etc. Aquí te
muestro cómo puedes importar datos desde algunas de estas fuentes comunes:

1. Importar desde un archivo de texto:

```powershell
# Importar contenido de un archivo de texto línea por línea
Get-Content -Path "archivo.txt"
```
2. Importar desde un archivo CSV:

```powershell
# Importar datos desde un archivo CSV
Import-Csv -Path "archivo.csv"
```
 3. Importar desde una hoja de cálculo de Excel:

```powershell
# Instalar el módulo ImportExcel (solo es necesario la
primera vez)
Install-Module ImportExcel -Scope CurrentUser -Force

# Importar datos desde una hoja de cálculo de Excel

Import-Excel -Path "archivo.xlsx"
```
4. Importar desde una base de datos (por ejemplo, SQL Server):

```powershell
# Instalar el módulo SqlServer (solo es necesario la
primera vez)
Install-Module SqlServer -Force -AllowClobber

# Conectar a la base de datos SQL Server

$connectionString =
"Server=mi_servidor;Database=mi_base_de_datos;Integrated
Security=True;"
$conn = New-Object
System.Data.SqlClient.SqlConnection($connectionString)
$conn.Open()

# Ejecutar una consulta SQL y guardar los resultados en una

variable
$query = "SELECT * FROM mi_tabla"
$cmd = $conn.CreateCommand()
$cmd.CommandText = $query
$result = $cmd.ExecuteReader()

# Leer los datos y cerrar la conexión

 $dataTable = New-Object System.Data.DataTable
$dataTable.Load($result)
$conn.Close()

# Mostrar los datos

$dataTable
```
5. Importar desde un servicio web (por ejemplo, JSON):

```powershell
# Utilizar Invoke-RestMethod para hacer una solicitud GET a
un servicio web que devuelve datos en formato JSON
$response = Invoke-RestMethod -Uri
"https://api.example.com/data" -Method Get

# Los datos devueltos se pueden acceder como propiedades

del objeto $response
$response
```
Estos son solo algunos ejemplos de cómo puedes importar datos en PowerShell desde
diversas fuentes. Dependiendo de la fuente de datos específica y del formato en el que se
encuentren los datos, es posible que necesites usar cmdlets y técnicas adicionales para procesar y
manipular los datos según tus necesidades.

Exportar datos de PowerShell.

En PowerShell, puedes exportar datos a una variedad de formatos y fuentes, como archivos de
texto, archivos CSV (valores separados por comas), hojas de cálculo de Excel, bases de datos,
servicios web, etc. Aquí te muestro cómo puedes exportar datos a algunas de estas fuentes
comunes:

1. Exportar a un archivo de texto:

```powershell
# Exportar datos a un archivo de texto
$data | Out-File -FilePath "archivo.txt"
```
2. Exportar a un archivo CSV:

```powershell
# Exportar datos a un archivo CSV
$data | Export-Csv -Path "archivo.csv" -NoTypeInformation
```
3. Exportar a una hoja de cálculo de Excel:

```powershell
# Instalar el módulo ImportExcel (solo es necesario la primera
vez)
Install-Module ImportExcel -Scope CurrentUser -Force

# Exportar datos a una hoja de cálculo de Excel

$data | Export-Excel -Path "archivo.xlsx" -AutoSize -Show
```
4. Exportar a una base de datos (por ejemplo, SQL Server):

```powershell
# Instalar el módulo SqlServer (solo es necesario la primera
vez)
Install-Module SqlServer -Force -AllowClobber

# Conectar a la base de datos SQL Server

$connectionString =
"Server=mi_servidor;Database=mi_base_de_datos;Integrated
Security=True;"
$conn = New-Object
System.Data.SqlClient.SqlConnection($connectionString)
$conn.Open()

# Crear una tabla temporal en la base de datos

$tableName = "mi_tabla_temporal"
$createTableQuery = "CREATE TABLE $tableName (Columna1
VARCHAR(50), Columna2 INT)"
$cmd = $conn.CreateCommand()
$cmd.CommandText = $createTableQuery
$cmd.ExecuteNonQuery()

# Insertar datos en la tabla temporal

$data | ForEach-Object {
$insertQuery = "INSERT INTO $tableName (Columna1, Columna2)
VALUES ('$_.Columna1', $_.Columna2)"
$cmd.CommandText = $insertQuery
$cmd.ExecuteNonQuery()
}

# Cerrar la conexión
$conn.Close()
```
5. Exportar a un servicio web (por ejemplo, JSON):

```powershell
# Convertir los datos a formato JSON
$jsonData = $data | ConvertTo-Json

# Utilizar Invoke-RestMethod para enviar los datos a un servicio

web
Invoke-RestMethod -Uri "https://api.example.com/data" -Method
Post -Body $jsonData -ContentType "application/json"
```
Estos son solo algunos ejemplos de cómo puedes exportar datos en PowerShell a diversas
fuentes. Dependiendo de la fuente de destino específica y del formato en el que desees exportar
los datos, es posible que necesites usar cmdlets y técnicas adicionales para formatear y
estructurar los datos según los requisitos de la fuente de destino.

Comentarios y variables
Por supuesto, en PowerShell puedes usar comentarios para hacer tu código más legible y
mantener notas para ti mismo o para otros que puedan leer tu código en el futuro. También
puedes definir y utilizar variables para almacenar valores y realizar operaciones. Aquí te muestro
cómo puedes hacer ambas cosas en PowerShell:

Comentarios en PowerShell:

Los comentarios en PowerShell se crean utilizando el símbolo `#`. Todo lo que escribas
después de `#` en una línea será tratado como un comentario y no se ejecutará.

```powershell
# Esto es un comentario en PowerShell

# Este script realiza una tarea específica

# y está diseñado para ser ejecutado en un entorno de
Windows.
```
Puedes usar comentarios en una línea por separado o al final de una línea de código.

Variables en PowerShell:

En PowerShell, las variables se definen con el prefijo `$`. Puedes asignarles valores
directamente y utilizarlas en tu script.

```powershell
# Definir una variable llamada $nombre y asignarle un valor
$nombre = "Juan"
 # Imprimir el valor de la variable $nombre
Write-Output $nombre
```
Las variables en PowerShell son tipadas dinámicamente, lo que significa que el tipo de
datos de la variable puede cambiar automáticamente según el tipo de valor que le asignes.

```powershell
# Asignar un valor numérico a la variable $edad
$edad = 30

# Imprimir el valor de la variable $edad

Write-Output $edad
```
Además de las variables escalares que pueden contener un único valor, PowerShell
también admite otros tipos de variables, como arreglos, hash tables y objetos.

```powershell
# Definir un arreglo de nombres
$nombres = @("Juan", "María", "Pedro")

# Definir un hash table de información de persona

$persona = @{
Nombre = "Juan"
Edad = 30
}

# Definir un objeto de tipo persona

$objetoPersona = New-Object PSObject -Property @{
Nombre = "Juan"
Edad = 30
}
 ```
Estos son solo ejemplos básicos de cómo puedes usar comentarios y variables en
PowerShell para hacer tu código más claro y funcional. Los comentarios te permiten documentar
tu código y las variables te permiten almacenar y manipular datos en tus scripts de PowerShell.

Variables pre definidas

En PowerShell, hay varias variables predefinidas que proporcionan información útil
sobre el entorno de ejecución y otros detalles relacionados con el script en ejecución. Algunas de
las variables predefinidas más comunes en PowerShell son las siguientes:

1. `$PSVersionTable`:

Esta variable contiene información sobre la versión de PowerShell que se está

ejecutando, incluidos detalles como la versión principal, el número de compilación y la edición.

```powershell
# Mostrar información sobre la versión de PowerShell
$PSVersionTable
```
2. `$MyInvocation`:

Esta variable proporciona información sobre la invocación actual del script, incluido el
nombre del script, los parámetros pasados al script y la ruta del script.

```powershell
# Mostrar información sobre la invocación actual del script
$MyInvocation
```
3. `$PSCmdlet`:

Esta variable está disponible dentro de cmdlets avanzados y proporciona acceso al

contexto del cmdlet, como los parámetros pasados al cmdlet y los métodos y propiedades del
cmdlet.

```powershell
 # Mostrar información sobre el contexto del cmdlet
$PSCmdlet
```
4. `$ExecutionContext`:

Esta variable proporciona información sobre el contexto de ejecución actual, como la

ubicación del script en ejecución y el estado del contexto de ejecución.

```powershell
# Mostrar información sobre el contexto de ejecución actual
$ExecutionContext
```
5. `$Error`:

Esta variable contiene una lista de todos los errores que se han producido durante la
ejecución del script actual.

```powershell
# Mostrar una lista de errores
$Error
```
6. `$Host`:

Esta variable proporciona acceso al objeto host actual, que puede utilizarse para
interactuar con el entorno de PowerShell, como cambiar el color de la consola o mostrar
mensajes al usuario.

```powershell
# Mostrar información sobre el host actual
$Host
```
Estas son solo algunas de las variables predefinidas disponibles en PowerShell. Puedes
usar estas variables para acceder a información útil sobre el entorno de ejecución y el contexto de
ejecución actual, lo que puede ser útil para la depuración, el registro y otras tareas de
administración de scripts.

Constantes
En PowerShell, no hay un concepto directo de "constantes" como en otros lenguajes de
programación, donde una constante es un valor que no cambia durante la ejecución del
programa. Sin embargo, puedes simular constantes utilizando variables que no cambien de valor
durante la ejecución del script y convenciones de nomenclatura para indicar que una variable se
trata como una constante.

Aquí tenemos algunas formas de simular constantes en PowerShell:

1. Utilizar variables en mayúsculas:

Puedes usar convenciones de nomenclatura para indicar que una variable debe tratarse
como una constante. Por ejemplo, puedes nombrar tus variables en mayúsculas para indicar que
son constantes y no deben cambiar.

```powershell
# Definir una constante
$CONSTANTE = "valor constante"

# Usar la constante
Write-Output $CONSTANTE
```
2. Definir variables en el script principal:

Puedes definir tus "constantes" al principio del script principal y luego usarlas en todo el
script. Aunque las variables pueden cambiar su valor durante la ejecución del script, es una
práctica común no modificarlas.

```powershell
# Definir constantes
$CONSTANTE1 = "valor constante 1"
 $CONSTANTE2 = "valor constante 2"

# Usar las constantes

Write-Output $CONSTANTE1
Write-Output $CONSTANTE2
```
3. Utilizar funciones para obtener valores constantes:

Puedes definir funciones que devuelvan valores constantes y luego llamar a esas
funciones cuando necesites usar las constantes en tu script.

```powershell
# Definir una función que devuelve una constante
function Get-CONSTANTE {
return "valor constante"
}

# Usar la función para obtener la constante

$constante = Get-CONSTANTE
Write-Output $constante
```
Aunque PowerShell no tiene un tipo de dato específico para constantes, puedes utilizar
estas técnicas para simular constantes y mantener valores que no cambian durante la ejecución
del script. Es importante seguir buenas prácticas de codificación y documentar claramente el
propósito y el uso de tus "constantes" en el código.