hola nache, como ya sabemos todos que juande nos va ha dejar un folio con los commandos que creamos que vayamos a necesitar, podrias dejarnos un pequeño resumen de lo que nos hará falta a la hora del examen, mas que ná es por que seguramente el que hagamos nosotros estará incompleto […].

Bien, de lo que más hay que acordarse es de la sintáxis, es decir, de como se escribe el programa. Al fin y al cabo, con un «ls /bin/» o con un «ls /usr/bin/» podemos ver la mayoría de los comandos disponibles. Además, si todo va bien y Juande no nos quita los «man pages»  (dijo que estarían accesibles) disponemos de una gran ayuda a la hora de hacer el script. Por ejemplo, con «man sh» podemos ver un extenso manual de uso de la shell, lo cual nos indica la sintáxis que debemos usar en los scripts. Estaría bien echarle un vistazo en casa para saber donde se encuentran las cosas y saber interpretar la sintáxis que nos plantea esa página de manual. Podemos encontrar la sintáxis de while, de if, de case, etc etc…

Aun así, debemos recordar que seguramente en nuestros scripts nos pedirá cosas como:

-buscar un fichero

-buscar un contenido dentro de un fichero y mostrar una parte

-contar lineas de un fichero o extraer una linea concreta

-bucles (for o while)

-los case

-manejar información obtenida de un comando (ver quién está conectado con who) y separarla con «cut» y «tr»

-pedir que introduzcamos por teclado  una información (parametros) para tratarla desde dentro del script

-pasar información a un script desde la linea de comandos

Vamos a realizar una lista, vamos a completar la que ya publiqué en esta entrada: https://sti.nache.net/2009/12/04/manejo-basico-de-la-terminal-en-gnulinux/

Extraer la linea 10 de un archivo:

head -10 /etc/passwd | tail -1

Extraer la linea 10 y el primer dato de una serie de datos separados por dos puntos

head -10 /etc/passwd | tail -1 | cut -d»:» -f1

Compactar espacios en uno solo:

tr -s «» » »

Reemplazar un caracter por otro:

tr «a» «b»

Obtener el segundo dato de una serie de dato separados por dos puntos:

echo «dato1:dato2:dato3:dato4″ | cut -d»:» -f2

Obtener quién está conectado en la máquina (el nombre de usuario):

who | tr -s»» » » | cut -d» » -f1

Obtener la fecha de conexión de los usuaros conectados:

who | tr -s»» » »  | cut -d» » -f3

Obtener la hora de conexión de los usuarios conectados:

who | tr -s»» » »  | cut -d» » -f4

Obtener usuario, fecha y hora a la vez:

who | tr -s»» » »  | cut -d» » -f1,3,4

Con tr y esa sintáxis obligamos al comando who a compactar todos los espacios en uno solo, para luego decirle a cut que usando un espacio como delimitador de datos, obtenga la fila o filas dadas (-f1 o -f1,3,4)

Obtener los usuarios que empiecen por aj dentro del archivo passwd:

grep ^aj /etc/passwd

Hacer lo anterior y obtener la linea 10:

grep ^aj /etc/passwd | head -10 | tail -1

Usando el sombrerito ^ indicamos que lo que buscamos se encuentra justo al principio de la linea y no en otro lugar

Buscar un fichero:

find /proc -name «cpuinfo» 2>/dev/null

Usando 2>/dev/null  le decimos que toda la basura que no nos interesa la mande a otro lugar y no nos la muestre

Pasando información por parametros:

./script parametro1 parametro2 parametro3

los parametros, dentro del script serán las variables $1 $2 y $3

Pasar información leyendo entrada de teclado:

read nombrevariable

El texto introducido estará en la variable $nombrevariable

Comprobando si dos ficheros son iguales:

cmp fichero1 ficharo2

Enlaces duros:

ln /etc/passwd $HOME/passwd

Enlaces blandos:

ln -s /etc/passwd $HOME/passwd2

Listar el arbol de directorios y ficheros de un lugar dado:

tree /etc/

Buscar archivos:

find -name «nombrearchivo» /lugar/donde/buscamos/

find -name «passwd» /etc/

find -name «pass*» /etc/

Almacenar la salida de un comando en una variable:

variable=`cat /etc/passwd`

Se usan las comillas que hay al lado de la «P», la misma tecla que tiene un ^ y un [

Incrementar el valor de una variable dentro de un bucle:

i=`expr $i + 1`

#!/bin/bash
i=0

while (( $i != 10 )); do

     i=`expr $i + 1`
     echo $i

done

Tened especial cuidado con la sintáxis, comprobad que cerrais todas las comillas que habeis abierto, comprobad que todos los if, los while, los for y los case los cerrais correctamente if (fi) while (done) for (done) case (esac) etc etc…  Si os dá un error de sintáxis comprobad eso y que no os falte un espacio en la linea que os indica o la anterior. Comprobad y tened especial cuidado con las variables, cuando le asignamos un valor NO SE PONE DOLAR.

Recordad que cuando un comando nos muestra varias lineas podemos ir manejando cada una de ellas con el bucle for:

#!/bin/bash

for i in `ls /etc/`; do
  echo $i
done

Recordad que si hacemos lo anterior y las lineas mostradas tienen espacios, debemos camuflarlas con un caracter concreto y luego quitarselo con tr:

#!/bin/bash
for i in `cat /etc/passwd | tr " " "¿" `; do
 echo $i | tr "¿" " "

done

Recordad que cuando ejecutamos un comando, para comprobar si ha ido bien se usa $? (cero bien, uno mal). Cuando no esteis seguros de el valor que os tiene que dar, simplemente os vais a la terminal, ejecutais el comando y a continuación escribís «echo $?» y sabreis el valor que os da ese comando. Por ejemplo:

[usuario@version ~]$ cmp /etc/passwd /etc/passwd

[usuario@version ~]$ echo $?
0
[usuario@version ~]$

Nos devuelve 0, por lo tanto el valor cero significa que los archivos son iguales.

Y por último, recordad el PATH en donde está el script y el PATH donde quereis meter o sacar datos. Si el script está en /home/pepito/script.sh y dentro del script haceis «ls datos/» en realidad estáis haciendo «ls /home/pepito/datos/«. Por el contrario, si haceis «ls /datos/» estais buscando el directorio datos al principio del árbol de directorios (observad la barra invertida).

Como ya he dicho antes, tenéis mas comandos en: https://sti.nache.net/2009/12/04/manejo-basico-de-la-terminal-en-gnulinux/

Y con esto, se finí. Si me acuerdo de algún comando más, lo pondré. Si alguno de vosotros recuerda algún otro comando basta que lo comparta en los comentarios.

Un saludo, see you tomorrow x)

Los scripts no son mas que archivos que contienen comandos del sistema operativo e instrucciones que nos brinda la shell sobre la que trabajamos. La shell más utilizada en GNU/Linux es la llamada Bash.

Cuando creamos un script en GNU/Linux utilizando Bash, el sistema operativo nos ofrece la posibilidad de utilizar todos sus comandos dentro de nuestro script (ls, rm, cp, cat) y la shell Bash nos ofrece instruciones como while, if, if else, for, además de permitirnos crear variables para almacenar información.

Por lo tanto, un script para nuestro cometido es una conjunción de comandos GNU/Linux junto con controles de flujo y variables sobre Bash.

Cuando creamos un script, debemos SIEMPRE indicar en la primera línea del archivo el tipo de shell que queremos usar. Para esto, usaremos la almoadilla con exclamación (#!) seguida de la ruta donde se encuentra la shell:

#!/bin/bash

No me vale ponerlo en la segunda linea, si digo que en la primera linea, es en la primera linea. De lo contrario, golpe de remo ¿eh?

Bien, una vez hecho esto, el resto del archivo estará destinado a nuestro script. Lo primero que vamos a hacer es crear una variable con información y luego mostrar el contenido de dicha variable con un echo.

#!/bin/bash
variable="caraculo"
echo $variable

Nótese que las variables en bash se crean sin usar el símbolo $ pero cuando queremos acceder a su contenido, le ponemos un $ delante. Nótese también, que en bash no usamos punto y coma (;) al final de cada instrucción.

El echo en bash funciona de forma similar a como funciona en php. Cuando queremos mostrar una sóla variable, prescindimos de comillas. Cuando queremos mostrar texto y una variable; entonces las usamos:

#!/bin/bash
variable="kkfuti"
echo "la variable contiene $cacafuti"

En php, usabamos puntos para separar texto de variable, en bash prescindiremos de éstos. La tarea se simplifica:

#!/bin/bash
variable="tikitiki"
echo "El contenido " $tikitiki " esta almacenado en variable"

Control de flujos con if

La forma de utilizar if en bash es algo mas engorrosa que en php (o C por consecuencia), pero os voy a enseñar un truquito para poder usar la misma sintáxis. Esto es, los dobles parentesis.

#!/bin/bash
variabletexto="hola"
variablenumero=9
if (( $variabletexto == "hola" ));then
echo "la variabletexto contiene hola"
fi

if (( $variablenumero > 5 ));then
echo "la variablenumero es mayor que 5"
fi

Gracias al truquito if (( condicion ));then podemos usar la sintáxis que aprendímos en php. Recordad que if  se cierra con fi (if al revés) y entre estos se aloja el código que se ejecutará si la condición entre los dobles parentesis es cierta (1).

Para comprobar si un archivo o un directorio existe, hay que modificar el truco de antes y reemplazar los parentesis por un «[» y un «]» (corchetes) y usar las expresiones condicionales:

#!/bin/bash
if [   -f   "/etc/resolv.conf"   ];then
echo "el archivo existe"
fi

if [   -d   "/etc/"   ];then
echo "el directorio existe"
fi

Cuidado con esto: las expresiones contenidas dentro de los corchetes DEBEN estar separadas por espacios de los dichos corchetes. De lo contrario fallará.

Ni que decir tiene que podemos usar el método aprendido en clase ayudados del comando brindado por el sistema operativo; test:

#!/bin/bash
if test -f  "/etc/resolv.conf"
then
echo "el archivo existe"
fi


if test -d  "/etc/"
then
echo "el  archivo existe"
fi

Recordad, -f para archivos (file) y -d para directorios (directory).

Antes de terminar, comentar que bash también permite el uso de if else. (si la condición es cierta ejecuta esto, de lo contrario, ejecuta esto otro). Su uso es muy sencillo:

#!/bin/bash
variable="hola"
if (( $variable == "hola" ));then
     echo "La variable contiene hola, condicion cierta"
else
     echo "La variable NO contiene hola, condicion falsa"
fi

Observad que añadiendo la palabra else entre un código y otro, podemos controlar cual ejecutar dependiendo de si la condición es cierta (1) o falsa (0).

Y hasta aquí la primera entrega de Bash Scripting Básico. Continuará… x)

listar el contenido de un directorio:

ls : normalito

ls -l :datos adicionales de los directorios

ls -lh :datos adicionales y legibles para los seres humanos

ls -lha :datos adicionales, legibles y los ocultos

crear un archivo vacío

touch archivo

crear un archivo nuevo con contenido dentro

echo «contenido» >archivo

obtener el contenido de un archivo

cat archivo :obtenemos el contenido enterito

more archivo :lo obtenemos poco  a poco

less archivo :igual que lo anterior

copiar archivos y directorios

cp archivo1 archivo2 :copia normal

cp -rf directorio1 directorio2 :copia forzada y recursiva de directorios

moviendo archivos de lugar

mv /lugar1/archivo1 /lugar2/archivo2

borrar archivos y directorios

rm archivo :borrado normal

rm -f archivo :fuerza el borrado en archivos con protección de escritura

rm -rf directorio :fuerza a borrarse un directorio que no esté vacío

buscar archivos

find /ruta/donde/busca -name «*archivoquebuscas*» : los asteriscos son comodines, indican que antes y después del nombre puede haber cualquier cosa

buscar un texto, palabra o caracter en un archivo

grep «loquesea» archivo :busqueda normal

grep -i «loquesea» archivo :busqueda ignorando mayusculas y minusculas

grep -v «loquesea» archivo :busqueda inversa, muestra todo menos lo que le digamos

comparar archivos

diff archivo1 archivo2

cmp archivo1 archivo2

ver quién está conectado en la máquina

who

w