El shell-bash
Upcoming SlideShare
Loading in...5
×
 

El shell-bash

on

  • 1,200 views

 

Statistics

Views

Total Views
1,200
Views on SlideShare
1,200
Embed Views
0

Actions

Likes
0
Downloads
23
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

El shell-bash El shell-bash Presentation Transcript

  • El Shell Bash
  • El Shell Bash
    • Ficheros de configuración y variables de entorno
    • Programación básica del Shell
    • Control de flujo
    • Opciones de la línea de comandos, expresiones aritméticas y arrays.
  • Ficheros de configuración (…)
    • /etc/profile se ejecuta siempre para todos los usuarios al logarnos en el sistema.
    • Posteriormente se comprueba si en el home del usuario existe el archivo .bash_profile (puede llamarse también .profile o . bash_login ), en el se puede establecer configuración de entorno personalizada.
    • Si queremos aplicar cambios en .bash_profile sin tener que volvernos a logar, usariamos el comando source.
    • Si lo que queremos es ejecutar opciones de entorno para cada Shell que ejecutemos (abrir un Xterm), podemos usar el archivo .bashrc. Este archivo permite definir configuraciones adicionales.
    • Por último .bash_logout define ordenes que se ejecutarán al abandonar la cuenta de usuario, borrar ficheros temporales o almacenar datos de usuarios.
    • Ejemplo comando source:
    • $ source .bash_profile
  • Ficheros de configuración (…)
    • Variables de entorno:
      • Permiten configurar el entorno en el que se ejecutan los programas.
      • IMP . No deben contener espacios entre nombre y valor
      • Para obtener el valor de la variable debemos usar el operador ‘$’.
      • Para eliminar una variable usaremos el comand unset .
      • Ejemplos:
      • $ NOMBRE=‘Guillermo Hernández’
      • $ echo $NOMBRE
      • Guillermo Hernández
      • $ unset NOMBRE
  • Ficheros de configuración (…)
    • Podemos configurar nuestro prompt configurando las variables de entorno PS1 y PS2. Los valores que podemos asignarles aparecen en la tabla 3.2, página 43.
      • Ejemplo que mostraría # como prompt para root y $ para el resto, opción $:
      • ~-> PS1=‘w$’
      • ~$
  • Ficheros de configuración (…)
    • Hay una serie de variables de entorno predefinidas en el sistema, ver tabla 3.3 de la página 44.
    • Las variables de entorno tal y como las hemos definido solo podrían ser usadas por nuestro Bash y los comando interactivos que ejecutemos, nunca por los subprocesos que Bash arranque. Para ello debemos exportarlas:
        • $ EDITOR=/sw/bin/joe
        • $ export EDITOR
    • Para visualizar las variables de entorno exportadas usaremos el comando export o env . Para obtener las variables no exportadas usaremos set.
  • El Shell Bash
    • Ficheros de configuración y variables de entorno
    • Programación básica del Shell
    • Control de flujo
    • Opciones de la línea de comandos, expresiones aritméticas y arrays.
  • Programación básica del Shell
    • Un script es un fichero que contiene comados Bash ejecutables. Por ejemplo .bash_profile o .bashrc.
    • Para ejecutar un script lo haremos usando el comando source , (local al Shell y por tanto verá todas las variables de entorno del Shell). Ó asignandole permiso de ejecución lo cual implicará que se ejecutará en un subShell que ya no verá las variables de entorno del Shell padre, sólo las que se hayan exportado.
  • Programación básica del Shell
    • Funciones:
      • Son extensiones a los scripts, son heredadas del Bourne Shell.
      • Se ejecutan dentro de la memoria del propio Shell, por lo que son más eficientes que ejecutar otro script.
      • Bourne Shell C Shell
        • function nombrefn nombrefn()
        • { {
        • … . ….
        • } }
      • Para eliminar una función se ejecutará unset –f nombrefn.
      • Para ejecutar una función se escribirá su nombre seguida por los argumentos que requiera, al igual que un comando.
      • Ver orden de preferencia de símbolos página 47.
  • Programación básica del Shell
    • Variables del Shell:
      • Por defecto todas las variables son de tipo cadena.
      • Por convenio las variables que queramos exportar se escribirán en mayúsculas, las que no en minúsculas.
      • Los parámetros posicionales son los encargados de recibir los argumentos de un script y parámetros de una función: $1,$2,$3 … el parámetro $0 recibe el nombre del script que se ejecuta:
      • Ejemplo: ejemplo.sh
      • #!/bin/bash
      • # Ejemplo de script que recibe parámetros
      • echo “El script se llama $0”
      • echo “Recibe los parámetros $1, $2, $3 y $4”
      • $ chmod g+x,o+x ejemplo.sh
      • $ ejemplo hola adios
      • El script ./ejemplo.sh
      • Recibe los parámetros hola adios
  • Programación básica del Shell
    • Variables locales y globales:
      • Los parámetros posicionales son siempre locales al script o función, mientras que el resto de variables del script serán siempre globales.
        • #!/bin/bash
        • # Script que llama a una función para saludar de nombre saluda.sh
        • function diHola
        • {
        • echo “Hola $1”
        • }
        • $ saluda.sh Guille
        • Hola
  • Programación básica del Shell
      • Si quisieramos que la función recibiera el parámetro de entrada al script haríamos:
        • #!/bin/bash
        • # Script que llama a una función para saludar de nombre saluda.sh
        • function diHola
        • {
        • echo “Hola $1”
        • }
        • diHola $1
      • Al ejecutarlo tendríamos lo que buscamos:
        • $ saluda.sh Guille
        • Hola Guille
  • Programación básica del Shell
      • El resto de variables de un script serán siempre globales a éste:
        • #!/bin/bash
        • # Ejemplo de variables globales dondeestoy
        • function EstasAqui
        • {
        • donde=‘Dentro de la función’
        • }
        • donde=‘En el script’
        • echo $donde
        • EstasAqui
        • echo $donde
      • Al ejecutar el script tendríamos la siguiente respuesta:
        • $ dondeestoy
        • En el script
        • Dentro de la función
  • Programación básica del Shell
      • Si queremos que una variable no posicional sea local, utilizaremos el modificador local :
        • #!/bin/bash
        • # Ejemplo de variables globales dondeestoy
        • function EstasAqui
        • {
        • local donde=‘Dentro de la función’
        • }
        • donde=‘En el script’
        • echo $donde
        • EstasAqui
        • echo $donde
      • Al ejecutar el script con este cambio tendríamos la siguiente respuesta:
        • $ dondeestoy
        • En el script
        • En el script
  • Programación básica del Shell
      • Comentar también por último que las variables globales también se pueden definir dentro de una función.
      • Existen variables con un significado especial. Estas son: $#, $@ y $*
      • $# nos devuelve el número de parámetros que recibe una función en formato cadena.
      • $* y $@ nos devuelven todos los argumentos recibidos por un script o función.
  • Programación básica del Shell
      • Ejemplo: recibe.sh
      • #Ejemplo de script que recibe parámetros y los muestra
      • echo “El script $0 recibe $# argumentos que son:” $*
      • echo “El script $0 recibe $# argumentos que son:” $@
      • Al ejecutarlo obtendríamos:
        • $ recibe hola adios
        • El script ./recibe.sh recibe 2 argumentos que son: hola adios
        • El script ./recibe.sh recibe 2 argumentos que son: hola adios
      • Al entrecomillar (comillas simples), los parámetros $@ y $* es cuando aparecen sus diferencias. La primera, es que $* nos permite separar los argumentos con el carácter especificado en la variable IFS (Internal Field Separator), mientras que $@ siempre usa un espacio en blanco.
  • Programación básica del Shell
      • Ejemplo: recibe.sh
      • #Ejemplo de script que recibe parámetros y los muestra
      • IFS=‘,’
      • echo “El script $0 recibe $# argumentos que son:” $*
      • echo “El script $0 recibe $# argumentos que son:” $@
      • Al ejecutarlo obtendríamos:
        • $ recibe hola adios
        • El script ./recibe.sh recibe 2 argumentos que son: hola,adios
        • El script ./recibe.sh recibe 2 argumentos que son: hola adios
  • Programación básica del Shell
      • Hay otra diferencia entre $* y $@, y se produce cuando usamos parámetros entrecomillados. (ver página 54)
      • Las reglas generales que debemos seguir al usar estas variables son las siguientes:
        • Siempre conviene entrecomillar las variables $* y $@ para evitar que los argumentos que contengan espacios sean malinterpretados.
        • Si queremos cambiar el delimitador que separa los argumentos deberemos usar $* y la variable IFS.
        • Si lo que queremos es pasar los argumentos a una función debemos usar $2 entrecomillado.
  • Programación básica del Shell
    • Expansión de variables:
      • $VAR es una simplificación de la sintaxis general ${VAR}, que es la manera en la que debemos expandir una variable.
      • Ejemplo:
      • $ nombre=Fernando
      • $ apellido=Lopez
      • $ echo “$nombre_$apellido”
      • Lopez
      • El sistema buscaría la variable nombre_, que no existe. En cambio, si ejecutamos:
      • $ echo “${nombre}_$apellido”
      • Fernando_Lopez
  • Programación básica del Shell
    • Operadores cadena:
      • Los operadores cadena permiten manipular cadenas sin necesidad de escribir complicadas rutinas de procesamiento. Los operadores cadena más importantes pueden verse en la tabla 4.1, página 57.
      • Ejemplos:
      • Imaginemos que tenemos un fichero con los nombres y los sueldos de un conjunto de clientes:
      • $ cat clientes
      • 45340 Jose Carlos Martinez
      • 24520 Mari Carmen Gutierrez
      • 450 Luis Garcia Santos
      • … .
      • Escribir un script que imprima los N clientes que más saldo tienen. El script recibirá como primer argumento el nombre del fichero, y como segundo opcionalmente el número de clientes a imprimir (por defecto 5).
  • Programación básica del Shell
      • Solución:
      • # Script que saca los mejores clientes
      • # Tiene la forma:
      • # mejoresclientes <fichero> [<cuantos>]
      • fichero=$1
      • cuantos=$2
      • defecto=5
      • sort –nr $fichero | head -${cuantos:-$defecto}
  • Programación básica del Shell
    • Operadores de búsqueda de patrones:
      • Se utilizan para eliminar partes de la ruta de un fichero, como pueda ser el directorio o el nombre del fichero.
      • En la tabla 4.2 de la página 60.
      • Ejemplos:
      • $ruta=/usr/local/share/qemu/bios.core.bin
      • Operadors Resultado
      • ${ruta##/*/} bios.core.bin
      • ${ruta#/*/} local/share/qemu/bios.core.bin
      • ruta /usr/local/share/qemu/bios.core.bin
      • ${ruta%.*} /usr/local/share/qemu/bios.core
      • ${ruta%%.*} /usr/local/share/qemu/bios
  • Programación básica del Shell
    • Sustitución de comandos:
      • Nos permite usar la salida de un comando como si fuera el valor de una variable. La sintaxis es:
      • $(comando)
      • Ejemplo:
      • $midir=$(ls $HOME)
      • $echo $midir
      • Desktop Documents Library Movies Music Pictures Public Sites autor jdevhome tmp xcode
      • También podemos cargar el contenido de un fichero en una variable de entorno con la sintaxis $(<fichero)..
      • $copyrigth=$(<copyrigth.txt)
      • Otro comando interesante es el operador longitud.
      • $nombre=“Guillermo”
      • ${#nombre}
      • $9
  • El Shell Bash
    • Ficheros de configuración y variables de entorno
    • Programación básica del Shell
    • Control de flujo
    • Opciones de la línea de comandos, expresiones aritméticas y arrays.
  • Control de flujo
    • Sentencias if,elif y else:
      • if condicion if condicion ; then
      • then sentencias
      • sentencias elif condicion ; then
      • elif condicion sentencias
      • then else
      • sentencias sentencias
      • else fi
      • sentencias
      • fi
      • Este lenguaje nos obliga a que las sentencias estén organizadas con retornos de carro. Si queremos hacerlo en la misma línea debemos utilizar el separador de comandos en Bash (;).
  • Control de flujo
    • En UNIX los comando terminan devolviendo un código numérico al que se llama código de terminación, que indica si el comando tuvo éxito o no.
    • Un código de terminación 0 indica que el comando tuvo éxito y un código entre 1 y 255 significa que se produjo un error con un significado determinado.
    • El significado de los códigos dependerá del comando. Por ejemplo el comando diff devuelve 0 si no hay diferencas entre dos ficheros, 1 cuando hay diferencias y 2 cuando se produce algún error (por ejemplo que no se pueda leer alguno de ellos).
    • La sentencia if comprueba el código de terminación de un comando en la condicion, si éste es 0 la condición se evalua como cierta.
    • if comando ; then
    • procesamiento normal
    • else
    • procesamiento con errores
    • fi
  • Control de flujo
    • Operadores lógicos
      • Son && (and lógico), || (or lógico) y ! (not lógico).
      • Estos operadores pueden combinarse en una sentencia if para realizar condiciones más complejas.
      • if cd /tmp && cp 001.tmp $HOME ; then
      • … .
      • fi
      • Si el primer comando no tiene éxito no se ejecutaría el siguiente.
      • El comando test nos permite evaluar si un comando es correcto sin ejecutarlo. Un sinónimo de test son los corchetes [ ].
      • [ cadena1 = cadena2 ]
      • Los espacios son obligatorios.
  • Control de flujo
    • Operadores de comparación de cadenas. Tabla 5.1 en la página 74.
      • Pueden usarse con el comando test
    • Operadores para la númerica de enteros. Tabla 5.2 en la página 76.
    • Ejemplos:
    • if [ $reintegro -le $saldo -a
    • $reintegro -le $max_cajero ]
    • then
    • … ..
    • fi
    • Operadores para la comprobación de atributos de ficheros. Tabla 5.3 en la página 77.
  • Control de flujo
    • El bucle for :
      • La sintaxis es la siguiente:
        • for var [in lista]
        • do
        • .....
        • sentencias que usan $var
        • .....
        • done
      • La semántica es distinta a los bucles for de otros lenguajes. Este se parece más a un for each in lista . Se repite tantas veces como elementos haya en la lista entre corchetes.
      • Si se omite la lista, por defecto se recorre el contenido de la variable de entorno $@.
  • Control de flujo
    • Ejemplos:
    • for planeta in Mercury Venus Terra Marte Jupiter Saturno
    • do
    • echo $planeta # imprimimos cada planeta
    • done
      • La lista puede contener comodines. El siguiente ejemplo recorrería todos los ficheros del directorio actual:
        • for fichero in *
        • do
        • ls –l “$fichero”
        • done
  • Control de flujo
      • Para recorrer todos los parámetros que recibe un script, usaremos “$@”. Es importante entrecomillar la variable $@ ya que si no, no se interpretan bien los parámetros con espacios.
      • #!/bin/bash
      • # bucle que recorre todos los argumentos recibidos
      • for arg in “$@”
      • do
      • echo “Elemento:$arg”
      • done
      • La ejecución sería:
      • $ recibe “el perro” “la casa”
      • Elemento:El perro
      • Elemento:La casa
  • Control de flujo
    • Bucles while y until .
      • Su sintaxis es la siguiente:
      • while comando until comando
      • do do
      • .... ......
      • done done
      • El comando también puede ser una opción encerrada entre []. La diferencia entre while y until , es que while se ejecuta mientras el resultado del comando sea exitoso, es decir 0. Mientras que until se ejecuta hasta que el código de terminación sea exitoso. Por tanto until se puede interpretar como un bucle que ejecuta un comando hasta que tenga éxito.
  • Control de flujo
    • Ejemplo:
    • #!/bin/bash
    • # Script que muestra los directorios del PATH
    • path=$PATH
    • while [ $path ] ; do
    • echo ${path%%:*}
    • if [ ${path#*:} = $path ] ; then
    • path=
    • else
    • path=${path#*:}
    • fi
    • done
  • Control de flujo
    • La sentencia case :
      • Mientras que en otros lenguajes de programación esta sentencia permite comprobar el valor de una variable simple, como un entero o un carácter, en Bash permite realizar una comparación de patrones con la cadena a examinar:
      • case cadena in
      • patron1)
      • sentencias ;;
      • patron2)
      • sentencias ;;
      • .....
      • esac
      • Los patrones pueden ser varios separados por |. Si cadena cumple alguno de los patrones, se ejecutan sus correspondientes sentencias (que se separan por ;) hasta ;;.
  • Control de flujo
    • Ejemplo:
    • #!/bin/bash
    • # Script que convierte ficheros de imagen a formato .jpg
    • for fichero in “$@”
    • do
    • fichero_ppm=${fichero%.*}.ppm
    • case $fichero in
    • *.jpg) exit 0;;
    • *.tga) tgatoppm $fichero > $fichero_ppm;;
    • *.xpm) xpmtoppm $fichero > $fichero_ppm;;
    • esac
    • fichero_salida=${fichero_ppm%.ppm}.jpg
    • pnmtojpeg $fichero_ppm > $fichero_salida
  • Control de flujo
    • Sentencia select :
      • La sentencia select nos permite generar fácilmente un menú simple. Su sintaxis es la siguiente:
        • select variable [in lista]
        • do
        • sentencias que usan $ variable
        • done
      • Al igual que el bucle for, si omitimos [in lista], se recorre $@.
      • La sentencia genera un menú con los elementos de lista , donde asigna un número a cada elemento, y pide al usuario que introduzca un número. El valor elegido lo almacena en variable , y el número elegido en la variable REPLY . Una vez elegida una opción por parte del usuario, se ejecuta el cuerpo de la sentencia y el proceso se repite en un bucle infinito.
      • Aunque es un bucle infinito, podemos forzar su salida con la sentencia break . Por otro lado, el prompt que utiliza para el menú, puede definirse en la variable PS3. Por defecto vale #?.
  • El Shell Bash
    • Ficheros de configuración y variables de entorno
    • Programación básica del Shell
    • Control de flujo
    • Opciones de la línea de comandos, expresiones aritméticas y arrays.
  • Opciones de la línea de comandos
    • La sentencia shift :
      • Los comandos UNIX suelen tener el formato siguiente:
      • comando [opciones] argumentos
      • Es decir las opciones suelen preceder a los argumentos y suelen tener un guión delante.
      • Las opciones al igual que los argumentos residen en las variables posicionales. Por ejemplo si ejecutamos hacer –o esto.txt aquello.txt , en $1 tendríamos –o , en $2 tendríamos esto.txt y en $3 tendríamos aquello.txt . Por tanto para tratar las opciones no tendríamos problemas, excepto por el motivo de que son opcionales .
  • Opciones de la línea de comandos
    • if [ $1 = -o ] ; then
    • Ejecuta la operación con $2 y $3
    • else
    • Ejecuta la operación con $1 y $2
    • fi
      • En consecuencia el número de opciones crece y la programación se vuelve bastante engorrosa.
      • La sentencia shift nos permite solucionar esto de una forma elegante. La sintaxis de esta sentencia es:
        • shift [n]
  • Opciones de la línea de comandos
    • [n] opcional, es el número de desplazamientos a la izquierda que queremos hacer con los argumentos, si se omite n=1. Podemos reescribir el ejemplo anterior utilizando shift.
      • if [ $1 = -o ] ; then
      • Procesa –o
      • shift
      • fi
      • Ejecuta las operaciones con $1 y $2
  • Opciones de la línea de comandos
    • El siguiente ejemplo hacer recibe tres posibles opciones –a, -b y –c. La forma de implementar el reconocimiento de estas opciones sería:
      • while [ -n “$(echo $1 | grep ‘^-’)” ]
      • do
      • case $1 in
      • -a) Procesa opción –a;;
      • - b) Procesa opción –b;;
      • - c) Procesa opción –c;;
      • * ) echo ‘Use hacer [-a] [-b] [-c] args ...’
      • esacs
      • shift
      • done