Programación

 Shell  
Temas  selectos  de  Modelación  Numérica  
Dr.  Jorge  Zavala  Hidalgo  
Introducción  
• El  shell  es  un  intérprete  de  comandos.    

• Un  programa  de  shell,  llamado  un  script,  es  una  herramienta  

fácil  de  usar  para  crear  aplicaciones  de  "gluing  together”.  

• Prác<camente   todo   el   repertorio   de   comandos   LINUX,  

u<lidades   y   herramientas   están   disponibles   para   la   invocación  
en  un  script  de  shell.    

• Los  shell  scripts  son  especialmente  adecuados  para  las  tareas  

administra<vas   del   sistema   y   otras   tareas   ru<narias  
repe<<vas   que   no   requieren   las   campanas   y   lujos   de   un  
lenguaje  de  programación  en  toda  regla  bien  estructurado.  
El  shell  que  usamos  
• Para  saber  que  shell  usamos:  
• echo  $SHELL  
• /bin/bash  

• Para  conoce  todos  los  shell  de  que  dispone  su  máquina  
• cat  /etc/shells  
• /bin/bash  
• /bin/csh  
• /bin/ksh  
• /bin/sh  
• /bin/tcsh  
• /bin/zsh  

• chsh  –s  /bin/bash  

• En  el  caso  más  sencillo,  una  secuencia  de  comandos  no  es  más  que  
una   lista   de   comandos   del   sistema   almacenadas   en   un   archivo.  
Como   mínimo,   esto   ahorra   el   esfuerzo   de   escribir   de   nuevo   que   la  
secuencia  de  comandos  concreto  cada  vez  que  se  invoca.  

• El  sha-­‐bang  (#!)  al  inicio  de  una  secuencia  de  comandos  le  indica  al  
sistema  que  el  archivo  es  un  conjunto  de  comandos  que  se  alimenta  
al  intérprete  de  comandos  indicada.    

• Inmediatamente  después  de  la  sha-­‐bang  (#!)  es  una  ruta.  Esta  es  la  
ruta  de  acceso  al  programa  que  interpreta  los  comandos  del  script,  
ya  se  trate  de  shell,  un  lenguaje  de  programación,  o  una  u<lidad.    
   
 #!/bin/sh  
 #!/bin/bash  
 #!/usr/bin/perl  
 #!/usr/bin/tcl  
 #!/bin/sed  -­‐f  
 #!/bin/awk  -­‐f  
• Este   intérprete   de   comandos   a   con<nuación,   ejecuta   los  
comandos   en   el   script,   empezando   por   la   parte   superior   (la   línea  
que   sigue   la   línea   de     (#!),   y   haciendo   caso   omiso   de   los  
comentarios.  
• Después  de  haber  escrito  el  guión,  para  ejecutarlo  es  mucho  más  
conveniente   hacer   que   el   propio   script   ejecutable   directamente  
con  un  chmod.  

 chmod  555  scriptname    (da  a  todos  los  usuarios  permiso  de  lectura  y  ejecución)  
   
 chmod  +rx  scriptname    
   
 chmod  u+rx  scriptname  (solo  da  al  propietario  premiso  de  lectura  y  ejecucion)  
• Después   de   haber   hecho   el   script   ejecutable,   ahora   puedes  
probarlo  
   .  /scriptname  
Caracteres  especiales  
• Comentarios  
• Las  lineas  de  comentarios  comienzan  con  un  #  (con  excepción  de  
#!)  
 #  This  line  is  a  comment.  
• Comentarios  también  puede  ocurrir  después  comando.  
 echo  "A  comment  will  follow."  #  Comment  here.  
 #                                                                                                        ^  Note  whitespace  before  #  
Variables  
• Referenciar  variables  

• Las   variables   de   los   guiones   no   se   declaran,   y   siempre   están  

inicializadas  con  una  ristra  vacía  o  nula.    

• Una   ristra   vacía   o   nula   es   una   ristra   que   no   con<ene   ningún  

caracter.  

• Hay   que   tener   cuidado   al   asignar   valores   a   las   variables,   ya   que  

no  se  debe  dejar  ningún  espacio  entre  el  signo  de  asignación  (el  
‘=‘)  y  la  variable  o  el  valor  asignado  (algo  que,  por  otra  parte,  es  
una  muy  buena  costumbre  cuando  da  igual).  
• Para   referirse   a   las   variables,   hay   que   u<lizar   el   signo   pesitos   ($)  
antes   del   nombre   de   ésta,   siempre   que   nos   refiramos   a   ellas   para  
consultar  su  valor  (si  asignamos  un  valor  a  la  variable,  o  u<lizamos  la  
orden  read,  que  escribe  en  ella,  NO  hay  que  poner  el  signo  de  $).  Si  
nos  olvidamos  del  signo  $,  y  hacemos  algo  parecido  a:  
 y=hola  
 x=y  
• Nos   encontraremos   con   la   desagradable   sorpresa   de   que   el   valor   de  
x   es   el   carácter   y,   y   no   los   caracteres   hola,   como   quizás  
pretendiéramos.   Para   hacer   la   asignación   correctamente,  
tendríamos  que  haber  escrito:  
 y=hola  
 x=$y  
Como   en   todas   o   al   menos   la   mayoría   de   las   cosas   en   LINUX,   los  
nombres  son  case  sensi(ve,  es  decir,  que  no  es  lo  mismo  y  que  Y  
Órdenes  
• Dos   órdenes   bastante   ú<les   para   probar   algunas  
estupideces  con  variables  son:  

• echo  es  para  mostrar  texto  por  pantalla.  

• read   es   para   leer   del   teclado   y   poner   el   resultado   en   una  

o  varias  variables.  
READ,  ECHO  
• El  funcionamiento  de  read  es  el  siguiente:    
• lee  del  teclado  una  lista,  y  va  asignando  las  palabras  en  orden  a  
cada   una   de   las   variables   que   se   le   pasen   como   parámetros,  
asignando  el  resto  de  la  lista  a  la  úl<ma  variable.  Es  decir,  que  si  
se   le   pasan   tres   variables   como   parámetro,   se   asigna   la   primera  
palabra  a  la  primera  variable,  la  segunda  a  la  segunda  variable,  y  
el  resto  de  la  lista  leída  a  la  tercera  variable.  Por  ejemplo:  
   $  read  foo  bar  
   Escribo  demasiadas  palabras  
   $  echo  $foo  
   Escribo  
   $  echo  $bar  
   demasiadas  palabras  
Parámetros  
• Los   parámetros   son   variables   normales,   que   <enen   los  
nombres  $1,  $2  ...  $9.    

• Aunque  se  pueden  dar  más  de  nueve  parámetros  a  un  guión  
para  el  intérprete  de  órdenes,  sólo  se  puede  acceder  de  forma  
directa  a  los  nueve  primeros.    

• La  orden  shib  permite  desplazar  los  parámetros  de  si<o,  de  tal  
forma  que  sean  accesibles  los  que  estén  más  allá  del  noveno,  
con  el  inconveniente  de  no  poder  acceder  a  los  primeros.    

• En   realidad,   en   el   Korn   shell   (y   en   bash)   se   puede   acceder   al  

resto   de   los   parámetros   directamente   con   la   construcción   $
{número}.    
• El  funcionamiento  de  shib  es  el  siguiente:  

• Supongamos  que  tenemos  como  parámetros  $1=-­‐o,  $2=foo  y  bar,  

por   llamar   al   guión   (suponiendo   que   el   nombre   del   guión   es  
compila)  así:  
   compila  -­‐o  foo  bar  
• Lo   que   queremos   es   quitarnos   de   enmedio   las   opciones,   después  
de   haberlas   procesado,   de   tal   forma   que   el   tercer   parámetro  
(bar)   se   quede   como   primero.   Lo   que   haremos,   entonces,   es  
llamar   dos   veces   a   shib,   o   llamar   a   shib   con   el   parámetro   2.  
Teniendo  este  código:  
   shift  2  
   echo  $1  
Comillas  
• En   la   programación   en   shell   en   LINUX   hay   tres   <pos   de  
comillas  ú<les:  
•    
• Comilla  simple  (’).    
• Comilla  doble  (”).    
• Comilla  inver<da  (`).    

• Cada  una  <ene  un  propósito  diferente,  y  se  deben  saber  usar  
todas  bien.  
• La  comilla  simple  (  ‘  )  sirve  para  coger  literales.  Es  importante  
darse   cuenta   de   que   algo   encerrado   entre   comillas   simples  
siempre   es   un   solo   parámetro,   aunque   sea   una   ristra   vacía          
(  ’  ’  ).  
• La  comilla  doble  sirve  para  sus<tuir  lo  que  hay  dentro  (valores  
de  variables,  caracteres  especiales),  pero  después  de  sus<tuir  
queremos   tratarlo   como   si   estuviera   encerrado   entre   comillas  
simples.    
 x=100  
 y='500$x’  
 echo  $y                  #  Esto  enseñará  `500$x'  en  pantalla  
 y="500$x”  
 echo  $y                  #  Esto  enseñará  `500100'  en  pantalla  
• El  comando  (punto  y  coma  “  ;  ”  ).  Permite  poner  dos  o  más  
comandos  en  la  misma  línea.  
• El  comando  ;;  se  usa  como  terminador  de  una  opción  de  case  
¿Como  se  edita  un  script  de  Shell?  
• Los  scripts  de  Shell  son  extremadamente  ú<les.  
• Script:  Es  un  archivo  de  texto,  que  con<ene  una  serie  de  
comandos  para  shell,  que  el  sistema  ejecuta  ordenadamente,  
de  arriba  abajo.  Para  editarlos,  tan  solo  hace  falta  un  editor  de  
textos,  como  Emacs,  o  Vi.    
• Se  guardan  con  extensión:  .sh  y  se  ejecutan  desde  la  Shell  
mediante  el  comando:  sh  nombre  de  script.sh.    
• Los  scripts,  se  comportan  de  igual  manera  que  los  comandos  
de  la  shell.  
Ejemplo:  Calculadora  
echo  “soy  Gnu/Cal”  
echo  “Tu  me  dices  lo  que  quieres  calcular  y  yo  te  doy  el  resultado”  
echo  “Introduce  el  primer  valor”  
read  valor1  
echo  “  Introduce  el  operador.  Puedes  escoger  entre:  +  -­‐  *  /”  
read  operador  
echo  “  Introduce  el  segundo  valor”  
read  valor2  
echo  “El  resultado  es:”  
sleep  2  
expr  $valor1  $operador  $valor2  
sleep  1  
echo  “gracias  por  su  Tempo!”  
Calculadora  2  
• echo  ########################  
• echo  #  HOLA!  SOY  GNUCAL  V2  #  
• echo  ########################  
• echo  
• echo  Introduce  el  primer  valor:  
• read  valor1  
• echo  "Introduce  operador,  puede  elegir  suma  +,  resta  -­‐,  
mulTplicacion  *  y  division  /."  
• read  ope  
• echo  Introduce  segundo  valor:  
• read  valor2  
• resultado=`expr  $valor1  "$ope"  $valor2`  
• echo  Resultado=$resultado  
 Ejemplo  2:  trivial.sh  
• #!/bin/bash   • sleep  2  
• clear   • echo  "Pasemos  a  la  siguiente  pregunta.  
• echo  "Bienvenidos  a  GnuTrivial."   ¿Qué  célebre  filosofo  Griego  tuvó  por  
• sleep  2   discipulo  
• echo  "Soy  el  apico  juego  de  preguntas  y   • a  Alejandro  Magno,  platón,  aristoteles  o  
respuestas."   zenon?"  
• sleep  2   • read  respuesta2  
• echo  "Si  aciertas  todas  las  preguntas,  te   • if  test  $respuesta2  =  aristoteles  
concedere  el  Ttulo  de  magister  del   • then  
universo."   • echo  "respuesta  correcta."  
• echo  "¿Como  se  llamaba  el  ulTmo   • else  
emperador  Romano  de  occidente,   • echo  "Lo  siento,  la  respuesta  correcta  es:  
claudio,  teodosio   Aristoteles."  
• o  romulo."   • fi  
• read  respuesta1   • if  test  $respuesta1  =  romulo  
• if  test  $respuesta1  =  romulo   • test  $respuesta2  =  aristoteles  
• then   • then  
• echo  "Respuesta  correcta."   • echo  "Eres  un  pequeño  magister  del  
• else   universo."  
• echo  "Lo  siento,  la  respuesta  correcta  es:   • fi  
romulo."  
• fi  
Ciclos  
• Existen   tres   construcciones   conocidas   como   iteraciones   o  
bucles.   Son   while,   unTl   y   for.   Sirven   para   ejecutar   ciclos   de  
comandos  si  se  cumple  una  condición.    
• Empecemos  en  primer  lugar  por  while.  Su  sintaxis  es  
   while  condicion  
   do  
                   orden  
   done  
• while   evalúa   la   condición.   Si   esta   es   correcta,   entonces  
ejecuta  el  o  los  comandos  especificados.  
• Si  no  es  correcta,  salta  a  la  siguiente  orden  que  haya  después  
de  la  palabra  reservada  done.  
Ejemplo  while  
###########################  
#  PROGRAMA  DE  EJEMPLO  #  
#  DE  LA  SENTENCIA  DE  CONTROL  #  
#  DE  FLUJO  WHILE  #  
###########################  
 a=42  
 while  [  $a  -­‐le  53  ]  
 do  
                   echo  Contador  =  $a  
                   a=`expr  $a  +  1`  
 done  
• La  construcción  unTl  es  muy  similar  a  while.  De  hecho,  comparte  la  
misma  sintaxis.  La  diferencia  consiste  en  que  el  código  de  retorno  
de   la   condición   debe   ser   falso   (dis<nto   de   0)   para   iterar.   Si   es  
verdadero  saltará  a  el  comando  que  vaya  a  con<nuación  de  done.  
Veamos  un  ejemplo:  

 ###############################  
 #  PROGRAMA  DE  EJEMPLO  #  
 #  DE  LA  SENTENCIA  DE  CONTROL  DE  #  
 #  FLUJO  UNTIL  #  
 ###############################  
unTl  [  $a  =  hal9000  ]  
do  
               echo  "Bienvenidos  a  Programa1.  Para  conTnuar  escribe  contraseña"  
               read  a  
done  
               echo  "contraseña  correcta"  
• El  ciclo  for.  Su  sintaxis  es  como  sigue:  
 for  variable  in  lista  
 do  
             ordenes  
 done  
• Es   diferente   a   while   y   unTl.   En   la   construcción   for   no   hay   que  
cumplir  ninguna  condición.  
• for,   simplemente   u<liza   como   variable   la   primera   cadena   de  
una   lista,   ejecutando   las   ordenes   que   le   indiquemos   a  
con<nuación.    
• En   la   siguiente   iteración   u<lizará   la   siguiente   cadena   de   la  
lista,  y  así  sucesivamente.  Veamos  un  ejemplo:  
Ejemplo  
###########################  
#  PROGRAMA  DE  EJEMPLO  #  
#  DE  LA  SENTENCIA  DE  CONTROL  DE  #  
#  FLUJO  FOR  #  
###########################  
for  a  in  antonio  eva  fernado  joseba  julio  
do  
                 mail  $a  <  texto.txt  
done