Programación para todos I

Esto comúnmente es lo que se le llama en los Sistemas Operativos, La Consola. Con las
versiones nuevas de Microsoft Windows se ha dejado un poco atrás, con esto de que hay
asistentes, gráficos para facilitar el trabajo al usuario, pero cuando no existía estas cosas,
antaño se usaba lo que es el Intérprete de Comandos. Básicamente es el infierno de los
usuarios de interfaces gráficos, pero en realidad de esta forma tienes más control y más
opciones de configuración. Que sí, que es más feo, todo en texto plano, pero no deja de ser
eficiente, efectivo y lo mejor de todo, apenas consume memoria ya que no usa gráfico
alguno.

¿Que es Shell?
Básicamente un script de shell es un archivo de texto simple con listas de comandos que se
ejecutan de forma secuencial. Se compone de procedimientos, variables, funciones,
condiciones, bucles, arrays…etc, como cualquier otro lenguaje de programación, pero
orientado a la consola de un sistema operativo. Existen diferentes tipos de interpretes:
• Bourne Shell o sh. Se creó en 1977 y se convirtió en el intérprete por defecto en las
primeras versiones de UNIX.
• Korn Shell. Se creó a principios de los 80 para el proyecto GNU.
• Bash. Se creo en 1987 también para el proyecto GNU. Muchas ideas fueron basadas
del Korn Shell. Actualmente es el principal intérprete en las mayoría de las
distribuciones Linux que hay en la actualidad.
• Zsh. Se creó en 1990. En principio se diseñó para poder usarlo de forma interactiva.
• Todos son buenos intérpretes para usar, algunos con sus pros y sus contras, pero yo
me voy a centrar un poco en bash, que es el que se usa comúnmente en las
distribuciones Linux más usadas.

• Información de Shell.
• echo $SHELL # Indica el shell que estamos usando.
echo $BASH_VERSION #Indica la versión de shell bash.
whereis bash # Indica donde está instalado shell bash.
cat /etc/shells # Indica todos los shell que hay
instalado.
chsh -s /bin/bash # Poner por defecto shell bash.

• Creando mi primer Script.

• #!/bin/bash
# Esto es un comentario.

echo "Hola mundo"

• Se debe siempre empezar con #!/bin/bash. Esto le indica al sistema cual es el
intérprete que debe usar.
• Los comentarios es algo muy imporante en cualquier lenguaje de programación. En
bash se ponen con al signo #.
 • echo. Instrucción que muestra por pantalla información, ya sean variables, números o
cadenas.

• ¿Como se ejecuta un Script?

• Los Script se pueden ejecutar de las siguientes formas:
• bash <nombre del script>.
• ./<nombre del script>. Este forma tiene un inconveniente, hay que darle permisos de
ejecución al archivo con el comando chmod o no se ejecutará. La instrucción sería la
siguiente; chmod +x <nombre del script>
• source <nombre del script>.

Son trozitos de memoria a la cual asignamos un nombre para usarla en el procedimiento. El

nombre de una variable sólo puede contener letras a-z A-Z, números del 0–9 o el carácter de
guión bajo (_).
¿Como se definen?.
Las varibles se definen sin nada especial, simplemente se pone el nombre de la variable el
valor que queremos asignarle.
var=”mi texto”
var=0125
¿Como accedo a su valor?
La forma de acceder es anteponiendo el signo $ de la variable.
#!/bin/bash
var=”mi texto”
echo $var
Shell tiene una forma de evitar que se pueda modificar el valor de una variable, es decir,
ponerlo como sólo lectura.
#!/bin/bash
var=”mi texto”
readonly var
echo $var
Si ahora intentaramos hacer una asignación, nos dará un error indicando que no se puede
modificar el valor de la variable.
Ya no voy usar la variable ¿Que hago con ella?
Si no necesitamos alguna variable, podemos destruirla de forma que ya no se podrá acceder
al valor de ésta. Hay que tener en cuenta que no se puede usar esta instrucción en variables
definidas como sólo lectura.
unset <nombre variable>
Tipos de variables.
• Variables locales. Son las que se definen única y exclusivamente en el script que se
está ejecutando, no pudiendo ser modificada por ningún otro script o procedimiento.
• Variables globales. Son las que se definen de forma global, de modo que puede ser
modifciada por otros procedimientos en cualquier momento.
• Variables especiales.
• $$. Muestra el número de proceso del sistema que tiene el shell, es decir el PID.
• $0. Muestra el nombre del script que se está ejecutando.
• $n. El valor de n es el número de argumento que le pasamos al script, de forma que si
hay varios parámetros lo definiríamos como $1, $2, $3, en el caso de que haya 3
parámetros.
 • $#. Muestra el número total de parámetros que le pasamos en el script.
• $*. Muestra el valor de todos los parámetros que le pasamos al script.
• $@. Muestra el valor de todos los parámetros que le pasamos al script.
• $?. El estado de salida del último comando ejecutado. Shell devuelve un estado para
saber si es correcto la ejecución o no, es decir, mostrará un 0 si ha ido todo bien y un
1 si ha fallado o ha tenido errores
• $!. El número de proceso del último comando que está en segundo plano.
• Veamos un ejemplo:
• #!/bin/bash
echo “Nombre del script: $0”
echo “Parámetro1 : $1”
echo “Parámetro2 : $2”
echo “Valores de los parámetros: $@”
echo “Valores de los parámetros: $*”
echo “Total parámetros : $#”
echo $?
• Al ejecutar ./script.sh Benezor 79
• Nombre del script : ./script.sh
Parámetro1 : Benezor
Parámetro2 : 79
Valores de los parámetros: Benezor 79
Valores de los parámetros: Benezor 79
Total Total parámetros: 2
0
• Variables Arrays.
• Este tipo de variables es una forma de almacenar varios conjuntos de valores con un
sólo nombre. La forma de definirlo es la siguiente:
• #!/bin/bash
array=(ismael lourdes carlos jesus rosario)
echo “El primer elemento es: ${array[0]}”
echo “El segundo elemento es: ${array[3]}”
• Este ejemplo tenemos una array de 5 elementos (0–5). Asignamos a cada elemento un
valor y mostramos el valor del primero y el cuarto, para ver así como se accede a
éstos desde una array.
• Vamos a mostrar todos los elementos:
• echo “Todos los elementos son: ${array[*]}”
echo “Todos los elementos son: ${array[@]}”

En esta parte vamos hablar de los distintos operadores que existen en la programación;
ariméticos, lógicos, booleanos, string y los file test.
Aritméticos.
• +. Asignación.
• -. Substracción.
• *. Multiplicación.
• /. División
• %. Módulo o resto de una división.
• =. Asignación.
• ==. Comparación de números.
• !=. Negación.
• Algunos ejemplos:
• valor=`expr $a + $b`
valor`expr $a — $b`
valor `expr $a \* $b`
[ $a == $b ]
• Hay que tener en cuenta una cosa, Shell es un poco especial y debemos separar
siempre los operadores de las variables o dará un error;
• ¿Que es eso de expr?. Se utiliza para guardar el resultado de una expresión en una
variable.
• Relacionales.
• Este tipo de operadores se utilizan sólo y exclusivamente para cadena de carácteres.
• -eq. Compara si son iguales dos cadenas. Si lo son devuelve un true.
• -ne. Compara si son iguales dos cadenas. Si no lo son devuelve un true.
• -gt. Compara si la cadena de la izquierda es mayor que el de la derecha. Si es así
devuelve un true.
• -lt. Compara si la cadena de la izquierda es menor que el de la derecha. Si es así
devuelve un true.
• -ge. Compara si la cadena de la izquierda es mayor o igual que el de la derecha. Si es
así devuelve un true.
• -le. Compara si la cadena de la izquierda es menor o igual que el de la derecha. Si es
así devolverá un true.
• Booleanos.
• !. Niega una comparación.
• -o. Se utiliza para condiciones compuestas. Si una de las dos se cumple devuelve un
verdadero. [ $a -lt 20 -o $b -gt 100 ] .
• -a. Se utiliza para condiciones compuestas. Si se cumplen las dos condiciones a la vez
devuelve un true. [ $a -lt 20 -a $b -gt 100 ].
• String.
• =. Compara los valores y si son iguales devuelve un true.
• !=. Compara los valores y si es lo contrario que la expresión devuelve un true.
• -z. Compara si la longitud del valor es 0 y si lo es devuelve un true.
• -n. Compara si la longitud del valor es distinta de 0. Si es así devuelve un true.
• str. Compara si la cadena está vacia, si no está vacia devuelve un true.
• Files.
• Este tipo de operadores sirve para saber las propiedades dadas a un archivo en Linux,
es decir, los permisos de lectura, escritura y ejecución.
• -b file. Establece si el archivo es referente a un dispositivo del sistema, es decir,
perteneciente a /dev.
• -c file. Archivos especiales de tipo carácter.
• -d file. Que sea un directorio o carpeta.
• -f file. Que sea un archivo ordinario, es decir, que no sea ni un directorio ni archivo
especial.
• -g file. Comprueba que tenga activo el SGID, es decir, todo archivo que tenga activo
el SGID, al ser ejecutado, tendrá los privilegios del grupo al que pertenece.
• -k file Comprueba si tiene activo el sticky bit.¿Esto que es?. Cuando este bit está
activo, hace que un usuario sólo pueda borrar los ficheros que son de su propiedad en
dicho directorio.
• -p file Comprueba que el archivo sea named pipe.
• -t file Comprueba si el descriptor de archivo está abierto y asociado a una terminal.
• -u file. Comprueba si el archivo tiene establecido su SUID. El bit SUID activo en un
archivo significa que el que lo ejecute va a tener los mismos permisos que el que creó
el archivo
• -r file. Comprueba que el archivo tenga permisos de lectura.
 • -w file. Comprueba que el archivo tenga permisos de escritura.
• -x file. Comprueba que el archivo tenga permisos de ejecución.
• -s file Comprueba que el archivo tiene un tamaño mayor de 0.
• -e file Comprueba que el archivo existe. En el caso que sea un directorio el sistema lo
dará por válido.

Las condiciones son algo muy esencial en cualquier lenguaje de programación, dependiendo
de lo que pase a lo largo de un procedimiento, escogeremos un camino u otro. Veamos como
funciona:
if [ expression ]
then
instrucciones
fi
Cuando se cumple y no se cumple:
if [ expression ]
then
instrucciones cuando se cumple la condición.
else
instrucciones cuando no se cumple la condición
fi
Cuando son muchos if…else anidados:
if [ expression 1 ]
then
instrucciones
elif [ expression 2 ]
then
instrucciones
elif [ expression 3 ]
then
instrucciones
else
instrucciones
fi

Bucles.
Los bucles es una instrucción también muy usada e importante en la programación, ya que
permite crear bucles de instrucciones tantas veces como nos haga falta y así evitar repetir
mucho código.
While.
Este tipo de bucle hace las instrucciones que vienen dentro hasta que no se cumpla la
condicíon, es decir, lo va hacer mientras que la condición se cumpla. Veamos como funciona:
while command
do
instrucciones
done
Un ejemplo:
#!/bin/bash
a=0

while [ $a -lt 12 ]
do
echo “El valor de a es: $a”
a=`expr $a + 1`
done
En este ejemplo hacemos el bucle hasta que sea mayor de 11 o 12 y muestra el valor de a. Es
decir, el resultado será algo así; 0 1 2 3 4 5 6 7 8 9 10 11 y en el 12 sale del bucle.
FOR.
El bucle for funciona en listas de elementos. Repite un conjunto de instrucciones para cada
elemento en una lista.
for var in elemento1 elemento2 ... elementoN
do
instrucciones por cada elemento
done
Un ejemplo:
#!/bin/bash

for var in 0 1 2 3 4 5 6 7 8 9
do
echo $var
done
¿y que pasaría si fueran 300 elementos? Sería un poco pesado poner 300 elementos en el for.
Para evitar eso podemos usar la instrucción seq:
#!/bin/bashfor var in $(seq 0 9)
do
echo $var
done
Until loop.
Este tipo de bucle se usa cuando queramos que haga el bucle mientras las condición no se
cumpla. Veamos como se usa:
until command
do
instrucciones
done
Veamos un ejemplo:
#!/bin/bash

a=0

until [ ! $a -lt 12 ]
do
echo $a
a=`expr $a + 1`
done
El bucle lo va a hacer mientras que no se cumpla la condición, es decir, negar que a sea
menor de 12 quiere decir que es mayor o igual de 12. Como a no es mayor e igual de 12, hace
instrucciones que hay dentro. El bucle se acabará cuando sea 12.
Select.
Este tipo de bucle proporciona una manera fácil de crear un menú numerado desde el cual los
usuarios pueden seleccionar opciones. Veamos como funciona:
select var in opcion1 opcion2... opcionN
do
instrucciones
done
Veamos un ejemplo:
#!/bin/bash

select opcion in 1 2 3 4 5 6 none

do
case $opcion in
1|2|3)
echo "Has seleccionado entre los 3 primeros"
;;
4|5|6)
echo "Has seleccionado entre los 3 últimos"
;;
none)
break
;;
*) echo "ERROR: No has seleccionado nada"
;;
esac
done
Control del Bucle.
Existen momentos concretos en los que necesitemos parar un bucle para que no continúa o
que se salta parte de éste. Existen dos instrucciones que nos permiten hacer estas tareas;
Break y Continue.
Break. Esta instrucción sirve para romper el bucle de forma tajante, es decir, finaliza el
procedimiento repetitivo y se va la línea de código siguiente. Un ejemplo:
#!/bin/bash

a=0

while [ $a -lt 10 ]
do
echo $a
if [ $a -eq 5 ]
then
break
fi
a=`expr $a + 1`
done
echo “El bucle ha terminado en la posición $a”
En este ejemplo vamos hacer un bucle del 0 al 10. Pero cuando llega a 5 mediante la
condición, hace un break y se sale de bucle y echa la siguiente línea de código después de
bucle.
Continue. Esta instrucción funciona muy parecida a break, la diferencia está que no rompe el
bucle entero, si no la iteración y pasa a la siguiente en el bucle. Veamos un ejemplo:
#!/bin/bash

NUMS="1 2 3 4 5 6 7"

for NUM in $NUMS

do
Q=`expr $NUM % 2`
if [ $Q -eq 0 ]
then
echo "El numero es par!!"
continue
fi
echo "El número es impar"
done
Este ejemplo creamos un bucle con for, que comprenderá los números del 1 al 7.
Simplemente queremos averiguar si es par o impar, es decir, si el resto de dividir cada
número entre 2 es 0.
En cuanto entre en la condición y el resultado sea 0, muestra un mensaje de que es par. Como
sólo es en ese caso, usamos un continúa. El programa lo que hace es evitar el código que hay
después del If y no muestra nada, continuando con el siguiente número del For.

El shell realiza una sustitución cuando encuentra una expresión que contiene uno o más
caracteres especiales. Veamos un ejemplo:
#!/bin/basha=10
echo -e "Value of a is $a \n"
En este ejemplo, simplemente mostramos el valor de a.
La opción -e sirve para que nos de la interpretación de los caracteres espaciales que hay en la
barra invertida (\n).
• \n. Nueva línea.
• \\. Muestra el carácter de barra invertida como texto.
• \a. Muestra un pitido de alerta.
• \b. Retroceso.
• \c. Suprime línea nueva.
• \r. Retorno de carro.
• \t. Pestaña horizontal.
• \v. Pesteña vertical.
• Shell también nos permite guardar el resultado de la ejecución de comandos,
simplemente metiendo el comando entre comillas inversas:
• #!/bin/bashDATE=`date`
echo "Date is $DATE"#Incluso varios comandos a la vez
separados por comas.
UP=`date ; uptime`
echo "Uptime is $UP"
• Sustitución de Variables.
• La sustitución de variables permite al usuario poder modificar el contenido de éstas
según su estado:
• ${variable}. Sustituye el valor de variable.
• ${variable:-”mensaje”}. Si la variable es nula o no tiene valor, lo sustituirá por
“mensaje”, pero en ningún caso modificará el valor de variable. Se suele utilizar para
mensajes de errores.
• ${variable:=”mensaje”}. Si la variable es nula o no tiene valor, se guardará por
defecto el valor que pongamos después del igual.
• ${variable:?menaje}. Si la variable es nula o no tiene valor, se imprirá lo que
pongamos después de la interrogación.
• ${variable:+palabra}. Si la variable se establece, es sustituido por palabra pero el
valor de variable no se modificará en ningún caso.
• #!/bin/bashvar=1echo ${var:-"No tiene valor"}
echo "1 - El valor es ${var}"echo ${var:="No tiene
valor"}
echo "2 - valor es ${var}"unset var
echo ${var:+"Por Defecto"}
echo "3 - El valor es $var"var="Otro valor"
echo ${var:+"Tiene valor"}
echo "4 - El valor es $var"echo ${var:?"Muéstrame este
mensaje"}
echo "5 - El valor es ${var}"
• Si no tuviera valor mostraría “No tiene valor”
• Si no tuviera valor guardaría en la variable “No tiene valor”.
• Si no tuviera valor o no existiera guardaría en la variable “Por Defecto”
• Si tiene valor mostraría el mensaje “Tiene valor”.
• Si no tiene valor o no existe mostraría el mensaje “Muéstrame este mensaje”.

• Metacaracteres.
• Shell proporciona varios caracteres que tienen un significado especial al usarlos en
cualquier Script, es decir, son como reservados por el propio sistema para realizar
ciertas funciones especiales.
• Un ejemplo claro puede ser el signo ? . Se utiliza para referirnos a un sólo carácter
cuando se listan archivos o se busca por algún patrón. También le pasa al signo *, que
lo utilizamos para referirnos a una cantidad indeterminada de caracteres a la hora de
buscar o listar archivos.
• Aquí hay una lista de la mayoría de los caracteres:
• * ? [ ] ' " \ $ ; & ( ) | ^ < > new-line space tab
• Algunos ejemplos:
• #!/bin/sh

echo Hola \; Ismael

echo "I have \$1200"
• Si ejecutamos este script el resultado sería el siguiente:
• Hola; Ismael
I have $1200
• El truco para que el sistema no interprete los caracteres especiales ; y $ está en la
barra invertida \. Ésta hace que se olvide de que son metacaracteres y muestra el
propio signo que estamos utilizando como un texto.
• Si vamos a utilizar muchos caracteres especiales, es muy pesado poner una barra
invertida a cada una, la solución estaría poner todo entre comilla simples y el sistema
lo interpretará como si pusieramos una barra invertida a cada uno de ellos:
• echo '<-$1500.**>; (Estás seguro?) [s|n]'
• Si queremos que muestre variables y que interprete bien el $, debemos usar las
comillas dobles:
 • variable=Ismael
echo "$variable <-\$1500.**>; [ as of (`date +%m/%d`) ]"
• Las comillas dobles quita el significa especial que le da el sistema excepcionando los
siguientes:
• $
\$
\'
\"
• También podemos guardar el resultado de comandos del sistema en una variable, de
forma que podamos imprimir toda la información del comando:
• DATE=`date`
echo "La fecha de hoy es: $DATE"
• Para indicarle al sistema que es un comando, debemos especificárselo con las
comillas invertidas.

Cuando ejecutamos un comando cualquiera en una consola, normalmente te muestra los

resultados por la salida por defecto, es decir, la pantalla. Se puede desviar fácilmente a un
archivo si lo deseamos, a esto se le llama redireccionamiento de salida. Unos ejemplos:
who > usuarios
echo ismael >> usuarios
El truco de todo esto está en estos caractereres especiales:
• >. Redirecciona la salida por defecto del comando who a un archivo llamado usuarios.
Si existiera el archivo borraría su contenido y sólo añadiría el último resultado.
• >>. Redirecciona la salida por defecto hacia el archivo usuarios. En este caso al usar
doble redireccionamiento no borra el archivo si existiera, simplemente añade un
resultado más al contenido que hubiera ya dentro. Si no existe el archivo también lo
crea.
• Del mismo modo que la salida de un comando se puede redirigir a un archivo,
también se puede hacer lo contrario, es decir la entrada de un comando desde un
archivo. Así como el caracter mayor que (>) se usa para redireccionar la salida, la
entra se hace con el menor que (<).
• Vamos hacer un ejemplo. Lo que queremos es contar el número de líneas de un
archivo mediante esta forma:
• $ wc -l < users
• Simplemente le estamos dirigiendo el archivo usuarios al comando wc para que nos
cuente las líneas que contenga.
• También podemos redirigir los errores producidos hacia un archivo con el parámetro
2:
• $ cat < usuarios >usuariob 2> errores
• Con el parámetro 2 controlamos que donde se muestras los errores y en este caso
cambiamos la salida por defecto a un pequeño archivo llamado errores.
• Ocurre veces que nos puede interesar que no se muestren mensajes de ningún tipo en
la consola. Para realizar esta acción se redirecciona todo a /dev/null:
• $ gcc *.cpp > /dev/null 2 > /dev/null
• Delimitadores. Esto se suele usar para volcar código de un script o otro de forma que
le ponemos un delimitador indicándole hasta donde queremos que finalice tal
volcado. Un ejemplo:
• #!/bin/bash

cat << EOF

 Una frase de ejemplo
Otra frase de ejemplo
vale, ya es esta la última frase de ejemplo.
EOF
• En este ejemplo el delimitador lo he llamado EOF, se puede llamar como queramos.
Le indicamos que muestre el texto por la salida por defecto hasta que encuentre el
delimitador, si hubiese más texto depués lo ignoraría.

Las funciones funcionan exactamente igual que los script, la diferencia está en que lo puedes
llamar desde cualquier lugar, ya que se cargan directamente en el entorno del intérpretes de
comandos. Son muy similares a las subrutinas, procedimientos y funciones en otros lenguajes
de programación. Su sintáxis básica es la siguiente;
function nombre_funcion() {
lista de comandos
}
Vamos con un ejemplo muy básico para ver como funciona.
#!/bin/bash# Creamos la función.
function hola() {
echo "Hola Ismael, este es mi primer ejercicio de funciones"
}
A la hora de llamar al procediendo
#Llamamos al procedimiento con el nombre de la función
hola
Las funciones son muy eficientes a la hora de trabajar, ya que podemos usarlas en cualquier
momento, en cualquier lugar, la única pega que tiene es que se deben cargar en memoria
todas las funciones para usar esa ventaja. Aunque en la actualidad con la cantidad de
memoria que usan los ordenadores, no debería preocuparnos, pero bueno, por eficacia y
eficiencia no deberíamos malgastar memoria aunque sea mucha cantidad. Para ver todas las
funciones que tenemos en el entorno del intérprete de comandos se ejecuta:
declare -F
Si queremos borrar una función del entorno de trabajo ejecutamos lo siguiente:
unset -f nombre_funcion
Para definir una función sólo basta escribirla directamente en la consola o mediante un script,
de forma que cuando se ejecute se carga en memoria.
Las funciones también pueden devolver valores con la instrucción “return”, veamos un
ejemplo:
#!/bin/bash

# Definimos la función
function hola () {
echo "Hola $1"
return 25
}

# Llamo a la función y le pongo un parámetro, mi nombre.

Hola Ismael

# Guardo el valor del comando ejecutado, que en este caso es

return.
devuelto=$?
echo "El valor del return es is $devuelto?"

URL author
https://medium.com/@benezor79