1. LINUX Básico
TAKASHI SUGASAWA
LINUX Básico (8. Shells(3)) 1

2. Programa del curso
1. Introducción a LINUX
2. Operación básica de LINUX
3. Operación de archivos y directorios
4. Editor vi
5. Comprensión del sistema de ficheros
6. Shells(1)
7. Shells(2)
8. Shells(3)
9. Otros comandos
LINUX Básico (8. Shells(3)) 2

3. LINUX Básico
8. Shells(3)
Índice
8.1 Introducción a scripts de shell
8.2 Redacción de scripts de shell
8.3 Programación con control
8.4 Procesos de scripts de shell
8.5 Ajuste del ambiente del shell
LINUX Básico (8. Shells(3)) 3

4. 8.1 Introducción a scripts de shell
(1) Comprensión de los scripts de shell
• Normalmente escribimos los comandos en la terminal
usando el teclado.
• O sea los comandos pueden provenir de un archivo.
• Un script de shell es una colección de uno o más
comandos de shell en un archivo.
• Para ejecutar los comandos en el script de shell, basta
con escribir el nombre del archivo.
• Las ventajas de scripts de shell son que:
– No tiene que volver a escribir una secuencia de comandos.
– Determina los pasos para llevar a cabo un objeto una vez.
– Simplifica operaciones para usted mismo y para otros.
LINUX Básico (8. Shells(3)) 4

5. 8.1(2) Un ejemplo de scripts de shell
• Ahora vamos a crear un script de shell “donde” que
ejecute 3 comandos “whoami”, “hostname”, “pwd” en
secuencia.
1. Primero, confirme que está en el su directorio base.
[usr000@linuxpc usr000]$ pwd
/home/usr000
2. Inicie “vi” con el nombre del archivo, “vi donde”.
[usr000@linuxpc usr000]$ vi donde
3. Escriba como siguiente en el “vi”.
whoami
hostname primero teclee “i”, después escriba el texto.
pwd
4. Salga de “vi” guardando el archivo. teclee “ESC”, “Z”, “Z”
LINUX Básico (8. Shells(3)) 5

6. 5. Confirme el existencia el archivo y su contenido.
[usr000@linuxpc usr000]$ ls -l donde
-rw-rw-r-- 1 usr000 usr000 20 sep 22 09:29 donde
[usr000@linuxpc usr000]$ cat donde
whoami
hostname
pwd
6. Agregue el permiso de ejecución al archivo.
[usr000@linuxpc usr000]$ chmod +x donde
[usr000@linuxpc usr000]$ ls -l donde
-rwxrwxr-x 1 usr000 usr000 20 sep 22 09:29 donde
7. Ejecute el archivo.
[usr000@linuxpc usr000]$ ./donde
usr000
linuxpc el resultado del script de shell
/home/usr000
Si no sale así, chequee el contenido o los permisos del archivo.
LINUX Básico (8. Shells(3)) 6

7. 8.1(3) Arranque de scripts de shell
• Podemos ejecutar un script de shell como sigue
también.
bash <nombre_de_script>
[usr000@linuxpc[usr000@linuxpc usr000]$ ./donde
usr000
linuxpc
/home/usr000 igual
[usr000@linuxpc usr000]$ bash donde
usr000
linuxpc
/home/usr000
En este caso, el permiso de ejecución no es necesario.
[usr000@linuxpc usr000]$ chmod -x donde
[usr000@linuxpc usr000]$ ls -l donde
-rw-rw-r-- 1 usr000 usr000 20 sep 22
09:29 donde
[usr000@linuxpc usr000]$ bash donde
usr000
linuxpc
/home/usr000
LINUX Básico (8. Shells(3)) 7

8. • El shell tiene opciones que son convenientes en el
caso de la depuración.
-x: El shell sale cada comando (detrás de un “+”) a stderr
antes de ejecutarlo.
-v: El shell sale sus entradas a stderr al captar los.
-n: El shell solamente pasa los comandos, no ejecuta los.
[usr000@linuxpc usr000]$ bash -x donde
+ whoami
usr000
+ hostname
linuxpc
+ pwd
/home/usr000
[usr000@linuxpc usr000]$ bash -nv donde
whoami
hostname
pwd
LINUX Básico (8. Shells(3)) 8

9. 8.1(4) Variedad de scripts de shell
• Cada shell (BASH, Shell Bourne, Shell C, tcsh, ...) tiene
su manera de descripción de scripts.
BASH es el shell derivado de Shell Bourne. Por eso, BASH
puede ejecutar los scripts de Shell Bourne.
En este curso, aprendemos scripts de BASH.
LINUX Básico (8. Shells(3)) 9

10. 8.2 Redacción de scripts de shell
(1) Selección de shell que se arranca
• La descripción como sigue en la cabeza del script, selecciona el
tipo del shell que se arranca.
#!/bin/bash
nombre de ruta de acceso del shell
Vamos a escribirlo como frase hecha, para definir el tipo del
script de shell.
[usr000@linuxpc usr000]$ cat donde2
#!/bin/bash
whoami
hostname
pwd
[usr000@linuxpc usr000]$ ./donde2
usr000
linuxpc
/home/usr000
LINUX Básico (8. Shells(3)) 10

11. 8.2(2) Uso de comentarios
• El signo “#” le indica al shell el principio de un comentario. Cada
carácter a partir del signo “#” hasta el final de la línea es parte
de ese comentario.
• El shell ignora los comentarios. Un comentario es una nota para
usted mismo o para cualquiera que lea el script.
[usr000@linuxpc usr000]$ cat donde3
#!/bin/bash
# Esto es un comentario.
whoami # Esto es un comentario también.
hostname
pwd
[usr000@linuxpc usr000]$ ./donde3
usr000
linuxpc
/home/usr000
LINUX Básico (8. Shells(3)) 11

12. 8.2(3) Uso de variables
• Variables son disponibles en scripts de shell: podemos asignar
un valor a un variable y acceder el valor guardad en la variable.
[usr000@linuxpc usr000]$ cat donde4
#!/bin/bash
# "donde4": una prueba de script de shell
variable1=`whoami` Asignación del valor al variable
variable2=`hostname`:`pwd`
echo "Su nombre del usuario es $variable1."
echo "Ahora usted está en $variable2."
Sustitución del variable
[usr000@linuxpc usr000]$ ./donde4
Su nombre del usuario es usr000.
Ahora usted está en linuxpc:/home/usr000.
LINUX Básico (8. Shells(3)) 12

13. 8.2(4) Uso del comando “read”
• El comando “read” toma la siguiente línea de entrada y la
asigna a una variable.
[usr000@linuxpc usr000]$ cat quien
#!/bin/bash
# "quien": Presenta quién es el usuario de su selección.
Suprime aparte
echo -n "Nombre del usuario: "
read usuario Nombre de un variable
grep $usuario /home/copropiedad/cuenta.txt
Sustitución del variable
[usr000@linuxpc usr000]$ ./quien
Nombre del usuario: usr000 Entrar de la teclado (+[Enter])
usr000 Sugasawa Takashi
LINUX Básico (8. Shells(3)) 13

14. 8.2(5) Uso del parámetros de línea de comando
• Podemos consultar los parámetros de línea de comando con los
variables $1, $2, ..., $9.
[usr000@linuxpc usr000]$ cat quien2
#!/bin/bash
# "quien2": Presenta quién es el usuario de su selección.
Primer parámetro
grep $1 /home/copropiedad/cuenta.txt
Esto es necesario.
[usr000@linuxpc usr000]$ ./quien2 usr000
usr000 Sugasawa Takashi
$0 $1
$0: El nombre del comando.
$*: Todos los parámetros.
$#: El número de parámetros.
LINUX Básico (8. Shells(3)) 14

15. 8.3 Programación con control
(1) Uso de la estructura if
• “if comando then ... else ... fi” es una estructura de decisión que
le permite seleccionar uno de dos cursos de acción basados en el
resultado de un comando.
if comando
Si el resultado del
then comando es 0, ...
...
Todos los programas tienen
else Si no, ... su valor de resultado.
... Generalmente el valor 0
fi representa el estado de
salida del programa con
éxito.
El estado de salida del comando ejecutado últimamente, se
puede saber con el variable "$?".
LINUX Básico (8. Shells(3)) 15

16. (40) test Regresa un estado de salida de cero cuando
lo que se probó fue cierto.
(ej.) test -f FILE1
test $variable1 = STR1
test $variable2 -lt 10
-f FILE cierto si existe el fichero FILE y es regular.
-d FILE cierto si el fichero FILE es un directorio.
STR1 = STR2 cierto si la cadena STR1 es igual a la cadena STR2.
STR1 != STR2 no es igual
INT1 -eq INT2 cierto si el número INT1 es igual al número INT2.
INT1 -ne INT2 no es igual
INT1 -gt INT2 mayor que
INT1 -ge INT2 mayor que o igual
INT1 -lt INT2 menor que
INT1 -le INT2 menor que o igual
LINUX Básico (8. Shells(3)) 16

17. [usr000@linuxpc usr000]$ cat quien3
#!/bin/bash
# "quien3": Presenta quién es el usuario de su selección.
El número de parámetros.
if test $# -ge 1 Si el número de parámetros es mayor o igual que 1, ...
then
grep $1 /home/copropiedad/cuenta.txt
else
echo -n "Nombre del usuario: "
read usuario
grep $usuario /home/copropiedad/cuenta.txt
fi
[usr000@linuxpc usr000]$ ./quien3 usr000
usr000 Sugasawa Takashi
[usr000@linuxpc usr000]$ ./quien3
Nombre del usuario: usr000
usr000 Sugasawa Takashi
LINUX Básico (8. Shells(3)) 17

18. 8.3(2) Uso de la estructura for
• “for nombre in palabras do... done” es una estructura iterativa.
Un nombre del variable (ej.) $*
*.txt
a ab abc abcd
`seq 1 10`
for i in $* Todos los parámetros.
do
... por ejemplo,
$i si hay 3 palabras,
... se repite 3 veces.
done Podemos acceder cada palabra así.
LINUX Básico (8. Shells(3)) 18

19. [usr000@linuxpc usr000]$ cat quien4
#!/bin/bash
# "quien4": Presenta quién es el usuario de su selección.
if test $# -ge 1
then
for i in $*
do
grep $i /home/copropiedad/cuenta.txt
done
else
echo -n "Nombre del usuario: "
read usuario
grep $usuario /home/copropiedad/cuenta.txt
fi
[usr000@linuxpc usr000]$ ./quien4
Nombre del usuario: usr000
usr000 Sugasawa Takashi
[usr000@linuxpc usr000]$ ./quien4 usr000
usr000 Sugasawa Takashi
[usr000@linuxpc usr000]$ ./quien4 usr000 usr001
usr000 Sugasawa Takashi
usr001 Acosta Alonzo Jessica Elizabeth
LINUX Básico (8. Shells(3)) 19

20. 8.4 Procesos de scripts de shell
Aquí hay un script de shell ...
[usr000@linuxpc 8vo]$ cat ej_cd
#!/bin/bash
# "cd" en el script de shell
echo -n "pwd: "
pwd
echo "cd /:"
cd / En el script de shell, se ejecuta el comando "cd".
echo -n "pwd: "
pwd
[usr000@linuxpc 8vo]$ pwd Antes de ejecutar el script
/home/usr000/8vo
En el script, se ejecuta el
[usr000@linuxpc 8vo]$ ./ej_cd
pwd: /home/usr000/8vo comando "cd", y ciertamente
cd /: se ha cambiado el directorio
pwd: / de trabajo actual.
[usr000@linuxpc 8vo]$ pwd después de ejecutar el script
/home/usr000/8vo pero, no se ha cambiado...
LINUX Básico (8. Shells(3)) 20

21. • Normalmente el script de shell se ejecuta en el otro
proceso.
• Las operaciones en el una proceso no ejercen
influencia sobre otros procesos.
Proceso de
Shell
Proceso de
otro shell
./ej_cd
espera cd /
LINUX Básico (8. Shells(3)) 21

22. • Utilizando el comando "source", se ejecuta el script de
shell en el mismo proceso.
[usr000@linuxpc 8vo]$ pwd ". ej_cd" también tiene
/home/usr000/8vo mismo efecto.
[usr000@linuxpc 8vo]$ source ej_cd
pwd: /home/usr000/8vo
cd /:
pwd: /
Proceso de
[usr000@linuxpc /]$ pwd Shell
/
Esta vez, se ha cambiado el source ej_cd
directorio de trabajo actual.
cd /
LINUX Básico (8. Shells(3)) 22

23. 8.5 Ajuste del ambiente del shell
• Los cambios del ambiente del shell (umask, variables)
no tienen su efecto después de la terminación del
proceso. Al registrarse la próxima vez, tenemos que
hacerlos otra vez.
• Podemos escribirlos en el archivo “.bashrc” en el
directorio base, que el bash ejecuta automáticamente
al iniciar.
[usr001@linuxpc usr001]$ ls -a ~
. .. .bash_history .bash_logout .bash_profile .bashrc
.gtkrc
Al hacer logout, se ejecuta.
Al hacer login, se ejecutan.
Cuando el bash inicia como un
shell interactivo, se ejecuta.
LINUX Básico (8. Shells(3)) 23

24. Ejemplo de “.bashrc”
[usr001@linuxpc ~]$ cat ~/.bashrc
# .bashrc
# User specific aliases and functions
# Source global definitions
if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
umask 022 Asigna el valor del umask.
PS1="[u@h w]$ " Cambia el formato del indicador del shell.
alias ll='ls -l'
Definen alias del comando
alias la='ls -a'
Los cambios van a tener su efecto, cuando se inicia el shell la
próxima vez.
Tenemos que chequear el archivo antes de rehacer Login.
LINUX Básico (8. Shells(3)) 24

25. ¡ Muchas gracias por su atención !
¡ Hasta pronto !
LINUX Básico (8. Shells(3)) 25