Home

Shell

Definiciones

Variables de shell

$ AA=Hola que tal 

$ echo AA 

$ echo $AA

Variables de entorno

PATH

Indica la ruta de búsqueda de programas ejecutables. Está constituida por una lista de directorios separados por “:“. El directorio actual, de forma predeterminada, no viene incluida en PATH.

PS1

Especifica el indicador del sistema. Lo habitual es que PS1 sea “$” para usuarios normales y “#” para root.

PS2

Especifica el indicador secundario del sistema. Aparece cuando no se ha completado una orden.

LANG

Especifica el lenguaje que se aplica al usuario. Para español se utiliza “es”.

LC_ALL

Contiene el idioma y se utoiliza para usar los valores locales como mensajes del sistema, símbolo monetario, formato de fecha, formato de números decimales y otras características.

TERM

Indica el tipo de teminal que se está utilizando. Por ejemplo, si estamos en la consola el valor de TERM será “linux”, para usar las carácterísticas del teclado. Si entramos por telnet desde w9x entonces probablemente tengamos que poner vt100.

EDITOR

Especifica el editor por omisión del sistema. Lo habitual en los sistema Unix es que el editor por omisión sea “vi”.

DISPLAY

Especifica qué equipo muestra la salida que se efectúa en modo gráfico. Ese equipo deberá tener un servidor gráfico.

LD_LIBRARY_PATH

Esta variable se utiliza para definir rutas alternativas de búsqueda de para bibliotecas de funciones del sistema.

PWD

Contiene el directorio de trabajo efectivo.

$ env
PWD=/home/usuario/public_html/docs/shell
LTDL_LIBRARY_PATH=/home/usuario/.kde/lib:/usr/lib 
HOSTNAME=www.bdat.com 
LD_LIBRARY_PATH=/home/usuario/.kde/lib:/usr/lib 
QTDIR=/usr/lib/qt-2.2.2 
CLASSPATH=./:/usr/lib/jdk118/lib/classes.zip 
LESSOPEN=|/usr/bin/lesspipe.sh %s  
PS1=[\u@\h\W]$ 
KDEDIR=/usr 
BROWSER=/usr/bin/netscape 
USER=usuario
MACHTYPE=i386-redhat-linux-gnu 
LC_ALL=es_ES 
MAIL=/var/spool/mail/usuario 
EDITOR=joe 
LANG=es
COLORTERM=
DISPLAY=:0
LOGNAME=usuario 
SHLVL=4 
LC_CTYPE=iso-8859-1 
SESSION_MANAGER=local/www.bdat.com:/tmp/.ICE-unix/965 
SHELL=/bin/bash 
HOSTTYPE=i386 
OSTYPE=linux-gnu 
HISTSIZE=100 
HOME=/home/usuario 
TERM=xterm 
PATH=/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/usr/lib/jdk118/bin:./:/sbin:/usr/sbin:/usr/local/sbin:/opt/mozilla 
GROFF_TYPESETTER=latin1 
LESSCHARSET=latin1 

Ficheros ejecutables

• Binarios, cuando son resultado de la compilación de un programa, por ejemplo en C.
• Programas de shell, llamados scripts o guiones. Son ficheros de texto que contienen órdenes de shell y son interpretados por una shell.

Shell y subshell

Cerrar una shell

Variables exportadas

$ export EDITOR

$ export EDITOR=vi

$ export 
EDITOR=vi

Ejemplos:

$ AA=contenido

$ echo $AA

$ /bin/bash

$ echo $AA

$ exit

$ echo $AA

$ export AA

$ /bin/bash

$ echo $AA

Las comillas en la shell

'

Engloban un literal. La shell no trata de interpretar nada de lo que haya comprendido entre estas comillas.

“

La shell expande las variables que haya especificadas sustituyendo su nombre por el contenido. Para imprimir un $ es necesario protegerlo con una \.

̀ La shell intenta ejecutar lo que haya comprendido entre estas comillas.

$ AA=”ls -la”

echo '$AA'
echo “$AA”

echo  ̀$AA ̀

Personalización de la shell

$ export LANG=es

$ export PATH=$PATH:.

Intoducción

Modos de trabajo

• Modo inserción: En este modo se puede introducir texto en el fichero que estamos editando. Para salir del modo inserción tenemos que pulsar la tecla Esc.
• Modo orden: En este modo vi acepta órdenes. Las órdenes son letras con algún posible arguemento.

Terminales

Salir de vi

orden

acción

ZZ

sale de vi grabando el fichero

:q!

sale de vi sin grabar los cambios

:wq

sale de vi grabando los cambios

Introducir texto (modo inserción)

orden

acción

i

inserta texto en la posición del cursor

a

inserta texto después de la posición del cursor

A

inserta texto al final de la línea

o

Crea una nueva línea bajo la actual

O

Crea una nueva línea sobre la actual

Borrar

orden

acción

x

borra el carácter sobre el cursor

d0

borra hasta princio de línea

dw

borra hasta el final de la palabra.

dnw

borra hasta el final de la palabra n

db

borra hasta el principio de la palabra

dd

borr la línea actual

Desplazamientos

orden

acción

->,espacio

espacio a la derecha

<-,h

espacio a la izquierda

w

palabra a la derecha

b

palabra a la izquierda

$

fin de línea

0

principio de línea

return

línea siguiente

j

línea de abajo

k

línea de arriba

Búsquedas y sustituciones

orden

acción

/expreg

busca expreg hacia adelante

?expreg

busca expreg hacia atrás

/

repite la última búsqueda hacia adelante

?

repite la última búsqueda hacia atrás

s/buscado/sustitución[/g]

sustituye la primera aparición de la palabra buscado reemplazándola por la parabra sustitición. Si añadimos /g al final, la sustitución es global en todo el documento.

Otras órdenes

orden

acción

H

principio de la pantalla

M

mitad de la pantalla

L

final de la pantalla

nG

A la línea n

(

principio de frase

)

fin de frase

{

principio de párrafo

}

fin de párrafo

r

sustituye el carácter del cursor

R

sustituye caracteres

D

borra hasta el final de línea

:set

number numera las líneas

:set

ai establece el sangrado automático

:!orden

ejecuta el orden de shell

:w

graba el fichero sin salir de vi.

Código de terminación de una orden

[pfabrega@port /home]$ ls -la /home
total 32
drwxr-xr-x    5 root     root         4096 sep 20 14:16 .
drwxr-xr-x   18 root     root         4096 sep 20 03:23 ..
drwxr-xr-x    4 root     root         4096 sep 28 21:16 httpd
drwxr-xr-x    2 root     root        16384 sep 19 18:25 lost+found
drwx--x--x   20 pfabrega pfabrega     4096 nov 24 19:07 pfabrega
[pfabrega@port /home]$ echo $?
0
[pfabrega@port /home]$ ls -la asdfg
ls: asdfg: No existe el fichero o el directorio
[pfabrega@port /home]$ echo $?
1
[pfabrega@port /home]$

Ejecución consecutiva

$ sleep 300 ; ps axu

Ejecución condicional

Operador &&

orden1 && orden2

$ ls fichero && cat fichero

make module && make modules_install

Operador ||

orden1 || orden2

$ ls fichero || touch fichero

make modules || rm -r *.o

Ejecución simultánea

[pfabrega@port pfabrega]$ sleep 10 & sleep 20 & sleep 15 &
[pfabrega@port pfabrega]$ ps axu
USER       PID %CPU %MEM   VSZ  RSS TTY      STAT START   TIME COMMAND
root         1  0.1  0.2  1408  540 ?        S    22:19   0:04 init [3]
...
pfabrega  1263  0.3  0.2  1624  516 pts/4    S    23:24   0:00 sleep 10
pfabrega  1264  0.0  0.2  1624  516 pts/4    S    23:24   0:00 sleep 20
pfabrega  1265  0.0  0.2  1624  516 pts/4    S    23:24   0:00 sleep 15
pfabrega  1266  0.0  0.3  2732  848 pts/4    R    23:24   0:00 ps axu

Agrupando con paréntesis

(mkdir copiaseg; cp -r ./original/* ./copiaseg; rm -r ./original~; rm -r ./original.tmp) &

Resultado de la ejecución de una orden

Comillas invertidas ̀ ̀

$ A="ls /bin"
$ `echo $A`
arch        consolechars   ed          igawk     mount          rpm        tar
ash         cp             egrep       ipcalc    mt             rvi        tcsh
ash.static  cpio           ex          kill      mv             rview      touch
awk         csh            false       ln        netstat        sed        true
basename    date           fgrep       loadkeys  nice           setserial  umount
bash        dd             gawk        login     nisdomainname  sfxload    uname
bash2       df             gawk-3.0.6  ls        ping           sh         usleep
ssh         dmesg          grep        mail      ps             sleep      vi
cat         dnsdomainname  gtar        mkdir     pwd            sort       view
chgrp       doexec         gunzip      mknod     red            stty       ypdomainname
chmod       domainname     gzip        mktemp    rm             su         zcat
chown       echo           hostname    more      rmdir          sync

$ A="ls /bin" $ B=`$A` $ echo $B arch ash ash.static awk basename bash bash2 bsh cat chgrp chmod chown consolechars cp cpio csh date dd df dmesg dnsdomainname doexec domainname echo ed egrep ex false fgrep gawk gawk-3.0.6 grep gtar gunzip gzip hostname igawk ipcalc kill ln loadkeys login ls mail mkdir mknod mktemp more mount mt mv netstat nice nisdomainname ping ps pwd red rm rmdir rpm rvi rview sed setserial sfxload sh sleep sort stty su sync tar tcsh touch true umount uname usleep vi view ypdomainname zcat

El operador $()

Programas de shell

  #!/bin/bash  
  echo Hola Mundo 

subshell

echo “******** GUION ********”
echo “el valor previo de VAR es ** $VAR **”
VAR=”valor asignado dentro del guion”
echo “Ahora VAR vale ** $VAR **”
ps
echo “******** FIN DEL GUION ********”

$ chmod u+x pruebashell

$ export VAR=”valor previo”

$ ps 

$ ps |wc -l

$ ./pruebashell

$ echo $VAR

cd /tmp
echo “estamos en:“
pwd

$ chmod u+x cambia

$ pwd

$ ./cambia

$ pwd

Comentarios y continuaciones de línea

Parámetros posicionales

echo $0 
echo $1 
echo $2
echo $3 

$ parametros primero segundo tercero
prametros
primero
segundo
tercero

Modificación de los parámetros posicionales

$ set primero segundo tercero
$ echo $1 
primero
$ echo $2 
segundo
$ echo $3
tercero

La sentencia shift

$ shift n

$ set uno dos tres cuatro
$ echo $1
uno
$ shift
$ echo $1
dos
$ shift
$ echo $1
tres
$ shift
$ echo $1
cuatro

Operador {}

$ echo ${10}
$echo ${12}

$DIR=principal
$ DIRUNO=directorio
$ UNO=subdirectorio
$ echo $DIRUNO
directorio
$ echo ${DIR}UNO
principalUNO

Variables predefinidas

Variable $*

*

La variable $* contiene una cadena de caracteres con todos los parámetros posicionales de la shell activa excepto el nombre del programa de shell. Cuando se utiliza entre comillas dobles se expande a una sola cadena y cada uno de los componentes está separado de los otros por el valor del carácter separador del sistema indicado en la variable IFS. Es decir si IFS tiene un valor “s” entonces "$*" es equivalente  a  "$1s$2s...". Si IFS no está definida, los parámetros se separan por espacios en blanco. Si IFS está definida pero tiene un contenido nulo los parámetros se unen sin separación.

Variable $@

@

La variable $@ contiene una cadena de caracteres con todos los parámetros posicionales de la shell activa excepto el nombre del programa de shell. La diferencia con $* se produce cuando se expande entre comillas dobles; $@ entre comillas dobles se expande en tantas cadenas de caracteres como parámetros posicionales haya. Es decir “$@” equivale a "$1" "$2" ...

Variable $#

#

Contiene el número de parámetros posicionales excluido el nombre del probrama de shell. Se suele utilizar en un guion de shell para verificar que el número de argumentos es el correcto.

Variable $?

?

Contiene el estado de ejecución de la última orden, 1 para una terminación con error o 0 para una terminación correcta. Se utiliza de forma interna por los operadores || y && que vimos con anterioridad, se utilizar por la orden test que vermos más adelante y también la podremos usar explícitamente.

Variable $$

$

contiene el PID de la shell. En un subshell obtenida por una ejecución con (), se expande al PID de la shell actual, no al de la subshell. Se puede utilizar para crear ficheros con nombre único, por ejemplo $$.tmp, para datos temporales.

Variable $!

!

Contiene el PID de la orden más recientemente ejecutada en segundo plano. Esta variable no puede ayudar a controlar desde un guion de shell los diferentes procesos que hayamos lanzado en segundo plano.

Ejemplos

$ set a b c d e
$ echo $# 
5
$ echo $*
a b c d e
$ set "a      b" c d
$ echo $# 
3 
$ echo $*
a     b c d

ps
echo “ el PID es $$”

$ ./ejvar1
PID TTY          TIME CMD
930 pts/3    00:00:00 bash
1011 pts/3    00:00:00 bash
1012 pts/3    00:00:00 ps
el PID es 1011 

miproctemp=/tmp/miproc.$$
. . . .
rm -f $miproctemp

Uso de valores predeterminados de variables

Uso de variable no definida o con valor nulo

$ {variable:-valorpredeterminado}

$ echo ${resultado}
$ echo "E1 resultado es: {resultado:-0}"
E1 resultado es: O
$ resultado=1
$ echo "E1 resultado es: ${resultado:-0}"
E1 resultado es: 1

{$1: -o}

Uso de variable no definida

${variable- valorpredeterminado}

Uso de variable definida o con valor nulo

$ {variable: +valorpredeterminado}

$ resultado=10
$ echo ${resultado:+5}
5
$ resultado=
$ echo ${resultado:+30}
$

Uso de variable no definida

$ {variable+valorpredeterminado}

Asignación de valores predeterminados de variables

Asignación a variable o definida o con valor nulo

${variable:=valorpredeterminado}

 
$ echo ${resultado}
$ echo "El resultado es: ${resultado:=0}"
E1 resultado es: 0
$ echo ${resultado}
0

Asignación a variable no definida

${variable=valorpredeterminado}

Mostrar un mensaje de error asociado a una variable

Variable no definida o con valor nulo

$ {variable : ?Mensaje }

$ res=${resultado:? "variable no válida''}

Variable no definida

${variable?mensaje}

Otras operaciones con variables

Subcadenas de una variable

${variable:inicio:longitud}

$ A=abcdef
$ echo ${A:3:2}
de
$ echo ${A:1:4}
bcde
$ echo ${A:2}
cdef

Cortar texto al principio de una variable

${variable#texto}

$ A=abcdef
$ echo ${A#ab}
cdef
$ echo ${A#$B}
cdef
$ B=abc
$ echo ${A#$B}
def
$ echo ${A#cd}
abcdef

Cortar texto al final de una variable

${variable%texto}

$ PS1=$
$PS1="$ "
$ A=abcdef
$ echo ${A%def}
abc
$ B=cdef
$ echo ${A%$B}
ab

Reemplazar texto en una variable

${variable/texto1/texto2}
${variable//texto1/texto2}

$ A=abcdef
$ echo ${A/abc/x}
xdef
$ echo ${A/de/x}
abcxf

Evaluación aritmética

let variable=expresión aritmética

let A=A+1

Selección de la shell de ejecución

#!/ruta/shell

#!/bin/bash

#!/usr/bin/less
Cita de prensa tomada de la publicación de “El Byte sindicalista”:
Queda descartada la huelga de bytes en los sistemas Linux. Parece que sus condiciones de trabajo en este sistema son más que aceptables y no plantean ni quejas ni plantes. El último “core” ocurrió hace ya varios años y desde entonces la confictividad laboral con los bytes no ha existido en los sistemas Linux en cualquiera de sus sabores. Los representantes de los bytes reconocen que en los sistema Linux tienen unas condiciones sanitarias óptimas, el riesgo de contaminación con bytes enfermos es inexistente salvo en casos de pruebas de laboratorio. También hemos observado que los bytes están muy satisfechos con los medios de transporte que disponen en los sistemas Linux, medios cómodos y eficientes.
No se puede decir lo mismo en otros entornos de trabajo donde los bytes se quejan continuamente de sus condiciones laborales: falta permanente de espacio, tanto en la RAM como cuando duermen en su disco duro en unos incómodos sistemas de ficheros. También se reflejan las quejas de los excesivos puntos control sanitario que tienen que tienen que sufrir en sus desplazamientos y operaciones. Estas quejas se traducen en conflictos laborales periódicos de diversa intensidad. Son muy habituales las huelgas de celo cuando el sistema lleva cierto tiempo trabajando lo que ralentiza el sistema productivo global. Cuando las condiciones se hacen insoportables se producen manifestaciones y revueltas acompañadas de pancartas azules para exigir mejoras laborales.
Apoyemos a los bytes en sus reivindicaciones laborales, porque mejorando las condiciones en que se desenvuelve la actividad de los bytes mejoraremos las condiciones de todos.
No a la explotación del byte
 
El Byte sindicalista, junio 2004

Lectura desde la entrada estándar: read

read variable

read varl var2 var3 var4 

read nombre?"Nombre y dos apellidos? " apl ap2

Evaluación de expresiones: test

test expr

$ test -f /etc/profile
$ echo $?
$ test -f /etc/profile -a -w /etc/profile
$ echo $?
$ test 0 -lt 0 -o -n "No nula''
$ echo $?

Estructura de control

Sentencia if

if   lista_órdenes
then
  lista_órdenes
fi

if [ -f mifichero ] 
then 
  echo "mifichero existe"
fi

if grep body index.html
then
  echo “he encontrado la cadena body en index.html”
fi

if lista_órdenes
then
  lista_órdenes
else
  lista_órdenes
fi

if [ -f "$1" ] 
then
  pr $1
else
  echo "$1 no es un fichero regular"
fi

if [ -f "$1" ]
then
  cat $1 
elif [ -d "$1" ] 
then
  ls $1/*
else
  echo "$1 no es ni fichero ni directorio"
fi

Sentencia while

while lista_órdenes
do
  lista órdenes
done

I=0
while [ ${resp:=s} = s ]
do
  I= ̀expr $I + 1 ̀
  echo $I
  read resp?"Quiere usted continuar(s/n)? "
done

Sentencia until

until lista_órdenes
do
  lista órdenes
done

Sentencia for

 
for variabl ein lista 
do
  lista mandatos
done
 

for i in $*
do 
  echo $i
done

for i in *
do 
  echo $i
done

Sentencias break y continue

Sentencia case

case variable in 
  patrón1)
    lista_órdenes1
  ;; 
  patrón2) 
    lista_órdenes2
  ;;
...
  patrónN) 
    lista_órdenesN;;
esac

case "$1" in
  start)
        echo -n "Ha seleccionado start "
        ;;
  stop)
        echo -n "Ha seleccionado stop "
        ;;
  status)
        echo -n "Ha seleccionado stop "
        ;;
  restart)
        echo -n " Ha seleccionado restart "
        ;;
  *)
        echo "No es una opción válida"
        exit 1
esac 

Terminar un programa de shell (exit)

if grep "$1" /var/log/messages
then
  exit 0
else
  exit 10
fi

Opciones en un programa de shell: getopts

• Las opciones están formadas por una letra precedida de un guión.
• El orden de las opciones es indiferente, pero suelen preceder a los ntes de los argumentos propiamente.
• Cada opción puede llevar uno o más argumentos.
• Las opciones sin argumentos pueden agruparse después de un único guión

getopts cadenaopciones variable [args ...]

• Cuando a una opción le acompaña un argumento, getopts lo sitúa en la variable OPTARG.
• Si en la línea de mandatos apar ece una opción no válida entonces asignará "?" a variable.

while getopts ab:cd opcion 
do
        case $opcion in
                a) 
                  echo "Opción a"
                ;;
                b) 
                  echo "Opción b con argumento OPTARG"
                ;;
                c) 
                  echo "Opción c"
                ;;
                d) 
                  echo ”Opcion d”
                ?) 
                  echo "Uso: $0 -acd -b opcion "
        esac
done
shift `expr $OPTIND - 1`
echo "resto de argumentos: $*"

Evaluación de variables: eval

eval [arg1 [arg2] ...]

Funciones

function mi_funcion 
{ 
  código de la función
} 

           #!/bin/bash    
           function terminar {  
               exit 0 
           }  
           function saludo {  
               echo ¡Hola Mundo!  
           }  
           saludo  
           terminar 

              #!/bin/bash    
               function terminar {  
                  exit 0 
               }    
               function saludo {  
                    echo $1   
                }    
                saludo Hola  
                saludo Mundo  
                terminar 

Trucos de programación en shell

Script con número variable de argumentos:

for i in $*
do
  instrucciones
done

for i in $*
do
  if [ -f $i ]
  then
    mv $i ./papelera
  fi
done

Script para aplicar una serie de órdenes a cada fichero de un directorio

for i in *
do
  instrucciones
done

Leer un fichero de texto línea a línea

while read LINEA
do
  instucciones por línea
done <fichero

cat fichero|while read LINEA
do
  instrucciones por línea
done

Cambiar una secuencia de espacios por un separador de campos

$ /sbin/ifconfig
eth0      Link encap:Ethernet  HWaddr 00:90:F5:08:37:E4
          inet addr:192.168.1.5  Bcast:192.168.1.255  Mask:255.255.255.0
          UP BROADCAST MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:5103 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:100
          Interrupt:10 Base address:0x3200
 
lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:1726 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1726 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0

$ /sbin/ifconfig |sed "s/[ ][ ]*/;/g"
eth0;Link;encap:Ethernet;HWaddr;00:90:F5:08:37:E4;
;inet;addr:192.168.1.5;Bcast:192.168.1.255;Mask:255.255.255.0
;UP;BROADCAST;MULTICAST;MTU:1500;Metric:1
;RX;packets:0;errors:0;dropped:0;overruns:0;frame:0
;TX;packets:5241;errors:0;dropped:0;overruns:0;carrier:0
;collisions:0;txqueuelen:100;
;Interrupt:10;Base;address:0x3200;
lo;Link;encap:Local;Loopback;
;inet;addr:127.0.0.1;Mask:255.0.0.0
;UP;LOOPBACK;RUNNING;MTU:16436;Metric:1
;RX;packets:1773;errors:0;dropped:0;overruns:0;frame:0
;TX;packets:1773;errors:0;dropped:0;overruns:0;carrier:0
;collisions:0;txqueuelen:0;

$ /sbin/ifconfig | sed "s/[ ][ ]*/:/g" | grep inet | cut -f4 -d:
192.168.1.5
127.0.0.1

• Primero ejecutamos la orden ifconfig
• Sustituimos los espacios en blanco por ”:”
• Buscamos la línea que contenga la palabra inet
• Cortamos el campo 4 usando ”:” como separador.

Prácticas

Ejercicios propuestos

$ set a b c d e f g h i j k l m n
$ echo $10
$ echo $15
$ echo $*
$ echo $#
$ echo $?
$ echo ${11}

$ A=\$B
$ B=ls
$ echo $A
$ eval $A

Ejercicios resueltos sobre ficheros y directorios

for F in /etc/*
do
  if [ -f $F -a -r $F ]
  then
    echo $F >> listaetc
  fi 
done

while read LINEA
do
  if grep procmail $L >/dev/null 2>&1
  then
    echo $L
  fi
done <listaetc

DI=0
FI=0
for I in $1/*
do
  if [ -f $I ]
  then
    let FI=FI+1
  fi
  if [ -d $I ]
  then 
    let DI=DI+1
 fi
done

if [ -d $1 ]
then
  echo ”$1 existe”
  N=$(ls | wc -l)
  if [ $N -gt 0 ]
  then
    echo ”S1 no está vacio, contiene $N ficheros no ocultos”
  fi
fi

if [ ! -d csg ]
then
  mkdir csg
fi
cp * csg

NLIN=0
for I in * 
do
  if [ -f $I ]
  then
    N=$(wc -l $I)
    if [ $N -gt $NLIN ]
    then
      NOMBRE=$I
      NLIN=$N
    fi
  fi
done
echo ”$NOMBRE tiene $NLIN lineas”