Fundamentos de programación en Linux

No está permitida la reproducción total o parcial de este libro, ni su tratamiento informática, ni la

transmisión de ninguna forma o por cualquier medio, ya sea electrónico, mecánico, por fotocopia,
por registro u otros métodos sin el permiso previo y por escrito de los titulares del Copyright.

DERECHOS RESERVADOS. Copyright O 2001, respecto a la primera edición en español, por

.
McGRAW-HILL INTERAMERICANA, S. A. Avenida de las Américas, No. 46-41. Bogotá, D.C.,
Colombia.

Translated from the first edition of

LlNUX PROGRAMMING, A Beginner's Guide
Copyright O MMI, by The McGraw-Hill Companies
All rights reserved.
ISBN: 0-07-212743-0

Editor: Eder Mauricio Hernández B.

Jefe de Producción: Consuelo Ruiz M.

lmpreso en Colombia Printed in Colombia

Se imprimieron 6.400 ejemplares en el mes julio de 2001

lmpreso por Panamericana Formas e Impresos S.A.
 Síntesis del contenido

PARTE 1
Programación de los shells
1 Introducción a la programación en Linux ....................................... 3
2 Scripts del shell BAZH ................................................................. 33
3 Estructuras de control del shell BASH .......................................... 61
4 Programación del shell TCSH ..................................................... 9 3

PARTE 2
Lenguajes de alto nivel
5 GAWK ...................................................................................... 139
6 Perl ............................................................................................ 187
7 Tcl (Tool Command Language) ................................................. 247
8 T k ............................................................................................ 293
 Fundamentos de programación
-
en Linux 9

PARTE 3
Programación en GUI
9 GNOME .................................................................................... 327
10 KDE ............................................................................................... 371

PARTE 4
Apéndice
A Respuestas a las evaluaciones ........................................................... 417
 Contenido

AGRACECIMIENTOS ........................................................ xix

INTRODUCCIÓN.............................................................. xxi

PARTE 1
Programación de los shells
1 Introducción a la programación en Linux .................................. 3
Prograniación en Linux ............................................................ 5
Programación del shell BASH ...................................... 7
Programación del shell TCSH ...................................... 8
GAWK ....................................................................... 8
Perl ............................................................................. 9
Tcl (Tool Conimand Language) ................................. 10
T k ............................................................................. 11
Programación en GNOME ....................................... 11
Programación en KDE .............................................. 12
 programación en Linux
-9mw-B" <

Más acerca de Linux ................................................................ 14

Antes de Linux fue U N I X ......................................... 16
Cómo surgió U N I X ................................................. 17
La llegada de Linux ................................................... 20
Anatomía de Linux: shells. directorios y escritorios .... 22
Distribuciones de Linux .......................................................... 25
R e d Hat .................................................................... 25
OpenLinux ............................................................... 26
SuSE ...................................................................... 26
Debian ................................................................. 26
Slackware ............................................................... 27
Infoniagic .................................................................. 27
LinuxPPC ................................................................ 27
TurboLinux ............................................................... 27
Mandrake ................................................................ 28
Recursos de Linux ............................................................... 28
Evaluación ............................................................................... 32

2 Scripts del shell BASH ............................................................. 33

Scripts del shell: comandos y comentarios ................................ 35
Establecer permisos: símbolos de permisos ................. 36
.
Variables y scripts .................................................................. 40
Evaluación de variables: = y $ .................................... 41
Valores de una variable: cadenas ................................. 42
Entrada y salida de u n script: echo. read y << .......... 47
Proyecto 2-1: Entrada del usuario ............................................ 47
Argumentos de la línea de comandos del script ........................ 50
Exportar variables y shells del script ......................................... 53
Variables de entorno .................................................. 55
Proyecto 2-2: Exportar variables ............................................. 56
Operaciones aritniéticas del shell: let ....................................... 58
Evaluación ............................................................................... 60

3 Estructuras de control del shell BASH ...................................... 61

El comando test ..................................................................... 63
 Condiciones: if, if.else. elif y case .......................................... 66
La estructura if-then ................................................. 66
Los comandos lógicos: &Sr y 1 1 ................................ 70
La estructura case ..................................................... 71
Bucles: while. until. for-in y for ............................................ 73
El bucle while .......................................................... 74
Proyecto 3-1 : Bucles básicos .................................................... 76
La estructura until .................................................... 77
La estructura for-in .................................................. 77
La estructura for ....................................................... 78
El comando continue ............................................... 80
Los comandos true. false y break ............................. 80
Proyecto 3-2: Índice de páginas Web ........................................ 82
Usar redireccionarniento e interconexiones con estructuras
de control ................................................................ 85
Estructuras de desvío: trap ....................................................... 88
Evaluación ............................................................................... 91

4 Progran~acióndel shell TCSH .................................................. 93

Variables. scripts y argumentos del shell TCSH ......................... 94
Las variables del shell T C S H ...................................... 95
Los scripts del shell TCSH: entrada y salida ................ 97
Arreglos: ( ) y # ...................................................................... 99
Arreglo de argumentos: argv ................................................. 101
. .
Variables numericas: @ ............................................ 105
Variables de entorno: setenv .................................................. 108
Estructuras de control y operadores: while. if.
switch y foreach .................................................... 112
Expresiones de prueba ............................................. 113
Condiciones del shell TCSH: if-then. if-then-else y switch . 1 15
La estructura if-then ............................................... 117
La estructura switch ............................................... 120
Proyecto 4-1 : Menús con switch ........................................... 121
Estructuras de bucle: while. foreach y repeat ....................... 125
La estructura while ................................................. 126
La estructura foreach .............................................. 127
 ación en Linux

La estructura repeat ....................................................... 130

El comando continue .................................................... 130
Bucles infinitos y el comando break ............................... 131
Proyecto 4-2: Indices con el shellTCSH ....................................... 133
. .
Evaluacion .................................................................................... 135

PARTE 2
Lenguajes de alto nivel

5 GAWK ......................................................................................... 139

El comando gawk ........................................................................ 141
Búsquedas de patrón y caracteres especiales ................................... 142
Variables. constantes y funciones ................................................... 145
Variables de campo y delimitadores de campo ................. 146
Variables especiales de GAWK ........................................ 149
Variables definidas por el usuario .................................... 150
Constantes ..................................................................... 151
Funciones ....................................................................... 151
El segmento patrón como una condición ...................................... 158
Operadores de igualdad y relacionales ............................. 158
Operadores lógicos ......................................................... 161
Operadores de búsqueda de patrón ................................. 162
Los patrones especiales BEGIN y END ......................... 162
Patrones de rango ........................................................... 163
Operaciones aritméticas y de asignación ....................................... 164
Arreglos y arreglos asociativos ....................................................... 167
Archivos de instrucción de GAWK ............................................... 170
Estructuras de control ................................................................... 171
El bucle while ............................................................... 171
El bucle for .................................................................... 175
El bucle for-in ............................................................... 177
La estructura de control if .............................................. 178
 Los enunciados next y exit ........................................ 180
El enunciado getline ...................................................... 180
Uso de archivos con GAWK ......................................................... 182
Proyecto 5-1: Scripts de GAWK ................................................... 184
Evaluación .................................................................................... 186

6 Perl .............................................................................................. 187

Operaciones con la línea de cotnandos de Perl .............................. 188
Scripts de Perl .............................................................................. 190
Entrada y salida ............................................................................ 192
Uso de la entrada estándar .............................................. 193
Uso de la salida estándar ................................................. 194
Manejadores de archivos ............................................................... 196
El operador de texto: << ...................................................200
Variables y expresiones .................................................................. 202
Arreglos y listas ............................................................................ 207
Subconjuntos de arreglos: tajadas .................................... 210
Funciones de manejo de arreglos escalares:
operaciones de lista .................................................... 212
Arreglos asociativos ........................................................ 215
Estructuras de control ................................................................... 217
.
Expresiones de prueba ................................................ 2 1 8
Los comandos lógicos: &&, 1 1 , ! .................................... 218
Bucles ............................................................................ 221
Controles de bucle y de bloque ...................................... 227
Condiciones: if, elsif, unless y switch ........................... 228
Directorios ..................................................................... 232
Proyecto 6-1: índices con Perl ...................................................... 233
Funciones de cadena ..................................................................... 235
Concordancia de patrones ............................................................. 237
Concordancia de patrones en variables: =- ..................... 238
Funciones: sub ................................................................ 240
Alcance .......................................................................... 244
 gramación en Linux
.

Proyecto 6-2: Usar subrutinas ....................................................... 244

. .
Evaluacion .................................................................................... 246

7 Tcl (Tool Command Language) .................................................... 247

Extensiones y aplicaciones de Tcl/Tk ......................................... 249
El shell y los scripts tclsh ................................................ 251
Comandos de Tcl ........................................................................ 2 5 1
Expresiones .................................................................... 252
Variables ................................................................................. 255
Arreglos ................................................................................. 256
Variables y arreglos especiales: argv y env ....................... 258
Listas ............................................................................................ 258
Entrada y salida de Tcl: gets y puts ...................................... 263
Interconexiones .............................................................. 265
Estructuras de control ................................................................... 266
Las estructuras de control if y else .................................. 268
La estructura elseif ......................................................... 270
La estructura switch ................................................... 272
El bucle while ............................................................... 275
El bucle for .................................................................... 276
La estructura foreach .................................................... 278
.
Los comandos break y continue ................................... 279
Manejo de archivos con Tcl ...................................................... 280
Proyecto 7-1: Copia de archivos .................................................... 284
Procedimientos de Tcl: proc ....................................................... 285
El comando string de Tcl ............................................................ 286
Proyecto 7-2: Operaciones de archivo ........................................... 288
Expect .......................................................................................... 290
Evaluación .................................................................................... 292

8 T k ................................................................................................ 293
El shell wish y sus scripts .......................................................... 295
Widgets de T k .............................................................................. 295
Proyecto 8-1: Presentar un directorio ............................................ 302
Eventos y uniones ...................................................................... 304
Ventanas ...................................................................................... 31O
 Marcos y etiquetas ........................................................................ 314
Proyecto 8-2: Crear un administrador de archivo ........................... 316
Evaluación .................................................................................... 323

PARTE 3
Programación en GUI

9 G N O M E ..................................................................................... 327
Librerías GNOME ...................................................................... 331
GTK+ ......................................................................................... 337
Señales y eventos .......................................................................... 340
Funciones G N O M E ..................................................................... 346
Compilación de programas G N O M E ............................. 347
Proyecto 9-1: GNOME Hello ...................................................... 348
Los widgets G N O M E App. Toolbar y Menu ................................. 351
Proyecto 9-2: Menús Archivo y Editar ........................................... 358
Iconos de G N O M E ....................................................... 360
Cuadros de diálogo ..................................................................... 362
Entradas ....................................................................................... 365
Canvas de GNOME ..................................................................... 367
Evaluación .................................................................................... 369

10 KDE ............................................................................................ 371

Librerías KDE .............................................................................. 373
Aplicaciones y widgets de KDE ................................................ 376
Señales y slots ................................................................ 381
Cornpilador de metaobjetos: M O C ................................ 382
Proyecto 10-1 : Una ventana KDE ................................................. 385
Menús .......................................................................... 389
Barra de estado y barra de herramientas .......................... 391
Proyecto 10-2: Menús y barras de herramientas de KDE ............... 393
Programación en Qt ..................................................................... 399
Aplicaciones Qt .............................................................. 399
Señales y slots de Qt ....................................................... 403
Ventanas ......................................................................... 405
Herencia en objetos ........................................................ 406
 programación en Linux
-BwB-- .e...,.

Widgets de distribución .................................................. 407

Cómo crear sus propios widgets ...................................... 408
Cuadros de diálogo ......................................................... 411
Evaluación .................................................................................... 413

PARTE 4
Apéndice

A Respuestas a las evaluaciones ........................................................ 417

Capítulo 1: Introducción a la programación en Linux ................... 418
Capítulo 2: Scripts del shell BASH ................................................ 418
Capítulo 3: Estructuras de control del shell BASH .......................... 419
Capítulo 4: Programación del shell TCSH ..................................... 420
Capítulo 5: GAWK ....................................................................... 422
Capítulo 6: Perl ............................................................................ 422
Capítulo 7:Tcl (Tool Command Language) .................................. 423
Capítulo 8:Tk .............................................................................. 424
Capítulo 9: G N O M E ................................................................... 425
Capítulo 10: KDE ....................................................................... 426

Indice ........................................................................................... 429

 Introducción
L inux se ha convertido en uno de los sistemas operativos más iniportantes,
pues da a los P C todo el poder y la flexibilidad de una estación de trabajo
U N I X , junto con un conipleto conjunto de aplicaciones para Internet y una
interfaz de escritorio bastante funcional. Lo que niuchos quizá n o entiendan es
que todos los sistemas estándar Linux soportan un amplio rango de lenguajes
de prograniación que permite a los usuarios crear fácilniente sus propios
progranias. N o olvide que Linux se basó en U N I X , que fue diseñada como
una plataforma de investigación sobre la cual los investigadores pudieron
desarrollar con rapidez aplicaciones acordes a sus necesidades. Bajo este con-
cepto, todas las distribuciones de Linux incluyen una gran selección de plata-
formas de programación que ofrecen soporte a numerosas clases de
programaciones de shells, variedad de lenguajes de alto nivel, conlo Perl y Tcl/
Tk, y recursos para el desarrollo de aplicaciones tipo G U I para escritorios
conlo G N O M E y KDE. Una vez que instale Linux, usted puede empezar a
crear sus propios progranias.
Esta obra está diseñada como una guía para principiantes en prograniación
en Linux. Cubre nunierosas platafornias de prograniación y los lenguajes que
en la actualidad están disponibles para Linux. Usted puede comenzar a trabajar
con la mayoría de ellos sin tener experiencia alguna, salvo para el desarrollo de

xxi
 de programación en Linux

aplicaciones tipo G U I que se tratan al final del libro. La prograniación de esta

clase de aplicaciones supone contar con conocin~ientoy experiencia en pro-
gramación C y C + + .
Este texto identifica tres tenias importantes de la prograniación en Linux:
prograniación del shell, lenguajes de alto nivel y programación de aplicaciones
tipo GUI. Para escribir progranias del shell y en lenguajes de alto nivel n o es
indispensable que usted cuente con experiencia previa en prograniación. La
parte 1 del libro cubre la prograniación de los shell BASH y T C S H , que son
entornos de shell en Linux con características de prograniación. Desde el
interior de un shell BASH, usted puede crear progranias sencillos que puede
ejecutar con facilidad. La prograniación del shell BASH está organizada en dos
capítulos, uno acerca de los conceptos básicos y el otro acerca de las estructuras
de control que le permiten controlar la ejecución de un programa de nianera
que usted puede repetir coniandos o seleccionar algunos para ejecutarlos. Los
progranias del shell T C S H utilizan una sintaxis diferente, aunque trabajan de
nianera muy similar.
En la parte 2 se tratan algunos lenguajes de alto nivel, incluyendo GAWK,
Perl y Tcl/Tk. Cada uno de ellos le permite crear progranias muy coiiiplejos
utilizando unos pocos comandos de gran poder.Todos cuentan con estructuras
de control, muchas de las cuales operan en fornia similar. C o n GAWK, usted
puede procesar datos fácilniente generando versiones modificadas de los origi-
nales. Perl le permite tener acceso a archivos y nianipular cadenas, lo niisnio
que adiiiinistrar arreglos.Tc1 realiza muchas de las iiiisnias tareas que Perl.Tk es
una extensión de Tcl quegerniite crear interfaces gráficas de usuario (GUI).
C o n unos cuantos coniandos, usted puede crear sus propias ventanas con
nienús y botones.Tk soporta una aniplia gama de objetos para el desarrollo
rápido de GUI.
En la parte 3 se presenta una introducción a la prograniación con G N O M E
y KDE. El capítulo sobre el priniero de ellos (capítulo 9) sirve a nianera de
pequeña introducción y requiere conociniientos previos de prograniación en
C. El capítulo sobre KDE (capítulo 10) también cuenta con una introduccióii,
aunque la prograniación en KDE exige que usted entienda la programación en
C + + , particularniente lo relacionado con las jerarquías de clase. Para quienes
tengan esa formación, estos capítulos pueden ser de niucha utilidad. Quienes no
cuenten con esos conociniientos, deberán alcanzarlos porque son necesarios para
desarrollar aplicaciones para estos escritorios. La obra no cubre las llainadas del
nivel niás bajo del sistema Linux que se utilizan con frecuencia en progran~ación
de sistemas, desarrollando aplicaciones tales como controladores de dispositivos.
Para ello se necesita entender la estructura del sisteina operativo Linux, inclu-
yendo procesos, planificación y estructura de archivos. Estos tenlas están por
fuera del alcance de un texto para principiantes, aunque se manejan a nivel
intermedio. Este libro se centra en la prograniación que cualquier principiante
puede hacer, sin tener que saber cómo están construidos los sistemas operativos.
 en Linux

Los objetivos de este capitulo son:

Aprender acerca de los lenguajes de progranlación disponibles en Linux

Tener una visión general de la configuración de Linux

Aprender acerca de la historia de Linux

Estudiar las distribuciones disponibles de Linux

Encontrar recursos en línea para progranlación en Linux

 gramación en Linux
-m%. ,vw-

L inux es un sistema operativo para P C y estaciones de trabajo, que

cuenta con una interfaz gráfica de usuario totalmente funcional:
una GUI que es similar a la interfaz que se utiliza en las plataformas
Windows y Macintosh (aunque Linux es más estable). Linux se ha
convertido en la plataforma predominante para servicios de Internet,
tales como los servidores Web, el comercio electrónico y como soporte
de bases de datos. Linus Torvalds desarrolló Linux a comienzos de la
década de 1990,y desde entonces el programa ha sido corregido y
mejorado por otros programadores en todo el mundo. Como sistema
operativo, Linux realiza muchas de las mismas funciones que las máqui-
nas bajo UNIX, Macintosh, Windows y Windows NT. Sin embargo,
Linux se distingue por su poder y flexibilidad. Como parte de su
configuración básica, todos los sistemas Linux ofrecen un amplio apoyo
para el desarrollo de programas. Usted puede instalar Linux en su
sistema y comenzar a programar en diferentes lenguajes, sin ningún
costo ni esfuerzo extra.
La prograniación en Linux se puede clasificar dentro de cuatro
categorías generales: lenguajes de programación de shell, lenguajes de
alto nivel, programación de aplicaciones tipo GUI y programación
estándar usando llamadas al sistema. Este texto se concentra en el shell
de uso más común y más Gcil de entender, y en lenguajes de alto nivel,
con capítulos introductorios al tema de programación de aplicaciones
tipo GUI. La prograíiiación de shell y de alto nivel no requiere que
usted tenga conocimientos previos en programación, aunque algunos
principios al respecto ayudarán. Para la programación de GUI se requie-
re que conozca los lenguajes C y C + + . La programación estándar
consta de programas C y C + + que pueden tener acceso a operaciones
Linux de más bajo nivel, como archivos y programación de procesos.
Con frecuencia, esta progran~aciónse usa para crear aplicaciones de
administración como los controladores de dispositivo. Este tipo de
programación se halla bastante alejado del alcance del libro.
Los lenguajes de programación de alto nivel incluyen dos de los más
utilizados en Linux: Perl y Tcl/Tk, los cuales se estudian en otros
capítulos de este libro. Con el lenguaje Perl puede crear fácilmente
aplicaciones complejas para administrar archivos y manipular texto.
Con Tcl/Tk puede crear aplicaciones con interfaces GUI que hacen
uso de ventanas, menús y barras de herramientas. Los lenguajes de alto
 Capítulo 1:Introducción a la p
6

nivel son fáciles de aprender y utilizan comandos simples para generar

operaciones que normalmente requerirían programas en C extensos y
complicados. Como parte básica de su instalación, todas las distribucio-
nes de Linux incluyen soporte para la programación de shell, GAWK,
Perl,Tcl/Tk, C y C + + , lo mismo que para el desarrollo de GNOME y
KDE (K Desktop Environment).

Nota . .
1" soporte de programación puede no instalarse automáticamente en
un computador cuando se instala una distribución. Las principales
distribuciones, como Red Hat, Caldera y SuSE, le permiten instalar el
soporte de programación cuando instala el software de distribución,
como parte de un grupo de aplicaciones para el desarrollo.

Debido a que este es un texto de programación en Linux que

supone que muchos lectores ya están familiarizados con los aspectos
fundamentales del tema, este capítulo comienza con un análisis de
diferentes lenguajes de programación disponibles en Linux. Si usted
apenas empieza a conocer Linux y quiere aprender más acerca de él
antes de avanzar a temas más profundos, podría comenzar hacia la
mitad de este capítulo, en la sección "Más acerca de Linux", y después
volver al comienzo para aprender más. Más adelante, en el mismo
capítulo, también se presentan recursos en línea para docunlentación,
distribuciones, software, grupos de noticias y sitios Web que ofrecen la
información y los artículos más recientes acerca de Linux. Casi al final
del capítulo, encontrará una tabla que es un listado de sitios Web para
distribuciones, publicaciones sobre Linux, bancos de software y avances
de programación en Linux.

Programación Linux
Linux se ha desarrollado como un esfuerzo conjunto en Internet.
Ninguna compañía o institución controla Linux, y el software desarro-
llado en este sistema refleja esa condición. El progreso de este tipo de
software siempre se ha desarrollado en el entorno de Internet; su
 ación e n Linux

alcance es de carácter global e incluye a programadores de todo el

mundo. Lo único que usted tiene que hacer para comenzar un proyec-
to de software basado en Linux es contar con un sitio Web. Con fre-
cuencia, el desarrollo tiene lugar cuando los usuarios de Linux deciden
trabajar en forma conjunta en un proyecto. Cuando terminan, el
software se pone en un sitio de Internet para que cualquiera tenga
acceso a él y pueda bajarlo sin problenlas. Debido a este entorno de
desarrollo activo, el crecimiento del nuevo y cada vez más funcional
software de Linux es inmenso.
La mayor parte del software de Linux está protegido con derechos
de autor bajo una licencia pública de G N U (quiere decir que G N U no
es UNIX) que otorga la Free Software Foundation y a menudo se
conoce como software G N U (véase www.gnu.org). Este software es
gratuito y ha demostrado ser muy confiable y efectivo. Muchas de las
utilidades populares de Linux, como compiladores C, shells y editores,
son aplicaciones del software GNU.
Antes de ponerlo en funcionamiento en el sistema, un programa
Linux se debe transformar en comandos de lenguaje de máquina de
bajo nivel conocidos como código binario. Por ejemplo, cuando se está
programando se crea un conjunto de instrucciones utilizando palabras
ordinarias que después deben convertirse en códigos binarios que se
ajustan como una aplicación que se puede ejecutar. U n intérprete realiza
en tiempo de ejecucrón esta conversión o se puede generar explícita-
mente de una vez con un cotnpilador. La mayor parte de los lenguajes de
programación descritos en este libro utilizan un intérprete. Los lenguajes
de programación GAWK, Per1,Tcl y T k de los shells BASH y TCSH
usan sus propios intérpretes. Los programas desarrollados en estos
lenguajes se pueden poner a funcionar directamente aunque sean
archivos de la aplicación. U n compilador creará un archivo de aplica-
ción por separado con el código binario que entonces se puede ejecu-
tar, pero en este libro no se trata el tema de los compiladores.
La progranlación en G N O M E y KDE, que también se trata en este
texto, difiere mucho de este modelo. Los programas GNOME y KDE son
realmente progranias C y C++ que se deben compilar primero con el
compiladorg~(el compilador G N U de C y C++), que creará un archivo de
aplicación ejecutable que usted podrá poner en fbncionanliento. Esto
 Capítulo 1: Introducción a 1
w*#aww

significa que es necesario que sepa programar en C si desea usar

G N O M E y en C + + para trabajar con KDE.

Programación del shell BASH

U n programa del shell combina comandos Linux de manera que se
pueda realizar una tarea específica. El shell BASH brinda muchas
herramientas de programación que puede usar para crear programas del
shell. Usted puede definir variables y asignarles valores, lo mismo que
definir variables en un archivo del script y tener un usuario que ingre-
se valores en forma interactiva cuando se ejecute el script. El shell
ofrece estructuras de repetición y estructuras de control condicional que repiten
comandos de Linux o toman decisiones sobre los comandos que usted
desee ejecutar. Usted también puede construir expresiones que realicen
operaciones aritméticas o de comparación.Todas estas herramientas de
programación del shell BASH operan en forma similar a las que se
encuentran en otros lenguajes de programación. Puede obtener más
información acerca de BASH en su manual en línea de Linux (frente al
prompt ingrese m a n con la terminación bash, así: m a n bash) y en el sitio
Web de G N U en www.gnu.org (BASH en un producto de software de
GNU).
En este libro se presentan dos capítulos que tratan sobre programa-
ción del shell: uno sobre mnceptos básicos, como variables de declara-
ción y scripts de ejecución, y el otro sobre estructuras de control del
shell que le muestran cómo usar bucles y condiciones para crear pro-
gramas complejos. Usualmente, las instrucciones que constituyen un
programa del shell se ingresan en un archivo de script que se puede ejecu-
tar. Para operar el programa del shell, usted puede ejecutar el script del
archivo correspondiente. Inclusive, puede distribuir su programa entre
varios archivos del script, en uno de los cuales estarán las instrucciones para
ejecutar los demás. Considere las variables, expresiones y estructuras de
control como herramientas para usar varios comandos Linux en una sola
operación. En este sentido, un programa del shell es un comando Linux
nuevo y complejo que usted ha creado.
La ejecución de los comandos Linux en un programa del shell se
puede dirigir con estructuras de control que le permitan repetir coman-
dos y seleccionar algunos de ellos, en lugar de otros. Una estructura de
 gramación en Linux
".e* we* e

control consta de dos componentes importantes: una prueba y coniandos.

Si la prueba tiene éxito, los comandos se ejecutan. De esta manera,
usted puede emplear estructuras de control para tomar decisiones
acerca de si los coniandos se deben ejecutar.

Programación del shell TCSH

El shell TCSH, como el shell BASH, también tiene capacidades de
lenguaje de programación. Usted puede:

O Definir variables y asignarles valores.

0 Establecer definiciones de variables y comandos Liiiux en un
archivo del script y después ejecutar ese script.
0 Utilizar estructuras de repetición y estructuras de control condi-
cional para repetir comandos Linux o para tomar decisiones sobre
cuáles son los coniandos que quiere ejecutar.
0 Instalar trampas o desviaciones en su programa para manejar
interrupciones.

Puede obtener más información sobre el TCSH en su manual en

línea de Linux (frente al pronipt, ingrese el comando man con el
término tcsh, así: man tcsh).
El shellTCSH difiere de otros shell de Liiiux en que sus estructuras de
control son inás parecidas a las de un lenguaje de programación. Por ejemplo,
la condición test para una estruchira de control del shellTCSH es una
expresión para determinar falso o verdadero y no un conlando Linux.
Además, una expresión de este shell utiliza los mismos operadores que se
encuentran en el lenguaje de programación C, de modo que usted puede
realizar una variedad de operaciones de asignación, aritméticas,relacionales y
a nivel de bits. El shellTCSH también le permite declarar variables numéri-
cas que se pueden usar con facilidad en dichas operaciones.

GAWK
GAWK es un lenguaje de programación diseñado para que los usuarios
de Linux creen sus propios filtros. U n filtro lee información desde una
 Capítulo 1

hente de entrada, como un archivo o la entrada estándar,niodhca o analiza

esa infornlación y después produce los resultados. Estos pueden ser una
versión modificada de la entrada o un análisis. Por ejemplo, el filtro
sort lee un archivo y después da como resultado una versión clasificada
del mismo. El filtro w c lee un archivo y después calcula la cantidad de
palabras y líneas que contiene, dando como resultado sólo esa informa-
ción.
Con GAWK usted puede diseñar y crear sus propios filtros creando
sus propios coniandos Linux. Puede darle instrucciones a GAWK
como cat para presentar líneas en un archivo de texto, grep para
buscar patrones e inclusive hacer conteo de palabras con wc. En todos
los casos, usted podría agregar a sus programas sus propias capacidades
de filtros personalizadas. Por ejemplo, podría presentar sólo parte de
cada línea, buscar un patrón en un campo específico o contar única-
mente las palabras con niayúsculas.
La utilidad GAWK tiene toda la flexibilidad y coniplejidad de un
lenguaje de programación. GAWK tiene un conjunto de operadores
que le permiten programarlo para tomar decisiones y hacer cálculos;
también puede declarar variables y usarlas en estructuras de control
para controlar cómo se van a procesar las líneas. Muchas de las caracte-
rísticas de programación provienen del lenguaje de programación C y
coniparten la misma sintaxis.Todo esto la convierte en una poderosa
herramienta de programación. Puede hallar más información sobre el
tema en su manual Linux en línea (ingrese el comando m a n con la
terminación gawk) y en el sitio Web de GNU en www.gnu.org/
software.gawk.

Perl
Perl (Practica1Extraction and Report Lanpap) es un lenguaje para scripts
que se diseñó originalmente para trabajar en archivos con el fin de
generar informes y manejar archivos muy grandes. Se puede considerar
a Perl como el sucesor de GAWK y el lenguaje de programación del
shell BASH. Incluye muchas de las mismas capacidades pero con mayor
poder y flexibilidad. Perl se diseñó como un núcleo de programa al
cual se le podían agregar fácilmente más capacidades. Con el paso de
los años, estas capacidades se han ampliado muchísimo. Ahora puede
 ación en Linux

controlar conexiones en red e interacciones de procesos e inclusive

soporta una variedad de archivos de administración de bases de datos.
Con Perl usted puede tener acceso fácil a los archivos y manipular
cadenas, al igual que administrar arreglos.Al mismo tiempo, Perl sigue
siendo totalmente portátil y un script de Perl funcionará en cualquier
sistema Linux. Puede hallar más información en www.perl.com.

Tcl (Tool Command Language)

Tcl es un lenguaje de comandos de propósito general desarrollado por
John Ousterhout en 1987 en la Universidad de California en Berkeley.
Originalmente se diseñó para personalizar aplicaciones y con el tiempo
se convirtió en un lenguaje totalmente funcional. Igual que con Perl y
GAWK, usted puede escribir scripts con Tcl y desarrollar sus propios
programas en ese lenguaje.Tc1 es fácil de usar y sobre él puede encon-
trar más información en dev.scriptics.com.
T k y Expect son aplicaciones que amplían las capacidades del
lenguaje Tcl. La aplicación T k le permite desarrollar fácilmente aplica-
ciones gráficas interactivas. Usted puede crear sus propias ventanas y
cajas de diálogo con botones y cajas de texto de su elección. La aplica-
ción Expect permite una comunicación fácil con programas
interactivos conlo ftp y telnet.
Con frecuencia,Tcl se utiliza junto con T k para crear aplicaciones
gráficas.Tk se utiliza para crear elementos gtáficos mientras que Tcl
realiza acciones de programación, como administrar la entrada del
usuario. Al igual que Java,Tcl y T k son aplicaciones multiplataforma;
esto significa que un programa Tcl/Tk funcionará sobre cualquier
plataforma en donde esté instalado el intérprete Tcl/Tk. En la actuali-
dad existen versiones de Tcl/Tk para los sistemas Windows, Macintosh
y UNIX, incluido Linux. Usted puede escribir una aplicación Tcl en
Linux y hacer funcionar el mismo código en Windows o en
Macintosh.
Tcl es un lenguaje interpretado que opera, como Perl, dentro de su
propio shell. Para llamar al shell Tcl, usted usa el comando tclsh. Den-
tro de este shell puede ejecutar comandos de Tcl y crear archivos
dentro de los cuales puede llamar al shell Tcl y presentar una lista de los
comandos de Tcl; así, crea efectivamente un programa en este lenguaje.
 Capítulo 1: Introducción
s%sssB-s-

Tk
La aplicación T k extiende el Tcl con comandos para crear y administrar
objetos gráficos como ventanas, iconos, botones y campos de texto
utilizando el sistenia X Window. Puede encontrar más información
sobre T k en dev.scriptics.com.
Dentro del sistenia X Window,Tk usa su propio shell, llamado el
slzell wish, para ejecutar los comandos Tk. Para poner en funcionamien-
to programas en Tk, primero debe iniciar el sistema X Window y
después el shell wish ,usando el comando wish; verá una ventana en
donde puede hacer funcionar los comandos Tk. Si está utilizando una
GUI como Open Look o Motif, X Window está disponible de manera
automática.

Programación en CNOME
El G N U Network Object Model Environment, conocido como
GNOME, ofrece un poderoso escritorio fácil de usar, integrado básica-
mente por un panel, un escritorio y un conjunto de herramientas GUI
con las cuales se pueden construir interfaces de programa. Su objetivo
no es sólo ofrecer una interfaz consistente, sino también proveer una
plataforma flexible para el desarrollo de aplicaciones poderosas. Más
información sobre programación en G N O M E se puede encontrar en
developer.gnome.org.
GTK+ es el conjunto de ujidgets que se utiliza en aplicaciones de
GNOME. Los widgets son los botones, iconos, campos y otros objetos
que aparecen dentro de la GUI de una aplicación. GTK+ parece y se
considera como una derivación original de la interfaz Motif GUI (más
adelante, en este capítulo, se profundizará acerca de Motif), creada
pensando en poder y flexibilidad. Por ejemplo, los botones pueden
tener rótulos, imágenes o cualquier combinación de ellos. Los objetos
se pueden consultar en forma dinámica y modificarse en tiempo de
ejecución. GTK+ también incluye un manejador de estilos que les per-
mite a los usuarios cambiar el aspecto y consideración de las aplicacio-
nes que usan los widgets. Incluso con toda esta capacidad, el conjunto
de widgets de GTK+ sigue siendo pequeño y eficiente. Es totalmente
gratuito y distribuido bajo la Library General Public License (LGPL),
lo que les permite a los programadores emplear el conjunto con soft-
ware de uso restringido, así como gratuito.
En esencia, un programa en G N O M E es un programa en C que
incluye funciones de GTK+ lo mismo que funciones GNOME.
Aunque no es tan fácil de usar como el Tk, el G N O M E exige que
usted utilice sólo unas cuantas funciones básicas para crear interfaces de
usuario más simples. La programación en G N O M E hace uso de un
extenso conjunto de funciones y estructuras que se encuentran en
muchas librerías y constituyen los diferentes componentes que funcio-
nan en una aplicación GNOME. Usted puede considerar las funciones
de GTK+ como operaciones en nivel bajo y las funciones G N O M E
como operaciones de alto nivel, fáciles de usar. Usualmente, las funcio-
nes G N O M E incorporan varias funciones GTK+ que facilitan las
tareas de la GUI en el programa. Este capítulo le ofrece una visión
general de estas librerías y la manera de usarlas para crear programas en
GNOME.

Programación en KDE
KDE (K Desktop Environment) está organizado en un modelo de
objetos de C + + : es decir, objetos C + + que contienen funciones con
las cuales usted puede modificar el objeto. Muchas de las funciones son
heredadas y otras estan definidas por un tipo particular de objeto. En
un programa KDE, usted define un objeto y después utiliza sus funcio-
nes públicas y privadas para modificarlo. Por ejemplo, puede crear un
objeto del nienú y después usar las funciones de dicho objeto para
agregarle nuevos ítems de menú. Como un programa en C++ orienta-
do por objetos, el KDE utiliza un extenso conjunto de clases de objetos
jerárquicos que se encuentran en las librerías KDE y Qt. Las clases más
bajas en la jerarquía heredarán miembros de las clases más altas conectadas
en la jerarquía. Usted puede crear sus propias clases y después heredar
miembros (funciones) a partir de las clases de KDE predefinidas. El lengua-
je KDE usa la caja de herramientas de Qt y en la actualidad se basa en ella
directamente (Qt es una caja de herramientas de las funciones de GUI,
que Trolltech desarrolló y mantiene). En KDE se utiliza la Qt Free Edition
y a diferencia de GNOME, que tiene funciones de nivel más bajo, que
administra con cualquier caja de herramientas, KDE únicamente se basa en
 Capítulo 1: Introducción a la programación e n Linux
- - -
1 13
la caja de herrainientas de QT; en csei~cia,la programación en KDE es
progrm~acibnen Qt.
E11 la documentación que ofiece en su sitio Web,
developer.lcde.org., el creador de KIIE presenta un listado completo
de las clases de interfaces de usiiario de I<DE. En ese sitio se incluye un
tiitorial detallado y lilaterid de referencia completo para la AI'I I<llE,
lo iiiisiiio que docilmentación para el I<OM ( I W E Object Manager) y
rilaterial de referencia de Qt.Todas las clases se describen en detalle
junto con la declaración de tipo de clase, incluidas siis declaraciones de
las funciones niieriibro y las definiciones. Además, usted debe consiiltnr
los archivos con eiicabezados KDE y Qt. Los archivos .h cuentan con
un listado conipleto de las clases I<DE y Qt con comentarios detallados
que describen sus f~iticionesniieiiibro.

' Pregunta: ¿Cuál es la manera más fácil de crear programas que

usen elementos de escritorio como ventanas y menús?
Respuesta: UtiliceTk, la extensión deTc1 que soporta eleiiientos GUI,
1 1 1 m,
corno ventanas y Darras ae nrrrairiientas. ingrese los conianaos 1 K en cm

-
script. A diferencia de la prograiilacióii en GNOME y KDE, usted n o
necesita saber C o C++.
Pregunta: ;Cuál es la manera más fácil de escribir programas
para administrar archivos de texto?
Respuesta: Utilice Perl.Tieiie excelentes capacidades de manejo de
archivos. Con unos cuaiitos coliiandos sencillos. usted puede crear, leer o
actualizar archivos.
Pregunta: ¿Qué comandos del shell BASH deberé usar para
crear mis propios filtros para el shell?
Respuesta: Usted rio debe usar conxmios del shell HASM para crear
filtros del shell. En cambio, utilice GAW K, que está diseñado para trabajar
como un filtro, pero incltiye una coiripleta gama de capacidades de progra-
inación.
 ación en Linux
a.@GWS e

Prueba de repaso
¿Cuentan los shells de Linux con capacidad de programación?'

¿Qué lenguajes puede usar usted para crear programas más

complejo^?^
Si estuviera interesado en programación con aplicaciones
tipo GUI en Linux, ¿qué usaría?'

Más acerca de Linux

U n sistema operativo es un programa que administra el hardware y el
software de una computadora para el usuario. Originalmente, los
sistemas operativos se diseñaron para realizar tareas repetitivas de
hardware que se concentraban en administrar archivos, operar progra-
mas y recibir comandos que señalaba el usuario. Usted interactúa con
un sistema operativo a través de una intefaz de usuario que permite que
el sistema operativo reciba e interprete instrucciones enviadas por el
usuario. La interfaz de usuario de un sistema operativo puede ser tan
simple como ingresar comandos en una línea o tan compleja como
seleccionar menús e iconos en un escritorio.
U n sistema operativo también administra aplicaciones de software.
Para realizar diferentes tareas, como edición de documentos o hacer
cálculos, se necesitan aplicaciones específicas de software; un editor es
un ejemplo de esas aplicaciones pues le permite editar un documento,
hacerle cambios y agregar texto nuevo. El editor.es un programa que
consta de instrucciones que debe ejecutar la computadora. Para usarlo, se
debe cargar el programa en la memoria de la computadora y después se
ejecutan las instrucciones. El sistema operativo controla la carga y ejecu-
ción de todos los programas, incluida cualquier aplicación de software.
Cuando usted quiere usar un editor, simplemente le da las instrucciones
al sistema operativo para cargar la aplicación del editor y ejecutarla.

1 Sí; BASH y TCSH se estudian en este libro.

2 GAWK, Perl y Tcl.
3 Tk, GNOME y KDE.
 Capítulo 1:Introducció
a

Administración de archivos, de programas e interacción con el

usuario son características tradicionales comunes a todos los sistemas
operativos. Linux, como todas las versiones de UNIX, agrega dos
características:multitarea y multiusuario. Como sistema multitarea,
usted puede pedirle al sistema que realice varias tareas simultáneamen-
te: por ejemplo, puede editar un archivo mientras está imprimiendo
otro. Conio sistema multiusuario, varios usuarios pueden conectarse al
sistema al mismo tiempo, interactuando todos con el sistema a través de
sus propias terminales.
Los sistemas operativos se diseñaron originalmente para darle efi-
ciencia al hardware. Cuando se desarrollaron las primeras computa-
doras, sus capacidades eran limitadas y el sistema operativo tenía que
hacer la mayoría del trabajo. En este sentido, los sistemas operativos se
diseñaron considerando el hardware y no al usuario, de manera que
tendían a ser rígidos e inflexibles, obligando al usuario a ajustarse a las
exigencias de eficiencia del hardware.
Linux, por su parte, está diseñado para ser flexible, reflejando sus
raíces en UNIX. Esta flexibilidad le permite ser un sistema operativo
accesible al usuario. En lugar de que el usuario quede confinado a
interacciones limitadas y rígidas con el sistema operativo, éste le ofrece
un conjunto de herramientas altamente efectivas. Esto significa que
usted puede configurar y programar el sistema para satisfacer sus nece-
sidades específicas. Con Linux, el sistema operativo se convierte en un
entorno operativo.
Linux es una versión para P C del sistema operativo U N I X que se
ha utilizado durante décadas en mainframes y minicomputadoras y en
la actualidad es el sistema para las estaciones de trabajo. Linux brinda
velocidad, eficiencia y flexibilidad de UNIX a su PC, tomando ventaja
de todas las capacidades que las computadoras personales ofrecen en la
actualidad. Junto con sus capacidades de UNIX, Linux ofrece podero-
sas características de red que incluyen soporte para Internet, intranet,
Windows y trabajo en red con AppleTalk. Como un estándar, Linux se
encuentra en servidores de Internet rápidos, eficientes y estables como
servidores Web, FTP y servidores de correo, así como en servidores de
nombres de dominio, proxy, de noticias, y servidores de índices. En
otras palabras, Linux tiene todo lo que usted necesita para crear, soste-
ner y mantener una red totalmente funcional.
 programación en Linux
S**%* ~W

Ahora, con la inclusión de GNOME y KDE, Linux también sumi-

nistra GUI con un nivel extremadamente elevado de flexibilidad y
poder; a diferencia de Windows y Mac, usted puede elegir la interfaz
que desee y personalizarla, agregar paneles, applets, escritorios virtuales
y menús, todo con capacidades completas de arrastrar y soltar, y herra-
mientas que reconocen Internet. En su escritorio, una ventana adnii-
nistradora de archivos puede ingresar a cualquier sitio de Internet,
permitiendo que usted presente páginas Web y baje archivos de la red
por medio de unas sencillas operaciones con el ratón.
Linux hace todo esto por un precio estupendo: es gratis, incluyendo
los servidores de red y los escritorios GUI. A diferencia del sistema
operativo oficial UNIX, Linux se distribuye gratuitamente bajo la
licencia pública general de GNU, según las condiciones de la Free
Software Foundation y está a disposición de quien quiera usarlo. Aun-
que Linux tiene derechos de autor, su licencia pública G N U básica-
mente lo convierte en dominio público pues está diseñada para
garantizar que siga siendo gratuito y, al mismo tiempo, estándar, de
manera que sólo hay un Linux oficial. El proyecto G N U se inició y está
dirigido por la Free Software Foundation para suministrar software
gratis a usuarios y programadores. La lista de software disponible bajo la
licencia pública G N U es extensa e incluye entornos, lenguajes de

-
programación, herramientas de Internet y editores de texto.

Antes d e Linux fue UNIX

Para apreciar verdaderamente a Linux, usted debe entender el contexto
especial en donde se desarrolló el sistema operativo UN1X.A diferen-
cia de la mayoría de los demás sistemas operativos, U N I X surgió en un
ambiente académico y de investigación. En universidades y laborato-
rios, U N I X es el sistema que se debe elegir. Su desarrollo va paralelo a
toda la revolución de las computadoras y las comunicaciones que se ha
presentado durante las últimas décadas. Con frecuencia, los profesiona-
les de la computación desarrollaron nuevas tecnologías de computación
en UNIX, como las que se aplicaron para Internet. Aunque es un
sistema muy sofisticado, U N I X fue diseñado desde el comienzo para
ser flexible, de manera que se puede modificar fácilmente para crear
diferentes versiones. D e hecho, muchos proveedores mantienen sus
 Capitulo 1: Introducción a l a programación en Linux
- -- h
17

propias vcrsioiies oficiales de U N I X . IBM, Sun y Hewlett-Packard

venden y rriantieiieii sus propias versiones de U N I X . A iiienudo el
personal vinculado a programas de investigación crea sus propias ver-
siones de U N I X , ajustadas a sus necesidades especiales. Esta flesibilidad
inherente al diserio de U N I X no deinerita e n nada sil calidad; dc
hecho, esto lo atestigua sil resistencia, que permite adaptarlo práctica-
niente a ciialquier entorno.

v Pregunte a los expertos

Pregunta: Como Linux es cratuito, ¿eso indica que n o es un siste-
ma operativo tan bueno c o m o Windows?

Respuesta: El hecho de que Linux sea gratuito, en ocasiones produce en la

gente Ia impresión errada de que es iin sistcma operativo ineiios profesioiial.
Linux es, en realidad, una versión de UNIX para PC y estaciones de trabajo, y
.~...p~~nc
I~LLILIL\IJ
1-
IV
,.nmc;,~amm.. ,s..+m~~A,
L I I L I J ~ U L L I ~ I I I I I L ~ Jc > L a u l c
.,",,A..-..,~
J ~UCICLUXJ ~ L I L LI
..A-.. .,
" . . ~ WwI Ir I~U C. ~~W,>... .EI, ~~ U U L Iy .,1l a

estabilidad son las características que lo han convertido eii el sistema oper;itivo
preferido en los servidores de red.

Ilentro d e este contesto se desarrolló Linux, y en ese scntido, es

otra versión de U N I X para PC. El estudio por parte de profesionales
dc la computación que trabajan en entornos de investigación refleja la
manera como las versiones de U N I X se han desarrollado.

El hecho de que Linux tenga una licencia pública y sea gratuito

refleja las profundas raíces de UNIX en las instituciones académicas,
con su sentido de servicio público y respaldo. Linux es un sistema
operativo de primera clase accesible a todos, sin costo alguno.

Cómo surgió UNIX

C o m o una versión de U N I X , la Iiistoria de Linux iiaturalinente comien-
za con UNIX.Todo empezó a finales de la década de 1960 durante un
esf~ierzoconcertado para desarrollar nuevas técnicas para sistemas
 ramación en Linux
*& .

operativos. En 1968, un grupo de investigadores de General Electric,

AT&T Be11 Laboratories y el Massachusetts Institute of Technology
llevaron a cabo un proyecto especial de investigación en sistemas
operativos llamado MULTICS (MULTiplexed Information
Computing System). MULTICS incorporó muchos conceptos nuevos
en multitareas, administración de archivos e interacción con el usuario.
En 1969, Ken Thompson, Dennis Ritchie y los investigadores en
AT&T Be11 Laboratories desarrollaron el sistema operativo UNIX,
incorporando muchas de las características desarrolladas por el proyecto
de investigación MULTICS. Ellos ajustaron el sistema a las necesidades
del entorno de investigación, diseñándolo para que funcionara en
minicomputadoras. Desde su concepción, UNIX fue un sistema opera-
tivo multitarea y multiusuario, eficiente y de precio asequible.
El sistema UNIX se popularizó en los Laboratorios Be11 a medida
que más y más investigadores comenzaron a usarlo. En 1973, Ritchie y
Thompson volvieron a escribir el código de programación para el
sistema UNIX en el lenguaje de programación C. Ritchie creó dicho
lenguaje como una herramienta flexible para el desarrollo de progra-
mas. Una de las ventajas de C es que puede tener acceso directo a la
arquitectura de hardware de un computador con un conjunto generali-
zado de comandos de programación. Hasta ese momento, un sistema
operativo se tenía que reescribir especialmente en el lenguaje
ensamblador específico para el hardware de cada tipo de con~putadora.
El lenguaje de programación C permitió que los investigadores escri-
bieran una versión única del sistema operativo UNIX que después se
podía compilar por medio de compiladores de C en diferentes
computadoras. En efecto, el sistema operativo UNIX se volvió portátil,
es decir, capaz de funcionar en diferentes computadoras con poca o
ninguna necesidad de reprogramación.
UNIX creció gradualmente del diseño adaptado para una persona
hasta convertirse en un producto de software estándar distribuido por
muchos proveedores, como Novel1 e IBM. En un principio, UNIX se
consideró como un producto de investigación. Las primeras versiones
de UNIX se distribuyeron gratuitamente a los departamentos de
ciencia de la computación de muchas universidades de prestigio. Du-
rante la década de 1970, Laboratorios Bell comenzó a entregar versio-
nes oficiales de UNIX y a conceder licencias de los sistemas para
diferentes usuarios. Uno de estos usuarios fue el departamento de
 Capítulo 1:Introducción a
w V."" *%*We'W,.V

ciencias de la computación de la Universidad de California en

Berkeley, en donde se le agregaron muchas características nuevas que
más adelante se volvieron estándares. En 1975, dicha universidad lanzó
su propia versión de UNIX, conocida por su línea de distribución,
Berkeley Software Distribution (BSD). Esta versión BSD de U N I X se
convirtió en un contendor importante de la versión de AT&T Be11
Labs. Pronto surgieron otras versiones independientes de U N I X para
PC. En 1980, Microsoft desarrolló una versión de UNIX para PC
llamada Xenix. AT&T desarrolló varias versiones de UNIX y en 1983
sacó al mercado su primera versión comercial, llamada System 3, a la
que siguió más adelante SystemV, que se convirtió en un producto de
software con soporte comercial.
Al mismo tiempo, la versión BSD de UNIX se desarrolló a través de
varias versi0nes.A finales de 1970, el BSD UNIX se convirtió en la base
de un proyecto de investigación de la Advanced Research Projects Agency
(DARPA) del Departamento de Defensa. Como resultado, en 1983
Berkeley lanzó una poderosa versión de UNIX conocida como BSD 4.2
que incluía una sofisticada administración de archivos así como característi-
cas de conexión en red con base en los protocolosTCP/IP, que son los
nlismos que ahora usa Internet. Esta versión fue ampliamente distribuida y
adoptada por muchos proveedores, como Sun Microsystems.
La proliferación de diferentes versiones creó la necesidad de contar
con un estándar para UNIX. Los creadores de software no tenían manera
de saber cuál era la versión con que realmente funcionaban sus progra-
n1as.A mediados de la década de 1980 surgieron dos estándares en
competencia, uno basado en la versión de AT&T y el otro en la versión
BSD. Hoy en día en las librenas usted puede encontrar muchos libros
diferentes sobre UNIX para una u otra versión, de modo que algunos
son específicos para el SystemV UNIX y otros para BSD UNIX.
AT&T trasladó U N I X a una nueva organización, llamada UNIX
System Laboratories, que se pudo dedicar a desarrollar un sistema
estándar, integrando las principales versiones diferentes de UNIX. En
1991 esta entidad desarrolló el SystemV, versión 4 que incorporaba casi
todas las características de la SystemV versión 3, BSD versión 4.3,
SunOS y Xenix. Como respuesta, otras compañías, como IBM y
Hewlett-Packard, establecieron la Open Software Foundation (OSF)
para crear su propia versión estándar de UNIX. Entonces, se encontra-
ron dos versiones con~erciales:la OSF y la SystemV versión 4. En
 rogramación en Linux
a

1993,AT&T vendió su participación en U N I X a Novell, de modo que

los UNIX Systenls Laboratories se convirtieron en el UNIX Systems
Group de Novell, entidad que produjo sus propias versiones de UNIX con
base en el SystemV versión 4, conocidas como UnixWare, diseñada para
interactuar con el sistema NetWare de Novell. En la actualidad, UNIX
Systems Laboratories es propiedad de la Santa Cruz Operation. Con
Solaris, Sun ha introducido el SystemV versión 4 en sus sistemas. Dos GUI
que compiten por UNIX, Motif y Open-Look, se han unido en un nuevo
estándar de escritorio llamado Common Desktop Environment (CDE).
Durante gran parte de su desarrollo, U N I X mantuvo un sistema
operativo grande y exigente que necesitaba una estación de trabajo o
una miniconiputadora para ser eficaz. Se diseñaron varias versiones de
UNIX, básicamente para el entorno de estación de trabajo. SunOS se
creó para las estaciones de trabajo de Sun, y AIX para las de IBM. Sin
embargo, a medida que las computadoras personales se volvieron más
poderosas, los esfuerzos se encaminaron a crear una versión de UNIX
para PC. Xenix y el SystemV/386 son versiones comerciales de UNIX
diseñadas para P C conipatibles con IBM.AUX es una versión de U N I X
que funciona para Macintosh; es una comprobación de la portabilidad
inherente de UNIX que se puede encontrar en casi cualquier tipo de
computadora: estaciones de trabajo, minicomputadoras e incluso
supercon~putadoras.Esta portabilidad inherente hizo posible la creación
de una versión efectiva de U N I X para PC.

La llegada de Linux
En principio, Linux se diseñó específicamente para coniputadoras
personales basadas en Intel. Se inició como un proyecto personal de un
estudiante de sistemas llaniado Linus Torvalds en la Universidad de
Helsinlu. En esa época, los estudiantes utilizaban un programa llamado
Minix, que contaba con diferentes caractensticas de UNIX. El profesor
Andrew Tannebaum había creado Minix y éste se distribuía ampliamente
a través de Internet a estudiantes de todo el niundo. La intención de
Torvalds era crear una versión de U N I X efectiva en los P C para los
usuarios de Minix. La llamó Linux y en 1991 lanzó la versión O. 11.
Linux se distribuyó ampliamente a través de Internet y durante los
años siguientes otros programadores lo depuraron y le hicieron adicio-
nes, incorporando la mayoría de las aplicaciones y características que
 Capítulo 1: Introducción a la prog
"#- w
"-

ahora se encuentran en los sistemas UNIX estándar. Los principales

administradores de ventanas han sido adecuados para Linux, que cuenta
con todas las utilidades de Internet, como FTP, telnet y SLIPTambién
posee un conjunto completo de utilidades de desarrollo de programa,
como compiladores de C + + y depuradores.

Nota - a .

Dadas todas sus características, el sistema operativo Linux sigue

siendo pequeño, estable y rápido. En su formato más simple, puede
funcionar con efectividad con una memoria de sólo 4MB.

Aunque Linux se desarrolló en el entorno abierto y gratuito de

Internet, se ajusta a los estándares oficiales de UNIX. Debido a la
proliferación de versiones de UNIX en las décadas anteriores, el
Institute of Electrical and Electronics Engineers (IEEE) desarrolló un
estándar independiente para el American National Standards Institute
(ANSI) que se denominó Portable Operating System Interface for
Computer Environments (POSIX). El estándar define cómo debe
operar un sistema conlo UNIX, especificando detalles como llamadas e
interfaces del sistema. POSIX define un estándar universal al cual
deben ajustarse todas las versiones de UNIX, algo que hoy en día
cumplen casi todas las veniones de UNIX y, con base en ese estándar,
Linux se desarrolló desde el principio.

Prueba de repaso
O ¿Cuánto cuesta L i n ~ x ? ~
O ¿Más de un usuario puede trabajar al mismo tiempo en un
sistema Linux s e n c i l l ~ ? ~
0 ¿En qué sistema operativo se basó L i n ~ x ? ~

4 Es gratuito.
5 Sí, es multiusuario.
6 En UNIX.
 gramación en Linux
w m w a w - e ee

Anatomía de Linux: shells,

directorios y escritorios
Como UNIX, Linux se puede dividir en tres componentes principales:
el kernel (núcleo), el entorno y la estructura de archivos. El kernel es el
programa base que dirige otros programas y administra dispositivos de
hardware como discos e impresoras. El entorno ofrece una interfaz para
el usuario, recibe comandos de éste y envía otros comandos al kernel
para la ejecución. La estructirra de archivos organiza la manera como se
almacenan los archivos en un dispositivo de almacenamiento, como es
el caso de un disco. Los archivos están organizados en directorios, cada
uno de los cuales puede contener un número indeterminado de
subdirectorios con archivos. En conjunto, el kernel, el entorno y la
estructura de archivos forman la estructura básica del sistema operativo.
Con los tres, usted puede dirigir programas, administrar archivos e
interactuar con el sistema.
Un entorno ofrece una interfaz entre el kernel y el usuario. Se
puede describir como un intérprete que capta los comandos que da el
usuario y los envía al kernel. Linux ofrece varias clases de entornos:
escritorios, administradores de ventanas y shells de la línea de conian-
dos. Los usuarios pueden ajustar sus entornos a sus propias necesidades
especiales, sean shells, administradores de ventanas o escritorios. En este
sentido, para el usuario, el sistema operativo funciona más como un
entorno operativo que el usuario puede controlar.
La interfaz del shell es muy sencilla; por lo común, consta de un
pronlpt en donde usted escribe un comando y después presiona
E N T E R en el teclado. En cierto sentido, está escribiendo el comando
en la línea de conzandos. Usted encontrará que los comandos que se
ingresan en la línea de comandos pueden llegar a ser muy complejos.
Con el paso de los años, se han desarrollado varias clases diferentes de
shells. En la actualidad, los tres más iniportantes son Bourne, Korn y C-
shell. El primero de ellos es de Laboratorios Bells para el SystemV;
Korn es una ampliación posterior de Bourne y el C-shell se creó para
la versión BSD de UNIX. Las actuales versiones de UNIX, incluido
Linux, incorporan los tres shells permitiéndole elegir el de su preferen-
cia. Sin embargo, Linux utiliza versiones ampliadas o de dominio
público: Bourne Again,TC-shell y Public Domain Korn, entre otros.
 Capítulo 1:Introducción
S*

Cuando comience su sistema Linux, usted instalará el shell Bourne

Again, una versión actualizada de B0urne.A partir de ahí, puede cam-
biar a otros de su preferencia.
C o m o alternativa a una interfaz de la línea de comandos, Linux
suministra escritorios y administradores de ventanas que utilizan GUI
basadas en el sistema X Window desarrollado para U N I X por el con-
sorcio Open Group (www.opengroup.org y www.Xll.org). U n
administrador de ventanas es una versión reducida de un escritorio que
soporta solamente la operación de la ventana pero le permite trabajar
con cualquier otra aplicación. U n escritorio ofrece una GUI completa,
muy similar a la de Windows y Mac. Usted cuenta con ventanas, iconos
y menús, todos administrados a través de los controles del ratón. E n la
actualidad, hay dos escritorios disponibles en forma gratuita y que se
incluyen en la niayoría de las distribuciones de Linux: G N O M E y
KDE.
En Linux, los archivos están organizados en directorios, como se
encuentran en Windows, en gran parte.Todo el sistema de archivos de
Linux es un gran conjunto interconectado de directorios, cada uno
con sus archivos. Algunos directorios son directorios estándar reserva-
dos para uso del sistema. Usted puede crear sus propios directorios para
sus propios archivos, al igual que trasladarlos con facilidad de un direc-
torio a otro. Inclusive puede mover directorios completos y compartir
directorios y archivos coflotros usuarios de su sistenia. C o n Linux,
usted también puede establecer perniisos en los directorios y archivos,
permitiendo que otras personas tengan acceso a ellos o, por el contra-
rio, estableciendo la entrada sólo para usted.
Los directorios de cada usuario están conectados, finalmente, a los
directorios de otros usuarios y se encuentran organizados en una
estructura de árbol jerárquica que inicia con un directorio raíz inicial.
Los demás directorios se derivan, en definitiva, de este directorio raíz.
En realidad, usted puede viajar a través del sistema, entrando a cual-
quier directorio que pueda abrir. Esta interconectividad de la estructu-
ra de archivos facilita compartir datos: varios usuarios pueden tener
acceso a los niismos archivos.
El directorio raíz es un directorio especial que necesitará usar
cuando configure su sistema Linux por primera vez. Linux es un
 programación en Linux
a#Bws--*@

sistema multiusuario: varios usuarios pueden con~partirel niismo

sistenia operativo. Sin embargo, el sistema operativo mismo se en-
cuentra en programas ubicados en directorios especiales que comien-
zan con el directorio raíz. En ocasiones se les conoce como directorios
del sistema.
Con KDE y G N O M E , ahora Linux tiene una GUI completamente
integrada. Usted puede realizar todas las operaciones de Linux desde
cualquiera de las interfaces. Anteriormente, Linux sostenía a los admi-
nistradores de ventanas que contaban con alguna funcionalidad de
GUI, pero que, por lo común, estaban restringidos a operaciones con
ventanas. KDE y G N O M E son escritorios totalmente operucionulc~sque
soportan operucioncs de arrastrar y soltar, permitiéndole arrastrar iconos
a su escritorio y configurar sus propios tnenús sobre un panel de
Aplicaciones. Ambos funcionan en un sistenia X Window, lo cual
significa que en la medida que ambos estén instalados en el sistema, las
aplicaciones de uno pueden funcionar en el escritorio del otro. Usted
puede trabajar con programas KDE como el de correo o el lector de
noticias sobre el escritorio G N O M E . Las aplicaciones de G N O M E ,
como el cliente FTP: Gftp, pueden funcionar en el escritorio de KDE.
Inclusive puede intercambiar administradores de archivos, usando el
adniinistrador de archivos KDE en G N O M E ; en ese caso, perderá algo
de la funcionalidad del escritorio, como las operaciones de arrastrar y
soltar, pero las aplicadones funcionarán bien.
Ambos escritorios pueden funcionar en el programa del sistema X
Window, lo mismo que cualquier programa que utilice el cursor como
Emacs yVi, los cuales fueron diseñados para trabajar en un entorno de
shell. Al mismo tiempo, se escribieron gran cantidad de aplicaciones
para esos escritorios y se incluyeron en sus distribuciones. El escritorio
K tiene un completo conjunto de herramientas de Internet junto con
aplicaciones de editores y gráficas, multimedia y sistemas. G N O M E
tiene u n poco menos de aplicaciones, pero muchas funcionan en la
actualidad. En los sitios Web www.gnome.org y www.kde.org
encontrará nuevas aplicaciones. Cuando se lanzan nuevas versiones, en
ellas se incluirá el nuevo software.
 ¿Cuáles son los tres componentes principales del sistema
operativo Linux?'

¿Cuáles son los escritorios que se utilizan con más frecuencia

en el sistema Linux?$

¿Cómo están organizados los directorio^?^

Distribuciones de Linux
Aunque sólo hay una versión estándar de Linux, en realidad existen
diferentes versiones. Distintas compañías y grupos han creado paquetes
de Linux y software de Linux en formas ligeramente diferentes. Cada
compañía o grupo presenta su paquete de Linux, por lo general en
CD-ROM. Más adelante se pueden incluir versiones actualizadas de
los programas o de software nuevo. Algunas de las versiones más popu-
lares son R e d Hat, OpenLinux, SuSE y Debian.

Nota
Varias distribu a y Red Hat, también ofrecen sus
sistemas dentro del software comercial.

Red Hat
En la actualidad, R e d Hat Linux es la distribución más popular de
Linux. Ésta dio origen al sistema de paquetes R P M usado en varias
distribuciones, mediante el cual se instalan y retiran auton~áticamentelos
paquetes de software. R e d Hat también suministra gran parte del desa-
rrollo del so'ftware para el escritorio GNOME. Sin embargo, también
sostiene a KDE. Su distribución incluye a GNOME y KDE. R e d Hat,
como Caldera OpenLinux, mantiene alianzas de software con compañías

7 Kernel, entorno y estructura de archivo.

8 GNOME y KDE.
9 En estructura de árbol.
 amación en Linux
es--

importantes como Oracle, IBM y Sun. La distribución R e d Hat de

Linux está disponible en línea en www.redhat.com.

OpenLinux
Caldera OpenLinux está diseñado para uso corporativo comercial. El
sistema y los paquetes de software de OpenLinux incluyen todos los
paquetes de software de GNU, lo mismo que los administradores de X
Windows, servidores de Internet, WordPerfect y el K Desktop. Sin
embargo, en la actualidad no incluye a G N O M E , pero cumple con el
estándar POSIX y se ajusta a los de U N I X . Caldera distribuye gratuita-
mente su sistema OpenLinux y también ofrece una línea de paquetes
comerciales y paquetes de uso restringido (requieren autorización).
Debido a esta última condición, los paquetes de software que tienen
licencia no son de distribución gratuita y en ellos se incluyen produc-
tos como Partition Magic, Star Office, Novel1 NetWare y la base de
datos AdabasD. En www.calderasystems.com puede encontrar más
información. En la actualidad sólo soporta la plataforma Intel.

.
E n principio fue una distribución en idioma alemán. SuSE se ha
popularizado mucho a través de Europa y hoy en día es una de las
distribuciones con más rápido crecimiento. Su distribución actual
incluye KDE y G N O M E ; también, WordPerfect, Star Office y KOffice.
Igualmente, está unido a productos comerciales como AdabasD y la
Linux O f i c e Suite. Sólo soporta plataformas de Intel. Para mayor
información, consulte www.suse.com.

Debian
Debian Linux es un proyecto que no tiene ningún carácter comercial y
al que sostiene un grupo de programadores voluntarios. Sin embargo,
en su distribución incluye soporte para muchos productos conierciales.
Debian mantiene asociaciones de software con Corel y Sun, entre
otras.Tanibién sostiene plataformas Alpha, Intel, Mac 68K y Sparc. Más
información en www.debian.org.
 Capítulo 1:Introducción a la
"" ----e--

Slackware
Se encuentra disponible e n muchos lugares d e Internet y usted puede
pedir el C D a Walnut Creek Software. Incluye a G N O M E y KDE. La
distribución d e Slackware tiene especial cuidado e n mantenerse tan
cerca de los estándares U N I X como sea posible. E n la actualidad
únicamente soporta plataformas Intel. Puede consultar más informa-
ción en www.slackware.com.

lnfomagic
Infomagic distribuye recopilaciones de software d e Linux. El conjunto
Linux Developers Resource incluye las cuatro distribuciones principa-
les: R e d Hat, OpenLinux, SuSE y Slackware. El Linux Archive contie-
ne sitios de archivos espejo Linux que incluyen KDE, G N O M E ,
XFree86 y G N U . E n la actualidad sólo soporta la plataforma Intel. Más
información en www.infomagic.com.

LinuxPPC
La distribución LinuxPPC ofrece versiones de Linux diseñadas exclusi-
vamente para máquinas PowerPC. La distribución funcionará en cual-
quier máquina PowerPC,-incluidos los sistemas IBM, Motorola y Apple
(con máquinas G 4 e iMac). Ofrece soporte para el USB e n sistemas
Mac. Su distribución actual incluye el escritorio G N O M E y el adnii-
nistrador d e ventanas Enlightennient. Para más información véase
www.linuxppc.com.

TurboLinux
Lo distribuye Pacific HiTech, en versiones en inglés, chino y japonés. Incluye
varios de sus propios paquetes como TurboPkg para aplicaciones con actuali-
zación automática, el escritorio TurboDesk y el servidor Cluster Web
Server. C o m o R e d Hat, soporta paquetes R P M . E n la actualidad es de
amplia distribución en la zona este d e Asia y únicamente soporta la
plataforma Intel, aunque está e n desarrollo una versión para PowerPC.
Para más información véase www.turbolinux.com.
 programación e n Linux
P4wSw-a S e

Mandrake
Mandrake Linux es otra distribución popular de Linux con muchas de las
mismas características de Red Hat. Se concentra en suniinistrar las últimas
actualizaciones y una instalación facil y configuración por medio de GUI
fácil de usar. Puede aprender nlás acerca de Mandrake en www.linux-
mandrake.com.

Recursos de Linux
A través de las búsquedas en línea usted dispone de anlplios recursos sobre
casi cualquier tema de Linux. Las siguientes tablas presentan listas de sitios
en donde puede obtener software, ver documentación y leer artículos
sobre los avances más recientes. Sobre programación en Linux hay varios
5itios de interés que incluyen Perl,Tcl/Tk y los sitios GNOME y KDE
(véase tabla 1-1). Para BASH y GAWK puede encontrar documentación e
inforniación en línea en el ~ i t i Web
o de GNU, www.gnu.org.En
www.linuxprogramrning.com y en www.linuxworld.com puede
hallar artículos recientes sobre temas de programación en Linux.
Los sitios Web y FTF', como www.calderasystems.com y
www.redhat.com, ofrecen una amplia documentación y software sobre
Linux (véase tabla 1-2). Usted puede encontrar otras direcciones a través
de páginas de recursosque cuentan con enlaces hacia otros sitios Web.
La documentación de Linux también se ha desarrollado a través de
Internet (como se presenta en la tabla 1-3) y gran parte de ella se
puede bajar en los sitios FTP de Internet. U n proyecto especial, llama-
do Linux Documentation Project (LDP),encabezado por Matt Welsh,
está desarrollando un completo grupo de manuales sobre Linux. La
documentación, en su nivel actual, está disponible en el sitio inicial de
LDP en hhtp://metalab.unc.edu/LDP/, e incluye una guía del
usuario, una introducción y guías de administración. Están disponibles
en texto, PostScript o formato de página Web. La tabla 1-3 presenta un
listado de estas guías. Puede encontrar explicaciones más breves en los
documentos denominados H O W T O (CÓMOHACER PARA) dispo-
nibles sobre diferentes temas, como instalación,impresión y correo elec-
trónico. Los documentos se encuentran en los sitios FTP de Linux,
imalmente en el directorio /pub/Linux/doc/HOW-TO.
 Muchos sitios Web de Linux presentan noticias, artículos e informa-
ción sobre el tema; varios se basan en revistas populares como Linux
journal www2.linuxjournal.com/) y Linux Gaxettc (http://
isisesc.supelec.fr/lg) (véase tabla 1-4). Otros operan como portales
Web para Linux, como www.linux.com, www.linuxworld.com y
www.linux.org. Algunos se especializan en tenlas particulares, como
www.kernelnotes.org, con noticias sobre el kernel de Linux y
www.linuxgames.com para los juegos más recientes que se incluyen
en Linux. Los sitios www.gnome.org y www.kde.org contienen
software y docunlentación para los escritorios GNOME y KDE,
respectivamente.

URL Sitios en lnternet

www.gnu.org Sitio Web CNU con soporte para BASH y CAWK
www.perl.com Sitio Web con software de Perl
dev.scriptics.com Adelantos y recursos de Tk y Tcl
developer.gnome.org Sitio Web de programadores de CNOME
developer.kde.org Librería de programadores para KDE
www.blackdown.org Kit de desarrollo de lava para Linux, de Sun
www.openprojects.nu Open Projects Network
www.linuxprogramming.org Recursos de programación de Linux

A través de su conexión en Internet, también puede tener acceso a

grupos de noticias de Linux para leer los conlentarios de otros usuarios
y enviar sus propios mensajes. Existen varios grupos de noticias de
Linux y todos empiezan con comp.os.linux. Uno de especial interés
para el principiante es comp.os.linux.help, en donde puede hacer
preguntas. Sobre tenlas de progranlación usted puede encontrar infor-
mación en comp.os.linux.development. También hay una cantidad
elevada de grupos de noticias en desarrollo que comienzan con
linux.dev, como 1inux.dev.admin y 1inux.dev.doc.En la tabla 1-5
se presenta un listado de diferentes grupos de noticias sobre Linux,
disponibles en Usenet.
 mación en Linux
6" "-.%S S

URL Sitios en lnternet

www.redhat.com Red Hat Linux
www.caIderasysterns.com Caldera OpenLinux
www.suse.com SuSE Lunux
www.debian.org Debian Linux
www.inforrnagic.com lnfomagic
www.linuxppc.com LinuxPPC (versión Mac PowerPC )
www.turbolinux.com TurboLinux (Pacific Hi-Tech)
www.sIackware.com Slackware Linux Project
www.kernel.org Información relativa al kernel de Linux
www.linux-mandrake.com Mandrake
java.sun.com Sitio Web de Sun Java

Sitios Descripción
http://metalab.unc.edu/LDP/ Sitio Web del LDP
ftp://metalab.unc.edu/pub/linux/docs/LDP/ Sitio FTP del LDP
Guías Formato del documento y sitios Web

Linux User's Cuide .

Linux lnstallation and Cetting Started Cuide

Linux System Administrator's Cuide

DVI, PostScript, LaTeX, PDF y HTML
DVI, PostScript, HTML, LaTeX y PDF
PostScript, PDF, LaTeX y HTML
Linux Network Administrator's Cuide DVI, PostScript, PDF y HTML
Linux Programmer's Cuide DVI, PostScript, PDF, LaTeX y HTML
The Linux Kernel HTML, LaTeX, DVl y PostScript
Linux Kernel Hacker's Cuide DVI, PostScript y HTML
Linux HOWlOs HTML, PostScript, SCML y DVI
Linux FAQs HTML, PostScript y DVI
Linux Man Pages Formato de página manual
 Capítulo 1:Introducción a la
- ,
P

URL Sitio en lnternet

www.linuxdoc.org/ Sitio Web para el proyecto de documentación
de Linux
Linux Weekly News
Linux.com
Linux Today
Linux Power
Linux Focus
Linux Magazine
Linux World
Linux Mall
Linux Journal
Linux Cazette
Linux Online
Sitio Web de Linux lnternational
Sitio Web de Linux en Europa
Las más reciente noticias sobre el kernel de Linux
Foro sobre Linux
Observador del sitio Web de Linux

Grupo de noticias Contenido

linux.dev.group Hay un gran número de grupos de noticias en
desarrollo que empiezan con linux.dev, como
linux.dev.admin y linux.dev.doc
Para programadores que desarrollan aplica-
ciones de Linux
Para programadores que desarrollan aplica-
ciones de Linux
Para programadores que trabajan en el siste-
ma operativo Linux
Anuncios sobre avances en Linux
Especificaciones de hardware para Linux
Preguntas sobre administración del sistema
Preguntas y temas especiales
Problemas de instalación
Respuestas a problemas de comandos
Preguntas y respuestas a problemas específicos
Preguntas y temas sobre la red Linux
 nux

1. ¿Cuáles son las cuatro categorías generales de la progran~aciónen

Linux?
2. ¿Puede crear usted programas de tipo GUI sin escritorios de progra-
niación como G N O M E y KDE?
3. ¿Cuál lenguaje de prograniación utilizaría para crear filtros?
4. ¿Qué tareas de programación requieren que usted conozca. otro
lenguaje?
5. ¿Qué institución creó Linux?
 l.,
7
<
,

-
'
"
:"
4
.- ,
.. , ,

Scripts del shell BASH

Los objetivos de este capitulo son:

Desarrollar programas para el shell BASH

Administrar entradas y salidas del shell

Utilizar operadores del shell p x a operaciones aritméticas, de coinparación

y de asignación

Administrar los argumentos del shell utilizando múltiples scripts

Aprender a exportar variables hacia los subshells

 programación en Linux
-m->mm-%aBs. ,"

u n programa del shell combina comandos Linux de manera que

realicen una tarea específica. U n shell es conlo un intérprete de
comandos: sirve como intermediario entre el usuario y el sistema
operativo. Cuando usted se conecta a su cuenta, su sistema Linux
genera el shell del usuario para usted. El shell primario que se usa en
los sistenias Linux es BASH (Bourne Again Shell) y se basa en el shell
Bourne original de los sistenias UNIX.
El shell BASH ofrece muchas herramientas de programación que
usted puede usar para crear programas del shell. Puede definir variables
y asignarles valores, definir variables en un archivo de script y tener un
usuario que ingrese en forma interactiva los valores para esas variables,
cuando se ejecute el script. El shell ofrece estructuras de repetición y
de control condicional que repiten comandos Linux o toman decisio-
nes sobre los coniandos que desee ejecutar. Usted también puede
construir expresiones que realicen operaciones aritméticas o de com-
paración.Todas estas herramientas de progran~acióndel shell BASH
funcionan de modo similar a las que se encuentran en los demás len-
guajes de programación, de modo que si ya tiene fandiaridad con la
codificación, podría encontrar que BASH es sencillo de aprender.
Este capítulo tratará los aspectos básicos para crear un progrania
utilizando el shell BASH, que es el más usado en la mayoría de los
sistemas Linux. Usted aprenderá cónio crear sus propios scripts, definir
variables del shell y desarrollar interfaces de usuario, lo mismo que la
dificil tarea de combinar estructuras de control para crear programas
complejos. Las tablas a través del módulo presentan una lista de los
comandos y operadores del shell BASH, y por medio de numerosos
ejemplos se explica cómo implementarlos.
Habitualmente, las instrucciones que configuran un programa del shell
se ingresan en un archivo de script que después se puede ejecutar. Para
ponerlo en hncionainiento, usted ejecuta su archivo de script; inclusive
puede distribuirlo entre varios archivos de script, uno de los cuales conten-
drá las instrucciones sobre cómo ejecutar los otros. Considere las variables,
expresiones y estructuras de control como herramientas para unir varios
comandos U N I X en una sola operación. En este sentido, un progrania
shell es un coniando Linux nuevo y complejo que usted ha creado.
El shell BASH tiene un conjunto de comandos de programación
poderoso y flexible que le permite construir scripts complejos. Soporta
 Capitulo 2: Scripts del shell BASH
. ---
1 35
variables que pueden ser locales para el shell detern~inadoo que se
pueden exportar a otros shells. Usted puede pasar los ntprrnrritos de u11
script a otro. El shell BASH tiene un grupo conipleto de estructuras de
control, incluidos bucles y enunciados condicionnles, lo niismo que
estructuras case, que usted aprenderá a medida que avance en la lectura
de este 1ibro.Todos los con~andosdel shell interactúan coii facilidad en
operaciones de redireccioiiaii~ieiitoe interconexión que les permite
aceptar información desde la entrada estándar o enviarla a la salida
est5ndar.A diferencia del shell Bourne, el primero que se utilizó en
U N I X , BASH incorpora muchas de las características de los shells
TCSH y Z. Las operaciones aritméticas, eri particular, son inás t3ciles
de realizar en UASH.

Scripts del shell: comandos

y comentarios
U n srript del slirll es un archivo de texto que contiene coniandos Linus
que usted ingresa utilizando cualquier editor estáiidar, como vi, eniacs,
WordPerfect o cualq~iierade los editores de testo de C N O M E o
KDE. Hay varias iiianeras de hacer funcioiiar u11 script del shell. Una
de ellas es anteponer u11 phnto al nombre del script, como se presenta a
continuación. El shell leerá los comandos en el script y los ejecutarrí.
En este ejemplo, el nombre del script es Iicllo. El sírnbolo de punto (.)
le iiiforma a Linux que debe ejecutar este script.

Usted tamb~énpuede convertir el archivo dcl script en ejec~itable,o que se

"pueda correr", y mar el nombre directamente en la línea de comandoi de la
nxinla mmera que utilizaría el nombre de cualquier comando.
En el iipiente gemplo se nlueitra el icript I~cllo(en negrdas) y su
reiultndo, loi cuales ie prcientan conseivando eite eitdo a lo largo del texto.

H e l l o , how a r e y o u
$
36 1 Fundamentos de programación en Linux
-
Usted podría tener que especificar que el script que Lisa en el ino-
iiiento está en su directorio de trabajo actual. Para hacerlo, fija previa-
mente el iionibre del script con una combiilaciói~de punto y barra, ./,
conio en ./hello. E11 el siguiente ejemplo se presenta la inanera como
usted ejecutaría el script hcllo.
- -

$ ./he110
Hello, how are you
S

A ineniido, en un archivo del script resulta útil incluir explicaciones

cortas que describan la tarea del archivo y el propósito de ciertos
comandos y variables. Usted puede entrar esas explicaciones usando
i~o//icvltnrios.U n comentario puede aparecer en cualquier línea o parte
de una línea -excepto en la primera- y está precedido por el signo d e
i~úiiiero(#). N o puede usar comentarios eri la primera línea del archivo
del script porque dicha línea está reservada para la identificación del
shell. El shell no toinará en ciienta ningúii car5cter que se ingrese
seg~iidopor el signo de número. En el siguiente ejeniplo, un comenta-
rio qiic describe el nonibre y la f~incióndel script se pone al comienzo
del archivo.
El contenido del script Iwllo con una línea dc comandos inicial es el
siguiente:
- -
' # T h i he1 lo s c r i p t says he1 lo
echo "Hello, how a r r you"

Establecer permisos: símbolos de permisos

Antes de que iisted pueda operar directaniente un script, debe hacer que
sea eje-utable. Para ello, debe activar CI permiso de ejecución del script.
Todos los archivos de Liniis tienen un conjunto dc tres perniisos posi-
bles: lectura, escritura y ejeciicióri, los ciiales se pueden activar o
desactivar con el comando chmod y las opciones apropiadas. Estas
opciones son los caracteres 1; 111 y x para lectura, escritura y ejecución,
respectivamente. Cualquiera de estos permisos se piiede agregar o
retirar. El síinbolo que se usa para agregar un permiso es el más (+),
mientras que para retirar es el signo ineilos (-). En el siguiente ejemplo,
 Capitulo 2: Scripts del shell BASH
. .
1-
37

el coinai~dochmod agrega el permiso dc ejecuci6n y retira el de

escritura para el 'lrchivo irrydntn. El periniso para lect~ir'lno cainbia.

$ chmod +x-w mydata

Tanibiéii hay sírilbolos de permiso que especifican la categoría de

cada usuario. Las categorías d e propietario, grupo y otros se representan
con las letras I I , y~ o, respectivmmente. Observe que la categoría propie-
tario esti representada por una 11 y se puede coiif~mdircoi1 la de usua-
rio. El siii~bolopara una categoría se escribe antes de los pcrmisos para
leer, escribir y ejecutar. Si no se utiliza el símbolo d e la categoría, se
supone que todas serán ii~odificadasy los permisos especificados se
aplican para el dueiio del archivo, su grupo y los deiliis ~isuariosdel
sistema. E11 cl sig~iienteejemplo, el prinier coi~iaiidochmod establece
permisos para que el grupo lea y escriba. El seg~indoconiando chrnod
determina el periniso para la lect~irade otros ~isuarios.Observe que 110
hay espacios entre las especificaciones del periiliso y la categoría. La
lista de permisos siiiipletiiente es una frase larga, sin espacios.
+
S chmod g+rw myda'ta
$ chmod o+r mydata

U11 usuario p ~ i e d eq~iit3ro agregar perniisos. En el sig~iieiiteejeiii-

plo, el perii~isode lect~ira~e fija para los otros. pero el dc eccribir y
qecutar se retiran.
.. P . -- - -- .L

$ chmod o+r-wx h e l l o

Otro síimbolo de periniso, n, representa a todas las categorías. El

símbolo (1 es el predeterinii~ado.En el siguiente ejeiiiplo, ainbos co-
mandos son equivalentes. El permiso de lect~iraestn establecido esplí-
citaniente con el símbolo n , serialando a todos los tipos de usuarios:
otros, grupo y usuario.
-
$ chmod a+r he1 l o
$ chmod +r h e l l o
38 1 Fundamentos de programación
- en Linux

El permiso para ejecutar indica que u n archivo contiene instruccio-

nes ejecutables y puede f~incioilardirectamente en el sistema. E i i el
siguiente ejcmplo, el archivo Izcllo tiene autorización de ejecutable y
después se ejecuta.

1
"$ chm
6a-
$ he110
H e l l o , how a r e you
$

Los coniandos chmod y las opciones se presentan en l a tabla 2-1.

Comando Ejecución
chmod Cambia el permiso de un archivo o directorio.
Opciones
4- Agrega un permiso.
- Retira un permiso.
r Establece el permiso para lectura de un archivo o direc-
torio. Un archivo se puede presentar en pantalla o impri-
mir. Un directorio puede tener la lista de sus archivos
en pantalla.
w Establece el permiso para escribir en un archivo o direc-
torio. Un archivo se puede editar o borrar. Un directorio
se puede retirar.
Establece el permiso de ejecutar para un archivo o direc-
torio. Si el archivo es un script del shell, se puede ejecu-
tar como un programa. Un directorio se puede cambiar
e ingresar.
Establece permisos para el usuario que lo crea y es due-
ño del archivo o directorio.
Establece permisos para que un grupo tenga acceso a un
archivo o directorio.
Establece permisos para el acceso a un archivo o directo-
rio para los otros usuarios en el sistema.
Establece permisos para el acceso por parte del usuario,
el grupo y todos los demás usuarios.

Comandos y opciones de chinod

 Capitulo 2: Scripts del shell BASH ( 39

>pregunta: puedo hacer funcionar un script del rheil BASH en un

shell diferente, como el shell TCSH?
Respuesta: Si, puede liacerlo. Si lo desea, puede ejecutar un scriyt escrito
para tino de los shell de Liriux inientras está trabajando e n otro. Supong;~, por
ejeiriplo, que en este rnon~entoestá trabajando con el s l d l T C S H y desea
ejecutar un script escrito en el shell BASH que contiene comandos de ese
sheil. Primero tendría que cambiar al sbell BASH mando el cornai~dosh y
después podría ejecutar el script y regresar al sliell TCSH.
Sin embarga, usted puede automatizar este proceso escribiendo los signos
de número y admiración (#!) corno los priineros caracteres de su script,
seguidos por el nombre del directorio del programa del shell en su sistema.
Esto le señala al shell T C S H que usted quiere cambiar y usar los coniandos del
shell BASH nuentras trabaja con el shellTCSH. Este es un ejemplo:

Pregunta: ;Cómo sabe el script cuál es el shell que deber6 usar?

Respuesta: Su shell siempre examina el primer carácter de un script para
determinar de qué tipo es: BASH, PDKSH o TCSH. Los siguientes son los
carxteres con 10s que puede comenzar un script:
Espacio sencillo Se supone que el script sea de los shell BASH o
PDKSH. .
# El script es del shellTCSH.
#! Su shell lee la ruta donde se encuentra el programa de sheil deseado.

lkspués de los caracteres #! siempre debe aparecer la ruta del programa de

slielP que identifica el tipo de sl-iell en que trabaja el script. Si usted estj.
trabajando en i i r i shell diferente, este último leerá la ruta del prograina del
shell, cambiará al shell indicado y ejecutará el script. Si usted está en un shell
diferente a BASH o T C S H . el espacio sencillo o el signo de # por sí solos iio
son suficientes para identificar el tipo de shel1. Esta identificación funciona
únicamente dentro de los shell BASH o TCSH, respectivamente. Para identifi-
car u n script de u11 shell diferente, usted debe iiicluir los caracteres #! seguidos
por la ruta del shell.
Por ejt~nplo,si al comienzo de la primera línea del script hclh usted incluye
#!/bin/sh, podría ejecutar este código del shell BASH ditectai-rieiite desde el
shellTCSH. El ~ stript
t r i p canibiará
t al shell BASH, ejecutará sus comandos y
después regresará al shell TCSH (o a cualquier tipo de shrll desde donde Te
derpués se
40 1
- Fundamentos de programación en Linux

ejecute). EII el siguiente ejemplo, cl script incluye el curizando #!/bin/sh. El

script sc ejecuta rnicntras el programador todavía eiti trabajando en el shell
TCSH.

#!/bin/bash
# The he1 lo s c r i p t s a y s he110
echo "Hello. how a r e y o u "

Variables y scripts
Ileiitro del sliell usted p ~ i e d ecrear programas (programas dentro del
programa) ~ i s a n d ovariables y scripts. C u a n d o ejecuta iin archivo dcl
script, iisteci inicia u n nuevo proce5o qiic tiene \LI propio sliell. l>eiitro
d e &tc, usted piiedc defiiiir variriblcs, ejccutar coimildo\ LIIILISe
ii~cliiroejecutar otros ~ r i p t s .
U n a vnrinhlc es una referencia a u n u t i o q u e contieiie datos q u e se
pueden niodificar diiraiite la ejecución del programa. Dentro d e un
prograiiu d e shell, usted p ~ i e d edefinir variables y ~ s i g n a r l evalores.
i
Uiia v,iriable se define e n u n shell la primera vez q u e usted usa el
nonibre d e la variable. A continuación e ~ t á nlas reglas para usar una
variable.

El rioriibre de iina varidblc puede ser cu~lqiiierconjunto de caracteres

alfabéticos, incluyeiido el cigno de ~ubrayado.

El noiiibre de iiria variable no puede incluir niilgí111otro tipo de cardc-

anipersaiid o iricliisive LIII espacio. Estos
ter, coiiio signo de excl~iiiacií~ii,
sí~iibolosesthi reservados para el LISO por parte del niisiiio sliell.
El nonibre de iiiia variable no puede incluir ni5s de una plabra, porque
el sheli usa los espacim para aixilizar coinai~dos,delimitando los iioii~bres
de loi coniandos y los argiinientos.

Las definiciones d e Liiia variable se iitilizan e n los programas del

shell para muchos propósitos. Lac variables se usan ampliamente en las
 Capitulo 2: Scripts del shell BASH 1 41
operacionei d e entrada y salida de script. El comaiido read, por ejcin-
plo, permite quc el uiuario ingrese en foriiia iiiteractiva un valor para
una variable. C o n frecueiicia, read se coiiibiila con un proiiipt que
notifica al ii~uariocuándo entrar una respuesta.

Evaluación de variables: = y $
Usted asigna un valor con el opozidor dc as(qr?aci(h. Escriba el nonibre
de la variable, el operador de asigiiación y el signo igual a (=) y después
ingrese el vdor asignado. Cualquier conjiinto de caracteres se puede
asignar a una variable. E11 cstc ejeniplo, a la variable de saludo se asigna
la cadena "Hello".

2Nota
N o utilice espacios junto a un operador d e asignación.
- -- -
En tanto usted haya asignado un valor a una variable, puede usarla
coiiio referencia del valor. Por ejemplo, a i~ieiiudopodría usar los
valores d e las variables coino arguiiientos para un coinaiido. Podría
eiiiplear coiiio referencia e1 valor de una variable con cl iioiiibre de la
iiiisiiia precedido por el operador del signo de dinero ($). Este sigilo es
uii operador especial que lisa un iioinbre dc variable conio referencia
del valor de la niisiiia, cvalirhridc~la.La eval~iaciónrecupera el valor de
iiiia variable: un conjunto de caracteres, que reemplaza el iioiiibre de la
variable en la línea de comandos. Por consiguiciite, cada vez que
aparezca el sigilo $ antes del nombre de la variable, éste se reeinplaza
con el valor de la variable.
y sil
Eii el sigiiieiite ejemplo se evalúa la variable del shell,~qr.c~ctiiy,
contenido, "Hello", se utiliza después como el argiinleiito para el
coiiiaiido echo (este coiii;indo simpleoieiite hace eco o imprime un
conjunto de caracteres en la pantalla).
42 Fundamentos de programación e n L i n u x
---

Usted puede obtener una lista de todas las variables definidas

utilizando el comando set. Si decide que no quiere una determi-
nada variable, puede retirarla con el comando unset.

Valores d e una variable: cadenas

Usted sabe que los valores que asigna a las variables pueden estar
integrados por cualquier grupo de caracteres, los cuales pueden ser una
cadena de caracteres que usted escribe explícitamente o que pueden
aparecer como resultado de ejecutar un cotnando Linux. En la mayoría
de los casos, estos valores deben estar en medio de conlillas sei~cillas,
coinillas dobles, barras invertidas o coinillas invertidas, de modo que se
puedan separar de un código ejecutable.

Cadenas de signos y caracteres con comillas

dobles, comillas sencillas y barras invertidas
Aunque los valores de la variable pueden incluir cualquier carácter, se
presentan problemas cuando usted incluye signos que también se usan
en el shell como operadores. Su shell utiliza caracteres especiales para
evaluar la línea de coinandos. Por ejemplo:

Carácter Propósito en el shell

Espacio Analiza argumentos en la línea
de comandos
Asterisco (*), signo de interrogación Genera listados de los nombres
(?), paréntesis y corchetes (( y )) de archivo
Punto (.) Representa el directorio actual
Signo de dinero ($) Evalúa las variables
Signos de mayor que (>) y menor Redirecciona la entrada y la salida
que (4 estándar
Ampersand (&) Ejecuta comandos en segundo plano
Barra vertical Conecta la salida de un comando con
la de otro
 Capitulo 2: Scripts del shell BASH 1 43
Si usted desea usar alguno de estos caracteres con10 parte del valor
de una variable, primero debe trrarcarlos (incluirlos dentro de comillas
sencillas o dobles, o barras invertidas). Los caracteres especiales dentro
de estos signos no los evalúa el shell.
Al niarcar estos caracteres con coniillas dobles y sencillas, usted
puede incluir a la vez varios caracteres especiales. Ninguno de los
signos especiales que se encuentre dentro de comillas dobles o sencillas
se evalúa. Si quiere asignar niás de una palabra a una variable, también
debe incluir los espacios que separan las palabras; esto puede hacerlo
encerrando las palabras dentro de conlillas dobles. Puede considerar
esta acción como crear una cadena de caracteres para asignar a la
variable.
Si usted quiere marcar un solo carácter, puede usar la barra invertida
antes y después del inismo. Los siguientes ejemplos presentan tres
maneras de marcar cadenas. En el primer ejemplo, las coinillas dobles
encierran palabras separadas por espacios. Debido a que estos últinios
están dentro de coniillas dobles, se les considera como caracteres, no
como separadores que se usan para analizar los argumentos de la línea
de coinandos.

S. echo $notIce
"Thp m e e t i n g w i 1 T bg tomorrow"

En este ejeniplo, las coiniilas sencillas incluyen una oración con un

punto, de modo que este signo se tratará simplemente como un carácter.

En el siguiente ejemplo, hay un asterisco dentro de las condas dobles,

el cual se considera siniplemente otro carácter en la cadena y no se evalíia.

C e s w ~ f l - .T 4
sctro Snot ice
Yau can gef U l i s ? o f f i l e s h i t h 1 s *,c
El asterisco
44 1 Fundamentos de programación
- . .- . en Linux
-.

-5ugerenaa
Las comillas dobles no se utilizan para marcar el siano de dinero.

pt:~t:ur
ai iiuiiiuit: ur u i ia val i a u i r y r s i a urriiiu ur Iuiriiiias u u -
bles ("$variable") se evaluará, reemplazando el nombre de la
variable con su valor. Entonces, el valor de la variable, no el nom-
bre de ésta, se convertirá en parte de la cadena.

I'uede haber ocasiones en que usted desec evaluar una v~riable

entre signos. En el siguiente ejeniplo, las coniillas dobles se usan de
nianera que el nonlbre del ganador se incluirá eii la noticia.
- wi nne'r=dyían
$
- -La variable se--evalúq
- -
- --
---
-

$ notice="The person who won i s $winnerW

$ echo $notice
The pei-zori who wnii d y l an
i-,

D e otro lado, hay oc.isiones en que usted n o quiere evali~iruna

variable quc se encuentra dentro de signos. En csc caio, usari comillns
sencillas que ~ u p r i m e ncunlquier evaluación de la variable y tratan el
~ i g n ode dinero, o cualquier otro dciitro de las coiiiillai, iimpleniente
como otro c'lrácter. En el siguiente ejemplo, las con~illassencillai evitan
la evaluaci611 d e la variable winner.

Usted puede dejar dentro de las comillas cualquier signo especial,

incluyendo el operador $, precediéiidolo con una barra invertida, que
resulta de utilidad cuando quiere evaluar variables dentro de una
cadena y tanibibn incluir un signo de dinero regular ($). En el siguiente
ejemplo, la barrn invertida se escribe antes del signo $, de modo que el
signo d e dinero aparezca como: \$.Al misino tiempo se evalúa la
variable $winwrr, ya que las comillas dobles no encierran el operador $
que precede a la variable.
 Capitulo 2: Scripts del shell BASH 1 45
-$ wi nner-dyl a n - -

$ result-"$winner won \$100.00""

$ echo $result
d y l a n won $100.00

Obtener valores de los comandos Linux

con comillas invertidas
Aurique usted puede crear valores de variables escribiendo los si,<'nos o
cadenas de signos, también puede obtener valores usando otros coman-
dos Liniix. Sin embargo, para asignar el resultado de un coiiiando
Linux a una variable, primero debe ejecutar el comando. Si usted
escribe un comando Liinix dentro de conillas invertidas (') en la línea
d e coinaildos, ese c o n ~ a n d ose ejecuta prirnero y su multado se coil-
vierte en uii arguniento en la línea de cornaiidos. En el caso de asigna-
ciones, el resultado de un coniando se puede asignar a una variable
dejando el conlando dentro de coinillas invertidas. Coiisidere estas
comillas coiiio una clase de expresión que contiene un comando que
se va :I ejecutar y su resultado, el cual se asigna después a la variable. Los
caracteres qiic constituyen el c o i ~ i a i ~ diiiismo
o no se asignan.
En el siguiente ejemplo, se ejecuta el comando 1s *.c y el resultado
se asigna después a la variable listc. El coniando 1s * . c genera un listado
de todos los archivos coi1 l a extensión .c, el cual se asigna después a la
variable licrr.
.-
m-s
$ 1i
-
c -o r n ~ d-
ose-ejecuta_primero/
-- - - -.-. --
$ echo Blistc
main.c pr0g.c 1 i b . c

Comillas sencillas versus comillas invertidas. N o olvide la

diferencia entre la coiiiilla sencilla (') y la coinilla invertida ('). Las coniillas
sencillas le dicen a Liiiux que trate un con~andocoino un coiijuiito de
caracteres. Las coinillas invertidas obligan a la ejecución del coriiando Linux.
Puede haber ocasiones en que usted escriba accidentaliilente coniillas
sencillas cuando quiera usar cornillas iiivertidas. Los siguientes ejeiiiplos
ilustran la difei-ericia:en el priinero, la asignación para la variable lscc Lisa
coniillas sencillas, n o coniillas invertidas, para marcar el coiilando 1s *.c.
En este caso, la cadena 1s *.c se va a asignar a la variable l w .
46 1 Fundamentos de programación e n Linux

A continuación, las coniillas invertidas que encierran al comando

1s *.c obligan a la evaluación del nlisnio. Se genera un listado de los nom-
bres de los archivos que terninan en .c y se asigna como el valor de Iscc.

ecuta el comando)-
.- - - - -

Marcar comandos con comillas sencillas

Agregar coiidas sencdia~le permite asignar el coinando escrito a una
variable. Después, puede usar el nonlbre de esa variable conio otro iionibre
para el comando Linux. Al ingresar el nonlbre de la variable precedido por
el operador $ en la iínea de coniandos, se ejecutará la variable. En el si-
guiente ejemplo, se asigna una variable del sheli a los caracteres que consti-
tuyen un comando Linux para obtener una lista de los archivos, ' 1s -F '.
Observe las co~idiassencillas del coniando. Cuando la variable del sheli se
evalúa en la iínea de comandos, el comando Linux que contiene se con-
vierte en argumento de la iínea de coniandos y es ejecutado por el sheil.

Prueba de repaso
¿Debe definir usted una variable antes de usarla?'

¿Puede asignar usted el valor de una variable a otra?'

¿Cómo asignaría usted el resultado de un comando Linux a

una ~ a r i a b l e ? ~

1 No; una variable queda definida automáticamente al asignarle un valor o utilizarla.

2 Sí. Utilice el signo de dinero (S) frente a la variable cuyo valor desea asignar, como en
Address=SNcwaddrcss.
3 Marque el comando Linux con comillas invertidas.
 Entrada y salida d e un script: echo, read y <<
Dentro de un script usted puede usar el comando echo para imprimir
datos y el comando read para leer las entradas a las variables.Además,
puede crear un documento Here para especificar los datos dentro del
script y redirigirlo hacia un comando.
Dentro de un script, el comando echo enviará los datos a la salida
estándar, los cuales tendrán la forma de una cadena de caracteres.
Como pudo apreciar en el ejemplo anterior, el comando echo puede
producir valores para la variable, lo mismo que constantes de cadena.
El comando read lee un valor para una variable y le permite al
usuario asignar en forma interactiva un valor a una variable; literalmen-
te, este comando lee la siguiente línea en la entrada estándar.Todo lo
que aparece en la entrada estándar con el retorno del carro se lee y se
asigna a una variable. En los programas shell se pueden combinar los
comandos echo y read para indicarle al usuario el ingreso de un valor
y después leer ese valor en una variable.

Proyecto 2-1: Entrada del usuario

En el script greetvar al usuario se le indica entrar u n valor para la variable
greeting; el comando read lee entonces el valor que el usuario escribió y
greetvar
.
lo asigna a la variable en mención.

Paso a paso
1. Cree u n archivo llamado greetvar con u n editor de texto estándar
como Vi, Emacs, WordPerfect o cualquiera d e los editores de texto de
GNOME o KDE.
2. lngrese u n p r o m p t usando el comando echo.
3. lngrese u n comando de entrada read con la variable greeting. Todo
lo que el usuario escriba en una Iínea será reemplazado en la variable
greeting.
4. lngrese u n comando d e salida usando echo para transferir la línea
que el usuario escribió. Esto se mantendrá en la variable greeting.
5. Guarde y cierre el archivo.
6. Asigne el permiso de ejecución al archivo greetvar, chmod u+x greetvar.
48 1 F u n d a m e n t o s d e p r o g r a m a c i ó n en L i n u x
-- -

7. Haga funcionar el script escribiendo el nombre del script greetvar en

la línea de comandos Linux y presionando la tecla ENTER.
8. Asegúrese d e escribir u n saludo en el prompt.
El script greetvar se presenta a continuación:

'ech'o 'PTease e n i e r 'a g r e e t i n g :

-- ...

read greeting
echo "The g r e e t i n g you e n t e r e d was $ g r e e t i n g W

El siguiente es u n ejemplo d e la ejecución del script greetvar:

3 greervar
Please e n t e r a g r e e t i n g :
hi
The g r e e t i n g you e n t e r e d was h i
8

Cuando se trabaja con la entrada del usuario, usted debe considerar

la posibilidad de que el usuario pueda ingresar carac/ci.cs especiales al
shell. Ccialesquiera de estos caracteres en un conlando Linux, sea
dentro d e un script o no, se evaluará, a menos que esté marcado con los
signos ya sellalados. Si el valor de una variable es un carácter especial y
dicho valor se referen'tia con un signo $, el shell evaluará ese carácter.
Sin embargo, dejar la variable evaluada dentro de comillas evita la
evaluación de cualquier carácter especial, como el signo $.
En el script gr-cetvor del proyecto 3-1, $ g r e e t i n g está dentro de una
cadena entre signos, evitando la evaluación de los caracteres especiales.
Sin embargo, si $ g r e e t i n g no estií entre signos, los caracteres especiales
q ~ contiene
~ e se evaluarán.
En ocasiones, usted querrá que se evalíien caracteres especiales.
Suponga, por ejemplo, que desea recuperar la lista de archivos que
comienzan con caracteres que ingresó el usuario. En este caso, cual-
quier carácter especial que entre el usuario se debe evaliiar. En el script
lis!files que sigue, cualquier carácter especial para generar listados de
archivos se extenderá. Observe que $fref n o está entre signos.
 Capitulo 2: Scripts del shell BASH 1 49

' echo ' ~ l ' e a s ee n t e r - a f i l e referenc;:

r e a d f 1.-f
e c h o The f i l e s y o u r e q u e s t e d a r e : ' 1 s $ f r e f '

Un ejemplo de la ejecución del script listfilrs es el siguiente:

$ listfiles
Please entei. a f i l e reference:
*.c
The f i l e s you r e q u e s t e d a r e : c a 1 c . c 1 i b . c m a i n . c

Nornialinerite, un script del shell contiene una serie de coniandos.

Sin embargo, habrá muchas ocasiones en que usted necesite ingresar
datos y coniandos; en tal caso, puede escribir líneas de datos en el script
del sliell y usarlos como entrada para uno de los coniandos. La oyeroci6ii
Here le permite hacer esto ya que en ella se redirigen los datos dentro
del script del sliell liacia un comando. Se le denoniina Hcrc porque los
datos redirigidos están en el script del shell, no en ninguna otra parte
de otro archivo.
La operación Here está señalada con dos signos de menor que (<<),
los cuales se pueden considerar como una fornia de operador de
redireccionaniiento, que redirige las líneas en el script de un shell
coiiio entrada para un c o n p d o . El operador << se escribe d e s p i s del
coniando a donde se va a redirigir la entrada. Las líneas que van des-
pués de este operador se consideran, entonces, conio entrada al coniaii-
do.Aunque el final de la entrada se puede especificar con ~ i i carácter
i

de finalización de archivo (presione CTRL-D), usted puede especificar

su propio delimitador con una palabra seguida por el operador << en
la misma línea. Esta palabra se toma como el deliniitador final de las
líneas de entrada, y puede estar integrado por cualquier conjunto de
símbolos.Todas las líneas, hasta llegar al delirnitador, se leen conio
entrada al comando.
En el siguiente ejeiiiplo se envía uri iiiensaje al usuario mark. La
entrada para el mensaje se obtiene de una operación Here cuyo
delimitador es la palabra rriyend. El nombre del archivo del script es
rirailrilo~k.
50 Fundamentos de programación en Linux

La operación Here está I

P
asignando a rilark como el
4 argumento del comando maiI
iiiy ciru
D i c l you reinimber
the meeting
robert
niyetid

Prueba de repaso
¿Puede usar un script del shell para iniciar una apli~ación?~

¿Se podría usar una operación Here para conservar coman-

do~?~

Argumentos de la línea
-

de comandos del script

U n script del shell, como los coniandos Linux, puede tener argurnen-
tos. Cuando usted llama un script, puede ingresar argunientos en la
línea de coniandos después del nonibre del script. Entonces, cada
argumento se puede i-eferenciar dentro del script usando el operador $
y el número de la línea de coiiiandos en donde aparece. Los argumen-
tos de la línea de coniandos están nunierados en forma secuencia1 a
partir de 1.El primer argumento se referencia con $1,el segundo con
$2 y así sucesivamente. El $0 es una variable especial que contiene el
nonibre del script del shell, la primera palabra en la línea de coinandos.
Estas referencias a los argumentos se pueden considerar conio
ref~renciasa variables de d o lectura. Si usted está faniiliarizado con la
terminología de programación, puede considerar las palabras en la línea

4 Los scripts del shell se utilizan coii frecuencia coino script de iniciacióii para las aplicacio
nes y permiten que usted verifique el estado o la configuración de su sistema antes de
comenzar una aplicación.
5 Para aplicaciones como editores que leen comandos, podría usar la operación Here para
obtener un listado de un conjunto de comandos de la aplicación dentro del script del shell.
En efecto, usted tiene un programa dentro de un programa.
 Capitulo 2: Scripts del shell BASH 1 51
de coinandos coino arguinentos que se pasan a variables del argumen-
to, desde $1 hasta $9. Las variables del arguinento son de sólo lectura y
no se les puede asignar valores. Una vez que se lei dan sus valores
iniciales, no se pueden niodificar. En este sentido, las variables del
argumento fiincionan más como coristantcs (valores que no cambian, en
oposición a las variables) que se determinan mediante los argumentos
de la línea de comdndos. Cada palabra en la línea de con~andosse
analiza en un argumento, a menos que esté nlarcada con comilla~o con
los otros signos indicados. Si usted entra más de un argumento, puede
referenciarlo con el número que le corresponda. En el siguiente ejem-
plo, se ingresan cuatro argumentos a la línea de comandos. El conteni-
do del script greeta[qs se presenta a continuación:

echo "The s ~ r n t i dargiiment i s : $2"

echo "The t h i r d argi~ment i s : $3"
echo "The f o u r t h argument 1 s : $ 4 "

El siguiente es un ejemplo de la ejecución del script ~reetat-ys.

I he first-argument i s : Hello
The secnnd aigument i s z H i
The t h i rd 3rgurricnt +,: S a l u t ~iaris
~t
The f o i i r t h argurnent i s : How a r P you
$

Las variables especiales que usan los argun-~entosdel script del shell
se presentan en la tabla 2-2.
Argumentos de la Iínea de comandos Descripción
$0 Nombre del comando Linux.
La Iínea de comandos enésima
comienza desde 1 , $1 -$n;
puede usar set para cambiarlos.
Todos los argumentos de la Iínea
de comandos desde 1 ; puede
usar set para cambiarlos.

Argumentos de la línea de comandos del shell

52 1 Fundamentos de r>roprarnación en Linux

Argumentos de la línea de comandos Descripción

$@ Los argumentos de la línea de
comandos entre signos, indivi-
dualmente.
$# El número de los argumentos de
la línea de comandos.

)2- Argumentos de la línea de comandos del shell (contiiiuncidn)

> Pregunta: ?Hay alguna manera de referenciar todos los argu-

mentos de una vez?
Respuesta: Sí; la variable especial $* referencia todos los argumentos
de una línea de coniandos. El operador $@ ta111bit.n cumple esa función
pero le permite iilarcar por separado cada u110 de ellos. La diferencia
entre $* y $@, no es clara hasta que las use para refereiicinr argumentos
con la estructura de conttd for-in. Por esta razón, sólo se presentan en
forma breve aquí y se tratan más ampliamente eri el capítulo 3.
Pregunta: ¿Hay alguna tnanera de determinar el número de
argumentos que el usuario ingresó?
Respuesta: Sí la hay. La variable especial $# contiene el i~íiiiíerode
argumentos que se ingresaron en la línea de comandos. Esta variable es
útil cuando usted necesita especificar un iiúnieru fijo de argumentos
para un script.
En el script s a p que sigue, por ejeinplo, los argumentos de la iíiiea de
coma~iclocse presentai-i priinero usando la variable especial $* y después
$0.El mímero de argumentos se presentan usando la variable especial $#.
echo $*
echo $@
e c h o " T h e r e a r e $!/ arguments "

El siguiente es un ejeniplo de la ejecución del script sacqss:

$ s a r g s H e l f o H i Welcome
He1 1 o H i Wel come
He1 1 o H i Wel come
There a r e 3 arguments
 Capitulo 2: Scripts del shell BASH ( 53

Exportar variables y shells del script

Si ~istedejcc~itaotro script desde el interior del script q ~ i ecsti fiincio-
nando en el iiloiiiento, este íiltiiiio suspeiide la ejecución y el control
se transfiere al otro script.Todos los comaiidos de este otro script se
ejecutan antes de continiiar con el script suspendido. El proceso de
ejecución de ~ i nscript a partir de otro fiiiiciona de manera niuy similar
al llamado a una f~incióiio n un procedimiento eii otros lenguajes de
progranlación. Piense en ~ i nscript que llama a otro; el que llama espera
hasta que el script Ilanlado finalice la ejec~iciónantes de continuar con
su siguiente coiilando.
Las definiciones de las variables que usted ponga en un script se
definirán dentro del shell del script y sólo se conocerán dentro de &l.
Las definiciones de la variable so11 localcs para sus propios shclls. E11
cierto sentido, la variable está oculta dentro de su shell. N o obstante,
suponga que usted quiere definir una variable dentro de LIH script y
~isarladentro de ciialquier otro que pueda llamar. N o puede hacerlo
directamente pero puede exportar la definición de la variable de un
sllell a otro usando el coniando export. Cuando este comando se
aplica a una variable, le dará iiistr~iccionesal sisteiiia para definir una
copia de la misma para cada nuevo sribshrll que se genere. Cada subshell
nuevo tendrá una copia de la variable exportada, En el siguiente ejem-
plo se define y exporta la tariable myname.

$ myname="Charl es"
$ e x p o r t myname

C o m o se describió previamente en este capítulo, cuando usted se

conecta a su cuenta, su sistema Linux genera su shell de usuario. Den-
tro de este shell, puede incluir comandos y declarar variables, y mil-
bii-n crear y ejecutar scripts del shell. Sin embargo, cuando ejecute un
script del shell, el sisteiiia genera ~ i ns~ibshell,de inanera que tiene dos
shells: al que usted esti conectado y el que se genera para el script.
Dentro del shell de un script, podría ejecutar otro script, el cual tendría
su propio shell. Cuando se ha terminado la ejecución de un script, el
shell respectivo termina y usted regresa al shell desde el cual se ejecutó.
 n en Linux
e ,

En este sentido, usted puede trabajar con muchos shells, uno anidado
dentro del otro. Las variables que define dentro de un shell son locales
para él. Si define una variable en un script del shell, entonces, cuando
el script funcione, la variable está definida con el shell de ese script y es
local para éste. Ningún otro shell puede referenciarlo. En cierto sentido,
la variable está oculta dentro de su shell.
Para ilustrar esta situación con más claridad, en el siguiente ejemplo
se usarán dos scripts, para llamar a uno desde el otro. Cuando el primer
script se ejecuta, genera su propio shell; dentro de éste se ejecuta otro
script que, a su vez, genera su propio shell. En el siguiente ejemplo, el
usuario ejecuta primero el script dispjrst, que presenta un primer
nombre. Cuando el script dispjrst se ejecuta, genera su propio shell y,
entonces, dentro de éste, define la variablejrstname. Después de presen-
tar el contenido dejrstname, el script ejecuta el segundo script, llamado
displast. Cuando se ejecuta displast, éste genera su propio shell, luego
define la variable lastname dentro de su shell y después presenta el
contenido de lastname. Entonces, el script displast trata de referenciar
firstname y presenta su contenido; sin embargo, no lo puede hacer
debido a que firstname es local para el shell de dispjrst y no se puede
referenciar fuera de él. Como resultado, en pantalla aparece un mensaje
de error que indica que para el shell displast, firstname es una variable
indefinida. En la figura 2-1 se ilustra cómo se oculta cada variable
dentro de su propio shell.

firstname

o/
Charles
echo "First name is ffirstname" lastname
displast
I
bdis~'ast lastname="Dickens" 1-

N o hay ningunarvariable
firstname en el subshell de displast
 --
Capítulo 2: Scripts del shell BASH 55

El contenido del script dispjrst se presenta aquí:

TI r s l ; n a m ~ - - - ~ n ai,er,-
r 1

echa ' F i r s t n m e 1 s Ffirstname"

displast Ejecite el siript
Execute t h e dlsplast4 , displaa desde el script 1

El contenido del script displast se presenta aquí:

t I aztname=-vi c~ens.7 I
echo " L a s t name i s $ l a s t n a m e W
echo Y f i r s t n a m e $ l a s t n a m c V

Este es un ejemplo de la ejecución de los scripts dispfirst y displast:

7 a-ispfirst- -í
F i r s t name i s C h a r l e s
L a s t llame iS Dickens
Dickens
sh: f i r s t n a m e : n o t found
$

Variables d e entorno
Si desea el tnisiiio valor d< una variable que usó en el shell y el subshell
de un script, usted siniplemente podría definir la variable dos veces
-una en cada script- y asignarle el mismo valor. Mejor aún, ¿qué pasa
si quiere definir una variable en un shell y tener el valor de la misma
referenciado en cualquier subshell? Por ejeiiiplo, suponga que desea
definir la variable myfile en el script d i s p j l ~y tiene su valor, "List",
referenciado desde el script priri$le, en lugar de definir explícitamente-
otra variable en yriri@le. Coino las variables son locales para el shell en
donde se definen, n o hay manera de que usted pueda hacer esto con
variables ordinarias. Sin embargo, puede usar una variable de etztorno, que
permite referenciar el valor que ella tiene en cualquiera de los
subshells. Las variables de entorno constituyen un entorno para el shell
y para cualquier subshell que se genere, sin importar cuán profunda-
niente anidado esté.
 En el shell BASH se exportan las variables del entorno. Es decir, en
cada subshell se hace una copia de una variable del entorno. En cierto
sentido, si la variable myfile se exportara, automáticamente se definiría
una copia en cada subshell. Para crear una variable de entorno, usted
aplica el comando export a una variable que ya haya definido. El
comando export da las instrucciones al sistema para definir una copia
de esa variable en todos los nuevos subshells que se generen, cada uno
de los cuales tendrá su propia copia de la variable de entorno. Este
proceso se conoce como exportar variables. De otro lado, en el shell
TCSH una variable de entorno se define solamente una vez y se puede
referenciar directamente desde cualquier subshell.

Proyecto 2-2: Exportar variables

En el programa dispfile se define la variable myfile. Después se convierte
en una variable de entorno usando el comando export. En consecuen-
cia, la variable myfile se exportará a cualquiera de los subshells, como el
di s p f il e que se generó cuando se ejecutó printfile.

Paso a paso
1. Cree u n archivo llamado dispfile con u n editor de texto.
2. Defina la variablemyfile y asígnele el nombre de u n archivo, en
este caso "List". El nombre puede ser el de u n archivo sencillo que
haya creado con u n editor de texto simple.
3. Exporte la variable myfile con el comando export.

4. Muestre el valor de myfile.

5 . Presente en pantalla el contenido del archivo, usando el comando cat.
6. Entre el comando printfile para llamar el script printfile.
7. Cree u n nuevo script llamado printfile.
8. Presente en pantalla el contenido de la variable myfile (no defina
myfile ya que heredará su definición de dispfile).
9. Entre el comando para imprimir myfile.
10. Cambie los permisos para ambos archivos para hacerlos ejecutables.
 Capitulo 2: Scripts del shell BASH
- -. 1 57
- c

11. Hágalos funcionar entrando el comando dispfile en su línea de

comandos.
El contenido del script dispfile es el siguiente:

->

myfile="Li s t "
-
export myfi l e
echo "Displaying $ m y f i l e W
c a t - n dmyfile
printfile
El contenido del script printfile se presenta a continuación:

' echo " ~ F i r i t i n bdrnyfi le1'

l p Bmyfile &

El siguiente es un ejemplo de la ejecución del script dispfile:

g
Displaying L i s t
1 screen
2 modem
3 paper
P r i n t i n g Li s t
$
.
Como se muestra en la siguiente ilustración, cuando se ejecuta
printfile éste recibe su propia copia de myfile y puede referenciar esa
copia dentro de su propio shell. Usted ya no necesita definir explícita-
mente otra variable myfile en printfile.
myfile es tina vari:iblc q u e se
espoi-tci. Uria copia se defiiie
y ubica eii ciinlqiiier subshell.

myfile
pq

-
cspoi-t 11i)~filc
dispfile
e c h o "l>isplayiiig %iiiyfilc"
car -11 Sniyfilc
prilltfileb - pririrfiie

e c h o "Prinriiig $iiiyfile"
Ip Siiiyfile K
58 Fundamentos de programación- en Linux

Operaciones aritméticas del shell: let

El coniando let es el coinando del shell BASH que se utiliza para
realizar operaciones con valores aritinéticos. Al usar let, usted puede
comparar dos valores o realizar con ellos operaciones aritinéticas conlo
adición o inultip1icación.A menudo estas operaciones se utilizan en los
programas del shell para administrar las estructuras de control o realizar
los cálculos necesarios. El comando let se puede indicar con la palabra
clave let o con un paréntesis doble. La sintaxis consta de la palabra
clave let seguida por dos valores iiuméricos, separados por un operador
aritmktico o relacioiial, como se presenta a continuación:

Este es un ejemplo con paréntesis doble:

El comando let autoniáticamente supone que los operadores son

aritiiléticos o relacionales. Usted n o tiene que marcarlos como los
operadores del shell. Este comando también evalúa autoináticamente
cualquier variable y convierte sus valores en valores aritméticos. Esto
significa que usted puede escribir operaciones aritinéticas como expre-
siones aritméticas simples. En el siguiente ejemplo, el comando let
iniiltiplica los valores 2 y 7. El resultado es enviado a la salida estándar y
se presenta eii pantalla:

Si desea que aparezcan espacios entre los operandos en la expresión

aritmética, debe marcar la expresión, como se muestra en la pantalla. El
comando let espera una cadena.
 Capítulo 2: Scripts del shell BASH 59

Usted también puede incluir operaciones de asignación en su

expresión let. En el siguiente ejemplo, el resultado de la niultiplicación
se asigna a res.
-
V"T'!P.~-+S
= 2 jrPlk
$ echo $ r e s
14

Usted también puede emplear cualquiera de los operadores

relacionales para realizar comparaciones entre valores numéricos,
como la de determinar si un valor es menor que otro.

i
Puede usar conlo operador cualquiera de los que aparecen en la
tabla 2-3.

Operadores aritméticos Función

* Multiplicación
i División
+ Adición
- Sustracción
o?' Módulo -el resultado es el residuo de la
división-.
Operadores relacionales
> Mayor que
< Menor que
>= Mayor que o igual a
<= Menor que o igual a
- lgual en el comando expr
Igual en let
No es igual a
AND lógico
OR lógico
NOT lógico

Operadores de expresión: let

 gramación en Linux
* *,ws

Prueba de repaso
O ¿Podría crear programas complejos usando varios scripts del
~hell?~

0 ¿Qué clase de valor se mantiene en una variable después de

hacer una operación aritmética de asignación?'

C7 Evaluación I
1. 2Cónio puede operar un script del shell BASH desde el shell TCSH?
2. ¿Qué leería un coninndo read en la entrada del script de un shell si
el arguniento del script es *?
3. ¿Podría asignar el texto de varias líneas a una variable?
4. ¿Cómo referencia varios argumentos de un script como un argu-
mento único?
5. ¿Puede drfinir,variables globales?
6. ¿Cuál es la diferencia entre = = y =?

6 Sí; simplemente asegúrese de exportar las variables necesarias que un script podría usar.
7 Una cadena que representa un número.
 .
Los objetivos de este capitulo son:
Aprender a hacer pruebas para las estructuras de control

Iniplenientar condiciones coniplejas con enunciados if anidados

Verificar diferentes opciones usando un enunciado case

Inipleiiientar bucles estándar al igual que argumentos read con un bucle for

Leer autoniáticaniente cualquier opción que ingrese un usuario

Manejar las operaciones de redireccionaniiento e interconexión en los scripts del shell

Aprender a verificar ciertas señales, coino la señal de interrupción para detener

un programa
 ión en Linux
w", e*

E ste capítulo tratará los temas básicos para crear un programa del
shell BASH, que se utiliza en la mayoría de los sistemas Linux.
Usted aprenderá cómo crear sus propios scripts, cómo definir variables
del shell, cómo desarrollar interfaces de usuario y dominará tareas más
dificiles como la de combinar estructuras de control para crear progra-
mas complejos. Las tablas que se muestran en este capítulo presentan
los comandos y operadores del shell BASH, y a través de numerosos
ejemplos se enseña la manera de implementarlos.
Este shell tiene un completo conjunto de estructuras de control que
incluyen bucles y enunciados if, lo mismo que estructuras case. Todos
los comandos del shell interactúan fácilmente con las operaciones de
redireccionamiento e interconexión que les permiten aceptar datos
desde la entrada estándar o enviarlos a la salida estándar.
Usted puede controlar la ejecución de los comandos Linux en un
programa del shell con estructuras de control, las cuales le permiten
repetir comandos y seleccionar ciertos comandos sobre otros. Una
estructura de control consta de dos componentes principales: una
prueba y comandos. Si la prueba tiene éxito, los comandos se ejecutan.
De esta manera, usted puede usar estructuras de control para tomar
decisiones acerca de si los comandos se deben ejecutar.
En los programas del shell se utilizan dos tipos de estructuras de
control: de repetición y condicional. Una prueba de repetición repite
comandos, mientras que una de condición ejecuta un comando cuan-
do se cumplen ciertas condiciones. El shell BASH tiene tres estructuras
de control de repetición: while, for y for-in, y dos estructuras de
condición: if y case.
Las estructuras de control while e if se utilizan para propósitos
generales como los de realizar repeticiones y tomar decisiones usando
diversas pruebas.
Las estructuras de control case y for son más especializadas. La
primera es una forma restringida de la condición if y a menudo se
utiliza para implementar menús. La estructura for es un tipo limitado
de bucle que actúa a través de listas de valores, asignando un nuevo
valor a una variable en cada repetición.
Las estructuras de control if y while prueban la ejecución de un
comando Linux.Todos los comandos Linux devuelven un estado de
salida después de haber terminado su ejecución. Si un comando tiene
 Capítulo 3: Estru

éxito, su estado de salida será 0. Si el comando falla por cualquier

razón, el estado de salida tendrá un valor positivo que referencia el tipo
de falla presentada. Las estructuras de control if y while verifican si el
estado de salida de un comando Linux es O o algún otro valor. En el
caso de las estructuras if y while, si el estado de salida es un valor O, el
comando tuvo éxito y la estructura continúa.

comando test
Con frecuencia, podría ser necesario desarrollar una prueba para com-
parar dos valores; sin embargo, la prueba que se usa en estructuras de
control es un comando Linux y no una expresión relacional. No
obstante, existe un comando Linux llamado test que puede comparar
dos valores y regresar como estado de salida O, si la comparación tiene
éxito.
Al usar el comando test, puede comparar enteros y cadenas, e
incluso realizar operaciones lógicas. El comando (su sintaxis se presenta
más adelante) consta de la palabra clave test seguida por los valores que
se comparan, los cuales se separan por una opción que especifica cuál es
la clase de comparación que se realiza. Usted puede pensar en opción
como el operador, pero está escrito, como otras opciones, con códigos
de letras precedidos por up signo menos. Por ejemplo, -eq es la opción
que representa la comparación de igualdad. La sintaxis para el comando
test se muestra a continuación:

test value -option value

test string = string

Tenga en cuenta que dos operaciones de cadena en realidad usan un

operador en lugar de una opción. Cuando usted compara dos cadenas
por igualdad, usa el signo igual (=). Para la desigualdad, utiliza !=. En el
siguiente ejemplo se comparan dos valores enteros para determinar si
son iguales. En este caso, debe usar la opción de igualdad, -eq. El
estado de salida del comando test se examina para determinar el
resultado de la operación test. La variable especial $? del shell mantie-
ne el estado de salida del comando Linux que se ejecutó más reciente-
mente.
-
64
'
1 Fundamentos de programación e n Linux

h - 3 '

1
G-

$ num=5

$ echo $ ?
1

T-nTT=T

Nota
10q
1
--- . -

$ t e s t $num - e q 10

+..
Alteri1ativai11ente, e n cainbio d e usar la palabr,i prueba tcst para el
coiiiando test, iisted puede usar paréntesis cuadrados ([ y 1). El co-
niando test $greeting = "hi" tambikn se puede escribir conlo:

1
Comparación de c a d d
-- . ----

D e manera similar, el comando test, test $num -eq 10 se puede

escribir e n esta forma:
- k b a
-
aritmética,
-

Usted debe incluir los paréntesis con un espacio en blanco

presionando la barra espaciadora o las teclas TAB o ENTER.
Sin los espacios, este comando no tendrá validez.
.
-
1

cadenas. No confunda comparaciones de cadena y comparacio-

nes de enteros. Para comparar dos cadenas por igualdad, usted
usa el signo igual a (=); para comparar dos enteros, emplea la
7 -

opción -eq.

En la tabla 3-1 se presenta la lista d e opcioiies y operadores usados

p o r test.
Comparación de enteros Función
-gt Mayor que
-It Menor que
-g e Mayor que o igual a
-le Menor que o igual a
-eq Igual a
-ne No es igual a
Comparación de cadenas
-z Pruebas para cadena vacía
-n Pruebas para valor de la cadena
- Cadenas iguales
!= No son cadenas iguales
Str Pruebas para ver si la cadena no es nula
Operaciones lógicas
-a AND lógico
-0 OR lógico
! NOT lógico
Pruebas de archivo Función
-f El archivo existe y es un archivo regular
-S El archivo no está vacío
-r El archivo se puede leer
-w En el archivo se puede escribir o se puede mo-
dificar
,El archivo es ejecutable
El nombre del archivo es un nombre de direc-
torio
El nombre del archivo es un enlace simbólico
El nombre del archivo hace referencia a un
dispositivo de carácter
El nombre del archivo hace referencia a un
archivo de bloque
 n en Linux

Condiciones: if, if-else,

elif y case
El shell BASH tiene un conjunto de estructuras de control condicional
que le permite elegir cuáles comandos Linux ejecutar. Muchas de estas
estructuras son similares a las estructuras de control condicional que se
encuentran en los lenguajes de programación, con algunas diferencias. La
condición if pone a prueba el éxito de un comando Linux, no de una
expresión.Además, el final de un comando if-then se debe indicar con
la palabra clavefi y el final de un comando case con la palabra clave esac.
Las estructuras de control condicional se presentan en la tabla 3-2.

La estructura if-then
La estructura ifestablece una condición en los comandos. Esa condición es
el estado de salida de un comando Linux específico. Si un comando tiene
éxito y retorna un estado de salida igual a O, se ejecutan los comandos
dentro de la estructura if. Si el estado de salida es diferente de O, el coman-
do ha fállado y los comandos dentro de la estructura i f n o se ejecutan.
El comando if comienza con la palabra clave $y va seguido de un
comando Linux cuy: condición de salida se evaluará. Este comando se
ejecuta siempre. Después del comando, la palabra clave queda en línea.
A continuación puede seguir cualquier conjunto de comandos. La
palabra clavefi termina el comando. Con frecuencia, usted debe elegir
entre dos alternativas basado en si el comando Linux tiene éxito o no.
La palabra clave elsc permite que una estructura if elija entre dos
alternativas. Si el comando Linux tiene éxito, se ejecutan los comandos
que siguen a la palabra clave then. Si el comando Linux falla, se ejecu-
tan los comandos que siguen a la palabra clave else. La sintaxis para el
comando if-then-else se presenta a continuación:
if comando Linux
then
comandos
else
comandos
fi
 Capítulo 3: Estruct

Estructuras Función
de control condicional
if comando then if ejecuta una acción si su comando test es verdadero.
comando
fi
if comando then if-else ejecuta una acción si el estado de salida del comando
comando test es verdadero; si es falso, se ejecuta la acción else.
else
comando
fi
if comando then elif le permite anidar estructuras if, permitiendo elegir entre
comando varias alternativas; en la primera estructura verdadera if,
elif comando then sus comandos se ejecutan y el control deja la estructura
comando elif completa.
else
comando
fi
case cadena in case equipara el valor de la cadena con alguno de varios
patrón) patrones; si un patrón concuerda, se ejecutan sus comandos
comando;; asociados.
esac
comando && comando La condición lógica AND regresa un valor verdadero de O si am-
bos comandos regresan un valor verdadero O; si uno de ellos
regresa un valor diferente de cero, la condición AND es falsa y
también regresa un valor diferente de cero.
comando 11 comando La condicnjn Iógica OR regresa un valor verdadero de O si alguno
de los comandos regresa a un valor verdadero de O; si ambos
comandos regresan un valor diferente de cero, la condición OR
es falsa y también regresa un valor diferente de cero.
! comando La condición lógica NOT invierte el valor de retorno del comando.

El script elsels, en el ejemplo siguiente, ejecuta el comando 1s para

listar archivos con dos posibles opciones diferentes, bien sea por su
tamaño o con toda la información del archivo. Si el usuario entra una
S, los archivos se listan por su tamaño en bloques; en caso contrario,
aparece toda la información.
68 ! Fundamentos de programación en Liiiux
- - - -

-r

echo
---
Enter s t o l i s t f i l e s i z e r .
echo o t h e r w i s ~a l 1 f i l e i n f o r m a t i o n i s l i s t e d .
pcho - n "Please enter option: "
read choice

i f [ "$choice" = S 1
then
1s - 5
el s e
1s - 1
fi
echo Gond-bye

El sigiiiente es u11 ejemplo de 1'1 ejeciicibn del script clsds:

$ elsels
Enter ; t o l i s t f i l ~s i z p ? ,
o t h e r w i s e a l 1 f i l i itiformiitirin i , 1 i 5 t e d .
P1ea:e e n t e r o p t i o n : S
total 2
1 inonday 2 today
Yood - h y ~
$

T
3
. a los e x p e r t o s
Pregunte
Pregunta: puedo usar l a estructura if para verificar los argu-
mentos?

Respuesta: La estructura if sc Lisa coi1 frecuencia para verificar si el

iisiiario ingreso cl núinero apropiado de argunieiitos para un script del
sheil. La variable especial del shell # contiene la cantidad de arguinentos
.I . : .< r . . 2- .. . . . .. . I I J. 1.- l. -... :
q u e1 ~ L I S U! ~ ~ I iligrt'sv.
CI
1 . .
usanuo QW en uiia uperacioii ue -
prueua ie permi-
tos.

ncarrec-

i Respuesta: Si se ha ingresado uri riíirnero incorrecto de argumentos,

puede ser riecesario que usted termine el script del shell. Para hacerlo,
puede mar el comando exit que tertriiiia el script del shell y regresa a
 C a p i t u l o 3: Estructuras d e c o n t r o l d e l s h e l l BASH 1 69
una coiidición d e salida. El coiiiaiido exit toma un argumento iluriieri-
ca. Si es O, indica que el script del sheLl terminó con Exito. Cualquier
otro argumento, p o r ejemplo 1, sefiala q u e se presentó u n error.
E n el siguiente ejemplo, e¡ script sólo toma u n argumento. Si e1
usuario n o introduce u n argiirilerito o ingresa m i s de uno, la pi-ireba i f
será verdadera, se iriipririiirá el iiierisaje d e error y el script terminará su
ejecución retorilando un valor d e error.
if [ $H -ne 1 1
then
echo lnvalid number o f arguments
exit 1
fi

echo $ 3

A contiriuación se iiniestra la ejecución del scripe &% sin argiimentos.

Este errar se detecta y el mensaje d e error aparece e n pantalla.

$ ifarg
Invalid number o f arguments

La estructura elif le periiiite anidar operaciones if-theil-else. La

estructiira elif equivale a "dse if". La priiiiera operacióii se especifica
con la estructura if, seguida por otras operaciones, cada una eipccifica-
da por su propia estructiira elif. La operacibii para la última estructiira
elif se especifica con i i i ~else. Si la prueba para la primera estructiira if
falla, el control pasará a la siguiente estructiira elif y sil prueba se
realizará. Si falla, el control pasará a la siguiente elif y su prueba verifi-
cada. Este proceso continúa hasta q u e una prueba es verdadera. Enton-
ces, la elif verdadera ejecuta sus conlaiidos y el control pasa d e la
estructiira if al coniando que sigue a la palabra clave fi.
Esta es la sintaxis de la estructura elif:

if comando Linux
then
comandos Linux
el if
70 Fundamentos de programación
-en Linux

comandos Linux
else
comandos Linux
fi

En el script clifls se presentan dos forinas posibles de listar archivos.

El último else se reserva para detectar entradas no válidas (en este
caso, una elección no válida). Observe que sólo una palabra c l a v e j

ma .s. -LE?
SlZéS -
termina esta secueilcia con~pletade comandos if-else anidados.

echo 1. L i s t Á i 1 I n f o r m z t i o n
echo-e "Please lrntcr o ~ t - i o n :\ c W
7

read c h o i c ~
i f [ "$cholcen
thel;
- .S 1
1s - S
e l if [ "8chaícen = 1- 1
th~n
1s - 1
el se
echo I n v a l i d B p t i o n
fi
echo Goodbye
.
El siguiente es un ejemplo de la ejecución del script elgs:

' $ ellT1S l

s. L i s t Sizes
1 . L i s t A l 1 F i l e Ininrrnation

- 1 W-I W - I -A + LIIL 1 3 w e a u w r . J V O Feb 14 10:30 today

- r w - 1 c h r i s weather 308 Fe!, 1 7 12:40 monday

S

Los comandos lógicos: && y 11

Los coniandos lógicos realizan operaciones lógicas en dos conlandos
Linux. La sintaxis es como sigue:
 comando && comando
comando 11 comando

En el caso del AND lógico (&&),si ambos comandos tienen éxito,

el comando lógico también lo tendrá. Para el O R lógico ( 1 1 ), si
cualquier comando tiene éxito, O R tiene éxito y regresa un estado de
salida de O. Los comandos lógicos permiten usar operaciones lógicas
como sus comandos de prueba en estructuras de control.

La estructura case
La estructura case permite que su programa elija entre varias alternati-
vas posibles. La elección se hace mediante la comparación de un valor
con varios patrones posibles. Cada valor posible está asociado con un
conjunto de operaciones. Si se encuentra una correspondencia, se
realizan las operaciones asociadas.
La estructura case comienza con la palabra clave case, seguida por la
evaluación de una variable y la palabra clave in;después, sigue un
conjunto de patrones. Cada patrón es una expresión regular que termi-
na con un paréntesis de cierre, después del cual se listan los comandos
asociados con este patrón, seguidos por dos signos de punto y coma en
una línea separada, que señalan el final de esos comandos. Después de
todos los patrones listados,la palabra clave esac termina el comando
case. La sintaxis es como sigue:

case cadena in
patrón)
comandos
..
II

patrón)
comandos

comandos predeterminados
..
11

esac
72 1 Fundamentos de programación en Linux
-- -

-5.u g e,reM c ia
Un patrón puede incluir caracteres especiales de cualquier shell, los
cuales son *, [ ,1, ? y 1. Usted puede especificar un patrón predeter-
minado con un solo carácter especial, *. El carácter especial * con-
cuerda con cualquier patrón y, por consiguiente, se convierte en una
opción predeterminada efectiva. Si los demás patrones no concuer-
dan, el * lo hará. De esta manera, la opción predeterminada se
ejecuta; si no es así, se eligen otras opciones. El predeterminado es
opcional y usted no está obligado a incluirlo.

Una estructura case se usa a meiludo para iinplementar riieilíis. En

el programa Isclroice, del ~igiiienteejeiiiplo, se pide al ~isuarioentrar una
opción para obtener una lista dc archivos cn diferentes fornias. Observe
la opción predeterminada que advierte la entrada n o válida:
-- --- --
# Prograni t u allnw t h L~ I ~ Pt o~ . ; e l ~ c td i f f e r e n t w a y s ' u f
1 lisiiiig f i l e ;
pcho s. L i r t 5 i . z ~ ~
echo 1 . L i s r . A l 1 F i l e I n t o r m 8 ? t . i o i i
? c h r ~c . Li:t C F i l e s
e c h o - n " P l e a s e -iit,sr c h n i c e : "
r i a d c h o i ie
5

c a s P $ c t i ~ i ¿ ei n
S1
1'; - S

-- - - -- -
Concuerda con cualquier ,
1s * . c
. ,.
'carácter que n o haya
. -
-- -- previamente
concordado
I- --
1
echo l n v a l i d O p t i o n
5a c
 Capítulo 3: Estructuras d e control del shell BASH
- -
73

El siguiente es un ejemplo de la ejecución del script lsclzoice.

El usoen patrones de los metacaracteres de la qeneración de archi-

vos puede d$t.feuna gran-flexibilidad. Así, en ejemplo anterior
solarnsnt@se permitieron las versiones en minúsculas de los patro-
nes. Una A rnavúscula se consideraría una entrada no válida. Si
usted emplea 61carácter especial 1 en el patrón, éste le permitirá

Prueba de repaso
?Cuál operador utilizaría para probar una cadena vacía?'

?Puede realizar usted la misma tarea c o n una estructura case

que c o n una estructura i f ?2

Bucles: while, until, for-in y for

El shell BASH tiene un conjunto de estructuras de control de repeti-
ción que le permiten repetir comandos Linux: las estructuras while,
for y for-in. C o m o la estructura if de BASH, while y until verifican
el resultado de un comando Linux. Sin embargo, las estructuras for y
for-in n o realizan pruebas, sino que simplemente avanzan a través de
una lista de valores, asignando cada valor a la variable especificada.

1 El operador -2 e n una expresión d e prueba.

2 Sí, usaría clif para estructuras it'ariidadas.
 amación e n Linux
mw "

Además, las estructuras while y until operan en formas muy similares

a las estructuras correspondientes que se encuentran en lenguajes de
programación, mientras que for y for-in son muy diferentes de sus
estructuras de programación correspondientes. Las estructuras de
control de bucles se presentan en la tabla 3-3.

Estructuras de control Descripción

de repetición

while comando do while ejecuta una acción, en tanto su

comando comando test sea verdadero.
done
until comando do until ejecuta una acción, en tanto su
comando comando test sea falso.
done
for variable in lista-valores for-in está diseñado para usarlo con
do listas de valores: al operando variable se
comando asignan consecutivamente los valores de
done la lista.
for variable for está diseñado para referenciar argu-
do mentos del script; al operando variable
comando se asigna consecutivamente el valor de
done cada uno de los argumentos.
select cadena in lista de ítems select crea un menú con base en los
do ítems de la lista de ítems y después ejecuta
comando el comando que, por lo general, es case.
done

El bucle while
El bucle while repite con~andos,comienza con la palabra clave w l d e
seguida por un comando Linux. En la siguiente línea está la palabra
clave do. El final del bucle se especifica con la palabra clave done. Esta es
la sintaxis del coniando while:
 Capitulo 3: Estructuras d e control del shell BASH
- *
1 75
while comando Linux
do
comandos
done
El comando Linus que se usa en lai estructuras while con frecuencia
es un comando de prueba que se señala entre paréntesis cuadrados. En el
script iriynnrnc, del ejemplo siguiente, se le pide que ingresc un nombre;
luego se imprime el nombre. El bucle se controla poniendo a prueba el
valor de la variable again, usando el paréntesis del comando test.

--

while [ "$againn
do
= y e s 1-IComienzodelbucle

echo - n " P l e a s e e n t e r a name: "

1 -- -
con prueba
- I

r e a d name
echo "The name y o u e n t e r e d i s $nameV
echo - n "Do you w i s h t o c o n t i n u e ? "
read a g a i n * p 1
done I- - - - -
el usuario escribe
echo Good-bye
. lis, el buclezy_epite/

El siguiente es u11 ejen~plode la ejecución del script w-iynnrne:

P l e a s e e n t e r a name: George
The name y o u e n t e r e d i s George
Do y o u w i s h t o c o n t i n u e ? yes
P l e a s e e n t e r a name: R o b e r t
The name y o u e n t e r e d i s R o b e r t
Do you w i s h t o c o n t i n u e ? no
Good - bye

El bucle while se usa con frecuencia para realizar tareas

repetitivas, tales como entrar o sacar líneas. Usted puede combi-
nar while con una estructura case para dirigir un menú.
76 F u n d a m e n t o s d e p r o g r a m a c i ó n e n Linux
--

Proyecto 3-1: Bucles básicos

Las operaciones relacionales se usan a menudo para dirigir estructuras
de control de repetición y condicionales. El programa helloprg presenta
la palabra he110 tres veces. Hace uso de una operación l e t menor que o
he1 1 o p r g igual a para administrar el bucle, l e t "again <= 3" y para incrementar la
variable again, l e t "again = again + 1". Observe que cuando se
incrementa again, n o se necesita evaluarla. N o se requiere que la prece-
da el signo $. El comando l e t evaluará automáticamente las variables
usadas en las expresiones.

Paso a paso
1. Con u n editor de texto, cree u n archivo llamado helloprog.
2. Defina una variable con el nombre agoin y asígnele u n valor de 1.
Esta es una inicialización de la variable que usted usará para controlar
el bucle.
3. Ingrese u n comando while en donde el enunciado de Linux que se
usó para la prueba es u n comando l e t (véase el capítulo 2). Verifique
si el valor de la variable again es menor o igual a 3.
4. 'Muestre el resultado de la variable again y la palabra Hello.
5. lncremente la variable again usando el comando l e t con una opera-
ción aritmética deasignación.
6. Termine el bucle while con el comando done.
El script helloprg se presenta a continuación:

El siguiente es u n ejemplo de la ejecución del script helloprg:

 Capítulo 3: Estructuras de control del shell BASH
. -
77

La estructura until
La estructura until funciona en una forma muy similar a la de la
estructura while. Sin embargo, until sirve para probar si el resultado
de un comando Linux no tiene éxito. Cuando el comando Linux faiia,
la estructura until continúa el bucle. En cierto sentido, until revisa si
la cor:dición de la prueba es falsa; a ese respecto, esta estructura es muy
diferente de las estructuras until que se encuentran en los lenguajes de
programación y se asemeja rnás al operador de los n~ismos,que sirve
para poner a prueba expresiones falsas. La siguiente es la sintaxis de la
estructura until:
until comando Linux
do
comandos
done

La estructura for-in
La estructura for-in está diseñada para hacer referencia secuencialmente
a listas de valores. Utiliza dos operandos: una variable y una lista de
valores.Todos los valores de la lista se asignan uno a u110 a la variable
en la estructura for-in. C o m o el comando while, la estructura for-in
es uii bucle. En cada repetición a través del bucle el siguiente valor de
la lista se asigna a la variable. Cuando se termina la lista, el bucle se
detiene. Al igual que el bucle while, el cuerpo de un bucle for-in
comienza con la palabra clave do y termina con la palabra clave done. La
sintaxis del bucle for-in es la siguiente:
for variable in lista de valores
do
comandos
done
78 1 Fundamentos de programación
-. --
en Linux

'3 Pregunta: podría usarse el bucle for-in para referencia de

nombres de archivo en un directorio?
Respuesta: Sí; de hecho, el bucle for-in es niuy práctico para admi-
nistrar archivos. Usted puede tisar caracteres especiales para generar
nonlbres de arcllivos para eniplearlos c o i i ~ ouna lista de valores en el
bucle for-in. Por ejeinplo, el carácter especial * genera una lista de
todos los archivos y directorios, y *.c lista los archivos con la extensión
.c.El carácter especial * puesto en la lista de valores del bucle for-in
generará iiiia lista de valores integrada por todos los noinbres de arcliivo
en su directorio actual, como:
f o r myfi7es i n *
do
El script rbo~kirpcrea una copia de seguridad para cada archivo y la
iibica en tin directorio llamado scwrcebnk. Observe el uso del carácter
especial * p x a generar una lista de todoi loi ilonibres de archivo que
tengan una extensión .c.
. ) ' G e n e r a-listas d ~ c h i v o s ,
Sor b a c k f i l e i n *.c
do
cp $ b a c k f i l e sourcebak/$backfile
echo B b a c k f i l e g
done

La siguiente es una ejecución del script chackcip:

$ cbackup
i0.c
1ib.c
rnain.c
$

La estructura for
La estructura for, sir1 una lista de valores específicos, toma como u11 lista
de valores los argumentos de la línea de comandos. Los arg~iinentoi
que se especifican allí cuando se llaina el archivo del shell se convierten
en una lista de valores refereiiciados por el coniaiido for. La variable
 Capitulo 3: Estructuras d e control del shell BASH 1 79
que ie uia en este c o n ~ ~ i se~ destablece
o en forma automática y
secueiicial para c a d ~valor de arguineiito en la iecucncia. LJ. primera
vez que atraviesa el bucle, la variable se ajusta al valor del priiner
arguiilento: la icgunda vez, al v~loi-del segundo arguiiiento.
La citructura for iin una liita especificada equivdc a la hita genera-
da por $@, que cs una variable eipecial de arguiileiito cuyo valor ei la
lista de ai-guineritos de la Iíiiea de coiiiaiidoi. En el ejeinplo iiguieiitc,
una Iiita de arcliivoi de progrdinai en C se ingresa en la línea de co-
inandoi cuaiido ie llaiila el ,irchivo del ihell, cbcick~ipcity,en donde un
bucle for i-efei-ciicia autoiniticaii~eiitea cada arguineiito. La variable
backfile ie uia en el bucle for. La primera vez que pasa el bucle,
$backfile iilaiitieiie el valor del primer ~rguineiito,$1. La ieguiidd vez,
$backfile imntiene el valor del icgundo arguinento, $2.

for b a c k f i 1 e
do
cp gbackfile sourcebak/$backfile
echo "8backfile "
done

El iiguiente es uii ejeinplo de la ejecución del script cbcick~iyay:

Si lo desea, usted podría liacer referencia explícita a los argunientos

~itilizandola estructura for-in y los arguiiieiltos especiales $* o $@. La
estructura for-in hará refereiicia ir~dividualiiieiitea cada arguiiiento y
lo asigiiari a la variable for-in. Sin eirib:irgo, existe una diferencia en la
iiiaiiei-a coiiio se i-efereiiciaráii los arguinentos, depeiidiendo de si usted
usa los arguiiieiitos especiales $* o $@. E11 el primer caso (S*), for-in
refereiiciari cada palabra eii la línea de coimiidos coiilo un ai-guniento,
sea que eité niarcada o iio coi1 coniillas, etc. En otras palabras, por
ejeinplo, el arguiileiito hi "hello and goodbye" salutations se lee
conio ciiica argumentos separados. El arguinento inarcado entre coini-
Ilas "hello and goodbye" se inaneja coino tres arguiilentos separados.
80 Fundamentos de programación en Linux

Si usted fuera a niarcar el argumento $* como "$*", tendría un solo

argumento largo. En el siguiente ejemplo, el script i n d a ~ se
s considera
sólo con tres argumentos, pero la estructura for-in refei-enciará cinco,
pasando por alto el argumento marcado.

El siguiente es un ejemplo de la ejecución del script i n d a ~ s :

El comando continue C.

El comando continue se usa con bucles para superar los enunciados

restantes en el cuerpo de un bucle y continuar con la siguiente repeti-
ción. El uso del comando continue puede complicar los estilos de
prograniación. Se debe tener precaución.

Los comandos true, false y break

El comando true es un comando simple cuyo estado de salida siempre
es O y siempre tiene éxito. Su contraparte, el comando false, siempre
tiene un estado de salida de 1 y siempre es una falla. Usted puede usar
el comando true como el comando de prueba en una estructura
while para in~plementarun bucle infinito. Un coi~landofalse iisado
con la estructura until también inlplementará un bucle infinito. Cuan-
do se decida emplear un bucle infinito, necesitará contar con una
manera de detenerlo. El comando break, cuando se usa dentro de
 Capitulo 3: Estructuras de control del shell BASH 1 81
1

cualquier bucle, transferirá el control del bucle deteniéndolo en forma

efectiva.

1 Con frecuencia, un buile infinito contendrl un enunciado break

condicional que, cuando se ejecuta, termina el bucle. Sin embar-
go, usar a la vez el comando break y bucles infinitos, en ocasiones
pliede complicar el código de programación. Deben usarse con
precaución. También resulta práctico saber que,el comando break
es la Única manera que usted tiene para detener un bucle for o
for-in, antes de llegar al final de la lista.

íY
8 WWJ W I 8 Y.W V I I W

> Pregunta: ¿Cómohago referencia a los argumentos en una

W

w r *- *r -
estructura for-in?

un argumento, debe usar el argumento especial $@. Además, debe

marcarlo como "$@". Esto hará que cada argumento se trate como un
~ r r n i m P n t nindivirliigl
--b --A------ -m-- - '---riiandn In --
--"---' rpfprpnrip l--" -"-'-
fnr-in
i n g PCrnirhira '-- -.
Fn ~l
siguiente ejemplo, el scriptfnmrRspresenta argumentos en forma indivi-
dual usando una estruchlra for-in y el argumento especial $@ marcado
entre comiuas.

echo "There a r e $ # argurnents "

f o r a r g f i n "$@"
do
echo 8 a r g f
do n.e

El siguiente es un ejemplo de la ejecución del scriptforargs:

$ f o r a r g s h i " h e l l o and goodbye" s a l u t a t i o n s
There a r e 3 argurnents
hi
h e l l o and goodbye
salutations
 de programación en Linux
-m--*< dad*

Prueba de repaso
Si la prueba de un bucle siempre es verdadera, ¿se detendrá
alguna vez?3
¿Existe alguna manera de obligar a un bucle a detener~e?~

Proyecto 3-2: índice de páginas Web

El programa myindex incorpora muchas de las características de progra-
mación que se usan comúnmente en el shell BASH. El programa genera
automáticamente una página Web que puede funcionar como u n índice
myi ndex
para seleccionar otras páginas Web. Se supone que algunos subdirec-
torios contienen páginas Web.

Paso a paso
1. Encuentre los directorios que puedan estar en el directorio actual y
luego revise para determinar si hay alguna página Web en ellos. Las
páginas Web son cualquier archivo con las extensiones .html o .htm.
Los nombres de estos archivos se encuentran en cadenas que cons-
tan de comandos HTML, que son hrefs para seleccionar y presentar
en pantalla los archivos. Las referencias HTML están organizadas en
u n listado con las etiquetas <ul> y </ul>, precedidas por una etiqueta
<lb. Los nombres del directorio se usan como encabezados, con la
etiqueta <hl>.
2. Busque u n título dentro de u n archivo HTML y úselo como el texto
de enlace en el índice.
3. Use grep para buscar el patrón <TITLE>. Si encuentra uno, será
enviado a la variable tline.
4. Si n o encuentra el patrón, asigne el nivel de error 1 a la variable de
estado $?
5 . Verifique esta variable para saber si grep tuvo éxito. En caso afirmati-
vo, use u n conjunto de comandos sed para unir los rótulos preceden-
te y siguiente, <TITLE> y </TITLE>, junto con cualquier otro carácter.
6. Asigne el texto del título restante a la variable ntitle.

3 No; tendría un bucle infinito.

4 Sí; use el comando break.
 Capitulo 3: Estructuras de control del shell BASH 1 83
7. Si grep no encuentra una Iínea <TITLE>, asigne el nombre del
archivo a ntitle.
8. Utilice basename para extraer el nombre del archivo del nombre
del directorio, retirando cualquier nombre de directorio que lo
preceda.
9. Use cut para retirar la extensión (la salida será el primer campo
usando el punto como delimitador). Las extensiones .htm y .html
se pueden retirar.
10. Después de asignar el texto a ntitle, úselo como el texto de enlace
en la Iínea HTML href. Esta Iínea comienza con una etiqueta el¡>,
que indica que es un ítem de la lista.
El script myindex se presenta a continuación:

2i!i0 ' <HTML> '

i'.~:Iio '\HkAD>'
echo ',TITLE>My I n d e x < / T I T L E > '
pcho '</HEAD>'
echo '<BODY>'
echo ' < H I > I n d e x o f HTML F i i r:. ' H l > '
for i i n *
do
i f [ -d T i ]
tlien -
echo " < h 2 > $ i < / h 2 > "
echo '<iil>'
f o r j i n $i/*.htm*
do
i f [ - f bj 1
then
t l i n e = ' g r e p '<TITLE>' $ j '
i f [ $ ? -eq 1 1
then
n t i t l e = ' b a s e n a i n e $ j 1 c u t - f l - d W ." '
e l se
n t i t l e = ' e c h o $ t li n e 1 sed 's/*.*<TITLE>//' 1 sed
's/<\/TITLE>.*$//"
fi
echo "<l i, a h r e f - $ j > $ n t i t l e < / a > "
fi
done
echo ' < / u l > '
fi
done
echo '</BODY>'
echo '</HTML>'
84 Fundamentos de programación e n Linux

El programa myindex va a la salida estándar, de modo que tendrá que

redirigirlo a un archivo para guardarlo, usando esta línea:

El siguiente es un ejemplo del archivo mindex.htm1:

I (lul>
/h,?>rnywebs<!h2>
l &l>
I < l i i t a href=niywebs/rnypi c s . h t m l i n i y p i c s < / a >
< l i > < a h r e f = i n y w e b s / v a c a t i o t i . h t m l >My Suniiner V a c a t i c i n < / a >
c / u 1 >
CiBODY'
</l-iTML>

En la figura 3-1 se presenta el resultado, como aparecería en un

browser.

docnotes

Presentación en pantalla de mindex-httnl generado por el script

del sliell myindex
 Capitulo 3: Estructuras d e control del shell BASH ( 85

Usar redireccionamiento
e interconexiones
con estructuras de control
Usted puede considerar una estructura de control conlo un comando
que envía datos a la salida estáiidar. Esta salida se puede redirigir o
intevconectav (transferir a otro comando), igual que la salida de cualquier
comando Linux. En un coniando de una estructura de control, usted
ubica un operador de redirección inmediatamente después de la pala-
bra clave done para enviar la salida de un bucle a un archivo. En el
archivo nrylistsavc, por ejemplo, el coiiiando echo dentro del bucle for-
in pondrá el nombre del ítem en la salida estándar. Estos nonlbres se
envían luego a un archivo 1lainado.foods. El archi~o~foods tendrá, enton-
ces, una lista de todos los artículos de abarrotes.

El siguiente es el resultado de la ejecución del script ni)~listsave,

junto
con la presentación del contenido del archivo.foods creado por el script:

En el siguiente ejemplo, el script cbackupn ha sido alterado para

obtener el nombre de cada archivo copiado. El comando echo dentro
del bucle for-in pondrá los nombres de los archivos en la salida
estándar. Los nombres de los archivos se transfieren primero al filtro
86 1 Fundamentos de programación en Linux
-- -

sort para ordenarlos antes de redirigirlos a un archivo. Ob5erve que la

conexión se coloca a la derecha de la palabra clave dor?e.El archivo c-r?nitic'.c
contendrá entonces una lista de todos los archivos de programas en C de
los cuales se ha guardado una copia de seguridad.

r ~ o r b a c k t f l e Tn * . c Los nombres de archivo

do que salen con el comando

1 eclio se transfieren al filtro

c p I b a c k f i l e s o u r c e b a k / $ b a c k f i l e sort Y los nombres ordena-
echo $ b a c k f i 1e dos se guardan entonces
done / s o r t > cnames en el archivo ctiames

El siguiente es un ejernplo de la ejecución del script c-linc-krryrt,junto

con la presentación del archivo crinnirs que crea:

$ cbackupn
$ c a t cnames
io.c
1ib.c
main.c

Usted también puede redirigir la entra& estándar a una estriictura

de control.Ta1 como el comando echo escribe en la salida estándar, el
comando read puedcleer desde la entrada estándar. U n c o n ~ a n d o
read dentro de un bucle puede leer datos redirigidos desde un archi-
vo hasta el bucle. D e esa ri~aiiera,un coiilando read puede leer dcsdr
u11archivo.
En el script bookrec-.SRel usuario crea u11script para entrar registros en el
archivo de una base de datos y después presentar esos registros. En el
primer bucle, el usuario entra los registros de los libros y los almacena en el
archivo hooks utilizando el redireccionaiiue~~to a contin~~acióii del coinan-
do echo. Después de ingresar todos los registros, se utiliza un segundo
bucle para imprinur solamente el autor y el título de cada registro. Este
segundo bucle recibe los datos de entrada redirigidos desde el archivo Oooks
a la estructura de control while.
El coinando de prueba para el segundo bucle es el coiiiaiido read.
Cuando este comando lee la entrada, regresa a un estado de salida de O.
En tanto h a y una entrada, el coniando read regresará coi110 verdadero.
 Capitulo 3: Estructuras
.-
-
de control del shell BASH
y-.-
1 87
Sin embargo, ciiando dicho coiiiarido detecta la terminacióii de un
al-chivo, regresa 3 un estado dc d i d a diferente de ccro. E ~ t osignifica
que el bucle while teriiiinará cuando se Ilegiie al final del archivo. El
iiiisnio principio se aplica a la entrada d e datos que el iiwario hace con
$U teclado. El coinando read continuará leyendo las entradas hasta que
detecte iin retorno de carro (CTRL-D) que indique su terminación.

l
-ec=yes.
echo "Input format i s <book>:<author>:<price>:<publi sher>"
while [ "8morerec" = yes 1
do
echo - n "Please enter book record: "
read title author price publisher
~ L I I O -e "$title:\tbr7uthor:\t$price:\t$publ isher">> books
icho -n "Do you wish to continue? "
read morerec
done

whi 1 e read ti tl e author price pub1 i sher

do
echo " $ t i t l 2 $author "
done < books
-
El siguiente es 1111 ejeinplo de la ejecución del script bookrcuR. En
este caso, el iisuario entra 1111 registro completo una sola vez con cani-
pos separados por dos puntos (:).

$ bookrecsR
Input for-inat i s <book>:<author>:<pric2, :<pub1isliPr>
Pl ease e n t ~ ra book recoi d: War and peace:Tolstoy:15.75:Penguin
Clu you d.fisIi to contitiu~?yes
P l sasp enter a book i ecord: Christmas caro1 :Dickens:3.50:Academic
Do you wish to continue! yes
P l e a : ~ ~ n t r ra b o c k recnrd: Iliad:Homer:10.25:Random
Lo yo11 w i s h to continue? yes
P1 C.;ISF, e n t e 1 a book record: Raven:Poe:2.50: Penguin
Dc you wish to cantinue? no
88 Fundamentos de programación
-
en Linux

Estructuras de desvío: trap

Otra clase de estructura de control es un trap, la cual ejecuta un co-
niando o coniandos cuando ocurre un evento específico. El evento
podría presentarse en cualquier iiioniento y punto del programa y
comúnmente se conocen conio señales. Cuando el sistema recibe una
señal, el trap se ejecuta y el control se transmite a los comandoi aso-
ciados con el mismo. La siguiente es la sintaxis de la estructura trap:

U n trap está diseñado para manejar algún evento externo que

interfiere con un programa. U n evento común de esta situación es una
señal de interrupción que usualmente envía el usuario al presionar las
teclas C T R L - C (si, mientras ejecuta un programa, usted opriiiie estas
teclas, detendrá dicho programa). Cada vez que su programa se inte-
rrumpe de esta nianera, habrá acciones que usted o el programa que-
rrán realizar. Una operación común es salir del programa con un valor
de error.
Todas las señales de los eventos se asocian con un iiún~eroespecífico
en el sistema. Usted puede precisar la ocurrencia de un suceso específi-
c o usando el número de la señal del evento. En el siguiente ejemplo, el
usuario genera un evento de interrupción; es decir, presiona CTRL-C
para detener el programa. Si el usuario presiona CRTL-C, la trampa
ejecutará un comando echo y un comando exit. El número de la señal
para una interrupción con CTRL-C es 2.
 Capitulo 3: Estructuras d e control del shell BASH 1 89
El siguiente script cbackiry T contiene un coinando trap:

En el siguiente ejemplo, el usuario ejecuta el progrania chackclpT

y después decide cancelarlo presionando CTRL-C, que se representa
con el código " C .En ese punto de la cancelación, se realiza la trampa
y se ejecutan los coniandos asociados con ella, antes de que el progra-
nia terniiiie.

Usted también puede usar el comando trap para evitar que situa-
ciones externas lleguen a interrumpir la ejecución del programa. Por
ejemplo, suponga que n o desea que el usuario pueda detener el progra-
nla presionando CTKL-C; es decir, quiere que se pase por alto cual-
quier evento externo. El coniando trap puede desviar el evento
C T K L - C y evitar que interfiera con la ejecucióii del prograiiia. Usted
puede hacer esto ingresando un par de coniillas sencillas como primer
argumento del comando trap. Si trap no tiene coniandos Linux para
ejecutar, siriiplcrnente intercepta un evento que pudiera detener el
programa. El comando trap que se presenta a continuación atrapará
todas las ocurrencias de C T K L - C y evitará que el usuario utilice esa
combinación de teclas para detener su progrania.

E n el siguiente ejemplo, el núniero de la seíial O indica los eventos

de teriiiinnción del progrania. Cuando se utiliza con un trap, este
90 1 Fundamentos de programación
- en Linux -

número sellala que doridequiera que su programa teriniile, el coiliando

trap se ejecutará. Sea que su programa termine debido a una interrup-
ción, a u n conlando exit o simpleiiieiite por la ejecución del íiltinio
comando del programa, este trap se activará y realizará la acción
indicada. E11 el siguiente ejemplo, el mensaje "Goodbye" aparecerá
cada vez que el progrdina termine, cualesquiera sea la razón.
-
" t r a p 'echo

Este trap se ingresa en el script cbnc-kirpG,que se muestra aquí,

junto con el otro trap para verificar las iiiteri-upciones. El trap CTKL-C,
que se identifica con el número 2, se retira en este caso para ilustrar
cómo f~iricionael ti-ap O.
-
Trip I T 1'5
t r a p ' e c h o "Goodbye"' O

f o r b a c k f i l e i n *.c
do
c p $ b a c l : f i l ~s o u r c e b a k l $ b a c k f i l e
echo $ b a c k f i l e
done 1 s o r t > cnames

En el siguiente recuiadro se prewiltnil dos ejecucioiies del script

LIIIJ coi1 teriliimción e ~ t i n d a ry otra con u i i ~
LI)O[X>II~G, interi-upcibil
por CTIXL-C.

Goodbye
$
$ cbackupG
AC
Goodbye

En la tabla 3-4 se preseritaii los diferentes núnieros de las scliales y

una descripción de cada una.
 Señales Descripción
O Terminación del programa El programa termina
1 Descolgar Desconecta la línea de comunicaciones
2 Interrumpir terminal Presiona las teclas de interrupción CTRL-
C o DELETE
3 Salir Presiona CTRL-1 o CTRL-\
9 Eliminar Elimina un programa; no se puede desviar
15 Eliminar el software Utiliza el comando kill para terminar un
programa
24 Parar Detiene un programa con CTRL-Z; no se
puede desviar

C7 Evaluación
1. ¿Puede anidar usted estructuras i f ?

2. ¿Cómo se puede iinplementar una selección predeterminada en una

operación case? .
3. ¿Cómo podría leer los argumentos de un script, uno a uno, proce-
sando uno cada vez?

I 4. ¿Qué conlando podría utilizar para detectar automáticainente

opciones que se hayan ingresado en la línea de comandos?

5. ¿Podría ejecutar su programa algún conlando después de que el

usuario lo termine con la conlbinación CTRL-C?
 .
Los objetivos de este capitulo son:
Desarrollar programas en el shell T C S H

Definir el shell T C S H y las variables de entorno

Administrar las entradas y salidas del script del shell T C S H

Usar los operadores aritméticos, relacionales y de asignación del shell TCSH

Usar las estructuras de control del TCSH para implementar bucles y pruebas condicionales
 gramación en Linux

Ed shell TCSH, al igual que el shell BASH, tanibién tiene capacida-

es de lenguaje de prograniación. Usted puede definir variables y
asignarles valores. Puede establecer definiciones para las variables y
comandos Linux en un archivo del script y después ejecutar ese script.
Puede usar estructuras de repetición y estructuras de control condicio-
nal para repetir coniandos Linux o toniar decisiones acerca de cuáles
son los coniandos que quiere ejecutar.También puede colocar tranipas
o desviaciones en su progrania para nianejar las interrupciones.
El shellTCSH difiere de otros shells en el sentido de que sus estruc-
turas de control se ajustan más al formato de un lenguaje de progrania-
ción. Por ejemplo, la condición test para la estructura de control del
shell TCSH es una expresión que evalúa la condición de verdadero o
falso y no un coniando Linux. Una expresión del shell TCSH utiliza
los niismos operadores que se encuentran en el lenguaje de progran-ia-
ción C. Usted puede realizar diversas operaciones de asignación, arit-
méticas, relacionales y a nivel de bits. El shell TCSH tanibién le
permite declarar variables nuniéricas que se pueden usar con facilidad
en dichas operaciones.

Variables, scripts y argumentos

del shell -TCSH
El shellTCSH utiliza variables del shell casi de la niisnla manera como
lo hace el shell BASH. Usted puede definir variables en un shell y
asignarles valores, al igual que hacer referencia a argumentos del script;
tanibién puede definir variables de entorno que operan en forma muy
siniilar a las variables exportadas del shell BASH. Sin embargo, el shell
TCSH difiere en la manera conlo define las variables y el tipo de
variables que usted puede definir. Esa definición se hace con los co-
mandos set, @ y setenv.El shell tanibién le permite definir variables
nuniéricas y arreglos: con el coniando @ define una variable numérica
en la cual usted realiza operaciones aritméticas, mientras que los parén-
tesis redondos y los paréntesis cuadrados le permiten definir y
referenciar arreglos.
Los scripts tanibién operan casi en la misma forma aunque con
algunas diferencias importantes. El script de un shell TCSH debe
 Capítulo 4: Programación del shell TCSH
- -

conieiizar con un signo de níiiiiero (#) en la primera columna de la

priinera línea.Adeniis, auiiquc los proinpts se pueden obtener iisando
el comaiido echo, el TCSH no tiene coniando read para manejar la
entrada, de inodo qiic debe redirigir la entrada estindcir hacia una
variable.

Las variables del shell TCSH

En cste shell, primero debe declarar una variable antcs de que pueda iiw-la.
Ustcd declarri una varirible con el coniando set seguido por el nombre de
1,) vxiable. Estas son las reglas pan darle nombre a una variable:

Puede ser cualqu~erc o ~ i j ~ i ~de

i t ocxacteic\ alfabbticoq, iiicliiido rl
guióii de wbray~do.

I'uedc iiicluir LIII iií111ie1-o,

pero é\tc no puede qer el priiiier carí,cter en
el iioiiibre.

No puede incluir iiiiigíiri otro tipo d e carácter, coiiio i i i i punto de

admiración, ariipersaiid o, iiiclusive, u n espacio. Estos síiiibolos estáii
reservados para el liso propio del sliell.

El siguiente ejemplo presenta la variable greetiiig. Mis adelante,

.
~istedp u d e quitar la definición de la variable con el coiiiando unset
- -
'set gfheting

1Nota -. -

Un nombre no puede incluir más de una palabra, ya que el shell

analiza su Iínea de comandos incluyendo los espacios que haya. Un
espacio es un delimitador entre los diferentes elementos de la línea
de comandos.
-- . -
Usted taiiibién puede usar el coiiiaiido set para a\ig~iaruii valor ,i
una variable: escriba la palabra clave sct, el rioiiibrc d e la variable, cl
operador de xigiiación, =, y despuks el valor asignado. A una vari'ible
se le puede asignar ciialquier conjunto de caracteres. Eii el siguiente
ejemplo, a la variablc greeting \e le asigna la cadena "hello".
96 Fundamentos de programación en Linux

En la operación de asignación del shell T C S H usted debe colocar

espacios a ambos lados del operador de asignación o n o dejar ningún
espacio. Esta operación de asignación

fallará porque hay un espacio antes del operador de asignación (=),

pero no después.
Usted puede obtener una lista de todas las variables definidas usando
el coinando set, sin incluir ningún argumento. El siguiente ejemplo
utiliza set para presentar en pantalla un listado de todas las variables
definidas y sus valores:

C o m o en el shell BASH, el signo de dinero ($) es un operador

especial que evalúa una variable del shell. La evaluación recupera el
valor de una variable, por lo general un conjunto de caracteres, el cual
reeiiiplaza después el nombre de la variable. En efecto, cada vez que el
signo $ se anteponga al nombre de una variable, el shell reemplaza
dicho nombre con el valor de la variable. E n el siguiente ejemplo se
evalúa la variable del shell, greeting, y su contenido, "hello" se utiliza
entonces como argumento para un coniando echo. El comando echo
presenta un conjunto de caracteres en la pantalla.

C o m o con el shell UASH, las comillas dobles, las comillas sencillas y

la barra invertida evitarán la evaluación de caracteres especiales. Ade-
más, las coinillas invertidas se pueden usar para asignar los resultados de
los conlandos a las variables. En el siguiente ejemplo, las comillas
dobles suprimen el carácter especial ?:
 Capitulo 4: Programación del shell TCSH 1 97

Los scripts del shell TCSH: entrada y salida

Fácilmente, usted puede definir y usar variables dentro del script de u n
shell. C o m o en el ejemplo precedente, con un editor de texto en un
archivo puede poner conlandos Linux, tales como la operación de
asignación y echo. Después, puede ejecutar el archivo y llamarlo en la
línea de coinandos corno otro coinando. Recuerde que al agregar el
periniso de ejecutar, usa el comar-ido chmod con un permiso u+x o
con el permiso absoluto 700. Dentro de un script, usted puede en-iplear
el comando echo para obtener los datos. Sin embargo, la entrada se lee
e11 una variable nicdiante el redireccionamiento de la entrada estándar,
usando el operador >.

-iNota
El shell TCSH n o tiene una versión comparable del comando read
del shell BASH.
. _Y
'
El shell T C S H exaiiiiiia el prinier carácter de un archivo para deter-
minar si es o 110 un script. Recuerde que todos los scripts de este shell
deben tener un signo de # como primer carácter eii la priinera línea.
Esto identifica el archivo como un script del shell T C S H . Observe el
carácter # al conlienzo del script greet. Al colocarlo en un lugar dife-
rente al de primer carácter de la priinera línea del archivo, el carácter #
opera coino un carácter ordinario.
98 1 Fundamentos de programación
--
en Linux
- -

Eii el siguieiite ejeniplo, el script grcct se convierte eii ejecutable y

después se poiie eii f~~ncioiianiiento.

>" chmod u+x g r e e f

> greet
TIIP v a l u e o f g r e e t i n g i s he1 l o

El coi~iaiidoset, coiiibiiiado con la operación d e redireccioiiamiento,

$<, leerá todo lo que el usuario iiigrese e n la entrada eitjiidai-. El
~iguieriteejeiiiplo Ice la entrada del iisuario cii la variable greeting.
-
' 5 sét g r e e t i n g = $<

Usted puede poiier el proinpt en la niisina línea d e entrada, con el

comando echo. El sliell TCSH usa uiia opción especial para echo, la
foriiia -n, qiie eliiiiiria la iiecesidad de i i i i retorno del carro al filial
de la cadena de salida. El cursor se iiiailtieile en la niisnia línea a l final
de la cadena de salida:

Si deiea incluir 1111 espacio al final de su pi-oiiipt, debe inarcar la

cadena de salid'i coii~oniillasdobles, iiicluyendo cl eipacio:

El script gwctpt, qiie ie iiiucstra a coiitinuacióii, contiene una versióii

del shell TCSH de un proiiipt que se mantiene en la iiiisina línea dc la
entrada.

icho -n "Please eiiter a greeting: "

s e t g r e e t i n g = $<
 Capítulo 4: Programación del shell TCSH

El siguiente es iiii ejemplo de la ejecución del script gwctyt:

* - -

--
P l e a s e e n t e r a q i e e t i n q : he110
. - - ----*

T h i g r e i t i n g you e r i t e r ~ dn a í bollo
>

Arreglos: ( ) y #
En el shell TCSH ii~tedpliedc declarar y us'ir arreglo\, 11,iciendo refe-
rencia a cada eleniciito. declara arreglo\ con el coniaiiclo set y una lista
de valores por cada elenieiito cn cl m-eglo. La liita d e valores se marca
entre p'iréntesii y c ~ d avalor se separa con 1111 eipacio. El arseglo es tan
grande coino el iiúmero de valores asignado. El siguiente ejemplo
decl,ir'i i i i i arreglo llaiiiado weather y le aiigiia tres valorei (vt:crcr figura
4-1). El arreglo weather tendrá tres cIciiieiito\, cada lino con un v ~ l o r
corrcspondieiite:

-
> weather
set =
. r.~iStadeval~q
( h o t col r a i n ) ----
-.

El nombre del arreglo por 4 iiiiwio referencia todos loi eleiiicntos

del miinio. El sigiiieiite cjepplo iiiipriiiic el ~ r r e g l ocompleto.

hot cold rain

Usted puede referenciar cada elemento en el arreglo con la posición

del elemento riiarcado entre paréntesis cuadrados. Los eleineiitos del
arreglo se iiuineraii a partir d e 1 . El iiguieiite ejemplo asigna un nuevo
valor al primer eleiiiento:

I Iíndice del arreglo 1

> echo $ w e a t h ~ r
sunny ccild r a i n
100 1 Fundamentos de ~roerarnaciónen Linux

Después, puede tener acceso al contenido de un elemento, tal como

cualquier otra variable precediendo la referencia del elemento con un
signo de dinero ($). El siguiente ejemplo imprime el contenido del
tercer eleniento:

1 2 3
arreglo
weather
hot 1 cold 1 rain

% set weather (hot cold rain)

E&II Arreglos del TCSH

En el script timport, el arreglo weather se define y se usa en un

script:

El siguiente es un ejemplo de la ejecución del script wrcport:

1' ""r", y
TIie w a ' t l l p - t ~ l d a y5 5 cO]d
Toino.rrcy t h i r r ? ,wil'ibe. r;itii
>
Usted puede especificar una gama de elen~eritosmediante la especi-
ficación del comienzo y el final del rango, separado con un guión
corto entre paréntesis cuadrados. El siguiente ejemplo imprime el valor
para los elementos segundo y tercero:

mRwG 1
cold rain
7 Lonjunco ae eiementos
----
aei arregol
---
 Capítulo 4: Programación del shell TCSH
-
101

- -
mantiene el número de elementos en el arreg;lo weather es #weather. Como
con cualquier variable, usted puede tener acceso al contenido de #weather
precediéndolo con un signo $, como en $#u reather. En este ejemplo, se
1 , 1 1
imprime ei numero ae elementos en ei arreglo weather:

> echo Wweather

3

Arreglo de argumentos: argv

Cuando se llania un script del sliell, todas las palabras en la línea de
coiilandos se analizan y ubican en elementos de un arreglo llamado
argv. El arreglo argv[O] conservará el nonibre del script del shell y,
comenzando con argv[l];. cada elenlento niantendrá un argumento
en la línea de coniandos. En el caso de los scripts del shell, argv[O]
siempre contendrá el nombre del script del shell. Como con cual-
quier eiemento del arreglo, usted puede tener acceso al contenido de
un elemento del arreglo de argunientos precediéndolo con el opera-
dor $. Por ejemplo, $argv[l] tiene acceso al contenido del primer
elemento en el arreglo argv. En el script grectarg se pasa un saludo al
primer argumento en la línea del con~ando.A este primer argunlento
se tiene acceso con $argv[l].
102 1 Fundamentos de programación en Linux
*--

El sigciieiite es un ejeniplo de la ejecución del script p w t q q :

? greeta-rg He110
The g r e e t i n g y o u e n t e r e d was: H e l l o

Cada palabra se analiza en la línea de coiiiandos, a menos que esté

eiitre coniillas. En el siguiente ejeniplo, el script p w t q se llama con
una cadena sin comillas y después una cadena eiitre comillas. Observe
que la cadena entre coniillas "Hello, how are you" se trata como un
argumento.
- -- -- .
"7 g r e e t m o . how a r e you
he g r e e t i n g y o u e n t e r e d was: H e l l o ,
> g r e e t a r g " H e l l o , how a r e you"
The g r e e t i n g y o u e n t e r e d was: H e l l o , how a r e y o u
>
Si se ingresa iiiás de un arguiiiento, a cada uno d e ellos se liacc
referencia con cin elemento correipondiente en el arreglo argv. En el
5iguicntc ejeiiiplo, el script III)JAI$ iinpriine cuatro argumentos. Des-
pués se ingresaron cuatro argumentos en la línea de comandos (véasc
figura 4-2).

7-
echo "The f i r s t argument i s : BargvC11"
echo "The second argument i s : $ a r g v C 2 I w
echo "The t h i r d argument i s : $ a r g v [ 3 1 "
echo "The f o u r t h aryument i s : $ a r g v C 4 I w

Un ejemplo de la ejecución del script rti)wys es el siguiente:

R> myargs k e w
The f i r s t argument i s : H e l l o
The second argument i s : H i
The t h i r d argument i s : y o
The f o u r t h argument i s : How a r e y o u

Eii el script r v r ~ p r t ase viielve a escribir el script u~rcportpara usar

arguinentos. Los argumentos del primero de ellos son núineros que
 Capitulo 4: Programación del shell TCSH
.-
1-
103

forman el índice del arreglo weather. El primer arg~imentoes 2, que se

referencia con la variable del arg~imento$argv[l]. El segundo argumen-
to es 3, que se referencia con $argv[2]. La forma $weather[$argv[l]],
de este ejemplo, hace referencia a weather[2], cold.

$ myargs Hello hi y o " H o w are you"

Ari-eglo dc la líiiea de coiiiaiidos: argv

1 2 3 4
ar'glo
argv
1 iiiyarg 1 H ~ I I O1 ~ii
1 yo How ;ir? yoii

Ejecucióii
del script i r i p y s

myargs
Í echo
echo
echo
echo
"the first argiiiiieiit is SnrgvlIJ"
"tlie secoiid argiiiiieiit is $argv[2J1'
"tlie tliirci argiiniciit ic Sargvl.31"
"the fourth argiiiiieiit is Sargvl41"
L

E l arreglo arcv para l o s a r g u m e n t o s d e la línea d e c o m a n d o s

El siguiente es iin ejemplo de la ejecución del script iimpwtn:

-.> w r e p o ~ ~ ~ -
-7> - - - --

The w e a t h e r t o r l a y i col (1
r;

Tüniclrrcrw t h p r p w i l l be t ;iin
>

Un elemento de argv se puede abreviar al número del elemento

precedido por un signo $. $argv[l] también se puede escribir ~
'1 como $1. Eso significa que los scripts del shell TCSH pueden
incluir referencias de argumento que son muy similares a las
referencias de argumento del shell BASH.
104 Fundamentos de programación en Linux

nespuesra; La variame especial aei argumento, argvlnj, nace rererencia a

todos los argumentos e n la línea de comandos. $argv[*] se puede abreviar
como $*.Observe que éste es el niisino nonibre que se usa en el sheil BASH

para especificar un número fijo de argumentos para un script. El tiúmero se

puede verificar para determinar si el usuario ha ingresado la cantidad co-
rrecta. En el siguiente ejemplo, el script argnum muestra el número de
argumentos que el usuario ingresó:

#
echo "The number o f arguments e n t e r e d i s $ # a r g v W

El sipiente es un ejemplo de la ejecución del script aqnum:

> argnum H e l l o h i s a l u t a t i o n s
The number o f arguments e n t e r e d i s 3
 Capitulo 4: Programación del shell TCSH
--
1 105
El script nplist y la figura 4-3 muestran el uso d e las variable? eipe-
cialcs del arguiiiento, argv[*] y #argv. El usuario preienta primero en
pantalla el i~íiinerod e arguinentoi que usan #argv y deipués emplea
argv[*] para preseiitar en pant~llala lista de los arguiileiitos que se
ingresaron.

!Número de argumentos
ii' de la línea de comandos
- - y " - .
eclio "The number o f argurnents e n t e r e d i s $ # a r g v U
echo "The l i s t o f a r g u m ~ n t si s :
1 La lista de argumentos
Ide la línea de comandos

El siguiente es el resultado d e la ejecución del script nrqlisf:

> argiist He110 h i yo

The numhe~ o f argurneiits e n t e r e d i s 3
The l í s t o f a r q i i n e n t s i s : H e l l o h i y o

Variables numéricas: @
En el shell TCSH usted puede declarar variables numéricas usando el
c o m a i d o @, en lugar del coinando set y puede realizar operaciones
aritméticas, relacionales y en modo de bits en dichas variables (usaido
los operadores apropiados).-A este respecto, el shell TCSH es sindar a
los lenguajes de prograniación. Las variables nuinéricas y de cadena son
dos tipos muy diferentes de objetos adniinistrados en forinas muy
distintas. Usted no puede usar el comando set en una variable nuineri-
ca. El comando @ consta de la palabra clave @, el noinbre de la varia-
ble, un operador de asignación y una expresión. El sig~iienteejemplo
declara la variable numérica num y le asigna el valor 10.

> 8 num -'10

Usted dispone de ii~ucliosotros operadores d e asignación, como

incrementos y operadores aritniéticos d e asignación. Son los misn~os
que se einpleaii en GAWK (que se estudia en el capítulo 5) y en el
lenguaje d e prograinación C. La expresión puedc scr aritmktica,
relaciona1 y a nivel de bits. Usted puede crear expresiones coinplejas
106 1 Fundamentos de programación en Linux
-- -

$#arglist Hello hi yo
Caritidad \ Lista d e todos los argumentos

arglist C echo
echo
"the number of arg~iments=$#argV"
"the list of argunients are=$argv[*IM

Las variables #argv y argvl*]

usando paréntesis. Los operandos en una expresión se deben separar del

operador por medio de espacios; por ejemplo, 10*5 no es una expre-
sión válida y se debe escribir con espacios, así: 10 * 5. Usted también
puede mar una variable numérica corno operando en una expresión.
En el siguiente ejemplo, la variable count se declara como nuinérica y
se usa en una expresión aritm6tica. Observe que count se evalúa con
un operador $, de modo que el valor de count, 3, se einplea en la
expresión.
]operación de asignación
y @ C O U9
~ ~ , "jcon - expresibn-aritmética ' , .
> * ($count +
-

(a nurn = 2 10)
> echo d n u m
26

Los operadores aritméticos del shell TCSH se presentan e n la

tabla 4-1.
En el siguiente ejemplo se usan dos operadores de asignación dife-
rentes para increnientar la variable num en 1 : el operador incren~ento
(++) y el operador aritmético de asignación de adición (+=):
 Capítulo 4: Programación del shell TCSH
--

4
1
T n ü i i = $num 'i
> @ nurn += 1
> @ \incremento 1

Operadores aritméticos Función/descripción

- Operador unario menos
+ Adición
- Sustracción
* Multiplicación
1 División
Yo Módulo
Operadores de asignación
-
- Asignación
+= Suma la expresión y luego asigna
- - Resta de la expresión y luego asigna
*-- Multiplica con la expresión y luego asigna
/= Divide entre la expresión y luego asigna
%= Efectúa módulo con la expresión y luego
asigna
lncrementa la variable
Decrementa la variable

Tabla 4-1 Operadores aritméticos y del TCSH

.
Conio se niuestra eii el siguiente ejemplo, usted puede asignar los
resultados de una expresión aritmética a una variable numérica:

Las operaciones relacionales dan coma resultado los valores

aritméticos de 1, si es verdadero, y de O, si es falso.

En el siguiente ejemplo, el valor de num será de 1 , ya que la

operación relaciona1 es verdadera.
108 ( Fundamentos de programación en Linux

-
m u n t = 3
> @ num = ( $ c o u n t < 10)
> echo $num
1
>
La declaración de arreglos de elementos numéricos se complica por
el hecho de que usted necesita usar el coinando set para declarar
primero el arreglo. Después, puede usar el coniando @ para asignar
valores numéricos a los elementos del arreglo. En el siguiente ejeinplo,
primero se declara el arreglo degrees y después se le asignan valores.
Aunque estos valores pueden ser cualquier núinero, no se consideran
valores nrrrridricos.

> se€ degrees = ( O 45 0 1

Cuando ~istedusa el comando @ para asignar un valor numérico a

un elenlento, entonces el elenlento es un valor nuniérico. Después hace
referencia al eleinento con un núinero entre paréntesis cuadrados. En el
siguiente eje~nplo,al primer elemento se le asigna el valor riun~éricod e
100:

,> eechoaegreesll
$degrees[ll
J P 1017

1o0
>

Variables de entorno: setenv

El shell TCSH tiene dos tipos d e variables: loccilec y d e entortzo. Una
variable es local para el shell en donde se declaró; una variable de
entorno opera como una variable con alcance global. Cualesquiera de
los subshells reconoce la variable de entorno, pero ningún shell padre la
reconoce. Una variable de entorno se define con el comando setenv.
Usted asigna un valor a una variable del entorno usando el comando
setenv, el nombre de la variable y el valor asignado. N o hay operador
 C a p í t u l o 4: P r o g r a m a c i ó n d e l shell TCSH

d e asigriacióri. E n el siguiente ejemplo, a la variable d e e n t o r n o

greeting se le asigna el valor "hello".

Cada vez q u e se llama u11 script del shell, éste genera su propio
uhell. Si cl w - i p t 5e ejecuta deide otro ucript del shell, tendrá sil propio
shell, ieparado del shell del primer icript. Ahora hay d o i shelli: el shell
padre, q u e pertencce al priiner script, y 1111 subshell, q u e es el nuevo
shell q u e se genera cuando sc ejecutó el segundo script.

. , --- - . . --.
; P.

Cada shell tiene su propio conjunto de variables. El subshell no

puede hacer referencia a variables locales en el shell padre,
pero puede hacer referencia a variables de entorno. Cualquier
subshell puede hacer referencia a cualquier variable de entorno
que se declare en el shell padre.

En el iiguiente geinplo, la variable myfile se define c o m o una

variablc d e e n t o r n o en el icript dispfilc. Obuerve el uuo del comando
setenv en lugar d e set. Ahora ue puede hacer referencia a la variable
myfile e n cualquiera d c 165 iubihells, c o m o cl q u e i e generó cuando
se ejecutó prrn$l~. El u s u x i o ya ha creado u n archivo Ilai-i-iadoLisf c o n
lai entrada$ pantdla, m o d e m y papel.
El script d i c ~ f i l ces e1 siguiente:

..ff
setenv myfile "List"
e c h o "Displaying Bmyfile"
c a t - n Bmyfile
printfile

El script prirlffile es el siguiente:

~ - - . - - -- - - - - - .
' -#
echo "Printing Bmyfile"
Ipr Bmyfile &
 rogramación
-- -
en Linux

En el siguiente ejemplo se muestra la ejecución del script d i s ~ f i l e :

--mspírre
Displaying L i s t
1 screen
2 modem
3 paper
Printing List

C o m o se muestra en la figura 4-4, cualido se ejecuta piirr!fi/c, se

puede tener acceso directo a la variable myfile definida en el shell del
script di.spfile.

Prueba de repaso
;Cómo asigna usted valores a una variable?'
¿Cómo asigna usted valores a una variable n ~ m é r i c a ? ~
¿Qué arreglo especial se usa para mantener los argumentos
de un programa del shell?'

myfile es tina vririnble de rntoriio que

rrcoiioce ciialqiiiera de los subsliells y n
la que se pucde Iiacei- i-efereiicia en ellos
/

scteiiv iiiyfilc "List"

dispfile
echo "1)isplayiiig Siiiyfile"
cnt -11 Siiiyfile
priiitfile

r -1
Figura
:- 4-4 Variable de entorno del shell TCSH referenciada desde un subshell

1 Utilice el comando ser y el operador asignación.

2 Utilice el operador @? y el operador asignación.
3 El arreglo JrLv.
 Capítulo 4: Progra
* a, W*"S#

En la tabla 4-2 se presentan los comandos que se usan más coniún-

mente en el shell como argumentos de la línea de comandos.

Comandos del shell TCSH Función/Descripción

echo Presenta valores en la pantalla.
echo-n Elimina el retorno de carro al final de la Iínea.
eval Ejecuta la Iínea d e comandos.
exec Ejecuta u n comando en el lugar del proceso
corriente. N o genera u n nuevo subshell, sino
que usa el que se encuentra en el momento.
exit Sale del shell actual.
setenv var Hace que una variable esté disponible para que
sirva de referencia a cada nuevo subshell (Ila-
mado por referencia).
printenv Presenta en pantalla los valores de las variables
de entorno.
set Asigna nuevos valores a las variables. Usado
solo, lista todas las variables definidas.
@ Asigna expresiones numéricas.
shift Desplaza cada argumento de la Iínea de co-
mandos a la izquierda, de modo que el número
que se utiliza para referencia disminuye en 1
con respecto al anterior; por ejemplo, el argu-
.
mento $3 se referenciaría por $2 y así sucesiva-
mente; $1 se pierde.
unset Quita la definición d e una variable.
unsetenv Quita la definición de una variable de entorno.
Argumentos de la Iínea
de comandos Descripción
$argv[O] $0 Nombre del comando Linux.
$argv[n] $ n El argumento enésimo de la Iínea de comandos
comienza desde 1, $1 hasta $n.
Usted puede usar set para cambiarlos.
Todos los argumentos de la Iínea de comandos
comienzan desde 1. Usted puede usar set para
cambiarlos.
El conteo de los argumentos de la Iínea de co-
mandos.
112 1 Fundamentos de programación en Linux
---

Estructuras de control
y operadores: while, if,
switch y foreach
Coino en otros shells, el shell T C S H tiene un conjunto de estructuras
de control que le periniten controlar la ejecución de comandos en un
script. Usted pciede usar las estructuras de repetición y las estructuras
d e control condicional para repetir coniandos Lirius o tomar decisio-
nes sobre cuáles coniandos quiere ejec~itar.Las estructuras de control
while e if son niás estructuras de control de propósito general que
realizan repeticiones y toniari decisiones usando diferentes pruebas. Las
estructuras de control switch y foreach son operaciones más especia-
lizadas. La estructura switch es una forma restringida de la condición
if que verifica si cin valor es igual a uno de los valores d e un conjunto
posible d e valores. La estructura foreach es un tipo limitado d e bucle
que fiinciona a través de listas d e valores, asignando iin nuevo valor a
una variable con cada repetición.

El shell TCSH difiere de otros shells en el sentido de que sus estruc-

turas de control seajustan más al formato de un lenguaje de
programación. La condición test para una estructura de control
del shell TCSH es una expresión que evalúa la condición de verda-
dero o falso, y no a un comando ~inux.Una diferencia importante
entre las estructuras de control del shell BASH y del shell TCSH es
m....
yur l-- A - -.-+A .',l&;-- -- x:
uc c>Lc u i ~ i i i i u
la> C ~ L Iu c ~ u i c n I iu
.-.,.-A-.. --A;-:-:-
pucuci i I cuii iyii
A
u
+--..A-
~ i ai>ie-
i

rir a su salida. Básicamente, son estructuras de control que contro-

lan la ejecución de los comandos.

El bucle while y las condiciones if funcionan d e una manera iiiuy

similar a las d e los lenguajes de programación. El bucle continúa liasta
que la expresión d e prueba regresa un valor falso. La condición if
ejecuta sus comandos si su expresión de pr~iebaregresa un valor verda-
dero. La expresión de prueba es una expresión del shell T C S H y los
operadores que se utilizan en ella son similares a los que se encuentran
eii el lenguaje de programación C. El sheH usa una amplia gania de
 Capítulo 4: Progr

operadores de asignación, aritméticos, relacionales y a nivel de bits,

muchos de los cuales no están disponibles en los shells BASH o
PDKSH. Como expresiones de progranlas en C, la expresión del shell
TCSH es verdadera si el resultado es un valor diferente a cero; es falsa
si el resultado es O.
La estructura switch funciona conlo una versión restringida de la
estructura if. La estructura switch compara una cadena con un con-
junto de patrones posible; si se determina que hay concordancia, se
ejecutan las operaciones asociadas con ese patrón. La estructura switch
es útil para implementar menús en donde un usuario hace una elec-
ción entre varias opciones posibles.
La estructura foreach funciona a través de una lista de valores,
asignando cada valor a una variable específica. N o hay prueba. La lista
de valores se puede generar mediante un patrón y caracteres especiales
del shell. Por ejemplo, el asterisco (*) generará una lista con los nom-
bres de sus archivos. Una lista de valores también se puede especificar a
través de un conjunto de palabras. Cada palabra es, entonces, un valor
que se asigna a la variable for. El bucle continuará hasta que se hayan
asignado todos los valores.

Expresiones de prueba
Las estructuras de control iTy while utilizan conlo prueba una cxprc-
sión. Una prueba con resultado verdadero es cualquier expresión que
da como resultado un valor diferente de cero. Una prueba con resulta-
do falso es cualquier expresión que da como resultado un valor de O.
En el shell TCSH, las expresiones relacionales y de igualdad se pueden
usar fácilmente conio expresiones de prueba, porque el resultado es 1 si
son verdaderas y O, si son falsas. Usted puede usar varios operadores en
una expresión, como se muestra en la tabla 4-3. La expresión de prueba
también puede ser una conlparación aritmética o de una cadena, pero
las cadenas se pueden comparar solaniente por igualdad o desigualdad.
A diferencia de los shells BASH y PDKSH, usted debe incluir entre
paréntesis las expresiones de prueba del shell TCSH, if y while. El
siguiente ejemplo muestra una sencilla expresión de prueba para
coniprobar si dos cadenas son iguales:
-( Fundamentos de programación
114 - en Linux
--

1Expresi6nde co~n~araciónl
' ii ( ~ g r e e
.. --
t
.--
i n g 1
' deigualdad
s PI~I

echo Informal Greeting

endi f

E l shell TCSH tiene un conjunto de operadores por separado para

poner a prueba las cadenas frente a otras, o frente a expresiones regulares:
Los operndorcs = = y ! = priieban la igualdad y la desigiialciad de las
cadeiias.
Los operadores =- y !- ponen n pruebn iiiia c-adei~afi-elite a iina
expresión regular y dctei-iiiin~nsi la coiicordancia con un patrón
tiene éxito o no.

Comparaciones de cadenas Función/DescripciÓn

Cadenas iguales
Cadenas desiguales
Compara la cadena con un patrón para
probar si es igual; el patrón puede ser
cualquier expresión regular
Compara la cadena con un patrón para
probar si no es igual; el patrón puede ser
cualquier expresión regular
Operaciones lógicas '
&& AND lógico
Il OR Iógico
! NOT lógico
Pruebas de archivo
El archivo existe
El archivo se puede leer
En el archivo se puede escribir, se puede
modificar
El archivo es ejecutable
El nombre del archivo es un nombre de
directorio
El archivo es un archivo ordinario
El archivo es propiedad del usuario
El archivo está vacío

Operadores de expresiones de prueba

 Capítulo 4: Programación del shell TCSH

Operadores relacionales
> Mayor que
< Menor que
>= Mayor que o igual a
<= Menor que o igual a
!= No es igual
--
- - Igual

Operadores de expresiones de prueba (cotttinrración)

La expresión regular puede contener cualquiera de los caracteres

especiales del shell. Eii el siguiente cjeniplo, cualquier valor de d u d o
que coinieiice con una Ii en mayúscul~o ininíi~culatendrá coiicordan-
cia con 1,i espresióii regular, [Hhl*:

if i $gteeting =
;
4
~Hh3*'P)thP;irr
e c h o Inforinal Greeting
ncordancia con la
expresión regular
--
--
cndi f

Como en el shell BASH, .el shell TCSH también tiene varios opera-
dores especiales que ponen a prueba el estado de los archivos.
Muchos de estos operadores son iguales en ambos shells.
- ----- i

En el siguiente ejeniplo, el coinaiido if coiiiprueba si el archivo

niydnln se puede leer.

-- -

i c i i o Informal L r i e t i ng
endi f

Condiciones del shell TCSH:

if-then, if-then-else y switch
El shell T C S H tiene un conjunto de estructuras de control condicioiial
con las cuales usted puede tomar decisiones acerca de cuáles comandos
 gramación en Linux

Linux va a ejecutar. Muchas d e esas estructuras son similares a las que

se encuentran en el shell BASH; sin embargo, presentan algunas dife-
rencias relevantes. La estructura if del shell T C S H termina con la
palabra clave endij La estructura switch utiliza la palabra clave case de
manera diferente a como se usa e n el shell BASH, pues termina con la
palabra clave endsw y usa breaksw en lugar de los dos signos de punto y
coma que se emplean en el shell BASH. Adeniás, el T C S H tiene dos
estructuras if d e control: una versión simple que ejecuta sólo u n co-
mando y una más con~plejaque puede ejecutar varios comandos, lo
mismo que comandos alternativos. La versión sencilla de if consta d e la
palabra clave ifseguida por una prueba y u n comando sencillo Linux.
La versión con~plejatermina con la palabra clave endij Las estructuras
de control condicional del shell T C S H se presentan en la tabla 4-4.

Estructuras de control Descripción

if ( expresión ) then Si la expresión es verdadera, se ejecutan los
comandos comandos que siguen. Usted puede especificar
endif más de u n comando Linux.

if ( expresión ) then Si la expresión es verdadera, se ejecuta el comando

comando después de then. Si la expresión es falsa, se
else
comando . ejecuta el comando siguiente, else.

endif
switch(cadena) Le permite elegir entre varios comandos alter-
case patrón: nativos.
comando
breaksw
default:
comando
endsw ,.
 Capítulo 4: Programación del shell TCSH
-- -

La estructura if-then
La estructura if-then pone una condición sobre varios comandos
Linux. Esa condicióil es una expresión. Si la expresión da como resul-
tado un valor diferente de O, la expresión es verdadera y se ejecutan los
comai~dosque se encuentran dentro de la estructura if. Si el resultado
es 1111 valor de O, la expresión es hlsa y los con~andosdentro de la
estructura if no se ejecutan.
La estructura if-then comienza con la palabra clave [f; a la qiie le
sigue una expresióil entre paréntesis. La palabra clave t1w1 sigue en la
expresión. Usted puede especificar cualquier cantidad d e con~andos
Liniix en las líneas siguientes. La palabra clave crid!f termina el coman-
do if. Observe que, mientras en el shell BASH la palabra clave ~ h e n
ocupa una línea, en el shell TCSH tlzm está en la misma línea d e la
expresión de prueba. La sintaxis de la estructura if-then es la siguiente:

if ( expresión ) then
comandos
endif

El script ijls que se presenta a continuación le permite presentar

archivos por tamaño. Si usted ingresa una S en el proinpt, se muestran
en lista todos los archivos del directorio actiial, seguidos por el número
de bloques que ocupan. Siingresa un carácter diferente en el proinpt,
la prueba de if falla y el script no f~inciona.

P l ease e n t e r o p t i on :
in = $<

El siguiente es u11 ejemplo de la ejecución del script ifls:

118 1 Fundamentos de programación en Linux

> ifls
Please e n t e r o p t i o n : S
L i s t i n g f i l e s by s i z e
total 2
1 monday 2 t o d a y
>
C o n frecuencia, usted necesita elegir entre doi alteriiativas, de
acuerdo a si la expresión ei verdadera o no. La palabra clave clsc permi-
tc que una estructura if elija entre dos comaiidos alternativoi. Si la
expreiión es verdadera, se ejecutan los coimiidos que siguen ininedia-
taniente después de la expresión. Si la expresión es falsa, se ejecutan loi
coinaiidoi que siguen a la palabra clave elsc. La sintaxis para el coniando
if-else es la siguiente:

if ( expresión ) then
comandos
else
comandos
endif

En el siguiente ejemplo, el script clsds ejecuta el coniando 1s para

listar los archivos con dos posibles opciones: por tamaño o con toda la
inforniacióii del archhio. Si el usuario ingresa una S, los archivos se listan
por taiiialio; en caso contrario, aparece toda la inforinaciin de los mis-
mos. Observe cónio difiere la sintaxis de la versión del shell BASH del
script rlsels, descrita en el capítulo 3.

B
echo E n t e r S t o l i s t f i l e s i z e s .
echo o t h e r w i s e a l 1 f i l e i n f o r m a t i o n i s l i s t e d .
echo ,-n " P l e a s e e n t e r o p t i o n : "
s e t o p t i o n = $<

i f ($option == " S " ) then

1s - 1
endi f
echo Goodbye
 Capítulo 4: Programación del shell TCSH

El siguiente es u n ejemplo de la ejecución del script clscls:

Enter S t o l i s t f i l e s i z e s ,
o t h e r w i s e a l 1 f i l e i n f o r m a t i o n iS 1 i s t e d .
Please e n t e r o p t i o n : S
total 2
1 monday 2 t o d a y
Goodbye
>

. -
usted ingresó. Usar $#argv en una operación de pniel
si el usuario ingresó el núniero correcto de argumento
Si no fue así, puede ser neces~rioque termine el sci
,l t. *,.'.*. m , I I .. I I
120 1 Fundamentos de programación en Linux

El siguiente es u11 ejemplo de la ejecución del script $q:

> ifarg
I n v a l i d number o f a r g u m i n t c
E n t e r o n l y cine a r q i i i r i ~ n t

Pregunta: ¿Puedo anidar las estructuras if para crear decisiones

complejas?

Respuesta: Para anidar operaciones if-then, sii-iipleinente conecte una

estructura i f n una estructura else, en lugar de un bloque. I l e esta manera,
usted elige entre varias altern,itivas. La primera se especifica con la estructura
if, seguida por otras dos alternativas, cada itna especificada por su propio
componente else-if La alternativa para la última estructura i f se especifica
con un else. Si la prueba p m IJ primera estructura if f d a , el control pasar3 a
la estructura i f que va despué\, seguida por el otro else, y la prueba se ejccut.i-
rá. Si ésta fdla, el control pasa a la siguiente estructura i f p ~ r asu verificación.
Este p r o w w continúa hasta que rl resultado de la prueba es verdadero. Des-
pués que if ha ejecutado sus coni,indos, el control pasa de la estructura i f al
siguiente comando después de la palabra clave ctr@ En el ejeniplo que sigue se
ilustra el uso de las operaciones else-if anidadas.

i f (Ioptiori == "S") theii

1s -5
-
e l > ? i f ( 9 c i p t i o n == " 1 " ) tReri
1 s -1
e l se i f ( $ o p t i o n == " d " ) then
1s - F
~l s e
echo "Invalid Option"
endi f

La estructura switch
La estructura switch elige entre varios con-iaildos alternativos posiblcs
y e i iiinilar a la eitructiira case del shell BASH e11 el ientido d c q u e se
hace mediante coi~ip~raciói-i d e una cadcxa con varioi patrones posi-
bles. Cada u n o d e estos patrones está '-isociado con un coiijiii~tod e
 Capítulo 4: Programaci

coniandos. Si se establece que hay concordancia, se ejecutan los co-

mandos asociados.
La estructura switch coniienza con la palabra clave switch seguida
por una cadena de prueba dentro de paréntesis. A nienudo, la cadena se
deriva de la evaluación de una variable. Después sigue un conjunto de
patrones, cada uno precedido por la palabra clave case y terminado con
un signo de dos puntos. Los coniandos asociados con esta opción se
listan después de los dos puntos. Los comandos terminan con la palabra
clave breaksw. Después de listar todos los patrones, la palabra clave endsw
terniina la estructura switch, cuya sintaxis es la siguiente:

switch (prueba de cadena)

case patrón:
comandos
breaksw
case patrón:
comandos
breaksw
default:
comandos
breaksw
endsw
.
Nota
Todos los patrones se compararán frente a la cadena de prueba
hasta que se encuentre la concordancia. Si no es posible, la opción
predeterminada se ejecuta. Dicha opción está representada con la
palabra clave default. El predeterminado es opcional. Sin embargo,
resulta útil notificar al usuario de las cadenas de prueba que no
concuerden.

Proyecto 4-1: Menús con switch

Una estructura switch se utiliza con frecuencia para implementar
menús. En el programa Ischoice, del siguiente ejemplo, se pide al usuario
ingresar una opción para listar archivos en diferentes formas. Observe la
1 s c h o i ce opción predeterminada que advierte de la entrada no válida. El pro-
grama comienza por presentar en pantalla un menú de opciones e
 gramación
*e-, m
en Linux

indicar al usuario que seleccione uno. Entonces, la estructura switch

detecta la entrada hecha por el usuario y ejecuta el comando correspon-
diente.

Paso a paso
1. Cree u n menú de tres opciones para listar archivos por tamaño, por
información completa del archivo o sólo por archivos C (los que
terminan con extensiones .c). Utilice tres comandos echo sencillos.
2. Pida al usuario que ingrese u n opción, la cual lee después la variable
choice usando el comando set y el operador $<.
3. Utilice una estructura switch para determinar la opción que el usua-
rio hizo. Evalúe la variable choice en la expresión switch, $choice, y
use su valor para verificar si hay concordancia con el valor del patrón
en las entradas case.
4. Configure tres entradas case. La primera es para el patrón S, el cual, si
tiene concordancia, ejecutará el comando Is con la opción -S,
listando los nombres d e los archivos por tamaño. La entrada termina
con el comando breaksw.
5. Utilice la segunda entrada case para mantener el patrón 1, el cual, si
concuerda, listará los archivos con toda la información d e los mis-
mos, incluyendo la fecha del último cambio y los permisos de acceso.
La entrada t e r r n i n a ~ o nel comando breaksw.
6. Utilice la tercera entrada de case para mantener el patrón *.c. Si hay
concordancia aquí, se ejecutará el comando Is*c, el cual presentará
en pantalla todos los nombres de archivo que terminen con los
signos .c (el * es u n carácter especial que completa cualquier patrón).
La entrada termina con el comando breaksw.
7. Para la entrada predeterminada, presente en pantalla u n mensaje de
error "lnvalid Option". También terminará con el comando breaksw.
8. Termine la estructura switch con el comando endsw.
El siguiente es u n ejemplo del script Ischoice:
 Capitulo 4: Programación del shell TCSH
-
1 123
B -

echo s . L i s t S i z e s
echo 1 . L i s t A l 1 F i l e I n f o r m a t i o n
echo c. L i s t C F i l e s

echo - n " P l e a s e e n t e r c h o i c e : "

s e t c h o i c e = $<

switch ($choice)
case S :
1s - S
breaksw
case 1 :
1s - 1
b r e a ksw
case c :
1s * . C
breaksw
defaul t:
echo I n v a l i d O p t i o n
breaksw
endsw

El siguiente es un ejemplo de la ejecución del script Ischoice:

- .
5

s . L i s t Sizes
1. L i s t Al1 F i l e Information
c. L i s t C Files
Please e n t e r choice: c
i o . c 1 i b . c main.c

Usted puede especificar más de un valor en un patrón. En el ejemplo

anterior, solamente se permitieron las versiones en minúsculas del
carácter. Una C mayúscula se considerará como entrada no válida. Usted
puede especificar más de una opción para un conjunto de comandos
usando más de una estructura case sin un comando breaksw. También
puede usar los paréntesis cuadrados como caracteres especiales del
shell. Un patrón puede utilizar cualesquiera de los caracteres especiales
del shell, del mismo modo que se puede hacer con una estructura case
del shell BASH. Los paréntesis cuadrados listan un conjunto de posibles
caracteres válidos. El patrón [Cc] concordará con la c minúscula o con la
C mayúscula.
124 1 Fundamentos de programación en Linux
- --=

En el siguiente ejemplo, lschoice se ha reescrito como lulschoice para

incluir opciones del comando para letras minúsculas y mayúsculas. La c
para minúsculas o mayúsculas se escribe como dos entradas case conse-
cutivas sin que intervenga ningún comando breaksw. Sin embargo, los
patrones de mayúsculas y minúsculas de la s están escritos entre parén-
tesis cuadrados en un patrón [SS].

7 --
echo s . L i s t S i z e s
e c h o 1. L i s t A l 1 F i l e I n f o r m a t i o n
echo c. L i s t C F i l e s

echo -n "Please e n t e r c h o i c e : "

s e t c h o i c e = $<

switch ($choice)
case [SS]:
1s - S
b r e a ksw
case L:
c a s e 1:
1s -1
breaksw
case C:
case c :
1s-k.c
b r e a ksw
defaul t
echo I n v a l i d O p t i o n
b r e a ksw
endsw

-
El siguiente es un ejemplo de la ejecución del script lulschoice:

'">"1ulschoíce clcc.errm
s. L i s t S i z e s
1. L i s t Al1 F i l e Information
c. L i s t C F i l e s
Please e n t e r choice: C
main-c 1ib.c fi1e.c
 Capítulo 4: Progra
3

Estructuras de bucle: while,

foreach y repeat
El shell TCSH tiene un conjunto de estructuras de control de bucle
que le permiten repetir los conlandos Linux: while, foreach y repeat.
Las estructuras de control de bucle del shell TCSH se presentan en la
tabla 4-5.
La estructura while opera en una forma similar a las estructuras
correspondientes que se encuentran en lenguajes de progran~ación.Al
igual que la estructura if del shell TCSH, la estructura while com-
prueba el resultado de una expresión. La estructura foreach del shell
TCSH, como las estructuras f o r y for-in del shell BASH no realizan
ninguna prueba. Simplemente avanza a través de una lista de valores,
asignándole cada valor a una variable especificada. En este sentido, la
estructura foreach es muy diferente de las estructuras correspondientes
que se encuentran en los lenguajes de progran~ación.La estructura
repeat es una estructura de control simple y limitada que repite deter-
minado comando un número específico de veces. N o tiene ninguna
expresión de prueba y no puede repetir más de un comando.

Estructuras de control
de repetición
.
Descripción

while(expresión) Ejecuta comandos en tanto la expresión

comando sea verdadera.
end
foreach variable (arg-list) Repite el bucle para tantos argumentos como
comando existan en la lista de argumentos. Cada vez
end que se cumple el bucle, se asigna a la variable el
siguiente argumento de la lista; opera como
for-in en el shell BASH.
repeat num comando Repite un comando el número de veces especficado.
continue Salta a la siguiente repetición, pasando por alto
el resto de los comandos del bucle.
break Rompe u n bucle.
126 1 Fundamentos de programación
-- -- --
en Linux

La estructura while
El biicle while repite coinaidos; coinieilza con la palabra clave ir~lzilcy
esti seguida por una espresióil entre parkiitesis.
La palabra clave c i d especifica la teriiiiiiacióii del biicle. La sintaxis
del biicle while es la sig~iiei~te:

whi le ( expressión )
comands
end

La estructiira while se puede coinbiiiar con facilidad con una

estructura switch para dirigir uii ineilú. E11 el script Iscl~oic-cw,observe
que el menú contiene una opción quit qiie establecerá el valor de
again coino igual a no y detendrá el biicle.
- --
'H
s e t a g a i n=yes
-
w h i l e ( $ a y a i n == yes)-buclep principal
echo "1. L i s t S i z e s "
echo "2. L i s t A l 1 F i l e I n f o r r n a t i o n "
echo " 3 . L i s t C F i l e s "
echo " 4 . Q u i t "
echo - n " P l e a s e p n t e r c h o i c e : "
s e t c h o i c e = $<
Operación de switch para detec-
switch ($choice)*
Itar la selección del usuario 1

1s - S
b r e a lisi~r
c a s e 2:
1s -1
b r e a ksw
ca.se 3 :
1s *.c
b r e a ksw
c a s e 4:
s e t a g a i n = no-Hará que la prueba'
echo Goodbye del bucle
- - falle
- t -
breaksw
clefaul t
 Capítulo 4: Programación del shell TCSH
- .---

El siguiente es un ejemplo de la ejecución del script Ischoicciv:

1. L i s t S i z e s
2. L i s t Al1 F i l e Information
3. L i s t C F i l e s
4. Q u i t
Please e n t e r choice: 3
main.c 1ib.c fi1e.c
1- .. l i. s- -t -Y . -
~ ~- P s
2 . L i s t A11 F i l e I n f o r m a t i o n
3. L i s t C F i l e s
4. Q u i t
P l e a s e e n t e r cho i c e : 4
Good - b y e
>

La estructura foreach
La estructura foreach se diselió para hacer referencia en foriila
secuencia1 a una lista d e valores. Es siiiiilar a la estructura for-in del
shell UASH y cuenta con dos operandos: una variable y una lista de
valores entre parkntesis. Cada valor de la lista se a u g m a la variable en
la estructura foreach.Taiito la estructura w h i l e coino la estructura
foreach son buclei. Cada vez que pasa el bucle, a la variable se le
asigna el siguiente valor de la lista. Cuando se llega al filial de ésta, el
bucle se detienc. Loi cuerpos de los bucles w h i l e y f o r e a c h terminan
con la palabra clave c i d . La siiitasis de f o r e a c h es la siguiente:

foreach variable ( lista de valores )

comandos
end
 en Linux
-..--- -.

El bucle foreach es útil para administrar archivos. Eii esta estructura,

iisted puede emplear caracteres especiales del shell en un patrón para
generar una lista de noiiibi-es de archivo para usar e11 su lista de valores.
Este listado de nombres de archivos se convierte entonces en la lista
referenciada por la estructura foreach. U n asterisco geriera un listado de
todos los arcliivos y directorios. El patrón *.c lista los archivos con la
esterisión .c, que, por lo general, son archivos de código fuente en C.
En el siguiente ejemplo se hace una copia de seguridad de cada
archivo y se pone en un directorio Ilan.iado sniircebak. El patrón *.c
geriera un listado de los nonibres de archivo en donde puede operar la
estructura foreach.

r - -
&Asigna . . ..
el siguiente archivo
rariable
-reptiticicin~
-
. - - - -

f o r e a c h b a c k f i l e ( * . c )f Genera una lista de

todos los archivos que !
cp g b a c k f i l e s o u r c e b a k / $ b a c k f i l e
.-.*he @ h - - l , L < l .-.
t'LIIU PUdLKI I I
1 terminan
-
-en .c
-
I
end

El siguiente es un ejemplo de la ejecución del script cbt~ckrry:

La estructura foreach, sin una lista específica de valores, toma coino

lista los argumentos de la línea de comandos. Los argunieiitos especifi-
cados en la línea de conlandos, cuando se llania el archivo del sliell, se
convierten cii uri listado de valores referenciados por la estructura
foreach. La variable que se usa e11 dicha estructiira se establece
automáticaiiieiite para cada valor del a r p r n e n t o en la secuencia. La
priiiiera vez que pasa el bucle, la variable se configura para el valor del
primer argunlento. La segunda vez, se configura para el valor del
segundo argumento, y así siicesivaiiiente.
Usted puede hacer referencia explícita al argumento de la línea de
coiliandos usaiido la variable especial argv[*]. En el siguiente ejemplo,
una lista de los archivos del progranla C se ingresa en la línea de comandos
 Capitulo 4: Programación del shell TCSH
- -
1 129
cuando se Ilaina el archivo del sliell cbncki~poq.En el bucle foreach,
a r e [ * ] hace referencia a todos los argumentos en la línea de coman-
dos. Cada arguiiiento se asignará en forma consecutiva a la vari~ble
backfile e n el bucle foreach. La primera vez que paia el bucle,
abackfile es el mismo $argv[l]. La segunda vez, $backfile es igual a
$argv[2]. La variable argnum se iiia para hacer referencia a cada
arguniento.Tanto el arguniento coiiio el valor de backfile se preientnn
e n pantalla para demostrar que son los niisiiios.

@ argnum = 1
f o r e a c h b a c k f i l e ($argv[*l)
cp Bbackfile sourcebak/$backfile
echo "$backfi l e $argv[$argnuml"
@ argnum = $argnum + 1
end

El siguiente es ~ i r ejemplo
i de la ejecución del script cbnckrq~ay:
e- - -
>
y

cbackuparg main.c 1ib.c io.c

main.c main.c
1ib.c 1ib.c
i 0 . c i0.c
1

Prueba de repaso
¿Qué estructura se podría usar para reemplazar una estruc-
tura switch?'

¿Se pueden usar operaciones de concordancia de archivos

como *, 1 j o ? en las prueba^?^

Si la variable que se emplea en una prueba de bucle nunca

se cambia dentro de ese bucle, jse detendrá el programa en
algún m ~ m e n t o ? ~

4 Estructriras if anidadas con rlir.

5 Sí.
6 N o ; usted tiene un bucle infinito.
130 1 Fundamentos de programación
--.- - . -
en Linux

La estructura repeat
Esta es una estructura que siii~pleriieriterepite deteriiiinado coniando
un núiiiero específico d e veces. Sólo puede repetir un coniando. La
estructura repeat coiiiienza con la palabra clave rqwot, una cifi-a para
indicar el riúinero de repeticiones y el comando que se ha de repetir.
Esta ei la sintaxis:
> repeat num comando
En este ejemplo, el coniando echo se repite tres veces.

T7 ZlFEeTo
_-II

=eat 'a
g
-
he110 a g a i n
he1 l o a g a i n
he1 l o a g a i n

El comando continue
Conio en el ilicll BASH, el coiiiando continue del shell T C S H se usa
con bucles para no tomar en cucnta los enunciados restantes e n el
cuerpo de u n bucle y continuar con la siguiente repetición.

El uso del comando-continue puede complicar los estilos de pro-

gramación. Se debe usar con precaución.
-E
7
En el siguiente geinplo, el script looyohí da conio resultado sólo
i-epeticionei impares del bucle mediante cl uio dcl coinando continue,
para superar al c o n i u d o echo en las repeticiones parei. Literalmente, el
coiiiaiido continue transfiere el coi~trola la palabra clave oid al final del
bucle, la cual, a su turno. continúa con la siguiente repetición del bucle.

Q num=0
w h i l e ($num < 6 )
0 num = $num + 1
i f ( (8num % 2 ) == O ) c o n t i n u e
echo "8num i t e r a t i o n o f l o o p "
end
echo Goodbye
 Capítulo 4: Programación d e l shell TCSH
-.

El siguiente es u n ejeniplo de la ejecución del script ioopodd:

- -. -
? loopodd
1 it e r a t i o n o f l o o p
3 i t e r a t i o n o f loop
5 i t e r a t i o n o f loop
Goodbye

Bucles infinitos y el comando break

Usted puede inipleinentar un bucle infinito en el shell T C S H u u ~ n d o
la constante nunii.rica 1 c o m o la expresión d e prueba en una eutructu-
ra while. Si usted uua un bucle infinito, necesitará contar con un
mecanitmo para detenerlo. El coiiiando break, cuando tc utiliza con
cualquier bucle, trantferirá el control f~ierade étte.

1Nota - -

Con frecuencia, un bucle infinito contendrá un comando break

condicionado que, cuando se ejecuta, termina el bucle.

En el siguiente script loopirrfirritc, el usuario coiifigura un bucle

infinito que preuenta el n ú ~ ~ e der o la repetición. C u ~ n d onum eu
mayor q u e 3, se ejecuta el coiiiando break, ronipiendo el bucle.

while ( 1
i f ($num > 3 ) b r e a k
echo "$num i t e r a t i o n o f l o o p "
@ num ,= $num + 1
end
echo Goodbye

El siguiente es u n ejemplo de la ejecución del script loopii!finitc:

132 1 Fundamentos de programación
- en Linux

1 i t e i a t i o n o f loop
2 i t e r a t i o n o f loop
sn o f l o o p

Pregunta: ;Se puede usar el comando break para detener el bucle

foreach?

Respuesta: El coiliando break es la única nianera que usted tiene para

detener un bucle foreach antes de que llegue al final de la lista. En el script
fimiicsAM que sigue, el usuario quiere que el resultado sea solainente los
nonibres de los archivos que comienzan con la primera mitad del alfabeto: los
nombres que c~niieiizancon las letras desde n hasta m. La estructura foreach
dará coiim result,ido todos los noiiibres de archivo de su lista. Para detenerla,
utilice el cornaiido break.

f o r e a c h f i lename ( * )
i f ( $filename =- Cn-zl* ) break
echo $ fi 1 mame
e nd

echo "Goodbye"

El siguiente es un ejeinplo de la ejecución del script fnnrizcsAM

> 1s
1 i b . c mait1.c resume terrnpaper
> fnamesAM
1ib.c
main.c
Goodbye
 Capítulo 4: Program
"'*d " 2

Proyecto 4-2: índices con el shell TCSH

El programa myindext es una versión en el shell TCSH del programa
myindex en BASH, descrito en el capítulo 3. Realiza las mismas funciones,
generando automáticamente una página Web que puede funcionar
myi ndext como índice mediante la selección de otras páginas Web. Se supone que
hay subdirectorios que tienen páginas Web. Muchas de las operaciones
que se presentan en esta sección son iguales a las del programa
. - del shell
BASH. ¡os comandos grep, echo, basename, al igual que cut y sed que
se usan en myindex, se mantienen sin cambiar en myindext.
Las estructuras de repetición, if, lo mismo que las asignaciones, son
muy diferentes en el programa de este capítulo. Sin embargo, hay dos
bucles foreach anidados en myindext, muy similares al bucle for en el
programa BASH. Las operaciones de asignación usan el comando set
con el signo =. Las condiciones if usan paréntesis y los operadores
estándar al estilo de C funcionan con ellas. La palabra clave then se
ubica en la misma línea de la prueba del shell BASH y la condición if
termina en la palabra clave endif.

Paso a paso
1. Detecte cualquier directorio en el directorio actual y después verifi-
que si contienen páginas Web (cualquier archivo con extensiones
.html o .htrn). Los nombres de estos archivos se ponen en cadenas
que comprenden comandos HTML, href para seleccionar y presentar
en pantalla los archivos. Las referencias HTML se organizan en una
lista con las etiquetas (ró?ulos) <ul> y </ul>, precedidos por un
rótulo <lb. Los nombres de directorio se utilizan como encabezados,
con la etiqueta <hl>.
2. Utilice el comando foreach con un para comparar todos los archi-
vos y nombres de directorio, ubicándolos en la variable $i.
3. Si encuentra un directorio, busque cualquier archivo HTML en un
bucle interno foreach. Ponga los archivos HTML en la variable j.
4. Busque el archivo HTML para un título y úselo como el texto de
enlace en el índice. Utilice grep para buscar la presencia de un
patrón <TITLE>. S i encuentra alguno, regréselo a la variable tline. Si
no encuentra el patrón, regrese a 1 a la variable de estado $?
5. Revise la variable de estado $? para comprobar si grep tuvo éxito. En
caso afirmativo, use un conjunto de comandos sed para conectar las
etiquetas precedente y final <TITLE> y </TITLE>, junto con cualquier
134 1 Fundamentos de programación en Linux

otro carácter. El texto del título se mantiene y se asigna a la variable

ntitle.
6. Si grep no encuentra una Iínea de <TITLE>, asigna el nombre de
archivo a ntitle. Primero, use basename para extraer el nombre de
archivo del nombre del directorio, retirando los nombres de directo-
rio precedentes. Después use cut para retirar la extensión (sale del
primer campo usando el punto como delimitador). Las extensiones
.htm y .html se pueden retirar.
7. Después de asignar texto a ntitle, úselo como el texto de enlace en
la Iínea href de HTML. Esta Iínea comienza con un rótulo < l b que
indica que es un ítem de la lista.
A continuación se presenta el script myindext:

echo '<html>'
F C ~ Q íhead>'

! tio ' < t ti l c . + i ~Inh?\</TITLE>'

i
echo '</head>*
m l n ',hly>

echo '<hl>Index o i H7"L F i l e s < i H l >

C7 Evaluación
¿Qué coniando se utiliza para leer la entrada en un script del shell
TCSH?

¿Se puede hacer referencia de una vez a múltiples elenientos de un

arreglo?

2Cónio se puede determinar el número de argunientos

- que un
usuario entra en la línea de conlandos cuando está operando un
script?

¿Cómo se define una variable a la que se puede hacer referencia en

los subshells?

¿Cuál es la diferencia entre los operadores =, = = y =-?

¿Cómo verificaría si el argumento que un usuario suministra a un
script es un nonibre de directorio?
 . . .
...
.
. ,

de alto nivel
. . ' > . '. .*
.. ......
. ,
. . .. . ..
,
A'. .. .,
,, .
.." ..
. ,, . . , . . .. <
. . _ ' ' '

GAWK

Los objetivos de este capitulo son:

-
Utilizar GAWK para operaciones de búsqueda simples

Crear scripts complejos utilizando comandos de GAWK

Implementar operaciones de búsqueda en archivos de registro basados en texto

Utilizar expresiones regulares para ejecutar operaciones complejas de concordancia

Administrar entrada y salida básica y formateada de GAWK

Aprender a utilizar los operadores GAWK aritméticos, relacionales y de asignación

Utilizar estructuras de control de GAWK para implementar pruebas de repetición

y pruebas condicionales

Implementar operaciones de preprocesamiento y posprocesamiento en scripts GAWK

 ación en Linux
9- S-

H ay dos maneras de considerar a GAWK: como un filtro que usted

puede llamar en una línea de comando, como cualquier otro
filtro, y también como un instrumento para crear sus propios filtros.
Unjltro, en Linux, lee información de una fuente de entrada, tal
como un archivo, o la entrada estándar, modifica o analiza esa informa-
ción y después produce los resultados. Éstos pueden ser una versión
modificada de la entrada o un análisis de la misma; por ejemplo, el filtro
sort lee un archivo y después da como resultado una versión ordenada
del mismo. El filtro w c lee un archivo y después calcula la cantidad de
palabras y líneas que contiene, suministrando sólo esa información.
Con GAWK usted puede diseñar y hacer sus propios filtros, creando
sus propios comandos Linux. Usted puede instruir a GAWK para
presentar en pantalla simplemente líneas de un texto (muy similar a
cat) o para buscar patrones como grep, o inclusive contar palabras
como w c . En todos los casos, usted puede agregar sus propias capacida-
des de filtros adaptadas a sus necesidades. Puede presentar en pantalla
sólo parte de cada línea, buscar un patrón en un campo específico o
contar únicamente las palabras que se encuentren en mayúsculas.
La utilidad GAWK tiene toda la flexibilidad y complejidad de un
lenguaje de programación. GAWK posee un conjunto de operadores
que le permiten tomar decisiones y hacer cálculos. Usted también
puede declarar variables y usarlas en estructuras de control para contro-
lar la manera como Se procesan las líneas. Muchas de las características
de programación proceden del lenguaje de programación C y compar-
ten la misma sintaxis.Todo esto la convierte en una poderosa herra-
mienta de programación.

CAWK es la versión CNU de la utilidad de UNIX: AWK, que se creó

originalmente como una utilidad estándar para el sistema operativo
UNIX. 'Uno de sus creadores es Brian Kernighan, quien ayudó a desarro-
llar el sistema operativo UNIX. Más adelante se desarrolló una versión
ampliada de AWK, llamada NAWK, para incluir el manejo de archivos.
Con NAWK, usted puede acceder a varios archivos en el mismo progra-
ma. CAWK es una versión más avanzada, que incluye las características
de NAWK y las capacidades estándar de AWK. Más información sobre el
tema se puede encontrar en www.gnu.org/software/gawk.
,.
 Capitulo 5: GAWK 1 141
Usted puede usar GAWK directamente como un filtro o colocarlo
dentro de iin archivo de shell que p~ied:iejecutar más adelante. En este
último caio, el noinbi-e del archivo de sliell p~iedeser el de un nuevo
filtro que usted ha creado. En este capítulo se esan~inaránambos
aspectos de GAWK. Primero, lo estudiarenios como un filtro con sus
característicai particulares y desp~iésverenlos cónio ?e p ~ i e d e~itilizareii
un archivo de shell para definir sus propios filtros.

El comando gawk
El coniando gawk toma como sus argumentos una instrucción y una
lista de nombres de archivos. La instruccióii GAWK se encierra entre
coinillas siniples y se lee coino ~ i i argumento.
l

La instrucción consta de dos segmentos: un patrón y una acción, y esta

última va entre corchetes. Los registros que cumplen con este patrón se
recuperan y las accioiies en el seginento de acción se aplican a dichos
registros. La sintaxis de una instrucción GAWK es como sigue:
patrón l a c c i ó n l

del tipo que se encuentra en lenguajes de prograinacióii. La utilidad

GAWK tiene u n comuleto coniunto de o ~ e r a d o r e scon los cuales se
Pl
bí
" I I

grep, el usuario especifica una condición. Los registros que cumplen

esa condicióii se recuperan luego. Las acciones en e1 segmento acción se
,..-rl;-.-.- ,1," ,,,:,c..,, r,,..+.u...-.rl,, E, ,-ca .-,-+;J, 1- r:,en,r:r
d ~ 1 l L d l lCIILUI1CCS d 1UJ L C ~ l J L I U 3I C C L l p C l d U U S . 1;11 CSCC >CIIClUU, I d J l I l L d A l J

de una operación GAWK puede considerarse coino:

condición {acción)
142 1 Fundamentos de programación en Linux

Pregunta: ;Puede funcionar GAWK en archivos?

Respuesta: La utilidad GAWK funciona en archivos o en la entrada
estándar. Usted puede introducir una lista con los noinbres de los
archivos en la línea de coiiiandos despuks de la instriicción y si n o hay
ninguna lista, la entrada se toma desde la entrada est6ndar. En el si-
guiente ejemplo se muestra la estructura de toda la instrucción GAWK.
La llamada de GAWK consta de la palabra clave p i v k seguida por una
instrucción y los nombres de archivo. La iiistrucción debe expresarse
entre comillas sencillas para evitar que el shell la interprete. Dado que la
condición y la acción no son argumentos separados para GAWK, usted
debe ponerlos entre comillas. La sintaxis de un coiiiaiido gawk es
similar a la forma siguiente (viasc también la tabla):

$ gawk 'patrón {accih)' nombres de archivo

Usted puede considerar el patrón en una instrucción GAWK cuan-
do funciona en cada línea. La accióii GAWK se desarrolla Iuego en cada
una de esas líneas.

Opciones Descripción
-f nombre-archivo Con esta opción, GAWK leerá los comandos des-
de nombre-archivo. Esta opción se estudia más
adelante en la sección "Archivos de instrucción
~ ~ % A w K "de
, este capitulo.
-Fc Esta opción especifica un delirni'tador de campo,
c, para el archivo de entrada. Esta opción se estu-
dia más adelante en la sección "Delimitadores de
campo", de este capítulo.

Búsquedas de patrón
y caracteres especiales
La búsqueda de un patrón en GAWK se identifica con una barra
vertical inclinada hacia la derecha (slash) al coniieiizo y al final, y se
coloca en el segmento patróii, o condiciórr, de la instrucción GAWK.
 Capitulo 5: GAWK 1-
143

lpa trón/ {accionj

La búsqueda de patrón se realiza en todas las líneas del archivo. Si el

patrón se encuentra en una línea, la acción se realiza en ella. En este
sentido, GAWK se desenipella en una forma 11111y similar a una opera-
ción d e edición. C o m o sed, una línea se trata coi110 una I í n e ~de texto,
y el patrón se busca a travt.5 de toda la línea. En el siguiente ejemplo,
gawk busca todas las líneas que tengan el patrbn "Poe". Cuaildo se
encuentra un^ concordancia, se iiiipriiile la línea.

- v
p..
S gawk ' / P o e / E p r i n t l ' books
Raven Poe 2.50 Pengui n

El siguiente ejeniplo iniprinie todas las líneas con el patrón

"l'eiiguin". Se recuperan todos los registros con ese patrón. El segnien-
to acción en el priiiler ejemplo contiene el comando print, que da
coino resultado l~ línea en la wlida estándar.

g gaw s
Tempest Shakespeare 15.75 Penguin
Raven Poe 2.50 Penguin

A continuacióii se presenta el contenido del archivo books que se usa

en este y los siguientes ejenlplos:

~hristmac ~icken; 3.50 ~ c a d e mci

Iliad Homer 10.25 Random
R a ven Poe 2.50 Penguin

Tanto la acción como el patrón tienen condiciones predetermina-

dai, de inodo que puede oiiiitirlos. La acción print es la acción prede-
terminada. Si una acción no se especifica, la línea se iriiprime. El patrón
predeterrniiiado es la selección d e todas las líneas en el texto. Si n o se
especifica el patrón, la acción se aplica a todas las líneas.
144 1 Fundamentos de programación
- en Linux
-=-

En el siguiente ejemplo, iio hay segniento acción. Eiitoiices se usa la

accióii print que eitá predeterininada.

Tempest Shakespeare 15.75 Penguin

kven Poe 2.50 Pengu in

En el siguiente ejemplo, la instrucción GAWK n o tiene segilieiito

patrón. En ese caso, la acción se realizará en todas las líneas. La acción
es print, que imprime una línea, de modo que la ii-istrucción iiiipriine
efectivainente todas lai líneas en el archivo.

' $ ga w l - m
Tempect Shak~:pí?ar,? 1 5 . 7 5 Periqtrin
C h r i ::mas Di~kens 3.50 Academi r
11-¡;id Homr r 10.25 Fandom
Raven Poil 2.50 Pengui ti

Usted puede usar en GAWK los iiiisinos caracteres especiales que

se iitilizaii para espresioiiei regularei. Por ejemplo, CI signo circiinflejo
especial (") especifica el coniienzo de una línea y el signo $ especifica
el final de la línea. En el primer ejemplo que sigue se busca un patrón
al coniieiizo de la línea. En el segundo, un patrón al final d e una línea,
usando el carrícter especial del signo de dinero ($).
/carácter especial al /
c o m i e n z o d e la lineal-
~ n C h b l r t m a s / l p r i n t ) ' books L---y =--
Christiw; Dickens 3.50 4cadtmic

S gawk ' / R a n d o m $ / C p r i n t l ' books

Iliad Homer 10.25 Random

Usted tainbiéii puede emplear caracteres especiales para especificar

variaciones sobre un patrón. El punto (.) concuerda con cualquier
carácter, el asterisco (*) equivale a caracteres repetidos y los paréntesis
cuadrados ([ 1) concuerdan con una clase de caracteres. E11 cl ejemplo
siguiente se usa el punto para coinpletar cualquier patrón en donde LIII
carácter único estrí seguido por las letras "en".
 Capitulo 5: GAWK 1 145

Tenpis t Shakespeare 15.75 Penguin

C h r i s tnias Dickens 3.50 Academi c
Raven Pn.2 2.50 Penguin

En el ejemplo que sigue se emplean los paréntesis cuadrados y el

asterisco para especificar una secuencia de nún~eros.El conjunto de
posibles núnieros está representado por los parkntesis cuadrados que
encierran el rango de caracteres numéricos [O-91. Después, el asterisco
especifica cualquier secuencia en donde se repitan los núineros. El
contexto para una secuencia de esa clase está integrado por los caracte-
res .50. Se tomar5 cualquier níimero que termiiie con ''.50W.Observe
que cl punto está con una barra invertida d e modo que se trata como
el signo punto y n o coino uii carácter especial.

En GAWK también se usan los signos especiales extendidos más

(+),de iiiterrogación (?) y barra vertical (1). Los signos + y ? son
variaciones del carácter especial * . El signo + representa una o 1115s
veces un carácter; el signo i! equivale a ninguna vez o a iina vez u n
carácter. El signo 1 ofrece patrones alternativos para buscar. En el
siguiente ejemplo se busca una línea que contenga el patrón "I'enguin"
o el patrón "Acndemic".
. .
T gawk ' 7 ~ v c 1~'Fiñ'ES'-607j-s
/ .
Tfrnllc8 t T.liak~.;prare 15.75 Ppnguin
t it i Dicl,~n- 3.50 Ac-tdemi c
Rav~ti Poe 2.50 Penguin

Variables, constantes y funciones

GAWK permite definir variablei. Exiiten tres tipos de variables: vrrria-
blcc dc. rompo, vrrrioblcc cspcrioles de CAl/VI<y iminhlcs dcrfinidns por 41
iisirorio. CAWK define automáticamente las variables d e campo y las
146 1 Fundamentos de programación en Linux

especiales, y el usuario puede simplemente definir sus propias variables,

al igual que constantes aritméticas y de cadena. Las coricfarzfes (rir.iftnéficris
están formadas por caracteres nuinéricos y las co~statitesde cadcrici, por
caracteres enn~arcadosdentro de comillas dobles.
Además de variables y constantes, GAWK incluye f~iilcioimque
pueden operar sobre las variables y las constantes.También hay f~iiicio-
nes aritméticas y de cadena. Por ejemplo, existen f~incionesde cadena
que pueden determinar la longitud de una cadena o localizar la posi-
ción de un caricter en una cadena.

Variables de campo y delimitadores de campo

Las variables de campo están diseñadas para hacer referencia a los
campos en una línea. U n carrrpo es cualquier conjunto d e caracteres
separados por un delimitador de cainpo y el delimitador predeterinina-
do es u11 espacio o una tabulación. GAWK define una variable de
caiiipo para cada caiiipo en el archivo. Una variable d e canipo consta
de un signo de dinero ($) seguido por el número del campo y, conio
con otros filtros d e bases d e datos, GAWK numera los cainpos a partir
d e 1, d e modo que la variable de caiiipo $2 hace referencia al segundo
campo. La variable $0 es una variable d e campo especial que contiene
toda la línea.
C

gg ~ e - ~ -.

Una variable se puede usar en el segmento patrón o en el seg-

mento acción de la instrucción CAWK. Si se presenta en la lista
más de una variable, entonces se separan por comas.

En el siguiciite ejeiliplo, que se ilustra en la figura 5-1, las variables

$2 y $4 hacen referencia a los cainpos segundo y cuarto, de modo que
se iinprimeii eios campos dcl archivo bookc.

Sha kespeare Pengui n

D i ckens Acadeini c
Horne r Randorn
Poe Pengui n
 Capitulo 5: GAWK 1 147
El archivo books utilizado es el siguiente:

"'Tempest
7..-.-- -.
Shakespeare
----1 5 . 7 5 7 K j i ; T r i - - -
>,-

Christmas Dickens 3. 50 Acadcriti c

Iliad Homer 10.25 hendom
Raven Poe 2.50 Penguin

En el ejeiiiplo que sigue, el usuario obtiene dos veces los resultados

de la línea con el patrón "Dickens": primero reversando el orden de los
campos y después con los campos en orden. La variable $0 se usa para
obtener todos los campos en orden (toda la línea).
I

' $. gawk ?cjInckens/-4. 33, $2, $1: p r i n t $ójpbooks

Academic 3.50 Dickens Christmas
Christmas Dickens 3.50 Academic

{priiit 52, S I )
Lns vnriablei de cnnipo hacen refereiicia

-
3 los cnnipw en cada Iíiien

1 1
-
Y- -i
7-
Teiiipest Shakespeare 15.75 Penmiin 0
Shakespeare I'eiig~iin
Christiiias lJickens 3.50 Acadeiiiic + gawk-, I>ickens Acadeiiiic
Iliad Homer 10.25 Kandoin Hoiner Ilnndoiii
IJenguin
\

aii th-piib
Teiiipest Sliakespeare
Chri~tiiias Ilickeris
Iliad
Ilavcii
Hoiiier
Ibc
15.75
3.50
10.25
2.50
I'engiiiii
Acadeiiiic
Ilniidoiii
I'engiiin X
Shakcspcarc l'erigiiiii
Dickens
Hoiiier

S gawk '(print $2, $4)' books>auth-pub

Acadciiiic
Ilnndoiii
Peiigiiiii
148 1 Fundamentos de programación en Linux
--

Usted puede realizzir varias acciones en la misma línea separándo-

las con u n signo de punto y coma, como se presenta en el ejem-
b

plo anterior: {print $4, $3, $2, $1; print SO).

Delimitadores de campo
Por defecto, GAWK separa campos por medio de espacios o tabula-
ciones. Sin embargo, si usted quiere usar iin delimitador específico,
puede especificarlo con la opción -F, la cual, en realidad, establece una
variable GAWK especial llainada F S que actíia como separador de
campo. C o n la opción -F, puede especificar cualquier carácter que
desee como delimitador.
En el siguiente ejemplo, el archivo b o o k s l utiliza un signo de punto
y coma para separar campos. La opción -F hace que GAWK considere
el signo de dos puntos conio un delimitador de campo.

Mar and peace 1 5 . 7 5

C h r i s t m a s c a r o l 3.50
I l i a d 10.25
Raven 2.50
5

El siguiente es el contenido del archivo booksC:

- 7
p a r and p e a c e : ~ 0 1 s t o m 5 ~ e n s ; i n
C h r i stmas c a r o l : D i c kens:3.50:Acadernic
Iliad:Horner:10.25:Random
Raven:Poe:2.50:Penguin

El siguiente ejemplo repite uno anterior iisando la opción -F, dando

como resultado la línea con el patrón "Dickens" dos veces: primero
reversando el orden de los campos y después con los cainpos en orden.

T
T
'Z
Tm
-
tit $4. '3'3'31;-
print G j T % k s C
Academi c 3.50 Dickens Christmas caro1
Christmas caro1 : Dickens: 3.50: Acadernic
 Prueba de repaso
¿Qué sucede si usted especifica una acción sin ningún patrón?'
¿Puede aplicarse la concordancia del patrón de una expresión
regular a campos particulare~?~

Variables especiales d e GAWK

GAWK define un conjunto de variables especiales que ofrecen infor-
mación acerca de la línea que se está procesando. La variable N R
contiene el número de la línea actual; la variable N F , la cantidad de
campos en la línea actual. Existen otras variables especiales que contie-
nen los delimitadores de campo y de registro. Inclusive hay una,
FILENAME, que contiene el nombre del archivo de entrada. En la
tabla 5-1 se presentan las variables especiales de GAWK.

Variable Descripción
NR Mantiene el número del registro actual.
NF Número de campos en el registro actual.
$0 Todo el registro actual.
$n Los campos en el registro actual, numerados a partir de 1;
por ejemplo, $1.
FS Delimitador$e campo de entrada; el delimitador predeter-
minado es un espacio o una tabulación.
OFS Delimitador del campo de salida; el delimitador predetermi-
nado es un espacio o una tabulación.
RS Delimitador del registro de entrada; el predeterminado es
un carácter en una Iínea nueva.
ORS Delimitador del registro de salida; el predeterminado es un
carácter en una nueva línea.
OMFT Formato de salida para números; el delimitador predetermi-
nado es O/og.
FILENAME Nombre del archivo de entrada actual.

1 La acción se aplica a todas las líneas en el archivo.

2 Sí; el patrón que concuerda se puede limitar a campos individuales.
150 1 Fundamentos de programación en Linux
-- --

A las variables especiales y a las que define el usuario n o se les

antepone el signo de dinero. Para usarlas, sólo se necesita especificar el
nonibre de la variable. En el siguiente ejeniplo se conibina la variable
especial N R con las variables de campo $2 y $4 para imprimir el níinie-
ro de la línea, seguido por el contenido de los campos dos y cuatro. La
variable N R tiene el iiúrnero de la línea que Fe está procesaiido.

9 ga'wk v r p r l ' F K V 5 f m ~ k ~ 1
1 Shakespeare Penguin
2 Dickens Academi c
3 Huiiier Randoni
4 Poe Pengui n

Variables definidas p o r el usuario

Usted puede definir sus propias variables dándoles el noiiibre que
prefiera. Las variables se pueden nombrar usando cualquier carácter
alfabético o numérico, incluyendo el signo de subrayado. El nonibrc
debe comenzar con un carácter alfabético. Una variable se define la
primera vez que se utiliza y el tipo de la niisnia se determina según la
manera conio se use. Si la eniplea para contener valores niiiriéricos, la
variable se considera aritmética; si es para contener caracteres, se consi-
dera iina cadena. Es riecesario qiie usted sea consecuente con la nianera
e n que utilice una vxiable: las variables de cadena no se deben usar en
cálculos aritméticos y viceversa.
Usted puede asignar un valor a una variable usando el operador de
asignación (=). El lado izquierdo de una operación de asignación
sieiiipre es una variable y el derecho es el valor que se le asigna a la
iiiisnia. U n valor puede ser el contenido de una variable, conio un
campo, una variable especial o una variable definida por el usuario;
también puede ser una constante, como se describe en la siguiente
sección. En este ejemplo, el usuario asigna el contenido del segundo
caiiipo a la variable myfield.

Sha kespeare .
Dickens
Horner
Poe
 Capitulo 5: GAWK 1 151

Constantes
Lai c o n i t ~ n t e pueden
i ser valorei mtini.ticos o cadenas. Las constx~tes
m t m é t ~ c xie representm con dígitos. El número 56 representa cl v ~ l o r
aritn~ético56. Las constantes de cadena pueden ser cualquier conjunto
de caracteres entre comillas dobles, de inodo que una conitante de
cadena pJra la palabra cdrtrorl es "edition".N o olvide que un núnlero
precedido con un signo de dincro es una variable de cainpo y un
número SIII cse signo ei una conitante aritmética.

consejo -

Las constantes se utilizan ampliamente con operadores. CAWK tiene un

conjunto de operadores relacionales, aritméticos y de asignación que se
pueden usar con variables y constantes para formar expresiones com-
plejas. Estas expresiones se pueden emplear en segmentos de acción o
de condición de la instrucción CAWK. En las siguientes secciones se
estudian con más detalle. - -
l
Funciones
La utilidad GAWK brinda 1111conjunto de f~incionesque pueden
operar en campos, patrones o variables. Existen funciones de cadena
y f~incionesaritméticas. Las f~iiicioiiesaritméticas se describen en la
sección "Operacioiies aritiuéticas y de asignación", que se presenta mis
adelante en este capítulo.Varias de las f~incionesde cadena más coinún-
mente usadas son length, index, substr y split (vinrisu tabla 5-3
y sección "Arreglos y arreglos asociativos").
La f~inciónlength obtiene la longitud de una cadena. Se puede
aplicar a cualquier variable de cadena, incluyendo variables de cainpo.
El llamado de la f~inciónlength($2) da la longitud del segundo cain-
po. El llamado de la f~inciónlength($O) presenta la cantidad de carac-
teres en una línea, que incluye cualquier cantidad de espacios o
tabulaciones. E11 el siguiente ejemplo, la longitud de cada línea se
imprime antes de la línea.
i
'fc"ggriwk y p T -
3 1 Tempest Shakespeare 15.75 Penguin
31 Christmas Dickenc 3.50 Academi c
24 I l i a d Homer 10.25 Random
20 Raven Poe 2.50 Penguin
 ramación e n Linux

Funciones de cadena Descripción

length(ca4 Regresa el número de caracteres en una cadena.
Si length n o tiene argumento, calcula la longi-
t u d del registro actual en caracteres.
index(cad1, cad2) Determina si cad2 contiene a c a d l y, en caso
afirmativo, devuelve el valor de la posición en
cad2 en donde comienza cadl. En caso negati-
vo, devuelve el valor de O.
split (cad, arr, delim) Copia los segmentos de cad que están separados
por el delimitador delim en los elementos del
arreglo arr. Regresa el número de elementos en
el arreglo (véase "Arreglos y arreglos asociativos"
en este capítulo)
substr(cad, pos, len) Regresa una subcadena de cad. Los caracteres en
la cadena se numeran a partir de 1. El argumento
pos es u n número que hace referencia al carácter
en donde comienza la subcadena. El argumento
/en es u n número que indica cuántos caracteres
usará la subcadena desde el carácter pos.

La función substr obtendrá una subcadena de un campo o una

variable. La función spbstr tiene tres argumentos: el primero es el
campo o patrón de donde se copia la subcadena, el segundo es la
posición desde la cual comienza la subcadena, y el tercero es el número
de caracteres copiados desde la posición inicial. El llamado de la fun-
ción substr($2,4,3) presenta una subcadena que comienza desde el
cuarto carácter en el segundo campo, que termina con el sexto carác-
ter. La subcadena estará conformada por los caracteres de las posiciones
4 , 5 y 6 en el segundo campo.
La función index encuentra la posición de un patrón dentro de una
cadena. La posición del patrón "en" en "Dickens" es 5. En el siguiente
ejemplo, el usuario imprime la primera palabra de los títulos que
contienen más de una palabra en el archivo booksC. Este archivo posee
campos que contienen más de una palabra con campos separados por
el signo:. Primero, index encuentra en dónde termina la primera
palabra al ubicar el primer espacio. La posición del espacio es asignada
a la variable pos definida por el usuario. Si no hay ningún espacio,
 ..--
Capitulo S: GAWK 1 153
entonces el título tiene una sola palabra y el índice regresará a O. Eri-
tonces, substr copia la priiiicra palabra usando 1'1 poiición del espacio
regresado por index, para determinar cuántos caracteres debe copiar.

7 - 7 7 ~riñts'uitr ,i',
<$i pos 1) * bookst
War
Chri stmas

GAWK tiene un extenso número de f~incioiiesde cadena que le

permiten realizar operaciones, tales como sustituciones de patrón (sub
y gsub), búsquedas d e patrón (match) y cainbios de inayíisculas y
ininúsculas (tolower y toupper). Viasc tabla 5-3.

Comparación de cadena Descripción

y sustituciones
match (cad, patrón) Compara el patrón en la cadena. Si lo encuen-
tra, match regresa la posición de la concor-
dancia; de otro modo, regresa O.
sub(patrón, cad, reemplazo) Realiza una operación de sustitución, reempla-
zando el patrón en la cadena, cad, con la cade-
na de reemplazo. Si no se especifica la cadena
de reemplazo, entonces se usa $0.
gsub(patrón, cad, reemplazo) Realiza una sustitución global en la cadena,
reemplazando todas las veces patrón con
reemplazo.
Cambia a mayúsculas todos los caracteres que
se encuentren en minúsculas en la cadena.
Cambia a minúsculas todos los caracteres que
se encuentren en mayúsculas en la cadena.

n y sustituciones en el cadena GAWK

Salida formateada: la función printf

Usted puede usar la función printf para asignarle un formato a su
resultado. El coriiando printf simplemente produce cadenas, seguidas
por un carácter en una nueva línea. Suponga que desea obtener varias
cadenas diferentes en la misma línea o valores numéricos para una
154
7
1 Fundamentos de programación en Linux
--. --

posición decinial específica. La función printf puede usar una serie de

especificadores de control especiales y constantes para darle forniato a
su resultado. La sintaxis de la fiinción printf es coi110 sigue:

print("format0-cadena", arg 7, arg2, ..., argn)

La f~mciónprintf toma conlo sil primer argumento una cadena del
formato, que, por lo general, es una cadena entre comillas dobles, que
contiene especificadores de conversión o cualquier constante que usted
quiera en el resultado. Loi caracteres en la cadena del formato se toman
conio caracteres que se van a obtener. Los caracteres que no se impri-
men, como la nueva línea y la tabiilación, se representan con su$ equi-
valentes entre comillas.

Ilespués de la cadena del foriiiato, usted presenta en una lista coino

argumentos los valores que desen en el resultado, los cuales pueden ser
valores de variables, variables de cainpo o variables especiales.Tanibién
pueden ser valores que resultan de expresiones, tales como expresiones
aritnlkticas. En la inayoría de los casos, usted presentará en lista las
variables cuyos valores desea tener coi110 resultado d e sus arguinentos.
Por cada argunient? que usted presente en la lista, debe contar con
un especificador de coiiversión que le corresponda en la cadena del
formato. U n especificador de coiiversión consta de un sigilo d e por-
centaje ('%) seguido por un código d e iina letra que indica un cierto
tipo de conversión. U n especificador de conversión toma el valor de
L I argunlento
~ y lo convierte en caracteres que pueden ser el resultado.
Por ejemplo, el especificador de conversión %d tomará un valor
entero, como 465, y lo convierte en los caracteres 4, 6 y 5, los cuales
pueden ser, entonces, el resultado. En la mayoría de los casos, usted
obtendrá cadenas y el especificador de coi~versiónpara una cadena es
%s. Los especificadores de conversión se presentan en la tabla 5-4.
Los especificadores d e conversión en su cadena del formato con-
cuerdan eii fornia secuencia1 con los arguinentos que usted incluyó en
la lista. El primer especificador de conversión en la cadena del formato
convertirá el priiner argiiinento; el segundo especificador de conver-
sión convertirá el segundo argumento, y así sucesivamente. En el
 Capitulo 5: GAWK 1 155

siguiente ejemplo, el usuario obtiene como resultado el valor eiitct-o de

23 y la cadena "visitantes" utilizando primero 1111 %d y después u11
especificador de conversión %s.

Especificadores d e conversión Descripción

%d Decimal, entero
%f Punto flotante
%e Notación exponencial
%g Usa la notación del punto flotante que sea más corta, f o e
%o Representación octal d e u n entero
%x Representación hexadecirnal
%S Cadena d e caracteres

Especificadores de conversión de printf

También puede incluir dentro de la cadena del forniato cualquier

carácter que, como constante, desee obtener en el resultado. De hecho,
usted puede usar printf para obtener una cadena de caracteres que use
solaiiieiite la cadena del fcuniato sin argiirnentos. En el siguiente ejem-
plo, el usuario iii~priiiie,primero, sólo la cadena "Visitors Keport";
después, en el sig~iienteprintf, el usuario imprime los valores 23 y
"visitors" precedidos por "There were".
3

m f 5.1t o i F C e p o r t-
9
p r i n t f here re were %d % S " , 23. " v l s i t o r s . " ) ;

V i s i t o r s Report There w e r e 23 v i s i t o r s .

Observe que todo el resultado se obtiene en una línea. La función

printf no da como resultado un retornqdel carro, a menos que
tenga la instrucción explícita de hacerlo de ese modo con una
constante de nueva línea.
156 1 Fundamentos de programación
---
en Linux -

Dentro de la cadena del formato, usted puede ingreiar constantei

especiales, tales coino líneas nuevas o tabulaciones, que controlan el
resultado. Esas conctantes especiales están formadas por una barra
invertida y una letra como código. La constante especial \n es una
conitante de nueva línea que dará como resultado un retorno de carro;
\ t es una constante de tabulación que dará coino resultado una
tabulación. Usted también puede obtener un valor octal para cualquier
carácter en el conjunto de caracteres precediendo el número octal con
una barra invertida y un cero. \O07 dará coiiio resultado el carácter en
el código ASCII que hace sonar el timbre. Estas constantes especiales se
presentan en la tabla 5-5.

Constantes especiales Descripción

\n Nueva línea
\t Tabulación
Equivalente octal de un carácter, tal
c o m o \O07
Equivalente hexadecimal d e u n carácter,
tal c o m o \ x 7

Constantes especiales de printf

En el siguiente ejemplo, el usuario entra \n al final de las cadenas

del formato printf para obtener como resultado una nueva línea.

p r i n t f ( " T h e r e were %d % s \ n W , 23. " v i s i t o r s . " ) :

V i s i t o r 5 Report
There vero 23 v i s i t o r s .

' En el siguiente ejemplo, la f~inciónprintf se usa en cambio del

comando print, para dar formato al resultado. Observe los caracteres
\n, al final de la cadena del formato.

Wgjwk - ~ m n b eu i r rs f l
The authot i s Shakespca~P p i b l i s h e d by Penguin
The author i s D i i k ~ n spub1 i:h-d b v Academic
Ttir a u t h n r i s Homer pulllim;hed b.v Randoiii
Tht d u t r i i ~ r i s Poe p u b l i s h e d by Penguin
 Capitulo 5: GAWK 1 157

La función printf trabaja igualniente bien con variables especiales y

con variables definidas por el usuario. En el siguiente ejemplo, se da el
forniato para el resultado de la variable especial NR, la cual requiere
un especificador de conversión %d porqiie es un entero.
1 Especificador-de--conversión-para N R ~
-

b$- g a w k '[prlntfl"keEord % d \ t % s \ t % s \ n WN R. . $ 2 . $ 4 ) 1 ' books

Record 1 Shakespeare Penguin
Record 2 Dickens Academi c
Record 3 Homer Random
Record 4 Poe Pengui n

Además de especificadores de conversión, la función printf tambiéii

tiene iiiodificadores de conversión, como se presenta en la tabla 5-6.
Los modificadores de conversión dirigen longitud del campo, ubica-
ción de decimales y justificación. U n número situado entre el signo de
porceiitaje (%) y el código de la letra de conversión deteriiiiiiari la
longitud míninia del canipo de un campo de resultado. Si uii valor es
menor que la longitud del canipo, el resultado se coiiipletarrí con
espacios; esto garantiza que las columnas del resultado queden alineadas
correctaniente. Sin embargo, el modificador de la longitud del campo
n o corta los valores que sean deiiiasiado largos.

Modificadores de printf
.num
- Descripción
Modificador de ubicación del punto decimal
flotante. El punto se usa para dar formato a
valores con punto decimal flotante y especifi-
ca la cantidad de lugares que se deben pre-
sentar en pantalla a la derecha del punto
decimal. Por ejemplo, O/0.2f.
Num Modificador de la longitud del campo. Cual-
quier número que modifique el especificador
del formato determina el ancho mínimo del
campo del valor que se está formateando.
Por ejemplo, %5s.
Justificación a la izquierda (la justificación a la
derecha está predeterminada). Por ejemplo,
%-los para un número justificado a la iz-
quierda, con 10 dígitos.

Modificadores de conversión
 ramación en Linux
,.

El modificador de ubicación d e decimales para las conversiones con

1
punto flotante se usa con bastante frecuencia. Este modificador deter-
mina cuántos lugares se imprimirán después del punto decimal en un
valor con punto flotante; consta de un punto seguido por un número y
se sitúa entre el signo de porcentaje ('%) y el código de la letra de con-
versión. El especificador de conversión %.2f dará como resultado un
punto flotante con dos lugares decimales, únicamente. El valor de 3.4528
se presentará como 3.45, aproximando por redondeo la última cifra.

segmento patrón
como una condición
El segmento patrón de una instrucción GAWK se puede considerar
corno una condición de prueba. Las estructuras de control en los
lenguajes de programación tienen expresiones de prueba para determi-
nar si son falsas o verdaderas; en caso de que la prueba sea verdadera, se
ejecutan los enunciados de la estructura de control. Del mismo modo,
un patrón en GAWK se puede considerar como una expresión de
prueba: si el patrón tiene un resultado exitoso, entonces es verdadero y
se ejecuta su acción GAWK. En este sentido, un patrón es una condi-
.
ción para la ejecución de la acción. Los operadores que usted puede
usar para crear pruebas de este estilo se presentan en la tabla 5-7.
También se incluyen patrones especiales que especifican ciertas condi-
ciones. Por ejemplo, los patrones BEGIN y END ejecutarán el código
antes y después del código principal.

Operadores d e igualdad y relacionales

Usted puede construir condiciones simples usando operadores de
igualdad, variables de campo y constantes. Los operadores de igualdad
son los mismos que se encuentran en el lenguaje de programación C.
El operador de igualdad consta de dos símbolos de igual (= =), que
son ligeramente diferentes de los de otros lenguajes de programación.
Un solo símbolo de igual es el operador de asignación (=). Resulta
fácil confundir los dos símbolos. El operador de desigualdad es el signo
de admiración con el símbolo de igual (!=).
Operadores de igualdad Descripy n
-- lgualda
!= No es igual a
Operadores relacionales
> Mayor que
< Menor que
>= Mayor que o igual a
<= Menor que o igual a
Operadores lógicos
&& AND lógico
II OR lógico
! NOT lógico
Operadores de búsqueda
de patrón
cad - expresión regular Concuerda con una expresión regular; el
operando de la derecha es una expresión
regular
cad !- expresión regular No concuerda con una expresión regular:
el operando de la derecha es una expresión
regular.
Patrones especiales
BEClN Ejecuta operaciones antes de que CAWK
comience a procesar
Ejecuta operaciones después de que CAWK
termina de procesar
Patrones de ranqo
primera condición,
. Hace referencia a un rango de línea que
segunda condición comienzan con la línea que cumple con la
primera condición y termina con la siguien-
te Iínea que cumple la segunda condición

En el siguiente ejemplo, solamente se imprimen aquellas líneas cuyo

último campo es igual a la cadena "Penguin". Observe que aquí se usa
una constante de cadena en lugar de un patrón enniarcado entre barras,
el cual sería una operación de búsqueda de patrón para determinar la
presencia de cualquier patrón en el campo, en tanto una cadena es un
valor sencillo que compara todo el campo con el valor de la cadena.
160 1 Fundamentos de programación en Linux
- -

. - - - . . - .
i gawk '$4 -= 'Venguiri" ~ ~ r i ' n t 1 T o o k s - - %

Pregunte a los expertos

Preaunta: ;Qué tan coinvleias vueden ser las exvresiones?
Respuesta: En Ierigu'ijes de prograinaciih, las expresiones de prueba
pueden estar constituidas por siibexpresiories con~plejasqiie iisaii operadores
relacionales y lógicos, lo rnisnio que expresiones aritméticas y llamados de
,- ., , .
tuncion. t o m o expresrories cle prueba, iin pdtrori de CrAWK puede contener
subp~troiiesque usan operacionec relaciondei, lógicas e incliico aritméticas.
En este seiitido, iin patr6ii piirde coixiderarse como una expresión.
Sin eriibargo, en leiigiiajes de piogianiaciói~los opermdos que se usan eri
las euyrecione5 son iiúmrroc o c;iracteres, pero en el patrón GAWK los
operandoi se concide~iripatronri. En GAWK, ima operación relaciona1
compara un valor con un patrón, de modo qiie una operación Iíigica tendrá
subexpresiones que coinpdrari pdtrones. I)e hecho, las subexpresiones técnicaI-
., ., . ..
mente se derioiiiinan patroiiei y a una operacroii logica corilplela se puede

Taiiibitii puede usar opcradores relacionales p m coristruir condi-

ciones. GAWK tiene los iiiisiiios operadores relacionales q u e se usan en
otros lenguajes d e programación: >, <, >= y <=. Sin embargo, a
diferencia d e las versiones del lengiiaje C , los operadores relacioiiales
d c GAWK pueden coniparar cadenas, clasificáiidolas por orden
alfibético. Por ejeniplo, "Aleina" es nienor q u e "Larisa". Los operadores
d e igialdad y relacioriales se presentan e n la tabla 5-7.
Eii el siguiente qjeinplo, el com:iiido lista todos los libros q u e cues-
tan 1115s d e $10.00. Observe q u e se usa una constante aritinktica para el
operando.
 -
Capitulo 5: GAWK ( 161

U11 operaiido cn iiiia condición GAWJC también puede ser i i r i valor

que se rcgrew iiiediaiite uii'i fiiiicióii. E11 el giguiente cjciiiplo, 1;i f~iri-
cióii length se usa para inipriiiiir ~olarrieiitcaquellos regigtroi cuyo
seg~indocampo tiene una longitud wperior a 5.
- -- -----
' $ 9 á W k Z
Toriip~st S h d k e z p ~ a r . 3 15.75 P m o i i i n
i l i i istiiiis D i c k e n - 3.50 kc ademi c

Operadores lógicos
GAWJC tiene 1111 coiijuiito de operadores lógicos que usted piicde usar
para crear condiciones coniplejas. Los operadores lógicos son los
niisiiios que se iisari en e1 lenguaje de programación C y se presentan
en la tabla 5-7. El operador lógico para A N D es i i i i ampersatid doble
(&a),el operador lógico para OR es iina barra vertical doble ( 1 1 ) y el
operador lógico para N O T es 1111 signo final d e admiración sencillo (!).
Los operaiidos para operadores lógicos son las coiidiciones iiiisiiias que,
por lo general. van entre paréntesis.
En el siguiente ejeiiiplo, se iniprinie la lista de todos los libros
publicados por I'enguiii qiie cuestan mis d e $10.00. Esto iiiiplica
comparar el cuarto caiiipo con "l'engiiin" y comprobar si el tercer
campo cs mayor que 20.00,

W4'(;f4 a ~ 4 i t3-'-b 00 k S
- i .
Tenipest Shakespeare 15.75 P e n g u i n

En el sigiiiente ejeinplo, el conlando imprime los libros que publi-

can Pengiiin o Acadeinic. Esto iniplica verificar si el cuarto canipo es
igual para la cadena "Penguin" o la cadena "Acadeiiiic".

g c a d e m i c " ' j (prlntl ' books

T+inp~~,t .,h(fkcrpeare 1 5 . , 5 Penquin
7lirirLn;ic Di'kciis 2 . C ~ O Aca~lciiiic
Pat 211 Fn-l . O Ppngui n
-1 Fundamentos de programación en Linux
162

Operadores d e búsqueda d e patrón

Usted puede usar dos operadores que conipareii patrones: la virgulilla
sol^ (u)y con el iigno de adnliración (!-) para realizar la búsqueda de
patronei en loi campos. En lugar de emplear el operador de igualdad
para comparar todo el c m i p o con una cadena, usted puede u i x los
-
operadores para ver si existe determinado patrón dentro del caiiipo.
Cuando se usan estos operadores para buscar canipos, el operando d e la
derecha es el patrón y el operando d e la izquierda ei el campo en
donde te va a buscar. En el siguiente ejeniplo, en el primer caiiipo se

-
busca "niai".
-
-- - -
m $ - 1 / m i > m b o o k ~ - - ' '--'-
Christmas D i c k e n s 3.50 Academic

En el siguiente ejemplo se recuperan todos los registros ciiyo primer

canipo no contiene el patrón "nias".
rrrr
1
S Sawk 'n"i !- fma3I.l b 0078- -
Ternpest Shakespeare 15.75 Penguin
11 i a d Homer 10.25 Random
Raven Poe 2.50 Penguin

Así como usted ~itilizacaracteres especiales en una búsqueda general

de i ~ i patrón,
i también puede usar caracteres especiales para buscar en
campos. En el ejeniplo que sigue, el usuario busca lai vcrsiones eii
niayúsculai y iiiinúsculas de "Peiiguin" cn el cuarto caiiipo. Los parén-
tesii cuadrados, corno caracteres especiales ([ 1) se emplean para definir
una clase para la P mayúscula y riiinúscula.

-nrm
' $'gawk * ( f 4 7 l ~ p j é n g / ' ) - ~ p % t ? ~F O O ~
Tempest Shakespeare 15.75 Penguin
Raven Poe 2 . 5 0 Penguin

Los patrones especiales BEClN y END

La iristrucción GAWK ticne doi patrones eipeciales que le perniiteri al
usuario eipecificar acciones que se han de ejecutar antes y despues d e
procesar las líneas en la entrada. El patróii BEGIN es una condición
 - -.
Capitulo 5: GAWK ( 163

que especifica acciones que se han de realizar antes de procesar las

líneas, y cl patrón E N D especifica las acciones que 5e deben realizar
después d c procesar las líneas.
E11 el siguieiite ejemplo, el encabezado "Book List" es impreso antes
de que se procese cualquiera de las línex. Después del procesamiento,
sc imprime el valor de N R . Dado que N R se increnienta con cada
línea, despuks del procesainiento, mantendrá la cuenta total de los
registros en el archivo.
[La condición DEGIN ejecuta
r - . .
4 __;Idaantes delprocesamient
- aawk
$ --.... 'RFGTN. Inrint
---.- . .- "Rnnk
---.I-.--
i s t Y,l lir.
n r i. .n. -tJl FNnf nrint ' 7 n t a l r w z " NRl' h
Book L i s t
Terip~st Sh~L~;peare15.75 F-n'riiin
tL- - a c--.,
ondicion~~~e~cuta~
c h r i ,trnas D i c k ~ i i s 3.50 Academi c después
-
del procesamiento
- --
Iliad H L ~ ~t I C 10.25 Random
P,~ven Po:, 2.50 Fenguin
Total recs 4

Patrones de rango
La utilidad GAWK ~itilizala coma coino un operador e~pecialque se
puede ubicar entre dos coildicioties para recuperar un rango de las
líneas. La primera Iínea en el conjunto es la prinlera línea que cumple
con la primera condición. La últinia línea en el conjunto es la sig~iiente
línea que cuiilple con la seguild'~coildición.
El operador coma resulta d e particular utilidad para seleccionar un
rango de líneas utilizando la variable especial N R , la cual tiene el
núiiiei-o de la línea actual. La condición N R = = 4 seleccioiiará la
cuarta línea porque cuando se alcanza la línea cuatro, el valor de N R
será 4 y la condición ser5 verdadera. N R = =1, N R = = 3 especifica
u n rango de líneas que comienzan con la l í n e ~1 y termiilaii con la
lítiea 3. En el siguieiite ejemplo, solainente se iinprimen las tres priine-
ras líneas.

m
Tempest
-Shakespeare
l. NR ' TO
-~KS
1 5 . 7L8 Periquin
Christrax Dickens 3 . 5 0 Academi c
lliad Hhne:' 1 0 . 2 5 Random
164 1 Fundamentos de programación en Linux
--

La instrucción GAWK literalmente busca la primera condición; una

vez que la encuentra, entonces busca exclusivamente la segunda
condición. En el proceso, puede pasar por alto concordancias con la
primera condición. De hecho, puede haber otros conjuntos de
concordancia y GAWK los recuperará todos. GAWK no se detiene
con el primer conjunto recuperado: reinicia la búsqueda después de
cumplir la segunda condición, buscando otra pareja que concuerde.

Operaciones aritméticas
y de asignaclon
GAWK tiene un conjunto conipleto de operadores aritmbticos. Usted
puede realizar los cálculos de riiultiplicación, división, adición, suitrac-
ción y módulo. Los operadores aritniéticos son los mismos que se usan
en cl lengiiaje d e prograinacióii C y se presentan en la tabla 5-8, junto
con los operadores de asigiiación, los cuales se explican brevemente.
Usted puede realizar cálculos aritméticos con valores numéricos
representados por patrones nuniéricos. U n patrón numérico es cual-
quier seciiencia de d!gitos y una coiistante aritmética es un patrón
numérico obvio. U n cainpo cuyo contenido son dígitos, tainbién es un
patrón numérico. Las constantes aritméticas, las variables de campo y
las variables definidas por el usuario, cuyos valores son patrones i ~ u m é -
ricos, se p~iedenusar coino operandos en operaciones aritniéticas.
Taiiibién hay ciertas variables especiales d e GAWK que se definen
coino numéricas, tales como NR y NF, que taiilbién piiedeii ser
operaidos aritméticos
Las operaciones aritniéticas se piieden usar como el segmento
acción o patrón de la instrucción GAWK. En el siguiente ejeinplo, el
usuario obtiene conio resultado la línea con núniero par. El signo de
porcentaje e%) es un operador de inódulo que da como resultado el
residuo de una división. Si 2 divide igiialinente el iiúiiiero de la línea
sin que haya nirigúii residuo, entonces la Iínea es una Iínea con número
par. Observe que el paréntesis se utiliza para arreglar la expresión.
 Capitulo 5: GAWK 1 165
~ [ W
2 Christmas
TBR - . m r r n t R7T'F books
Dickens 3.50 Academic
-

4 Raven Poe 2.50 Penguin

Operadores aritméticos
y funciones Descripción
* Multiplicación
División
Adición
Sustracción
Módulo; el resultado es el residuo de una división
Corta un número de punto flotante, num, para
aproximarlo a su valor entero
cos(num) Presenta el coseno de num
sin(num) Presenta el seno de num
log(num) Presenta el logaritmo natural de num
exp(num) Presenta el exponente de num
sqrt(num) Presenta la raíz cuadrada de num
rand() Presenta un número aleatorio
srand(num) Usa num como una nueva semilla para rand()
Operadores de asignación
-
- ~si&ación
++ Incremento
Decremento
Adición y asignación; i = i + 1 es igual a i +=1
Sustracción y asignación; i = i - 1 es igual a i -=1
Multiplicación y asignación; i = i * 1 es igual a i *=1
División y asignación; i = i / 1 es igual a i /=1
Módulo y asignación; i = i % 1 es igual a i %=l

1 Tabla 5-8 1 Los operadores aritméticos y d e asignación y las funciones d e GAWK

166
.-
1 Fundamentos de programación en Linux

C o n operadores ): variables aritméticas, usted puede realizar ficil-

mente cálculos en un campo de un archivo d e base de datos. Por
ejemplo, podría suiiiar los valores del inisnio campo eii cada línea, tal
conio podiía sumar una columna en una hoja d e cálculo. En el si-
guiente ejemplo se suiiia el tercer campo en el archivo books. La varia-
ble tot, definida por el usuario, coiitieiie el total ): la condición END
iniprime después el valor final de la v;iriable tot. Conio las variables se
inician automáticaiiieiite con O, la variable tot comienza con un valor
inicial d e O.

m m p r 7 n t "T~t'ai-'~,fotl'-tjoo'k~
Tempest Shakespeare 15.75 Pengiiin
Christmas Dickens 3.50 Acadt-ini c
Iliad Homer 10.25 Randorn
Raven Poe 2.50 Penguin
Total- 32

Ademiís de los operadores aritiiiéticos estáiidar, taiiibién ha): iin

conjunto de operadores aritméticos d e asignación, listados e n la tabla
5-7. Estos operadores coiiibinan la operación de asignación con una
operación aritmética. Se usan conio una forii~ade taquigrafia para
especificar una operación que asigna una variable al resultado d e una
expresión en donde la misma variable también es un operando. La
operación tot = tot-+ 1 se puede escribir con el operador aritmético
+= conio tot += 1. Usted no tiene que especificar la variable tot en
la expresión aritinética porque la operación aritinética d e asigiiación la
asume. La operación i = i * 2 se puede escribir conio i *= 2. El
coniando siguiente produce el niisiiio resultado que en el ejemplo
anterior usando una operación aritinética d e asignación.

m p r i n t ; tot += $31 EN-0 ' i p r i ntl*njotal-",' t o t j i - books'

 Capitulo 5: GAWK 1 167

El operador decremento realiza una sustracción combinada y una operación

- . . -
de asignación. La expresión i- equivale a i=i-l.
, .. ..
LUJ W~CLLIGIWIICJ uc IIICLLLLICIICV JVLL AnLwy UULJ ~ L O.Y(LIILLIL
U a iu ioihv u~ uii

arreglo y con frecuencia se utiliza en bucles para actualizar variables que controlan
un bucle. En el siguiente ejemplo, el iisiiario emplea la varhble linenum para
"a,-.:..
-1
-
"-,Ao+-- A A p,,A.. .
.L.*'%..,. A 1:..&* a,- fiA--l.;n A& .
."e
.- MD L
.-.
...
- "a

iiicremerita en 1 en cada h e a y después se usa para obtener el níimero de la line

$ gawk ' ( 1 inenurn*; p r i n t 1 inenurn. $0 1 ' books

1 Ternpest Shakespeare 15.75 Penguin
2 Christrnas Dickens 3.50 Academic

Arreglos y arreglos asociativos

U n subscript expresado entre paréntesis cuadrados y junto al noinbre
de u n arreglo hace referencia a u11 elemento en el arreglo. C o m o las
variables, el priiiier uso de un subscript en GAWK taii~biéndefine el
arreglo. A diferencia de los lenguajes de programación, los arreglos no
se declaran y n o se necesita dar un tainaíio niáxiino para un arreglo, ya
que éste se extenderá dinin~icainentecuando se haga referencia a los
elementos.
En el siguiente ejemplo se define el arreglo tit1es.A cada elemento
del niis~nose asigna el valor del primer campo de una línea. Unica-
mente habri tantos elementos en el arreglo como valores asignadoi. La
variable num se lisa para hacer referencia a cada elemento del arreglo
168 1 Fundamentos de programación
p. .A -
en Linux

y se increinenta después de cada LISO.Al final, se iniprinie el últiiiio

eleniento del arreglo.

Sin embargo, suponga que desea asignar cada campo de un registro

en particular a un arreglo; podría hacerlo a través de operaciones de
asignación individuales para cada canipo, pero GAWK ofrece un atajo.
Usted puede asignar campos a elementos del arreglo con la función
split, la cual toma conlo sus argumentos una línea, un arreglo y un
separador de campo. El separador de canipo se especifica por medio de
una cadena; para usar un signo de dos puntos como un separador de
canipo, usted especificaría la cadena ":". El separador de canipo es
opcional y, si no se ingresa, se asume como predeterminado una
tabulación o 1111 espacio.
La fiincióil split también puede funcionar eii cualquier cadena.
split("9-10-92", date, "-") asigna 9 a date[l], 10 a date[2] y 92 a
date[3]. En el siguiente ejemplo, cada campo en una línea se asigna a
un elemento del arreglo myrec. La línea asignada se selecciona por
medio del patrón de búsqueda /Dickens/. Después se obtienen los
campos en orden inverso. -
i g ' a w k ' 7 K K n s / ' ( s p i t t 1 S O , myi-ecl:' p r r n t Yfr%43, rn$?&T33'; -
myrecC21. myrec[l]] ' books
Academic 3.50 Dickens Christmas

CAWK también permite que usted defina nrre$os nsociafivos. U n

arreglo asociativo permite que las cadenas sean subscripts del arreglo.
Suponga q u e usted quiere hacer referencia al editor d e un autor a
través del nombre de eite último. En el siguiente ejeniplo, y en la
figura5-2, el usuario asigna los editores a un arreglo organizado por el
nombre del autor. El segundo campo es el nombre del autor y el
cuarto es el nombre del editor. En este caso se iniprinie el editor d e
Dickens. Observe las cornillai dobles que rodean a "Dickens".Cuando
usted usa una constante de cadena coi110 un subscript en un arreglo
asociativo, debe incluir la cadena dentro d e coniillas dobles.
 Capítulo 5: GAWK 169

IXckens
Hoiiicr
Poe

priiit piibl"lhckeiis"j

(piibl[S?] = $4)
Se drfiiie un arrcglo llamado pub1 y sus
elementos se asignan a los valores del cuarto
caiiipo y se organizan segúri el nombre del gawk Acadkinic
autor cn el segundo campo.

Iliad H&cr 10.25 Random

Raveii Pve 2.50 Peiigiiin

\ books

Christinas Ihckens 3.50 Acadeiiiic

Iliad Hoiner 10.25 Kaiidoin
Raven Poe 2.50 Penguin

S gawk '{publ[S2] = S4)'

/ ~ i ~ * r5-21
a Un arreglo asociativo que usa cadenas para organizar los elementos
-1 Fundamentos de programación en Linux
170 - -

Archivos de instrucción
de GAWK
Coilio las iiistruc-cioiies de G A W K se hacen coniplejas, es inás fácil
imnejarlas eii archivos que G A W K pueda leer con f d i d a d . Si usted
necesita hacer algúii cambio, sólo debe modificar cl archivo. La opcicín
-f permite que G A W K lea las instruccioi~csG A W K desdc ~ i i iirchivo,
l cn
lugar de hacerlo desde la Iíriea de comandos (la opción -f se estiidi0 en
una pregiirita de 1ii sección "El coiii;indo gawk" al comit:nzo de este
capítiilo). E11 t.1 ejemplo sigiiicnte, las iiistruccioncs dc G A W K para listar
los libros publicados por I'ei~g~iiiise colocan en ~ i i archil~o
i llamado
Jirirlbk. Entonces, se llama a G A W K con la opción -f y el noinbi-c dcl
archivo.firrdbk.La instruccióii G A W K se leerá desde el archii~o-findbk.
-
BEGIN [ p r i n t "Book L i s t " ;
count = 0;
1
$4 - IPenguinI I
c o u n t = count + 1;
print;

END (
3
-
p r i n t " T o t a l r e c o r d s found i s ", c o u n t :
1

Un ejemplo de la ejecuci6ri del ~cript~fir~ifbk

es el siguieiitc:

$ gawk - f f i n d b k books
Bool L1st
5li;iko ;noare 15.75 Petiqirin
2.50 Fpnqiiin
is 2

--L Con5q.O --- - - - -

Observe que usted n o necesita comillas sencillas para encerrar la

instrucción. También puede organizar diferentes partes de su instruc-
ción en líneas separadas, para hacerla más legible. Esta característica
es m u y útil cuando se usan estructuras de control.
-
-
-
 Prueba de repaso
¿Se puede usar GAWK para acceder a la entrada y salida
estándar en la línea de comandos Linux, como lo hacen los
filtros de Linux?'
¿Es posible ubicar todo el comando GAWK dentro de un
archivo que se pueda ejecutar, convirtiéndolo en parte de un
script de ~ h e l l ? ~

Estructuras de control
GAWK opera como un lenguaje de programación y le permite definir
variables, construir expresiones y asignar valores.También incluye un
conjunto de estructuras de control para permitir la capacidad de repe-
tición y selección. En GAWK hay tres estructuras de control para
construir bucles: while, for y for-in. Existe una estructura de control
de selección: if. Las estructuras de control de GAWK se presentan en la
tabla 5-9 y se describen en detalle en las secciones siguientes. Con
excepción del bucle for-in, estas estructuras de control son similares a
las del lenguaje de programación C.

El bucle while
.
El bucle while consta de la palabra clave while seguida por una exprc-
sión de prueba entre paréntesis. Una acción GAWK sigue a la expresión
de prueba y se pueden combinar varias acciones GAWK en un bloque
de acciones con corchetes, separando cada acción con un signo de
punto y coma.Al colocar un bloque de acciones después de la expresión
de prueba de un bucle while se ejecutan todas las acciones que se
encuentren dentro del bucle. Esta es la sintaxis del bucle while:

while ( expresión de prueba )

{
acciones - gawk;
1

3 Sí; GAWK puede leer desde la entrada estándar y escribir en la salida estándar.
4 Sí; usted puede crear scripts de shell que usen comandos GAWK.
 amación e n Linux

La mayoría de bucles requieren tres componentes para trabajar apropia-

damente: una iniciación, una prueba y un incremento.Todos los compo-
nentes operan sobre una variable que se usa para controlar el bucle.
En el archivo direefields, que se presenta más adelante, se imprimen
los primeros tres campos de cada registro. La variable i se usa para
controlar el bucle, y el incremento de i se ubica dentro de un bloque
entre corchetes en el interior del bucle. Entonces, la variable se pone a
prueba en una operación relaciona1 con la expresión de prueba del
bucle para determinar cuándo se detiene este último.

Sintaxis de la estructura Descripción

de control
{ acciones ) Un bloque se forma con corchetes de apertura
y cierre y se utiliza para agrupar acciones, po-
niéndolas bajo una estructura de control
-como u n bucle- o encerrando las acciones en
la instrucción GAWK apropiada.
if (expresión) La estructura de control if ejecuta una
acción acción si su expresión es verdadera. Si es falsa,
else se ejecuta la acción else.
acción
while(expresión) La estructura de control while ejecuta
acción
for (exp 7; exp2; exp3)
acción
- una acción en tanto la expresión sea verdadera.
La estructura de control for ejecuta una
acción en tanto exp2 sea verdadera. La primera
expresión, exp7, se ejecuta antes de que co-
mience el bucle. La tercera expresión, exp3, se
ejecuta dentro del bucle después de la acción.
for(variab1e in nombre La estructura de control for-in se diseñó para
del arreglo) usarse con arreglos asociativos. El operando
variable se asigna consecutivamente a las cade-
acción nas que forman el índice del arreglo.
next El enunciado next detiene las operaciones en el
registro actual y salta hacia el registro siguiente.
exit El enunciado exit termina todo el procesamien-
t o y ejecuta el comando END, si hay uno.
 Capitulo 5: GAWK 1 173
El valor de i se usa para hacer referencia a cada campo en el regis-
tro. La primera vez que pasa el bucle, el valor d e i ser5 1, de 111odo que
$i hará referencia a la primera variable de campo del registro. Cuando i
se incrementa, su valor cambiará y $i hará referencia consec~itivamente
a cada variable de campo para la línea que sigue, hasta el tercer campo,
en donde el bucle termina.

IConmjb .. .

Usted puede emplear cualquier variable numérica definida por el

usuario, como la variable i, para hacer referencia a una variable de
campo. La identificación de una variable de campo consta de un
signo de dinero antes de un valor numérico; dicho valor se puede
obtener de una constante o de una variable numérica. Si el valor de
la variable i es 2, entonces $i hace referencia al segundo campo.

Este es el script t1lrceficld.c

El siguiente es un ejemplo de la ejecución del script t1lreejcld.s:

_I

'books
T~mpest Shakesptá~r-e 15.75
Chri stmas D i ckr.ris 3.50
11 iad íiomer 10.25
Raven Poe 2.50

Usted puede adaptar con facilidad el bucle while para usarlo con
arreglos. La variable que se utiliza para controlar un bucle también se
puede emplear, dentro del bucle, para establecer el índice de un arreglo.
En el scriyt titlearrczy que sigue, los elementos del arreglo title se asignan
 C a p i t u l o 5: GAWK 1 175

copi,ido\ por split \e ii\igiia entonces a 11' variable fnum y loi elemento\
dcl arrcglo se inipriiiien u~,iiidofnum c o m o el e i i l ~ c csuperior.

El ejemplo siguiente iiiucitra una cjcc~icióiidel ccriptJcldr~iiay.

El bucle for
Este bucle realiza las iiiisiiias tareas que el bucle while pero tiene un
formato diferente. La iiiici'ación, la prueba y los coiiiponeiites del
increiiieiito d e uii bucle estliii incorporados en la sintaxis del bucle for,
que cuenta con tres expresiones entre parkiitesis y separadas por punto
y coinii.
for ( expresión 7; expresión2; expresión3)
1I
acciones-gawk;
1
La priiiiera expresión se ejecuta antes de que el bucle realniente se
ingrese; por lo común, consta de una iniciación de iina variable que se
lisa para controlar el bucle. La ieguiida expresióii es la expresión de
prueba, tal c o m o una expresión relaciona1 qiie controln el bucle. La
tercera expresióii se ejecuta dentro del bucle al final. En general, se
ciiiplca para increiiicntar la variable que controla el biicle. llespuks de
las expresiones va la acción GAWK que se ejecuta dentro del bucle.
176 1 Fundamentos de programación en Linux

Esta acción puede ser un bloque de acciones enmarcadas entre corche-

tes. La tercera expresión se ejecuta después de la acción de GAWK.
for( iniciación; expresión de prueba; incremento)
{
accionesgawk;
1
E n el archivoJeld3for, los primeros tres campos se imprimen usando
el bucle for. Observe que el bucle for es n ~ u c h omás compacto que el
bucle while.

El sigiiiente es un ejemplo de la ejecución del scriptJield3for.

- .
' $ gawk - fTiiiCTd3for books
Tempest Shakespeare 15.75
C h r i stmas D i c k e n ~ 3.50
11 i a d Homer 10.25
Raven Poe 2.50

Usted puede usar con facilidad el bucle for, al igual que el bucle
while, para administrar arreglos. La variable que se usa para controlar
un bucle también se puede emplear dentro del mismo como el índice
del arreglo. En el archivo titlenrrq, los elementos del arreglo title se
asignan al valor de cada título. Despué5, el contenido de cada elemento
se imprime usando un bucle for. La variable i se utiliza para controlar
el bucle. Se inicia en 1, en la primera expresión de for y se increinenta
~ J la
I última expresión; el increniento tendrá lugar después de la acción
print. La segiinda expresión es la expresión de prueba que controla el
bucle.
 --
Capitulo 5: GAWK 1 177

El siguiente es iin ejernplo de la ejeciición del script titfcarrrnyfi

Ternpest
Christmas
Iliad
Raven

El bucle for-in
Aunque en los ejemplos anteriores se usó una variable numérica para
referirse a los elei~ientosen un arreglo, no sirve como ayuda cuando
usted necesita aludir a elemeiltos de iin arreglo asociativo, a los cuales
se hace referencia por medio de cadenas, no de números. CAWK tiene
una estructura especial de control del bucle for-in que le permite a
usted hacer referencia a un arreglo asociativo.
Esta estructura del bucle-consta de la palabra clavefor, pero es muy
diferente del bucle for. Es una expresión especializada que usa la
palabra clave ii? como su operador, que es la razón para que el buclc se
describa coino for-in y no sólo como bucle for.
El primer operando en la expresión del bucle for-in es una variable
y el segundo operando es el rioinbre del arreglo. Cuando se ejecuta el
bucle, la cadena qiie contiene el índice de cada elemento se asigna a
esta variable. Entonces, usted puede usar el contenido de esa variable
para referirse al índice de un elemento dentro del arreglo. N o se per-
mite ningún otro tipo de expresión. El bucle for-in para un arreglo
asociativo es muy restrictivo en este sentido. La sintaxis para el bucle
for-in es como sigue:
for(variab1e in nombre-arreglo)
í
I
acciones-ga wk;
1
-1 Fundamentos de programación
178 - .
en Linux
- -- .- .

Eri el siguiente script, l ) k r o i i ~ i ttodos

, los eleiiieiitos del arreglo
bookcnt se imprinieii dcspiii.~de habcr procesado la5 líiie,is. 1)uratite
cl procesamiento, e1 índicc par,) el xrcglo bookcnt c\ cl c ~ ~ a -campo to
del registro, el iiombre del editor. En el bucle for-in, la val-i~blede
cadciia, pubname, se usa para el índice del arreglo bookcnt eii l i i g ~ r
dc utia vxiable iiunikrica. Cada vez qiie se ejeci~t'~ el biiclc, 13 cadena
cliw hace refercnci~al sigiiieilte clcnieiito se asigna ,i pubname. LJ
variable pubname se L I Weiitoiiccs,
, pdrd incliiir eii cl índicc ese elc-
meiito del 'irrcglo. Sc inipriiiieii tanto el índice coino el elemeiito del
'irreglo.

El sigiiicnte es iin ejeniplo d e iina ejecución del script bkr~niitrt.

- - , - -
4 gawk -f bkcount books

La estructura de control if
GAWK tanibikri tienc una estructura dc control de selección que
perniite seleccionar acciones alteri~ativas.Esta estructura, if, c~ieiitacon
una cspresión de prueba entre paréntesis y después de la pruebn sigue
uiia acción (;AWI<. Si la priieba es verdadera, se realiza la acción. En
caso contrario, la acción se pasa por alto. Esta es la siiitaxis d e la estruc-
tura i f

if(expresión de prueba)
{
acciones-gawk;
1
 Capitulo 5: GAWK 1 179

L'i estructura if taiiibih tiene un coiiiponentc opcional else, al que

sigue otra iiccibn C;AWI<. Si 1;i cxprcsibn de prueba dc la estructiira if
es falsa, cntoncci je ejecuta la accibn que le sigiic a else. En eite senti-
do, la cstructiira if-else se puede coiisiderar como una estructura de
rainificación. Si la prueba es verdadera, se realiza una acción; si ei falsa,
se realiza otra acción. La siguiente es la sintasii dc la estructiir~if-else:

if (expresión de prueba)
acciones-ga wk;
else
acciones-ga wk;

JNota
Tenga especial cuidado y observe que no haya ningún signo de
punto y coma al terminar las acciones de CAWK que se realizan antes
de else. La estructura if-else de CAWK es similar a la estructura if-
else del lenguaje de programación C, con esta excepción. Si usted
usa lenguajes de programación, puede agregar inadvertidamente un
punto y coma, algo que se considerará un error porque un punto y
coma en CAWK separa acciones. - --.

Eii el script 11m4wpquc se presenta a contii~uación,el tercer canipo

del archivo books ei un precio. Si el psccio cs iiiás de $1 0.00, eiitonccs
el script lo auiiiciitará en 10 por ciento. I l e otro modo, lo aiiiiientari
20 por cielito. Obscrve Guc no hay signo de puiito y c o ~ mal final
dc la nccióii arites de else.

' C
i f ( S 3 > 10.00)
$3 - $ 3 + (0.10 * $3 )
el se
$3 -
p r i n t $0
$3 + ( 0 . 2 0 * $ 3 1;

El siguiciite es iin ejemplo de la ejecución del script mnrkuy:

 ación en Linux

Los enunciados next y exit

GAWK tiene otros dos enunciados, next y exit, que se usan con
frecuencia con bucles y la estructura if. Ambos enunciados detienen el
procesamiento de un registro.
El enunciado next detiene el procesamiento del registro actual y
pasa a procesar el siguiente. En efecto, next detiene la ejecución de las
instrucciones GAWK en un registro en particular. Después, se lee el
siguiente registro y el procesamiento continúa. El enunciado next se
usa con frecuencia para pasar por alto un registro.
El enunciado exit detiene el procesamiento de todos los registros y
ejecuta la instrucción END.

El enunciado getline
Este enunciado le permite controlar la lectura actual de las líneas de
entrada. Por lo común, GAWK leerá una línea de entrada a la vez y
aplicará todos los comandos y acciones que hay en un archivo GAWK
a esa línea; getline le permite leer una línea de entrada dentro de una
acción GAWK. Usted puede realizar, entonces, unas pocas operaciones
específicas sobre la línea, en lugar de tener que aplicar en ella todos los
comandos y acciones.
Por ejemplo, suponga que desea realizar una acción, pero no en la
línea que se encuentra conlparando, sino en la siguiente. Usted puede
usar las poderosas capacidades de comparación de patrón de un co-
mando gawk para localizar la línea que necesita y después, usando
getline,leer la siguiente línea y realizar en ella la operación que desee.
El comando getline lee una línea de entrada y la ubica en la varia-
ble $0. La primera vez que usted usa getline en una acción, ese co-
mando reemplaza la línea de entrada que GAWK acaba de leer
automáticamente. Asegúrese de realizar las operaciones que necesite en
la línea de entrada cuando GAWK hace la lectura, antes de salir con su
enunciado getline.
Cuando use getline en un bucle es necesario que verifique una
condición de terminación de archivo; getline no detendrá a GAWK
automáticamente al final de un archivo sino que presenta un O, si llega
a esa parte. En caso de que no llegue al final de archivo, presenta un 1.
Usted puede asignar este valor de retorno a una variable y después
 -
Capítulo 5: GAWK 181

ponerla a prueba en su bucle, de rnodo que pueda detenerla cuando

llegue al final.
E11 el ejen~ploque sigue con ~errables,el script hace uso de la varia-
ble endfile para verificar si se ha llegado al final del archivo (endfile es
una variable corriente). Primero, endfile se inicia en 1 y después se
revisa dentro de la prueba del bucle while. En cada llamado a getline,
el valor de getline se asigna a la variable endfile;así, si se alcanza el
final del archivo, getline dará O, el cual se asignará a endfile, convir-
tiendo la prueba de while en un endfile falso. La iniciación en este
ejeinplo es redundante pero se incluye para hacer énfasis en el tenla.
El script cqettables está diseñado para extraer todo el texto con for-
mato de tabla de u11 archivo troff de UNIX. Usted podría usar la
rnisi~ialógica para estraer un rango de líneas de cualquier documento
con los separadores begin y end. Cualquier rango de líneas que co-
mience con .TS y termine con .TE son textos con formato de tabla.
El comando gawk compara el .TS inicial y el bucle continúa leyendo
líneas hasta llegar al final del archivo o cuando se alcailza la línea .TE
de terniinación. Recuerde que el carácter " indica la existencia de un
patrón al comienzo de una línea, de modo que la forma /"\.TS/
especifica una línea que comienza con .TS.

!"\ .TSr
endfile
C
- 1: *
w h i l e I ( e n d f i l e !- 0) && ( $0 !- / " \ . T E / 1
(

endfile
1
-
p r i n t $0;
getline;

p r i n t $0:
1

IC o n ~ e ~ b
Es importante poner a prueba esta condición de fin de archivo cuan-
do usted usa bucles con getline. Sin ella, getline continuará tratan-
do de leer, desde su entrada, incluso cuando se encuentra al final del
archivo. El bucle mismo continuará como un bucle infinito hasta aue I

usted lo elimine forzosamente con la combinación de interrupción,

CTRL-C - 3
D
182 1 Fundamentos de programación en Linux
- - -

Uso de archivos con GAWK

Usted ha visto cómo GAWK piicde leer datos d e archivos y enviar c1
resultado a la salida estándar, la cual sc piiede redircccionar para escribii-
el resiiltado en ~ i narchivo. C~ialqiiicrarchivo q ~ i ciisted espccifiqiie
conio entrada, eii rcalidad se coinbiiia en ~ i i iflujo de datos continuo
qiie se lee líiiea por línea. l_)e hccho, hay un fl~ijocoiitiniio de entrada
y iin flujo c o n t i n ~ ~deo salida para GAWK.
N o obstante, suponga q ~ i edcsca obtener diferentes tipos de datos
p ; ~ r a s e p x ~ r a r c l ~ i vdeo sdatos. Enipleando el ejemplo de los libros,
suponga que desea obtciier iina lista de editores y iiiia lista de títiilos en
archivos separados. Podría escribir dos filtros GAWK diferentes, uno
para cada tarea. pero tainbién puede crear un script GAWK y escribir
los dos archivos directamente. Los coniandos de entrada y salida dc
GAWK para archivos se prcscntan en la tabla 5-10, y se explican a
continiiacibii.
Para escribir datos en 1111 archivo dentro de iin progrania en GAWK,
t i m e que usar iin operador de redireccioiiamieilto coi1 una operacibn
de salida coiiio p r i n t o p r i n t f . Para anexar datos a u11 archivo, ascgíire-
se de usar el operador d e 1-edireccioiiaiiiieiito de anexos, >>. El si-
guiente coinando g a w k escribirá el contenido del tercer caiiipo en el
archivo cos[$Ic. El noilibre del archivo es una cadena y aquí csti entre
comillas coino una constante de cadeiia.

print $3 >> -"costfile";

Para lcer datos de un archivo baita con ~itilizaruii operador cstáiidar

de redireccionainiento de entrada con el nombre del archivo y un
coinando de eiitrxia d e GAWK, tal conio getline.junto con la varia-
ble que desee p a n leer los ddtoi. En el iiguientc cjeinplo se Ice u i l ~
Iínca d e datoi del script yii0licf y se coloca en la val-i~bleb u f f e r p u b .
Observe que el nombre dcl archivo qued'i entre comillas: GAWK
crpera usar una c,ideria como 1ionibl-e del archivo y, en eite caso, eitá
recibiendo una conitante de cadena. Usted podría asignar el rioinbrc
del archivo a una variable y ~ir,irlaa cambio.
 Capitulo 5: GAWK
-- 1 183
-F

Operaciones d e salida Descripción

print Lleva la Iínea corriente a la salida estándar.
print var Lleva la variable vara la salida estándar.
prin t var>> filename Lleva la variable vara u n archivo.
prin t>>filename Lleva la Iínea actual al archivo especificado.
printf(format, van)>> filename Lleva el resultado formateado al archivo espe-
cificado.
Operaciones d e entrada
getline var Lee la siguiente Iínea de entrada y presenta O si
se encuentra al final del archivo. Si se especifica
una variable, var, leerá la Iínea de entrada.
getline var << filename Lee la siguiente Iínea d e la entrada del archivo
especificado y presenta O si se encuentra al
final del archivo. La Iínea se lee en la variable
especificada, var.

l~abla5-10
- 1 Operaciones d e entrada y salida de GAWK c o n archivos

7
getl i n m e r p u b < "publíst";

El progranid zctat, CILIC vercnios breveiiiente, revisará los registros

que tienen cditorcs en Id lim del arcliivo yirblist. El archivo yilblist fiie
creado por \ e p ~ r a d uy contiene el coiijuiito de noinbi-es de editores
íiiiicos, como se muestra a contiriiiacióii:

En el programa zrtclt, esta Iistri dc editores del archivo p~lblistsc lisa

para establecer el índice de un arreglo asociativo a cuyo elemento se le
asigna el valor 1 . Los demás editores qiic se incluyan en este arreglo
tendrán el valor predeterminado de O. Al usar el campo cuarto, del
editor, se hacer referencia a pubarray. Si si1 ~ l o esr 1 , entonces el
campo del autor, $2, se escribe en el archivo clrrthnrlist y el campo de
título, $1, se escribe en el arcliivo titlclist. El coniando print con
redireccionaniento del anexo realiza la operación dc escritirra.
 programación
--
en Linux

El siguiente es el progranla getnt:

while ( ( g e t l i n e bufferpub

3
pubarrayCbufferpubl -< "publlst")
1;
!- 0)

C
.-
C en un archivo 1
I~scribiendo-datos
-
c o u n t c 1:/
p r l n t $1 >> " t i t l e l i s t " ;
p r i n t $2 >> " a u t h o r l i s t " :
J
1
END (
p r l n t " T o t a l r e c o r d s found I s
1
". count

El siguiente es un eje~nplode l a ejecución del script getat:

' i4iwk - i - g e
T o t a l r e c o r d s found i s 3
r
- - - --- 4

$ cat t i t l e l i s t
Tempist
11 i a d C .

Raven
S c a t a u t h o r l is t
Shakespeare
Homer
Poe

Proyecto 5-1: Scripts de GAWK

Usted puede usar CAWK para definir sus propios filtros situando toda la
instrucción de CAWK en un archivo de script. Puede hacer que el archi-
vo se ejecute y que el nombre del archivo se convierta en un nuevo
comando Linux.
Dentro del archivo de script, las instrucciones de CAWK se deben
marcar entre comillas. Literalmente, un archivo de script contiene un
comando Linux que se ejecutará en el shell, de modo que dentro de ese
archivo debe escribir la instrucción como si fuera a ejecutarla en la línea
de comandos. Usted puede escribir las condiciones y acciones de CAWK
en sus propias líneas; pero cualquier retorno de carro se debe marcar
dentro de las comillas de iniciación y terminación de la instrucción
CAWK. Esto significa que la primera Iínea de la operación CAWK comen-
zará con la palabra clave gawk seguida en la misma Iínea por una
comilla sencilla. Después, usted puede ingresar la condición y las accio-
nes de la instrucción CAWK en líneas diferentes. Sin embargo, el térmi-
no de la acción debe marcarse con una comilla sencilla, seguida en la
misma Iínea por cualquiera de los argumentos del nombre del archivo.
La sintaxis para un formato de esta naturaleza es el siguiente:
gawk '
patrón {
acciones-gawk;
) ' nombres de archivo

Paso a paso
1. Cree un archivo de script llamado field3 en donde pueda ubicar la
instrucción CAWK. La instrucción imprimirá los primeros tres campos
de cada Iínea.
2. Marque entre comillas la instrucción CAWK, comenzando con una
comilla sencilla antes del corchete de apertura y termine con otra
después del comando gawk.
3. Cree un bucle for que iniciará una variable llamada i y la
incrementará tres veces.
4. Cree enunciados printfque usen el valor de i para referenciar un
campo, comenzando con el primer campo y terminando con el
tercero.
5. Cree un enunciado final printf que dé como resultado un carácter de
nueva Iínea después que el bucle termina.
6. En la última Iínea, después de la comilla sencilla de cierre y luego del
corchete de cierre, ingrese el nombre del archivo que ha de leer
CAWK (books).
7. Establezca el permiso de ejecución para el archivo de script, y des-
pués ejecute ese archivo ingresando simplemente el nombre del
mismo.
A continuación presentamos el contenido del script field3:
186
,-
1 Fundamentos de programación en Liniix
-

p r i n t f ( " % s \ t m , S i 1:
1
p r i n t f("\nW);
1 ' books

Este es u n ejemplo de la ejecución del script field3:

- -A- . -
$ chmod 755 f i e l d 3
6 field3
I S l ~ ~ i k s s r e a r e15. 75
C r7 1 13 D i i he 11: 3.50
Il iad Horw 1- 10.2Ft
R a :/ i?
11 ' ,? r:
2 2 . f,(I:

I1 1. ¿I>iiedcLisas expresiones i-eg~ilaresen las cspresioiies de prueba?

2. ¿Ciiálcs son las diferencias entre los siiiibolos -, = y = =?

3. il'ara trab.jar con q ~ clase
~ é de arreglos esti diseiiadn la estructura de
coiiti-o1 for-in?

4. ¿ Q u é fiiiicih usaría para asignar cada palabra en una oración n los

cleirientos i~idividualesile iin arreglo en Liiia operación siliiple?

5. C u i l variable especial de GAWK ~~tilizaríri

para crear una operación
GAWK que presentara desde la cuarta hasta ln séptima línea de ~ i r i
archivo?
Los objetivos de este capitulo son:
Usar los comandos Perl sencillos para operaciones básicas

Crear y ejecutar scripts de Perl

Administrar entradas y salidas de Perl para archivos, para entrada y salida estándar y error

Aprender a definir y a controlar arreglos empleando las funciones de administración de

arreglos

Utilizar estructuras de control de Perl para implementar bucles y pruebas condicionales

Aprender a usar funciones de Perl y sus características de concordancia de patrones

y manejo de cadenas
 P erl (Practica1 Extraction and Report Ldtguage) es un lenguaje para
escribir programas, que tiene todas las capacidades de GAWK pero
con más características. Originalmente, Perl se diseñó para operar en
archivos, como lo hace GAWK, generando reportes y manejando
archivos muy grandes. Sin embargo, se creó como un programa núcleo
al cual se le pueden agregar características con facilidad. Con el paso de
los años, las capacidades de Perl se han ampliado enormemente: ahora
puede controlar la interacción de procesos en una conexión de red e
incluso soporta una variedad de archivos de manejo de bases de datos.
Al mismo tiempo; Perl sigue siendo totalmente portátil. Un script de
Perl funcionará en cualquier sistema Linux. Puede encontrar más infor-
mación al respecto en www.perl.org.

Existen páginas manuales extensas y detalladas en Perl que analizan

todos los aspectos del lenguaje con ejemplos estupendos. Las pági-
nas manuales comienzan con el término perl; por ejemplo, perlfunc
analiza las funciones incorporadas de Perl y perlsyn describe las
diferentes estructuras de control.

Operaciones'con la línea
de comandos de Perl
Perl puede ejecutar un comando Perl que se ingresó en la línea de
comandos o un archivo de comandos Perl. Los archivos de comandos
se utilizan más comúnmente, permitiéndole crear lo que, en esencia,
son programas Perl. Perl se llama usando el comando perl; después de
ingresarlo, se necesita introducir una opción para especificar si está
ejecutando un script de Perl o un comando Perl simple: -e para un
comando simple y -f para leer comandos de un archivo. Las opciones
de Perl se presentan en la tabla 6-1.
 Capitulo 6: Perl 1 189
Opción d e la Iínea d e comandos Descripción
-e Entra una línea de un programa Perl
-n Lee desde los archivos que se listan en la línea
de comandos
-P Lleva cualquier dato leído hacia la salida
estándar

FZa,ó_il Opciones de la línea de comandos de Ped

Para ejecutar u11 solo comando Perl e n la línea de comandos del
shell, utilice el coinando perl con la opción -e. Entonces, ingrese el
comando Perl que desee ejecutar y iiiárquelo con coniillas sencillas. La
siguiente operación Perl imprime la cadena "hello" usando el coniando
print de Perl. El comando terinina con el signo punto y coma.

Vr1 -e 7

Usted puede usar Perl de esta manera para operaciones simples, de

manera muy similar a los comandos de una sola Iínea de CAWK. Es
muy raro que se use esta Iínea de comandos en Perl. Normalmente,
los comandos Perl se ponen en archivos de script que luego se ejecu-
tan, de modo muy parecido a los scripts de shell.

Respuesta: Perl no leerá desde la entrada estándar a menos que usted le dé

instrucciones explícitas con un bucle while.A diferencia de GAWK. este progra-
ma no lee la eiitrada estlindar conio predetern-iinada.En el siguiente ejemplo se
busca el patrón "Uickens". El archivo bmks se lleva primero a la salida estándar a
través del comando cat y se trarisinite al conlando Perl como entrada esdndar.
c a t books 1 perl - e 'while(<STDIN>){i f ( / D i c k e n s / ) l p r i n t ; 1 1 '
El siguiente comando de GAWK es equivalente:
c a t books 1 gawk ' I D i c k e n s I { p r i n t l '
Este tema se trata inás detalladaineiite en la sección "Entrada y salida", de
este capítulo.
190 1 Fundamentos de programación
.-- - -.
en Linux
-

Scripts de Perl
Usualiiiei~te,los co1ii:indos de l'ei-1 se ponen en un archivo que
dcspués lee y ejecuta el comando Perl. En efecto, usted est5 crcando
u11 sl-iell en donde se e ~ e c u t a nsus coinandos l>erl.Los archivos que
coiitieneii coinandos Perl deben tencr la extensión .pl. Esto identifica
el archivo coino un script de l'crl que se piwde leer con el coiriando
perl. Hay dos maneras d e usar este coiiiaiido con el fin d e leer scripts
d e I'erl.
La primera opción es ingresar el coiiiando perl en la línea de
c o i m i d o s del shell, seguida por el noinbi-c del script de I'erl. Este leerá
y ejecutará los coii~andos.En el siguiente ejcniplo se ejccuta un script
dc Perl Ilaiiiado 1rello.yl.

La segunda forma es iiicluir la llaiiiada del coiliando perl dentro del

al-cliivo d c sc-ript de l'erl, de niaiiera sciiiejaiite a coi110 lo haría con 1111
script de shell; /usr/bin/perl debe ser el sitio de su sisteiiia en doiidc
dcbc estar el coniaiido perl. Si usted sitúa la iiistruccióii del shell que
sigue en la primera línea de su archivo, autoiiláticaniente llriina el shell
de I'crl y ejecutará los siguientes c-oniaiidos l'erl eii el script de shell.

Para hacer que el script se pueda e~ecutar,usted debe establecer los

peririisos para que así suceda. El coinaiido chmod con la opción 755
fija los perniisos de ejecución de iin archivo, convirtibndolo en 1111
programa que puede funcionar en la línea de coinandos. Usted sólo
ticiie que realizar esto una vez por script y iio tiene que hacerlo si está
iisaixio el coii~andoperl en la línea de coinandos, coino se indicó
prcviaiiiente.
En el siguiente ejemplo se deterniinaii los perniisos de ejecución
para el script 1.relIo.pl:
 Capitulo 6: Perl 1-
191

Perl tiene miichas similitudes coi1 el lengiiajc de prograimción C y

con (;AYVI<. C o m o en C , los comando5 Perl teriiiiiinii con un sigiio de
p~iiitoy c o i i ~Ig~ial
~ . que en GAWK, hay iin coiiiaiido print para
obtener cl texto. I'crl también Lisa la inisma wmencia de cscape para
obtencr líneas I ~ L I W J ~(\n)y tabulacioiicq (\t). Los coiiieritai-ios, conio
cn el shell y cii GAWIZ, son líiic~qqut. coinicnzan c.oii 1111sigilo #.
El siguiente script 1wllop1;qcs ~ i i ejeiiiplo
l i ript d c I k - l . Im-
de ~ i i S<
pririic la palabra "licllo" y uiia niicva liiica. Observc. cl llainado del
c o i i ~ a i ~ dperl
o en la priii~cralínea.

p r i n t "hellb\n":

El siguicntc e i u11 ejemplo dc 1'1 ctjcccuió del script 1rrlloyr;y:

g u n t e -a los expertos
9
Pregunta: ¿Cuáles son algunos errores comunes en la sintaxis?
Respuesta: Aunque Perl es ui~leriguajeinterpretado, todo el script de I'er
se valida primero antes de ejecutarlo, verificando si hay errores en tirnipo dt
A ..,.. a-.-..
.. c- ?A",. ,.c-..-.
L..- L b - " .-,.-A A- -.,.".. ..-.. +,.ll,. :c-.-.,a- l

Muchos iiieiiqes de error pueden w r coiifiisos. Los sigiiientes son algunos

de los errores iiiás coiiiunei:

* Uno de ello5 es no marcar los signos de punto y coma al final de iiiia

línea. Los coniandos de I'erl se asemeian a los coinaiido~de shell y a los
coiiiaiidos de GAWK. que no tieiieii este signo, de iiianei-a que es niiiy
ficil olvid;irstt íie n~arcarlos.
1 ., ,...e.,. ........ A , *..... c,,.l A..i ..,....,..,.c !.l ,.,.., ... .,. ....... 4 L....,...,,
..e

inncio d o , como en el C J W de C.
varihle5 siempre deben estdr prefijjadas con un h h a l o de dinero
Esto es muy diferente de GAWK y C.
192 1 Fundamentos de programación en Linux

Lag partes de un programa en Perl se pueden dividir eii archivos

separados y después leerlas dentro de un archivo principal con el
comando use. Estos archivos terminan con la extensión .pm y a ellos
se hace referencia como paquetes o inódulos. C o n freciiencia contie-
nen operaciones anipliadas para realizar tareas como nianejo de archi-
vos o búsquedas de texto. Un conjunto estándar de n~ódulosy
paquetes de Perl se encuentra en el directorio /usr/lib/perl5. La
página nianual perlmod tiene un análisis detallado de los paquetes
y módulos de Perl, que incluyen n~óduloscargados dinámicamente.
El coiiiando que sigue lee el paquete find.pm,el cual provee una
versión en Perl del coniando find del shell para buscar directorios.

Entrada y salida
Un script de Perl puede aceptar entradas desde diferentes f~ieiites.
Puede leer entradas de diferentes arcliivos, desde la entrada estándar e
incluso desde interconesiones. Por esta razón, usted tiene que ideiitifi-
car dentro del progrania la fuente de su entrada; y a diferencia de
GAWK, pero como en un programa de shell, tiene que darle instruc-
ciones explícitas al script de Perl para leer la entrada. Una fuente de
entrada en particular se identifica por medio de un \\lnrrejador de archivo,
un nombre que usa un progrania para hacer referencia a una fuente de
entrada, corno en el caso de uri archivo en particular. Perl ya cuenta
con un manejador de archivo para la entrada estándar y para la salida
estándar, lo nlismo que para el error estándar. El manejador de archivo
para la entrada estándar es STDIN.
Lo mismo se aplica para la salida. Perl puede llevar a muchos destinos
diferentes, sean archivos, interconesiones o la salida estándar, y los
manejadores de archivo se utilizan para identificar archivos e interco-
nexiones cuando se usan para entrada o salida. El manejador de archivo
STDOUT identifica la salida estándar y STDERR es el archivo para el
error estándar. Primero estudiareinos cómo usa Perl la entrada y la salida
estándar y después cónlo se trabaja en los archivos. En la tabla 6-2 se
presenta una lista de los distintos coiiiandos de entrada y salida.
 ~ a ~ i t u6:l oP e r l 1 193

Uso d e la entrada estándar

El c o m a n d o para leer desde la entrada estándar consta de los símbolos
m e n o r q u e (<) y mayor q u e (>).Para leer desde un archivo, un
manejador d e archivo se coloca entre ellos, c o m o e n e l caso d e
<MYFILE>. Para leer desde la entrada estándar, usted simplemente
usa e l nianejador d e archivo S T D I N , así:

< S T D I N > e s similar al c o i n a n d o read e n e l lenguaje de programa-

c i ó n d e l shell BASH.

Sintaxis d e l c o m a n d o
d e entradalsalida Descripción
open(manejador de archivo, Abre el archivo identificado por el manejador
permiso-con-nombre de archivo) de archivos.
close(manejador de archivo) Cierra el archivo identificado por el
manejador de archivos.
Lee el archivo con el nombre filename.
Lee la entrada estándar.
Lee archivos cuyos nombres se encuentran
e n la lista d e argumentos cuando se llamó el
programa.
print <manejador de archivo> text; Escribe en u n archivo; si el manejador de ar-
chivos n o se especifica, escribe e n la salida
estándar, y si n o se especifica ningún texto,
escribe el contenido de $-.
printf <manejador de archivo> Escribe una cadena formateada en u n archi-
"Format cad ",valores ; vo; los especificadores de conversión, format-
cad, se usan para dar formato a los valores.
Si n o se especifica el manejador de archivos,
escribe en la salida estándar; si n o se especifi-
can valores, usa el contenido de $-.

(Tabla Operaciones con archivos en Perl

194 1
- Fundamentos -de- programación
--
en Linux
-

sprintf cad-var " format-cad ", Escribe los valores formateados en una ca-
valores; dena, usando los especificadores d e con-
versión, format-cad, para dar formato a los
valores. Si no se especifican valores, se usa
el contenido de $-.

Tabla 6-2 Operaciones con archivos en Perl (corrtitirrrici~n)

-- - .

Para usar la entrada que el comando <STDIN> lee, usted lo asigna

a Liiia variable. I>ucdc definir uiia variable o usar una variable predeter-
iiiiilada llairiada $-, coiiio se inuestra cii el siguiciite ejemplo. S- es la
forma prcdeterniinada para iiiiiclios coinaiidos. Si el coiiiaiido print
iio tic'iie arg~iinciitos,se iiiipriiiiiri el valor de $-. Si el coiiiando
chomp iio tiene arguriieiitos, opera en $- eliiiiinaiido la iiiieva línea.
El sci-ipt rrryiuwd que se presciita a contiiiiiación ilustra cl LISO dc $- coi1
la entrada estándar.

$ =iSTD 1IN? :
p r i n t "Ttiis i s w h a t 1 e i i t p r ~ d : 8 - " ;

El \iguieiitc es uii cjeniplo J c la cjecucióii del script / i i ) w n d :

$ myread
l a r i s a and a l e i n a
T h i z i s w h u t 1 e n t e r e d : l a r i s a and a l e i n a

Uso de la salida estándar

Usted puede usar el coriiaiido print para escribir datos en cualquier
arcliivo o en la salida cstándar. Los iiianejadores de archivo se sitíian
después del coiiiaildo print y antes de cualquier tipo de datos, coi110
cadeilas o variables. Si iio se especifica el inaiiejador d e arcl-iivos, eritoii-
ces print lleva a la salida estindar. El iiianejador de arcliivos explícito
para la salida est5ildar es STDOUT.
 -.
Capitulo 6: Perl lo

print "hello\nW;

Si no se especifican los datos que se van a escribir, el coniando

p r i n t ~isarríel coi~tciiidodc $-. Eil otras palabras, p r i n t escribirá todo
lo que el comando <STDIN> lea y asigne ,I $-; si p r i n t se Ilcva a la
sdida cstríildar, cl coiitci~idode $- sc coloca cn la salida estríndar. El
script rirycc-lio.pl que sigue Ice una línea desde la eiitr,id,i c s t h d ~ yr
después presenta todo lo que se leyó.

El siguiente es un ejcinplo de la cjccución del script rrrycclio.yl:

--- $ myecho.pl
my name i s D y l a n
my naine i s D y l a n

14x1 también tiene un coniando p r i n t f que opera de rilarier'i i i ~ ~ i y

simil.ir a los coiiiandos p r i n t f de GAWK y C , y que t o i i ~ icoi110
xguinentos una lista de foriiiato y una lista d e variables o valorcs. La
lista de foriilato usa especiTcadores de conversibii para convertir lo\
datos eii v,iri,iblcs o v,ilores que correspoiidm con la sdida. Por ejeni-
plo, "/od es el cspecificador de coilvcrsióii para un entero, %S es para
un'i cadenn !J % f es para ilúineros con piinto flot'intc. En el capítulo 5,
acerca dc C;AWK, se ei~cuentraiin lista coinpleta y i 1 1 - i ~~splicncibii
detallada de printf. Eii cl siguiente ejeijen~plosc coilvicrte ~ i nentero
y una cadend.
-
'
-

$num = 14 ;-
$inyti;.ime = " L a r i s a " ;
p i i n t f "Tor l u n c h % S a t P %d a p p l e s \ n " . $myname. 4num;

La salida para esta operación p r i n t f es como sigue:

' m i s a at'e i 4 ' d p p i e s - -

---
196 1 Fundamentos de programación en Linux

U n inailejador nulo de archivos, < >, es una operación especial de

entrada que leerá la entrada de un archivo que se encontraba en la línea
de comandos cuaiido se Ilanió al script de Perl. Este configura
autonláticamente u n manejador de archivo y lee. Si usted presenta una
lista de varios archivos en la línea de comandos, entonces Perl leerá el
contenido de todos ellos usando el manejador nulo de archivos. Esta
operación puede considerarse como una operación cat en la cual se
concatena el contenido de los archivos de la lista y después se leen en
el script de Perl.
El script de I'erl, rryat.yl, y el comando CAWK que sigue son
equivalentes. Observe que en Perl se debe usar explícitamente un bucle
para leer cada línea de la entrada.
El siguiente es un ejemplo de la ejecución del script mycat.yl:

#! / u s r / b i n / p e r T -- - ---

wh i 1 e ( <> )-{Lee los archivos que se ingresaron- I

{ -
c--o m o argumentos
- para elscript
..
..-
A de-Perl-
A----- /
p r in t :
I

Este es el comnndo GAWK:

Manejadores de archivos
U ~ t e demplea el comando open a fin de crear un manejador de archi-
vo para un archivo o una interconesióil. El coiiiando open toma dos
argumentos: el ilombre del manejador de archivo y la cadena del
nombre del archivo. El nonlbre del manejador de archivo puede ser el
que ustcd desee y por convención se escribe en mayúsculas. La cadena
del nombre del archivo puede ser el nombre del archivo o la variable
que detenta el nombre del niismo. Esta cadena también puede incluir
diferente5 modos de abrir un archivo. Por defecto, un archivo se abre
para lectura; pero usted también puede abrirlo para escribir, insertar o
para leer y escribir. La sintaxis de open es la siguiente:
 --
Capitulo 6: Perl 1 197
open ( m a n e j a d o r d e a r c h i v o , nombre de a r c h i v o - c a d e n a ) :

En el siguiente ejemplo se abre el archivo reports, que llama al

manejador de archivo REPS

Para abrir u n archivo en un modo específico, como escribir o

insertar, usted incluye los símbolos apropiados para el modo en la
cadena del nombre del archivo, separados por un espacio. Los símbolos
de modo se presentan en la tabla 6-3.

? Pregunta: ¿Puedo mantener el nombre del archivo en una variable?

Respuesta: Con frecuencia, el nombre del archivo se mantendrá en la

variable. Después, use el signo de dinero ($) con el nonibre de la variable para
hacer referencia al nonibre del archivo. En este ejemplo, el nombre del archivo
"reports" se mantiene en la variable filen.

l f i l e n = "reports";
open ( R E P S . $ f i l e n 1;

Permiso para abrir archivos Descripción

< filename Sólo lectura
> filename Sólo escritura
+> filename Lectura y escritura
>> filename Insertar (se agregan datos al final del archivo)
command 1 Lee datos desde una interconexión
1 command Envía datos a través de una interconexión

Operaciones con archivos en Perl

198
-
'
1 Fundamentos de programación en Linux

El símbolo dc iliayor quc (>) abrc un rircliivo para cscritura y cl

signo m,ís scgiiido por cl síinbolo dc iiiayor que (+>) pnra acciones de
lectura y cscritura. En el siguiciite cjeiilplo, el ;irchivo r-cport~se abre
para lcctui-a y escritura.
,-- ---- e-

o p e n ( R E P S , "+> r e p o r t s m) :

Si e5tá iic,indo uiia ~~~~~iablc para iiimtcnrr el iioinbrc del archivo,

puede iiicluir 11' vciri,~bleev'iluad,i deiitro de la cadciln del iioinbre del
archivo, como Fe ii1ucstr:i a continu~ición:

Para leer 1111archivo einpleaildo el niaiiejador del misino, ponga el

niaiiejador entre los signos < y >; <REPS> lee una línea de la entrada
del archivo ~ q ~ o r fE11 se abre cl archivo r-cyorfr y su
c . el script i~r)u~'~~oi.f
contciiido se prescilta cil pantalla.

I
print;
t -
clase R E P S :

Para leer la entrada desde una intercoiiexibii, usted usa el comando

open para crear uii iiiaiiejador de archivo para csa iriterconexión. Para
la cadena del iioiiibre del archivo, ustcd lista el comaiido que ingresa
los datos a la interconcsiói~,seguido por el operador 1. Por e j e i q l o , al
usar "cat -n reports 1 " conio la cndcnn del iioiiibre del archivo, se
ejecutar; el coiiiando cat -n reports que lleva cada línea en el archi-
vo rcpot~scon los riíinieros de línea y dcspu&slos ingresa en una inter-
coiiexión. Ln salida d e esta últiina son las líiieas iiuiiieradas que salen
del archivo r c p o r t ~Al usar el manejndor del archivo para esta interco-
nexión, PREP, su programa I'erl piicde leer estas líneas nuri~eradas.
 Capitulo 6: llerl 1 199
Usted tainbién p i d e Ilcvar datos a iiiia intercoiiexi6ii qiic dcspu¿s
se pucdcri canalizar hacia otro coiiiaiido. E11 este caso, el operador 1 se
ponc antes del coiiiando de los datos que se van a traiisinitii-. En el
sigiiicnte qjeniplo, cl iilai~ejadorPTF identifica una ii~tcrcoricsiónq u e
envía datos al foriiiatcador de texto pr.

El script ~ri)li.cpor.fZ.pliiiiicstra cóiiio iisaría iisted las operncioiics de

interconexión pnrn lccr la ciltrncia dcsdc iiilci iiitci-coiiexibii y 1lewrl;i
hacia otra. Estas oper:icioncs lc periiiitiráil obtciicr el iii:iyor provecho
de filtros de slicll. coiiio sort, cut, unique o de otros progi-aiiias qiic
traba-iaii coii 1'1 ciitiada y la salida estindnr.

open ( P R E P , " c a t r e p o r t s 1"):

open ( P T F . " 1 p r " ) ;
while ( < P R E P > )
1
p r i n t PTF:
1

close PREP:
closi PTF;

Prueba de repaso
¿Qué c o m a n d o se utiliza para leer desde la entrada estándar?'
¿Cuál e s la variable predeterminada q u e se p u e d e usar para la

¿Cuál e s el operador q u e se emplea para abrir u n archivo

para lectura y escritura?'

1 <STDIN.
2 S-.
3 +>.
 ación en Linux

El operador de texto: <<

Perl tiene una clase especial de entrada que funciona como la opera-
ción << que se usa en el shell BASH. En Perl, el operador << lee el
texto que se ha escrito directamente en el script de Perl; después,
genera una cadena a partir del texto que usted puede asignar a una
variable, imprimir o inclusive convertir en una lista. La sintaxis para
este comando es el operador << seguido por una etiqueta y un signo
de punto y coma. No hay espacios entre << y la etiqueta, la cual se
utiliza para especificar la terminación del texto que se va a leer. Todo lo
que usted ingresa a partir del enunciado <<, se leerá a medida que lo
escriba, hasta que se llegue a una línea en donde aparezca la etiqueta.
La sintaxis para la operación de texto es como sigue:
<<Etiqueta;
texto
Etiqueta

El comando << puede tratar el texto en tres formas diferentes,

dependiendo de cuáles sean las comillas con que esté marcada la eti-
queta. El texto se puede tratar al pie de la letra, o palabra por palabra,
leyéndolo exactamente como se escribe, como una cadena entre comi-
llas en donde se pueden evaluar las variables y los caracteres especiales
de Perl o como una Serie de comandos, como los comandos de shell,
para ejecutarlos línea por línea. La acción que se tome depende del
tipo de comillas con que se marque la etiqueta: simples, dobles o
invertidas, antes y después de la etiqueta.
Las comillas sencillas alrededor de la etiqueta indican que el texto se
leerá exactamente como se escribió, sin cambios, como si fuera una
cadena entre comillas sencillas.
Las comillas dobles indican que se evaluará cualquier variable dentro
del texto que se va a leer. Si usted escribe una referencia a una variable,
por ejemplo $myname,entonces se leerá el valor en lugar del nombre
de la variable.
Las comillas invertidas hacen que cada línea del texto se lea como
un comando y se ejecute; de la misma forma como las comillas inverti-
das que enmarcan un comando de shell en un programa de shell hacen
que se ejecute ese comando.
 Capitulo 6: Perl 1 201
En todos estoi c'iios, los resultados de las operaciones se ubican en
un'i c'ideiia qiic después puede usar en su programa.

"TAG" E v a l ú a l a s v a r i a b l e s en una cadena

'TAG' E j e c u t a comandos

Las conlillas sencillas están predeterminadas y se asumen cuando la

etiqueta no se marca con ninguna clase de comillas; son útiles para
manejai- grandes cantidades de texto sin tener que usar constantes de
cadena o u11 archivo. Las coiiiillas dobles le dan más flexibilidad, permi-
tiéndole utilizar todas las características de las cadenas inarcadas con
comillas dobles. En el siguiente ejemplo se genera una cadena que
consta de tres líneas; en ella se sustituirán los valores $title y $author.

B t i t l e L w ~ o c k e ~ " :
Bauthor = "Dylan Christopher";
p r i n t <<"BKINFOW; 1 ~ t i q.u e t-
- - arotulada
-- - -

The t i t l e o f t h i s b o o k i s $ t i t l e
The a u t h o r i s $ a u t h o r
The n e x t e d i t i o n i s u n d e r d e v e l o p m e n t
BKINFO

Cuando la etique~arotuhda va entre coniillas invertidas, se esperará

que lea comaridos ejecutables. Cuando se opera desde el shell, un script
de I'erl con una etiqueta con coniillas invertidas ejecutará los coinan-
dos del shell. Al asignar el resultado de la operación de la etiqueta a una
variable, usted puede, de hecho, canalizar la salida estándar de un co-
mando del shell hacia uria variable en su script de Perl.
En el siguiente ejemplo, el coinniido del shell 1s -m *.c generará
una lista de archivos de C como resultado de la operación de <<'CF',
que después se asigna a $mycfiles. La operación <<'LC' ejecuta un
comando de shell más coniplicado que cuenta todas las líneas en los
archivos .c y .h, deteriniriando ese níiiilero, el cual se asigna luego a
$linescode.Aunque únicaniente se utiliza un coniando de shell en
cada lirio de estos ejemplos, usted puede emplear tantos como desee.
En lugar de asignar el resultado a una variable, podría usar el coniando
ptint para presentarlo en pantalla. Sin embargo, el contexto es importante.
202 1 Fundamentos de programación en Linux

Si usted llama el script de Perl desde L I shell

~ de TCSH, esperará ejecu-
tar coinandos T C S H , algunos de los cuales son ligeramente diferentes.

La o~eraciónde texto se usa am~liamenteen la ~roaramaciónen I iI

CGI: En dichos programas, la enirada de texto suele estar integra-

da por comandos HTML que ejecutará el programa de navegación
(browser). En este caso, dado que el script de Perl se llamó desde
-. .n.-.
P! -
a v-~ n-a-d-n -
. rd ~'.la."Wph -
..- , - - Pn-'-i"'i ~ r l ~piprlitar
',"-'
n .". .-- rnmandnc
lnc -...-..-" d-'
~
HTML. Los valores o las variables de Perl se pueden sustituir en
varias partes de los comandos de HTML. Sus resultados se pueden
asignar directamente a una variable de Perl.

Variables y expresiones
Las variables de Perl pueden ser nuinéricas o de cadena. Su tipo está
determinado por el contexto o manera como se usan. Usted no tiene
que declararlas. Una variable a la que se asigna un valor nuniérico y re
emplea en operaciones aritméticas es una variable numérica, y todas las
demás se tratan como cadenas. Para hacer referencia a una variable en
su programa, anteponga al noinbre de la variable el signo de dinero ($)
tal como lo haría con una variable de shell.
Usted puede utilizar el mismo grupo de operadores con las variables
Perl como con lar variables C , except~iaildolos operadores para cade-
nas. Lai cadenas usan los mismos términos especiales de comparacióii
que se emplean en el shell BASH. Los operadores de comparacióii
estándar ertán reservados para variables iluiiiéricas. Sin embargo, otros
 Capitulo 6: Perl 1 203
operadores, coi110 loi de asignación, funcionan tanto en las variables de
cadena como en las variables numéricas. Los operadores aritméticos y
los operadores aritil~éticosde asignación funciorian con valores nunié-
ricos. En la tabla 6-4 se presentan los diferentes operadores de I'erl.
En el siguiente ejeniplo, la variable myname está asignada a la
cadena "Aleina". El operador de asignación es el símbolo de igual (=).

Operadores aritméticos Función

* Multiplicación
División
Adición
Sustracción
Módulo; es el resultado del resi-
duo de una división
Potencia (exponenciación)
Operadores numéricos d e comparación
> Mayor que
< Menor que
>= Mayor que o igual a
<= 7
Menor que o igual a
-
-- lgual en let
!= No es igual a
Operadores d e comparación d e cadena Descripción
gt Mayor que
It Menor que
ge Mayor que o igual a
le Menor que o igual a
eq lgual a
ne No es igual a
Operadores de incremento
++ lncrementa la variable en 1
Disminuye la variable en 1

Operadores de Perl
204 1 Fundamentos de programación
.--.
en Linux

Operadores aritméticos de asignación

+= Incrementa en el valor especificado
Disminuye en el valor especificado
La variable es igual a sí misma dividi-
da por el valor especificado
La variable es igual a sí misma multi-
plicada por el valor especificado
La variable es igual al residuo de la
división de sí misma entre el valor
especificado
Operador d e asignación
- Asigna un valor a una variable

Tabla 6-4 Operadores de Perl (corttinrinción)

Usted puede asignar un valor entero o de punto flotante a uiia

variable niiniérica. Perl trata todos los valores de punto flotante con
una precisión d e dos lugares deciriiales.

"Trnyrium =T
Bprice = 54

Perl tainbiéii soporta expresiones aritinéticas y expresioiies que se

pueden anidar usaido parGiite5is.Todos los operadores aritrnGticos
estándar que se e i ~ u e i i t r a nen otros lenguajes d e programación se usan
en I'erl. Los operandos pueden ser constantes nuiiiéricas, vxiables
numéricas LI otras expresiones iiuilith-icas. En los siguientes ejemplos se
asigna $mynum al resultado de una expresión de adición. Desputs, ese
valor se usa en una expresión aritiiiética compleja cuyo resultado se
asigma aprice.

l'erl cuenta con todo el rango de operadorei de asignación que 5c

encuentran en GAWK y en C. Los operadores + + y - - increiiiei-itan
o disninuyeii una variable. Los operadores += ,- = y sus variaciones
realizarán el equivalente de actualización de una variable. Por ejeniplo,
 Capitulo 6: Perl 1 205

i++ es igual a i = i + 1 e i += 5 es igual a i = i + 5. Las operaciones

de incremento conio i++ se usan aniplianierite con bucles.
Usted puede incluir con facilidad el valor de una variable dentro de
una cadena, colocando sinipleniente la variable dentro de ella. Dado el
primer valor de asignación para la variable $myname, en el ~iguiente
ejemplo, el valor de $nameinfo sería la cadena "My nanie 1s Aleina \n".

Para asignar a una variable datos que se leen desde u n archivo,

sencillamente asigne el resultado de la operación xead a la variable. En
el siguiente ejemplo, los datos que $e leen desde la entrada estándar se
asignan a la variable $mydata.

En el script /rr)wad2 que sigue, el script myread se ha modificado

para usar la variable $myinput. Cada vez que el usuario escribe, se
asigna a $myinput. Después, el contenido de esa variable se iniprinie
conio parte de una cadena, usando cl comando print.

$myinput = <STDIN,,; '

p r i n t " T h i s i s w h a t 1 e n t e r e d : $myinput \ n W ;

El siguiente es un ejemplo d e la ejecución del script myread2

! .
$ myread2
l a r i s a and a l e i n a
T h i s i s w h a t 1 e n t e r e d : l a r i s a and a l e i n a

Ciiando se leen datos enviados desde el teclado a una variable, el

carácter d e retorno del carro se incliiirá con la cadena de entrada. Es
posible que usted no desee tener este retorno del carro como parte del
valor d e la variable; para rctirai-lo, puede usdr el comando chomp quc
elimina el último carácter dc cualquier cadena y con la entrada de
datos desde el teclado, esc carácter tiene que ser el retorno del carro.
206 1 Fundamentos de programación en Linux
-- --

En el script rc~adrra~ne.plque ~ i g u eel usuario entra su nombre y lo

asigna a la variable m y n a m e . El contenido de m y n a m e se iilipriilie
después coino parte de la cadena; c h o m p se uw para quitar el retorno
del carro al final de la cadena $ m y n a m e , antei de que se use como
parte de la cadena de ali ida.
1 .. 7
jj! / u s r 1 $ 1 7
$myname = <STDIN>;
chomp $myname:
p r i n t "$myname j u s t r a n t h i s program\nN:

El siguiente es un ejemplo de la ejecucióri del script i.cadnnmc.pl:

.dfiarii - -

Justin Petersen
J u s t i n P e t e r s e n j u s t r a n t h i s program

I'erl también soporta alias y referencias. U n alias es otro nombre

para una variable, un arreglo o una fiinción. Usted puede configurar un
alias general usando el signo d e asterisco (*), poniéndolo al frente del
nombre del objeto al que va a asignar el alias y despiiés asignándolo al
alias que tainbién va precedido por un asterisco. Por ejemplo, la si-
guiente asignación crea un alias llamado c o u n t para la variable n u m :

Esto se conoce coino operación g l d , porque en realidad asigna iin alias a

todas las variables, los arreglos o las hnciones que tienen el n ~ i s n ~nombre.
o
I l e acuerdo con el ejemplo precedente, si hcibiera un arregio @ n u m , ahora
también podría tener un alias Uainado @count; y si hubiera una tiinción
con el nombre n u m , también habría u11 alias para ella, ilamado count.
Para asignar uii alias igual a una variable o un arreglo especíticos,
usted emplea una rlfircncia. Una referencia es una variable, un arreglo o
una función precedida por una barra irlvertida (\). En el siguiente
 Capitulo 6: Perl 1 207
ejemplo se crea cost como referencia solaniente para la variable
$mycost,110 para ningíiii arreglo o furicióri con ese iionibre.

IConsqb -.-

Las referencias se utilizan ampliamente para operaciones de llamado

por referencia, para arreglos de argumentos que se usan en Ilama-
dos de función.

Arreglos y listas
En Perl usted crea un arreglo asigiilndole una lista de valores. Una lista
en Perl consta de un c o i i j ~ ~ i i de
t o valores entre parkntesis y separados
por signos d e conia. La siguiente es una lista d e cuatro valores.

Usted asigna esta lista al arreglo q u e desee crear, precedierido el

nonibre del niisrno con el sínibolo @. Esta asignación iniciará el arre-
glo, coiiienzaiido secuencidniente con el prinier valor de la lista. Cada
valor se asignari a su eleniento correspondiente, coiiieiizando con el
primer cleinento.

Una vez se haya creado el arreglo, usted puede hacer referencia a

cada uno de sus elenieiitos, los cualcs coniienzan desde O y no desde 1;
por tanto, el arrcglo mynums tiene cuatro elenieritos nunieraclos desde
O hasta 3. Usted puede Iiacer referencia a cada elenierito eniplearido LIII
iiíiiiiero de índice dentro de parSntesis cuadrados. [O] hace reterencia al
prinier elemento y [2] hace referencia al tercer eleinerito. En el siguiente
ejemplo, se iiriprinie el primer elenierito y después el cuarto.
208 1 Fundamentos de programación e n L i n u x

1Nota
Observe que usted utiliza u n signo d e dinero ($), n o u n símbolo (@),
antes d e u n elemento del arreglo. El símbolo @ se usa para hacer
referencia a todo el arreglo y se emplea cuando usted le está asig-
nando listas completas d e valores. El signo $ hace referencia a u n
elemento en particular, que esencialmente es una variable.

Usted puede cambiar el valor de cualquier elemento en el arreglo

asignándole un nuevo valor, como en el siguiente ejemplo:

N o hay límite para el número de elementos en el arreglo. Usted

pucdc agregar más, simplemente haciendo referencia a un nuevo
elemento y asignándole un valor. La siguiente asignación agregará un
quinto elemento al arreglo mynums.

Cada arreglo tendrá una variable especial integrada por un signo de

número (o libra) (#) y el nombrc del arreglo. Esta variable es el núme-
ro de elementos que en realidad tiene el arreglo. Por ejemplo,
#mynums niantiene el núrnero de elenientos en el arreglo mynums.
El siguiente ejemplo iiiiprime la cantidad de eleiiientoi en el arreglo
mynums. Observe cl signo $ que lo prccede.

Usted puede hacer referencia a todo el grupo de elementos en un

arreglo tal como en una lista de valores; para ello, emplee el noinbre
del arreglo precedido por el símbolo @. El siguiente ejemplo iniprimi-
rá todos los valores eii el arreglo mynums.
 Capítulo 6: Perl
- - -

Pregunta: <Necesito asignar los mismos tipos de valores a un

arreglo?

Respuesta: Cuando se asigna una lista a un arreglo, los valores en la lista no

tienen que ser del mismo tipo. Usted puede tener níimrros, cadenas e incluso
valores de las variables en una lista. De manera siiiiilar, los elementos del
arreglo no tienen que ser del nrisino tipo. En el siguiente ejemplo, una lista
con elemeiitos variados se asigna al arregla myvar.
@rnyvar = t " a l e i n a " , 11. 4 . 5 . " a new c a r " ) :

El símbolo @ se usa aquí en lugar del signo $ porque el nombre del

arreglo n o es una variable en sí mismo. Se considera una lista de valo-
res. Solamente los elementos individuales 5on variables.
Eita sintaxis taiiibién se aplica cuando se aiigna u11 arreglo a otro. En
el siguiente ejemplo, el valor de cada elemento en mynums se asigna a
los eleinentos correspondientes en newnums. Observe el símbolo @
que se usa para mynums. Usted puede considerar a @mynums conio
evaluar la lista de los valores en el arreglo mynums, y esta lista enton-
ces se asigna a newnums.

La lista de valores a la que se hace referencia con un nombre de

arreglo se puede usar en una cadena, tal como se puede hacer con el
valor d e una variable. En el siguiente ejemplo, los valores de los ele-
mentos en el arreglo mynums se incorporan en una cadena que
dcspués se asigna a la variable myreport. Observe el uso del sínibolo
@ conio prefijo del nombre del arreglo, mynums.

"3myrepor-e a r e t h e numhers 1 h a v e : @m-y

pi-i n t % m y r ~ p o r t :

Sin eiiibargo, conio se mencionó antes, elcmentoi individuales de

L I arreglo
~ ion variables y debcn referenciarie empleando un índice y
el signo $. El siguiente ejemplo usa el valor del tercer elemento en el
arreglo mynums.
210 1
I
Fundamentos de programación en Linux
---

memerit- T a l u - e ~ ~ f ? n ~ ;
p r i n t $myelement;

1Consqo
Los arreglos que utilizan números secuenciales para identificar los
diferentes elementos de un arreglo, como los que hemos estudiado
hasta ahora, se conocen como arreglos escalares. Más adelante
estudiaremos los arreglos asociativos que usan cadenas para el índice
de los elementos en lugar de números.

ri

Subconjuntos de arreglos: tajadas

Perl perniite liacer referencia a u n s u b c o n j ~ ~ n de
t o elementos en un
arreglo, empleándolos en operaciones de asignación o como listas d e
valorei. Dichos subconjuntos se conocen como t(!jadm y pueden ser
cualquier subconjunto de elementos o incluso un rango de elenientos
en el arreglo. Las tajadas se conocen por un signo @ antes del nombre
del arreglo, n o por un signo $. Las tajadas n o se consideran como
variables sino como listas.
I'ara hacer referencia a una tajada de un arreglo, usted debe listar los
iiíinieros del índice de los elenientos que quiera, dentro de paréntesis
cuadrados, separados por conlas; [0,2,4] hace referencia a los elementos
primero, tercero y q;into de un arreglo. En el siguiente ejemplo se
iiilprinien estos elenientos. Observe el sínibolo @, que sirve coiiio
prefijo del nombre del arreglo, mynums.

Usted taiiibikn puede especificar i i i i rango de eleiilentos para una

tajada. Un rango ie eipecifica con el primer número en el rango, seguido
por dos puntos y después por el últinio número dcl rango; [1..3] hace
referencia al rango de elcinentos que comienzan coi1 cl segiindo ele-
mento, 1, y terminan con el cuarto elemento, 3 (recuerde que los d e -
nientos ie nunieran a partir de O). En el siguiente ejciiiylo se inipriinen
el segiindo, tercero y cuarto elenientos en el arreglo mynums.
 Capitulo 6: Perl ( 21 1

Uited puede iiiar eita claie d e índices en operaciones d e aiignación,

especificando elemento\ en particular q u e quiera para tener nuevos
valorei o especificando u n rango d e elenientos. E n el siguiente ejeni-
plo, al primer eleinento del arreglo m y n u m i e le aiigna el valor 1700
y al cuarto, el valor d e 34.

Empleando un rango d e elcrneiitos, usted pucde asignar u n conjun-

t o d e valores a u n rango del arreglo. E n el siguiente ejemplo, al tercero,
cuarto y quinto eleiiientos del arreglo m y n u m s i e 1ci aiignan nuevos
valorei. A eitoi eleiiientoi i e h ~ c referencia
e con el rango [2..4].

1Nota
Si la cantidad de valores presentes en la lista es superior al número
de elementos del arreglo a los que se hace referencia, entonces los
valores restantes se pasan por alto. Si hay más elementos referen-
ciados que valores en la lista, los elementos restantes del arreglo se
asignan a una cadena nula.

V P r e g - un t e a l o - sexper-tos
Preguntar puedo asignar varios elementos, a la vez, de un arreglo
a otro?

Respuesta: Uwd puede usar tajadas para asignar parte de un arreglo en

-- En el
otro, o eleiilemos p~rticularesen iin arreglo a elementos en otro arreglo.
siguiente ejemplo se asignan los valores de los elementos tercero, cuarto y
quinto del arreglo mynums al arreglo newnums. Después, los elenientos
212 1 Fundamentos de programación en Linux
-

Las tajadas se pueden usar para los elementos del arreglo que se van a
asignar y para el arreglo al cual están asigmios. En el siguiente ejemplo, el
tercer y q u i n t o elementos del arreglo mynums están asignados al segundo
y cuarto elementos del arreglo newnums.Entonces, los elementos segun-
do, cuarto y q u i n t o del arreglo mynums [l, 3,4] se asignan a los ele-
mentos tercero, cuarto y q u i n t o del arreglo partnums [2..4].

Funciones de manejo de arreglos escalares:

operaciones de lista
Perl tiene un c o n j u n t o d e funcionei, disellado para ayudarlo a adminis-
trar c o n facilidad arreglos cscalares. C o n coinandos simples usted puede
realizar operaciones c o n drreglos coniuncs, tales c o m o listar e l conteni-
d o d e un arreglo, filtrar un arreglo o hacer referencia secuencial d e

Operaciones del arreglo Descripción

escalar
pus h(arreg10, lista de valores) Agrega elementos d e lista de valores al final de
arreglo
pop(arregl0) Retira el último elemento del final d e arreglo
uns hift(arreg10, lista de valores) Agrega el elemento en lista de valores al co-
mienzo d e arreglo
shift(arreg10) Retira u n elemento del comienzo de arreglo
sort(arreg10) Organiza arreglo en orden ascendente
(alfa bético)
reverse(arreg10) Organiza arreglo e n orden descendente
(alfabético)
split(delím, cad) Divide una cadena, cad, en u n arreglo de ele-
mentos; delimitador puede ser u n patrón o una
cadena y se usa c o m o el delimitador para sepa-
rar la cadena en valores del elemento
joi n(delim, arreglo) Combina los elementos d e arreglo en una cadena
grep(arreg10, patrón) Busca los elementos en arreglo para patrón

Operaciones del arreglo escalar de Perl

 Capítulo 6: Perl
- -

cada elenlento, uno a uno. En este sentido, usted puede considerar un

arreglo como una lista y en estas funciones como en la realización de
operaciones de lista. Las operaciones del arreglo escalar se presentan en
la tabla 6-5 y se explican a continiiacióri.
push y pop operan al final de un arreglo, agregando o retirando el
último elemento. Usted puede considerarlos como agregar o retirar u n
elernento al final de una lista; push agrega un nuevo elemento al final
del arreglo y tonia como s i l argumento el arreglo, segiiido por una lista
de los valores que usted quiere agregar como elementos al arreglo. Se
pueden agregar varios elementos nuevos a la vez. La operación pop
retira L I elemento
~ al comienzo del arreglo.
Los operadores shift y unshift funcionaii al comienzo de una lista;
shift retirará el primer elemento en una lista, haciendo que el siguiente
ocupe ese lugar. La operación unshift agrega un nuevo elemento al
comienzo de la lista; shift toma como su argumento un arreglo y
regresa el valor del primer elemento que retira; unshift tonia como sil
argumento u n arreglo seg~iidopor el valor del elemento que usted
quiere agregar; después, regresa el núniero total de elementos que se
eiiciientran ahora en el arreglo.
Las operaciones sort ordenarán los elementos en un arreglo de
acuerdo con el conjunto de caracteres del sistema, usualniente el
conjunto de caracteres ASCII; sort organizará los eleiiientos en orden
ascendente y regresa la lista'de valores organizados. Entonces, usted
puede asignarlo a otro arreglo, el cual será una versión organizada del
original; sort no cambia el arreglo original. En el sig~iienteejemplo,
sort genera una lista organizada usando los eienientos del arreglo
mylist. Esta lista se asigna luego al arregio mysort, que se convierte e n
la versión organizada elegida d e mylist.

La operación reverse también realiza una selección, pero en orden

descendente y no ascendente. Conio con sort, reverse genera una lista
organizada que usted puede asignar después a u n arreglo, suininistrando
una versión organizada en orden descendente.
214 ( Fundamentos de programación
---- .. en Linux

La operación split se emplea para crear un arreglo y asignarle

valores derivados de una cadena. Los valores están deterniiiiados por un
deliinitador específico que se usa para segmentar la cadena, formando
los diferentes valores que se asignarán a los eleiiientos en el arreglo.
C o n frecuencia, split se utiliza con líneas de datos que ya están organ-
zados en campos separados por un deliinitador, como una coma o un
signo d e dos puntos; split analizará automáticamente la línea de datos
usaido el delimitador, detectando cada campo y asignándolo al si-
guiente elemento en el arreglo.
La operación split toma como su arguniento un deliiiiitador y una
cadena. El deliinitador se puede indicar con una cadena o un patrón y
se usará para dividir la cadena e n elementos. Conio patrón, el
delimitador puede ser cualquier expresión regular, p e r n i i t i h i o l e
especificar varios deliniitadores diferentes e incluso delimitadores que
constan de palabras completas.
En el siguiente ejemplo, la operación split separa la cadena
$myline en campos que usan la coma como el delimitador. La lista
resultante se asigna entonces al arreglo linelist. Observe el uso de los
designadores literales de cadena (' ') para especificar el delimitador
co111a.
.
Usted puede emplear la función grep para buscar un arreglo o
cualquier lista; grep opera de iilanera muy similar a la utilidad grep de
U N I X . Toma como sus argumentos un patrón y una lista, usualnieiite
un arreglo, y usted puede utilizar expresioiies regulares en el patrón
para comparar más de un elemento; grep dará una lista de todos los
elementos que ha comparado. Cualquier patrón se puede usar en la
versión de Perl de grep (como se muestra en el siguiente ejeiilplo), el
cual busca las líneas que comienzan con la letra d.
 -
Capitulo 6: Perl 1 215
Arreglos asociativos
U n arreglo asociativo ~itilizacadenas para establecer el índice de los
elementos en un arreglo, en lugar de números. Usted puede considerar
la cadena del índice como una palabra clave que puede usar para
encontrar iin elemento. En Perl, un arreglo asociativo se define con un
sín~bolode porceiitaje ('%) que sirve de prefijo al nombre del arreglo.
La lista de valores que se asigna consta de pares de cadenas de índices y
valores de eleineritos. Una cadena del índice va seguida por el valor del
elemento, después de la cual va la siguiente cadena del índice y el valor
del elemento, y así sucesivainente. En el siguiente ejemplo, el arreglo
asociativo city está definido por cuatro elementos, cada uno con un
valor entero e indexado con el nombre de una ciudad.

v.-- . . I C-mi
Icity = ('Sa??amento'. pizad-i-
- --
' F a l l o n ' , 86.
.
.-m

'Napa', 7 ,
' A l a m e d a ' , 53 ; 1 -

-
-- - -- - .- - .
Valor del elemento]

Usted hace referencia a uil elenieiito en iin arreglo asociativo usan-

d o esta cadena del índice, que se eilcuentra entre coniillas seiicillas y
corchetes (no entre paréntesis).
5

.-
p b 7 m 1'oñ7') ;

Para agregar un nuevo elemento en u n arreglo asociativo, debe

suririnistrar la cadena que se va a utilizar como el índice para este
elemento y el valor del elemento.

Para hacer referencia a la lista de valores para un arreglo asociativo,

usted emplea '% con el norribre del arreglo. El siguiente ejemplo impri-
nie todos los valores del arreglo city.
 ogramación en Linux
a#-*-"

Perl también tiene un conjunto de operaciones d e lista diseñadas

para trabajar en arreglos asociativos. C o n estas operaciones usted puede
generar listas d e claves o valores. Son útiles para hacer repeticiones con
facilidad a través de u n arreglo asociativo. Las operaciones se presentan
en la tabla 6-6 y se explican en la siguiente sección.
En un arreglo escalar, usted sabe que el índice siempre comienza en
O y sigue consecutivamente hasta el últinio elemento; n o obstante, en
un arreglo asociativo las cadenas que se usan para el índice d e los
elementos pueden ser arbitrarias. Para iniprimir u n arreglo asociativo,
usted necesitará saber cuáles de estas cadenas del índice hacen referen-
cia a los elementos del arreglo. La operación keys le permite generar
una lista de las cadenas del índice en un arreglo asociativo. E n ella se
toma conio argumento u n arreglo asociativo y presenta una lista de
todas las cadenas del índice usadas para hacer referencia a los elenientos
en ese arreglo. Habiendo obtenido las cadenas del índice, entonces
usted puede usarlas para hacer referencia a los elenientos en el arreglo.
La operación each funciona d e manera niuy similar a la operación
keys. Sin embargo, presenta la cadena del índice para un eleniento y el
valor del elemento; each tonia como su argumento u n arreglo, y cada
vez que se le llania regresa el siguiente elemento del arreglo y su
cadena del índice. Usted puede usar each en un bucle para referirse a
.
cada eleniento e n el arreglo.

Operaciones del arreglo Descripción

asociativo
keys(%arreglo asociativo) Genera una lista de todas las cadenas del índi-
ce en u n arreglo asociativo
values(%arreglo asociativo) Genera una lista de todos los valores de los
elementos en u n arreglo asociativo
each(%arreglo asociativo) Presenta el valor y la cadena del índice del
siguiente elemento de u n arreglo asociativo
delete(%arreglo asociativo, Borra el elemento con la cadena del índice
cadena del índice) especificada en u n arreglo asociativo
 -- -
Capítulo 6: Perl
1- 217
La operación values presenta una lista de todos los valores en un
arreglo asociativo. Usted puede emplearla con facilidad para iinprimir
los elementos en un arreglo asociativo, descartando la necesidad de
cadenas para el índice.
Usted utiliza la operación delete para retirar un elemento de un
arreglo asociativo; delete toma conlo argumento la cadena del índice
del elemento que usted quiere retirar. Después presentari el coiiteiiido
de ese elemento. En el siguiente ejemplo, delete se usa para retirar el
elemento con la cadena del índice "Sacrainento".

pI-ñsac,a,,ñFo;Ti;
Ch- -_ .

1Nota
Para retirar t o d o el arreglo, usted utiliza la operación undef, q u e
funciona e n arreglos escalares o asociativos. C o n ella se elimina el
arreglo completamente, liberando memoria.
-
Prueba de repaso
" ¿Puede asignar valores a diferentes eletnentos en un arreglo,
al mismo tiempo?"
¿Qué clase de arreklo se puede indexar usando palabra^?^

Estructuras de control
Perl tiene un conjunto de estructuras de control similares a las que se
Lisa11 en los lenguajes de programación GAWK, C-sliell y C. I'erl tiene
biicles con los cuales usted puede repetir coniandos y condiciones que
le permiten elegir entre c o n ~ ~ n d específicos.
os Existen dos conjuntos
diferentes de operadores para las expresiones de prueba, para usar con
cadeiix y valores iiiiméricos.Tambiéii puede eiiiplear operaciones
patrón que le periniten utilizar expresiones regiilares.

-- -- -

4 Sí; simpletnente especifique los elementos separados por comas, como en @ i i i ) iiiiiii\(-1.0.171.

5 Un arreglo asociativo.
 ogramación en Linux

Expresiones de prueba
Perl tiene diferentes grupos de operadores para comparaciones nunié-
ricas y de cadena. Debe tener cuidado de no niezclar operadores
distintos. Los operadores de cadena son códigos con dos letras, siniilares
a los que se utilizan en el shell BASH. Por ejeniplo, el operador eq
pone a prueba la igualdad de dos cadenas y el operador gt realiza la
prueba para ver si una es mayor que la otra. De otro lado, las compara-
ciones numéricas emplean sínibolos siniilares a los que se encuentran
en los lenguajes de prograniación como operadores. Por ejemplo, >
representa mayor que, y = = sirve para la prueba de igualdad; en
esencia, son los mismos operadores de comparación que se usan en el
lenguaje de programación C. Estos operadores se presentaron previa-
mente en la tabla 6-4. Hay dos excepciones importantes: patrones de
cadena y patrones.
El operador del patrón de cadena, =-, pone a prueba un patrón en
una variable de cadena. El operando de la derecha es el patrón y el de
la izquierda es la cadena. El patrón puede ser cualquier expresión
regular, que hacen de ésta una operación niuy flexible y poderosa.
Los patrones realizan la comparación de una cadena o del contenido
de la variable especial -$. El operador patrón consta de dos barras
oblicuas que encierran el patrón que se busca, /pattern/. El patrón
puede ser cualquier expresión regular.
También hay varias pruebas que usted puede realizar en un archivo
para verificar su estado. Por ejemplo, puede usar el texto -e para asegu-
rarse de que un archivo existe, o -S para verificar si está vacío (véase
tabla 6-7).

Los comandos lógicos: &&, 1 1, !

Perl soporta las operaciones lógicas AND (&&), O R ( 1 1 ) y N O S (!),
que toman como sus operandos expresiones, tal como lo hacen en el
lenguaje de programación C. La sintaxis es como sigue:
(e x p r e s i ó n ) && ( e x p r e s i ó n )
(expresión) 1 1 (expresión)
!( expresión)
Pruebas de archivo Descripción
-e El archivo existe
-f El archivo existe y es u n archivo regular
-S El archivo n o está vacío
-z El archivo está vacío, tamaño cero
-r El archivo es legible
-w El archivo se puede escribir y modificar
El archivo es ejecutable
El nombre del archivo es u n nombre de
directorio
El archivo es u n archivo binario
El archivo es u n archivo de texto

La evaluación de estos comandos lógicos se resume en la tabla 6-8.

Usted puede extender estos con~andoscon los comandos agregados
&& o 1 1 , creando operaciones con~plejasAND y OR. Los comandos
lógicos le permiten emplear operaciones lógicas como su comando de
prueba en las estructuras de control y también puede usarlos en forma
independiente.

Sintaxis de la operación lógica Evaluación

expresión & & expresión La condición lógica A N D presenta u n
expresión and expresión valor verdadero (O) si ambas expresiones
tienen u n valor verdadero (O); si una da
u n valor diferente de cero, entonces la
condición A N D es falsa y también da u n
valor diferente de cero. La ejecución se
detiene en la primera expresión falsa. La
operación and es igual a &&, pero tiene
una precedencia más baja.
expresión 1 1 expresión La operación lógica OR tiene u n valor
expresión or expresión verdadero (O) si una expresión o la otra
tiene u n valor verdadero (O); si
ambas expresiones dan u n valor diferente
de cero, entonces la condición OR es falsa
y también da u n valor diferente de cero.
220 1 Fundamentos de programación en Linux
- --

La evaluación se detiene en la primera

expresión verdadera. La operación or es
igual a 1 1 pero tiene una precedencia
más baja.
! expresión La condición lógica NOT invierte el valor
not expresión verdadero o falso de la expresión. La
operación not es igual a ! pero tiene
una precedencia más baja.
-

Tabla 6-8 Evaluación de los comandos lógicos de Perl (contintrnción)

La otra impleinentación de los operadores lógicos and, or y not

soporta el procesamiento de listas. Estos operadores realizan las misinas
pruebas en las expresiones y su evaluación es la misma de los otros
operadores lógicos (conio se resiiiiie en la tabla 6 4 , pero también
pueden tener listas como sus operandos.Tienen una precedencia mis
baja que los operadores lógicos estándar. Su sintaxis es como sigue:
( 7 istalexpresión) and ( 1 istalexpresión)
(listalexpresión) or (listalexpresión)
not( 7istalexpresión)
Los operadores lógicos scielen usarse en expresiones de prueba para
estriicturas de control coiiio while e if. Sin embargo, tambibn se pueden
einplear independientemente coiiio sus propios enuiiciados. En efecto,
ofi-ecen una forma sencilla de escribir una operación condicional. En los
scripts de I'eil, con frecuencia usted puede ver una operación or utiliza-
da con un coniando de archivo open. Por ejeniplo, eii una operación or,
si la priinera expresión falla, entonces 13 segunda se verifica. Si Gsta es el
comando die para termiiiar el programa, entonces es una operación que
finaliza el programa s i la operación del archivo open falla.

La operación and trabaja de manera siniilar, excepto que si la

primera expresión es verdadera, eiitoncei la segunda se verifica. El
siguiente ejeniplo muestra una línea vacía y si encuentra una, imprime
el mensaje.
-
>'AS[ && d~¡rip- empty l i n e K <
Bucles
Los bucles de Perl incluyen a while, do-until,for y foreach. El bucle
while es el de propósito más general, e n tanto que los bucles for y
foreach b r i n d a n capacidades especiales. El bucle foreach es similar a su
contraparte e n el C-shell y es de particular utilidad e n e l procesaniiento de
listas y arreglos. Los bucles while, do-until y for operan de manera muy
sindar a sus contrapartes e n e l lenguaje de programación C. El bucle for,
e n particular, tiene los mismos tres formatos de expresión d e l bucle for de
C. En la tabla 6-9 se resumen las estructuras de bucle de Perl.

Estructuras de control de bucle Descripción

while( expresión ) { while ejecuta los enunciados en tanto
enunciados; su expresión de prueba sea verdadera.
1
for( expresión inicial; expresión La estructura de control for ejecuta los
de prueba; expresión de incremento) enunciados en tanto la expresión de
{ prueba sea verdadera. La primera ex-
enunciados; presión, expresión inicial, se ejecuta
antes de que comience el bucle.
1 La tercera expresión, expresión de incre-
mento, se ejecuta dentro del bucle
después de los enunciados.

.
foreach variable ( lista de valores)
{
foreach está diseñado para usar con
listas de valores, tales como las que se
enunciados; generan en u n arreglo; al operando
1 variable se asignan consecutivamente
los valores en la lista lista de valores.

do{ do-until ejecuta los enunciados en

enunciados; tanto su expresión de prueba sea falsa
} until( expresión )
next Descarta el residuo del bucle y co-
mienza la siguiente repetición; next es
como el comando continue de C; eje-
cutará cualquier bloque continue.
continue { enunciados;} Ejecuta u n bloque continue como los
últimos enunciados de u n bucle. El blo-
que se ejecuta incluso si u n enunciado
next inicia la siguiente repetición.
222 1 Fundamentos de programación
- en Linux
p- -

El bucle while
El bucle w h i l e coiiiieriza con la palabra clave while, a la que sigue una
expresión entre parbntesis. U n bloque sigue a la expresión, por lo
común en la línea siguiente. Este bloque puede contener varios enun-
ciados y termina con punto y coma. U n bloqiie es ~ i i conjuiito
i de
eiiuiiciados entre corchetes.
Usted puede adaptar fáciln~cnteel biicle w h i l e para eniplearlo con
arreglos. La variable que se emplea para controlar un bucle también se
puede usar, dentro de éste, para controlar el índice de un arreglo. En el
script titlpnrv.yl que sigue, los elementos del arreglo del título se obtie-
nen d e los valores de los títulos. Ilespués, el contenido de cada elemen-
to se imprinie usando u11 bucle while. Observe que $#title contiene
la cantidad de elementos en el arreglo; $#title se usa en el enlace
superior de la espresión de prueba del bucle w h i l e para verificar
cuándo se detendri el bucle.

@ t i t l e = ( " ~ e m p e s t " , " I l i a d " , "Raven");

$i = O;
while($i <= $ # , k i t l e )
print "$title[$i 1 \n":
$ i++
1 5

El siguiente es un ejemplo d e la ejecución del script tit1cnri:pl:

_1_- --
T E T E a r r . p m
T e m p ~ ts
Iliad
Raven

Bucles for
El bucle for consta de tres expresiones segiiidas por un bloque de
enunciados. Las tre5 expresiones se enciieiitran entre paréntesis y
separadas por punto y conia, y el bloque que se va a ejecutar dentro del
bucle for Te sitúa después de las expresiones.
Las tres expresiones corresponden a las que se eniplearon para
adniinistrar iin bucle while: de iniciación, prueba y actualización. La
 Capitulo 6: Perl 1 223

primera espresión se ejecuta d e una vez, antes d e que el bucle comicn-

ce. C o n frecuencia se usa para iniciar variables empleadas en la expre-
sión d e prueba. La segunda es la expresión d e prueba para el bucle.
Cuando el resultado d e su evaluación es falso, el bucle se detiene. La
última expresión es una d e actualización que se ejecuta como si fuera
el último enunciado dentro del bucle y, por lo conlún, se utiliza para
actualizar las variables en la expresión d e prueba. Esta ei la qintaxi5 del
bucle for.

f o r ( i n i c i a c i ó n ; expresión de prueba; expresión de actual izacióri)

e n u n c i ados ;
l
A ineniido 1111bucle for se utiliza para implementar bucles siii~ples
de conteo. En el siguiente ejemplo, el bucle for implernenta un bucle
de conteo usando la variable i. En la expresión de iniciación, a i se le
asigna el valor O. Esta expresión se ejecuta una vez, antes de entrar al
bucle. Luego, la expresión de prueba verifica si el valor de i es nlenor
que 3. Cuando i es niayor o igual a 3, entonces la prueba es filsa y el
bucle for termina.
En cada repetición del bucle se ejecuta el bloque que sigue a la
expresión for y, en este caso, se ejecuta el enunciado print. Despiiés de
él, se ejecuta la expresión de actualización, que aquí es un iricreiliento
de la variable i. Este incremento se realiza al final d e cada repetición:
iisted debe considerar la expresión de actualización como el íiltimo
enunciado en el bucle. Mientras que la espresión de iniciación se
cjeciita solaniente iim vez antes del bucle, la espresión de act~ialización
se ejeciita con cada repetición como el último enunciado dentro del
bucle. En este ejemplo, la expresión de actualización increnientará la
variable i en 1, con cada repetición. En la tercera repetición, i se fijará
en 3, haciendo que la expresión d e prueba sea falsa y terininando el
bucle for.

- -
-3-T ?; Bi++j
p r i n t " T h i s i s t h e $ii t e r a t i o n \ n l ' :
I
224 1 Fundamentos de programación en Linux
- -.- -

El bucle for tiene la misma flexibilidad que u n bucle while. De

hecho, usted puede considerar el bucle for como otra manera de
escribir u n bucle while. Para reemplazar u n bucle for con u n
bucle while, se cambia la expresión de iniciación a u n enunciado
localizado justo antes del enunciado while. La expresión de actua-
lización sería u n enunciado de la expresión localizada al final del
bloque while, y la expresión de prueba sería la expresión de
prueba del bucle while.

3 Pregunta: ¿Qué clase de expresiones toma un bucle for?

Respuesta: El bucle for no necesita de ninguna riianera que la primera
espresión sea una iniciacióii.Tani~ocorequiere que la última expresión sea
una operación de actualización o de increnierito. Las expresiones pueden ser
cualquiera que sea válida. El bucle for simplemente poiie estas expresiones en
una estructura de bucle. La primera va antes del bucle en donde es probable
que ocurra una iniciación. La Últiina expresión se pone al final del bucle, en
donde es posible que se presente tina actualización. El bucle for ni siquiera
exige que haya reali~ieiiteuna primera o última expresión. El siguiente ejem-
plo es una niaiiera simple de escribir un bucle for para leer desde la entrada
estándar. Equivale a whiIe ZSTDIN>.
for (;<STDIN>;)I
1
Pregunta: ¿Qué pasa si el bucle for no tiene una expresión de
prueba?

Respuesta: Aunque la primera y la últii~iaexpresión en uii bucle for puede

ser cualquier clase de expresión, la intermedia es especial eii el sentido de que
debe ser una espresión de prueba. Su resultado deterniindrá si continíia la
ejecuciim del bucle. Sin embargo, iisted puede dejar la expresión de prueba
vacía, ya que sirve para evaluar una respuesta verdadera, lo cual dará con10
resiiltado un bucle infinito. D e hecho, usted podría necesitar uii bucle de esa
clase en iin programa y uiia manera fácil de escribir10 es usando un eniinciado
for con expresiones vacías.
 Capitulo 6: Perl 1 225

Bucles foreach
El biicle f o r e a c h está disellado para hacer referencia e n forma
seciiencial a iina lista de valores. Es miiy similar a la estriictiira for-in del
C-shell. El bucle foreach toma dos operandos: iina variable y una lista de
valores entre paréntesis. Cada vez que pasa el biicle, se asigna el siguiente
valor en la lista a la variable del bucle; ciiando se llega al final de la lista, el
biicle se detiene. Coino e11 el biicle while, la expresión va seguida de un
bloque de enuilciados. La sintaxis para el bucle foreach es la sipiente:

foreach variable ( lista de valores )

I
enunciados;
1
El biicle f o r e a c h es útil para manejar arreglos. Usted puede us
nombre del arreglo para generar una lista d e todos los valores d e
elenlentos en el arreglo y despiiés einplear esa lista como la lista
refereilciad~por el bucle foreach.Tamlsi¿.n puede especificar un rango
de elenlentos del arreglo, iisaildo sólo los v~loresespecificados para la
lista o utilizar un conjunto de eleinentoi individiiales.
En el script I I Z ~ ~ I I ~ I I ~que
/ ~ SC
~ I. ~
~ L
/ el
I Cnoinbre
, del arreglo @mylist
se usa para generar iina lista de su5 valores, en la c i d opera el biicle

-
foreach, asignando cada uno a $mynum.

f o r e a c h Brnynurn ( (!%y1 i s t 1
I
p r i n t "8rnynurn \ n " :
1

El sigiiiente es un ejemplo de la ejecución del script il-iyrrumlist.yl.

226 1 Fundamentos de programación en Linux
- --

El arreglo @ARGV es un arreglo especial que contiene los argu-

mentos que un usuario ingresa en la línea de comandos.Al utilizarlo,
usted puede especificar los argumentos de dicha línea como una lista
d e valores. Los argui~ientosespecificados en la línea de coiiiandos
cuando se llamó al programa se convierten en una lista d e valores a la
que se hace referencia con el bucle foreach. La variable usada en este
bucle se asigna auton~iticainentea cada valor del argumento en la
secuencia: la primera vez que pasa el bucle, la variable se fija al valor
del priirier argumento; la segunda vez, al valor del seg~indoarguniento,
y así sucesivamente.
El número de argumentos que un usuario en realidad ingresa en la
línea de coinandos puede variar, y el valor de la variable especial
#ARGV siempre será la cantidad de elementos que hay en el arreglo
ARGV. Usted puede usar #ARGV para deterininar cuándo ha
referenciado todos los elementos en el arreglo ARGV usando los
ínclices. Por ejemplo, para usar el bucle foreach para hacer referencia a
cada eleniento en el arreglo ARGV, usted emplearía el operador .. para
generar una lista de índices: O.. $#ARGV genera una lista de núineros
que comienza con O y avanza hasta el valor de $#ARGV.
En el script ybnckrrpay.pl que sigue, en la línea d e coiiiandos se
ingresa una lista de los archivos del programa en C cuando se llama el
archivo del shell c6ockiryai:q. En el buclé foreach, 0.. $#ARGV genera
una lista de números: Para tres argumentos, $#ARGV tendría el 17alor
3 y la lista sería ( 1 , 2 , 3 ) . Cada núinero se asigna consecutivaniente a la
variable i, que se usa entonces para el índice del arreglo ARGV.

foreach 8 i ( O .. WARGV)
I
p r i n t "Copying $ARGVT$il\n";
oprn(SF1 LE, " < $ARGV[$i]");
o p p n ( B F I L E , "> snurcebak/$ARGVC$il");
while(<SFILE>) (
p r i n t BFILE ;
1
clnse(SFILE1;
c l o s r ~ E F I L E ;)
 . .
Capitulo 6: Perl 1 227
El siguiente es un ejeniplo de la ejecución del script ybackrrycli~.pl:
v
5- pbackuparg.pl mafn.c 1 l b . c 1o.c
Copyi ng ma i n .c
main.c
Copying 1 i b . c
1ib.c
Copying i o . c
i0.c

Controles de bucle y de bloque

I'erl tiene un conjunto de comandos especiales diseñados para darle un
control más preciso sobre bucles y bloques, y que corresponden a
coinandos siniilares que se usan en el lenguaje C . Estos coniandos
deben tener rótulos, de modo que si usted los emplea dentro de un
bucle, necesitará ponerle un rótulo a ese bucle. Cuando se usa uno de
estos coniaiidos, hace referencia a ese bucle.
El coniando last corresponde al comando break de C y sirve para
detener la ejeciicióii de un bucle.Tambiéi1 se puede utilizar para desha-
cer un bloque; last se usa con bloques para siniiilar estructuras switch.
El siguiente coniando last roniperá un bucle si el usuario iiigresa una 11
en la línea de coinandos. La expresión regular /"q$/ usa el signo "
para indicar el comienzo de una línea y el signo de dinero ($) para
indicar la terminación de la línea. El bucle se identifica con el rótulo
MLB al que después liace referencia el coniando last. El rótulo puede
ser cualquier nombre que usted desee.
- -
T e : ~ h i e C' C ' S T ~ D ~
1
if ( I A q $ / ) (last MLB; I
print $-;
1

El coniando next pasa por alto los deniás eriuiiciadoi en el bucle. Es

siniilar al coiiiando continue de C y está diseíiado para trabajar con el
bloque continue, el cual está formado por el coniando continue
seguido por un bloque. Este bloque se ejecuta al final del bucle. Inclu-
so, si un coiiiando next pasa por alto los enunciados restantes, el blo-
que continue sienipre se ejecutará. Usted puede usar next para
228 1 -
Fundamentos de programación
-- -
en Linux

garantizar que se realicen operaciones como las de incrementos. El

comando redo volverá a ejecutar un bucle, incluso si la prueba es falsa.
No tiene un coniando correspondiente cn C. Loi coinandos redo y
last no tomarán en cuenta n i n ~ ú nbloque continue.

Condiciones: if, elsif, unless y switch

I'erl soporta operaciones if-else siniilares a las que iisan otros lengiiajes
de programación. La estructura if con sus con~polienteselse y elsif le
periiiiten seleccionar acciones alternativas. Usted puede utilizar el
coinando if para elegir una alternativa o coinbinarlo con los coriipo-
nentes else y elsif para elegir entre varias alternativas. En la tabla 6-10
se resunien las estructuras de condición-control.

La estructura if tiene una expresión de prueba entre paréntesis, seguida

por u n bloque de eniinciados. Si la priieba es verdadera, se ejecutan los
enunciados del bloque. Si es falsa, el bloqiie se pasa por alto. A diferen-
cia de otros lenguajes de prograniación, solaniente un bloque puede
segiiir la prueba, y los enunciados, aunque sea lino solo, deben estar
dentro del bloque.
Una combinación if-else le permite tomar decisiones alternativas,
einprendieiido una u otra accióii. Si la expresión de prueba de la
estructura if es falsa, se ejecuta el bloque d e enunciados que sigue a
else. En el ejemplo que se presenta a contiiiuación, se pone a priieba si
tuvo k i t 0 una operación open en un archivo. En caso negativo, se
ejecutará iin coniando die para terminar el programa. El operador
NOT (!) liará que la prueba sea verdadera si open falla, ejecutando d e
ese modo el coniando die.

i f (!(open ( R E P S , "< $filenW))) l

d i e "Can't open $ f i l e n W ;
1
rilse {
print "Opened $ f i l e n successfully":
I
Estructuras d e condición-control Descripción
if( expresión ){ i f ejecuta enunciados si su expresión de prueba
enunciados; es verdadera.
1 Los enunciados deben estar incluidos dentro de
u n bloque.

if( expresión ) { if-else ejecuta los enunciados i f si la expresión

enunciados; de prueba es verdadera; si es falsa, se ejecutan
1 los enunciados else.

else( expresión ) {
enunciados;
1
if( expresión ) { elsif le permite anidar estructuras if, permitien-
enunciados; d o la selección entre varias alternativas; en la
1 primera expresión verdadera if, sus enunciados
elsif( expresión ) se ejecutan y el control deja la estructura com-
enunciados; pleta elsif.
1
else( expresión ) {
enunciados;
1
unles( expresión ) { unless ejecuta enunciados si su expresión de
enunciados; prueba es falsa.
1
L A BEL:{
if(expr){enunciados;
último LABEL};
. Esta estructura simula una estructura switch
usando los enunciados i f listados dentro de u n
bloque, con el último enunciado haciendo re-
} ferencia a u n rótulo para el bloque.

elsif
La estructura elsif le permite anidar operaciones if-else. Con elsif, usted
puede elegir entre varias alternativas. La primera se especifica con la es-
tructura i f y va seguida por otras alternativas,cada una especificada con su
propia estructura elsif. La alternativa para la Última estructura elsifse
especifica con un else. Si la prueba para la primera estructura if fdla, el
control pasará a la siguiente estructura elsif y se ejecutará la prueba. Si fdla,
el control pasará al siguiente elsify su prueba se verificará. Este proceso
sigue hasta que una prueba sea verdadera, caso en el cual elsifha ejecutado
sus comandos y el control pasa de la estructura if al siguiente comando.
230 1 Fundamentos de programación en Linux

El siguiente ejemplo ilustra el liso de operaciones if-else ~nidadds.

Observe que cada eitructura if, else y elsif tiene su propio bloque,
aunque haya 1111 solo enunciado en él. La f~incióiisystem ue usa aquí
para ejecutar un comando de shell.

systern( "1 S -1 " ;

1
e l s i f ( $ o p t i o n eq " d " ) I
systern("1s - F n ) ;
I
else I
p r i n t " I n v a l i d Option\nW;
t

unless
El coniando unless realiza la prueba opuesta a L I comando
~ i f Si la
prueba del coniando unless es falsa, se ejecutan los enunciados; si la
prueba es verdadera, los enunciados n o se ejecutan. La sintaxis es la
inisma del comando if C o n frecuencia, unless se usa para pruebas en
donde usted desea verificar si hay operaciones fallidas. A menudo lo
ver5 con el comando open para probar una operación open de archivo
que fracasó, como se muestra a continuación:
,) Rt

u n l e s s ( 0 p e n ( R E P S . "+> b f i l e n " ) l
d i e " C a n ' t open $ f i l e n M :
1

switch
N o existe una estructura de control switch en Perl, aiinque se puede
simidar. En una estructura switch clásica, se hace una elección conipa-
rando un valor con varios patrones posibles y cada valor posible se
asocia con un conjunto d e operaciones. Si se encuentra una concor-
dancia, se realizan las operaciones asociadas.
Usted puede siiniilar un switch en Perl usaiido un bloque y un
comarido last. Los bloques son estructuras de control válidas por sí
mismas. Usted puede presentar un bloque en forrila de lista y sus
 Capitulo 6: Perl ( 231

enunciados se ejecutarán de nianera consecutiva. Los enunciados dentro

de un bloque se consideran coino un grupo. El coniando last sale de un
bloqiie o b~icley pasa por alto un bloque continue, 71 hay alguno; last es
como el eiiunciado break de C. Cuando se usa en un eniinciado dentro
de un bloq~ie,el coi~iandolast saldrií de iniiiediato del bloqiie.
En el \iguieiite ejeinplo, el enunciado final riunc'i \e ejecuta debido
a que el coniaiido last oblig'i a una salida del bloque.

p r i n t "The f i r s t s t a t e m e n t \ n N ;
p r i n t " t h e second s t a t e m e n t \ n n :
1a s t :
p r i n t "The t h i r d s t a t e m e n t \ n w ;
1

Hay varias maneras de construir los enunciados en un bloque con el

fin de simular una estructura de control switch. La más ficil es tcner
una serie de estructuras i f seguidas por un bloque de enunciados que
terminan con un en~inciadolast. El bloque recibiría un rótulo al que
haría referencia el últinio enuncixio last, saliendo de esa inanera del
bloque con el rót~ilo.El enunciado final en el bloque sería una opera-
ción predeteriiiinada, que se ejecuta si todas las pruebas de if fallan. La
sintaxis para esta estructura sería la siguiente:

LABEL: {
if(expr) {enunciados; last LABEL);
1
El siguiente ejeinplo siniiila un switch usando un bloqiie de estruc-
tiiras if. El bloque está niarcado con MYSW, situado antei del corchete
de apertura. Cada estructura i f prueba los valores de la misma variable,
n u m . Si una prueba es verdadera, entonces se ejecuta su bloque de
eniiiiciados. El último enunciado en cada i f es un comando last que
saldrá del bloque i n á ~externo.

MYSW: I
i f ($num == 1 ) ( p r i n t "The f i r s t c h o i c e " ; l a s t M Y S W ; ) ;
i f ($num == 2 ) ( p r í n t "The second c h o i c e " : l a s t M Y S W ; ) ;
i f ($num == 3 ) { p r i n t "The t h i r d c h o i c e " ; l a s t MYSW;I;
print "Invalid Option";
1
232 1 Fundamentos de programación en Linux
- -.

Directorios
Perl también tiene incorporado un completo conjunto de coniandos
pnra el nianejo de directorios que operan de manera muy similar a los
comalidos de archivo, tales como open y close. El coniando opendir
abre un directorio, d e forma niuy seniejante a cuando se abre un
archivo. Al directorio se le asigna un rrimicjador de dircrtorio, iiiuy similar
a uii inanejador de archivo. En el siguiente ejeniplo se abrir,? un direc-
torio llamado reports y se asignar5 a la variable repdir que entonces
se convierte en el ~nanejadordel directorio.

El comando readdir leerá el primer ítem de u n directorio. Sin

embargo, cuando se usa en un contesto de licta, el coiiiando presentará
una lista de todos los nombres de archivo y directorio en ese directo-
rio. Por cjeniplo, un enunciado foreach operará en una lista y n o en
una expresión. En un enunciado foreach, readdir ofrecerá uiia lista
completa de archivos y subdirectorios. E n el siguieiite ejemplo, el
coniando readdir sc usa eii una estructura foreach para generar una
lict'a de noiiibres de archivo y subdirectorios en el directorio al que
repdir hace referencia. A su vez, cada nombre d e archivo y
subdirectorio se asignan a la variable filen.

Prueba de repaso
¿Cuántas expresiones tiene un bucle for?"

¿Qué estructura de control puede usar para leer con facilidad

los argumentos del script?'

¿Qué comando utiliza para simular una estructura switch?'

6 Tres: iniciación, prueba, de incremento.

7 Use foreacli para hacer referencia al arrcglo ARGV.
8 last.
 Capitulo 6: Perl (-
233

closedir cierra el directorio, chdir cambia directorios, mkdir cred

directorios y rmdir los retira. El ~iguienteejemplo cierra el directorio
reports que está referenciado por el iiianejacior de directorio repdir:
-- - --
c l osedTr ( ' $ r e p d r

Proyecto 6-1: índices con Perl

El siguiente ejemplo de programación implementa el programa myindex
descrito en el capítulo 3, que trata la programación del shell BASH.
myht.pl
Este programa detectará primero cualquier directorio en el directorio
actual y después revisará si hay alguna página Web en ellos. Las páginas
Web son cualquier archivo con una extensión .html o .htm. Los nom-
bres de estos archivos se ponen en cadenas integradas por comandos
href de HTML para seleccionar y presentar en pantalla los archivos. Las
referencias HTML se organizan en una lista con las etiquetas <ul> y </
ul> y cada ítem va precedido por una etiqueta <lb. Los nombres del
directorio se emplean como encabezados con la etiqueta <hl>.

Paso a paso
1. El programa debe generar primero el código HTML para establecer el
título para "My Index" y el encabezado para "lndex of HTML Files".
El comando print de Perl se puede utilizar para llevar los caracteres a
la salida estándar. 5

2. El comando opendir debe abrir, entonces, el directorio de trabajo

actual (.) usando el manejador CDIR.
3. El comando foreach se puede usar para leer la lista de archivos y directo-
rios en el directorio de trabajo generado por el comando readdir, y los
pone uno a uno en la variable dirname con cada repetición.
4. Si se encuentra un subdirectorio, y éste no es el directorio de traba-
jo, el nombre del directorio se debe imprimir como el subtítulo.
5. Entonces, se debe buscar el subdirectorio para hallar cualquier
archivo HTML en un bucle interior foreach. Genere la lista de archi-
vos y directorios para el subdirectorio con el comando readdir y
ubíquelos uno por uno en la variable filen.
6. Revise cada nombre de archivo para determinar si es un archivo y
que tenga la extensión .html o .htm, un archivo HTML.
234 ( Fundamentos de programación en Linux
-
7. Por cada archivo HTML válido, busque el archivo para un título y úselo
como el texto de enlace en el índice. Para hacerlo, abra el archivo con
el manejador HFILE; utilice un bucle while para leer este archivo Iínea
por línea y emplee grep para buscar la presencia de un patrón
<TITLE>. Asígnele 1 al indicador found si se encuentra el título.
8. Si grep no encuentra una Iínea <TITLE>, asigne el nombre de
archivo a ntitle. Use la función substr para retirar la extensión.
9. Si grep encuentra un patrón <TITLE>, utilice las funciones rindex y
substr para dividir las etiquetas precedente y final, <TITLE> y </TITLE>,
junto con cualquier otro carácter en la Iínea. El texto del título se
mantendrá. Asígnelo a la variable ntitle.
10. Después de que el texto se haya asignado a ntitle, use el valor ntitle
como el texto de enlace en la Iínea href de HTML, la cual comienza
con una etiqueta <li> que indica que es un elemento de la lista.
11. Termine el programa sacando una etiqueta de terminación BODY y
cerrando después el directorio actual, CDIR.
A continuación se presenta el programa myht.pl completo:

d i r e c t o r i * ~ . but not or . .. directories

I $ d i rname Y& !I Sdirname -- / ^ \ . /))
1
l r í n t "<hZ>$dirtcame</hC\\n" :
~ r i n t' < u l > ' ;
o p c n d í i rHt11K. " $ d i r n a m e U ) ;

íf i
1
'
1
"tldit'name18fi:en" &8 ( Sfilen - /

u n l e s s i l~pori(Hf[LE, "< O d i r n a i - i e / $ f i l e n W ) ) l
d i p "d:otlnt no opeii f i l e I d i r n a m e i
 Capitulo 6: Perl 1 235
$tline = Shllne:
-
1
Bfound = 1 ;
I
I
close(HFI1 E ) ;
i f ( Bfound
l
-O )

Bntitle = substr($filen, 0, index(Sfi1en. ".") 1;

1
else l
= index(St1ine. "TITLE>") + length("TITLE>"):
Slpos
Orpos --
r i ~ d e x ( S t l i n t , ".'/TITLEN):
$ntitle suostr(St1ine. t i p o s . Srpos - Slpos):
I
print "'i i><a href=Sdirname/$fllen>Sntitle</a>\n";
I
I
rrint '</ul>\nn;
closedir(HD1R) ;
I
t
print " ./BODY>\n</HTML>\n" ;
closedir(CD1R);

Funciones de cadena
l'erl cuenta con varias fiinciones y operadores para manipular cadenas,
los ciiales se resumen en la ctdbla 6-1 1 .
Las funcioi~eslength, index y substr realizan operaciones estándar
de cadena, tales con10 obtener 1'1 longitud de una cadena o copiar iina
siibcadena desde una cadena; split realiza una tarea especial, genera un
arreglo a partir de una cadena dividiéndola en valores del elemento del
arreglo (vinse la sección antcrior: "Funciones de manejo de arreglos
escalares: operaciones de lista"). El operador dot coilcatena cadenas
y el operador x genera cadenas formadas de caracteres repetidos. La
función chomp reducirá una línea de retorno d e carro, un espacio o
una tabulación que puede ser el final d e una cadena. Resulta útil retirar
el carácter de la nueva línea anexo a las cadenas que se leen desde la
entrada estándar, <STDIN> (el texto que el usuario entra en forma
interactiva en un programa Perl).
236 1 Fundamentos de programación en Linux
--
-

Operación de cadena Descripción

cad . cad El operador punto (.) concatena cadenas
cad x num El operador x repite una cadena o carácter, cad, un
número de veces, num
Función de cadena
chomp(cad) Remueve una nueva línea de retorno de carro
substr(cad, posición Regresa una subcadena de la cadena especificada,
inicial, longitud) cad, comenzando en la posición de partida posición
inicial para la longitud especificada
substr(cad, posición Reemplaza la sección especificada de la cadena, cad,
inicial, longitud) = cadena comenzando en la posición de partida, para la longi-
tud especificada, con la cadena asignada.
length(cad) Encuentra la longitud de una cadena, cad.
index(cad, patrón) Encuentra la posición del patrón especificado en una
cadena, cad.
rindex(cad, patrón) Encuentra la última posición de un patrón especifica-
do en una cadena, cad.

Tabla 6-11 Operaciones y funciones de cadena

Usted ~itilizael operador plinto (.) para coiicatenar dos cadenas. El

siguiente ejemplo agrega un sufijo .dat al rioiiibre de u11 archivo raíz.
Si el contenido de $curfile es "myadddress", $newfile sería
"iiiyaddress.dat". .

C o n el operador de repetición (x) usted puede repetir tina cadena

cualquier caritidíid de veces. Antes del operador x escriba la cadena que
se va a repetir y despubs del operador el núiiiero de veces que desea
repetirla. La cadena puede ser uno o más caracteres. En el siguiente
ejemplo se repite "hi" cuatro veces.

C o n la f~inciórilength se obtiene la longitud de una cadena. Se

puede aplicar a cualq~iiervariable de cadena incluyendo variables d e
campo. El llainado de fuiición length("Christopherl1)presenta 1 2 , ya
que contiene 11 caracteres. La función length se p ~ i e d eaplicar a
 cualquier variable; length($filename) presenta la longitud de la
cadena del nonlbre del archivo en la variable $filename. Cuando se
usa sin un argumento, la función length presenta la longitud de la
cadena en la variable 96-, la cual suele ser la cantidad de caracteres en
una línea de entrada.
La función index encuentra la primera posición de un patrón
dentro de una cadena y la función rindex encuentra la última posi-
ción. Puede considerar a rindex como el índice derecho, que busca
desde el extremo derecho de la cadena. La posición del patrón "en" en
Dickens es 5, como lo informa index.
La función substr se emplea para copiar una subcadena de una
cadena dada o para reemplazar una subcadena de una cadena específica.
La función substr toma tres argumentos. El primero es la cadena en
donde opera substr, el segundo es la posición en donde comienza la
subcadena y el tercero es el número de caracteres desde la posición
inicial (la longitud de la subcadena). La función substr normalmente
opera como una operación de copia. La única excepción es cuando se
usa al lado izquierdo de una operación de asignación, en cuyo caso
substr se convierte en una operación de reemplazo.

Concordancia de patrones
Como en GAWK, Perl puede buscar patrones. La sintaxis para las
diferentes búsquedas se presentan en la tabla 6-12.

Sintaxis de concordancia Descripción

de patrón
/expresión regular/ Compara u n patrón usando una expresión
regular
var =- /expresión regular/ Encuentra la expresión regular en una varia-
ble de cadena, var.
var !- /expresión regular/ Verifica si la expresión regular n o ocurre en
una variable de cadena, var.
238 1 Fundamentos de programación
- en Linux

Para buscar un patrón en una línea dada, el patrón de búsqueda está

entre barras oblicuas. /Dickens/ busca el patrón "Dickeiis" en una
Iíiiea. Por defecto, una búsqueda de patróii opera en el contenido de la
variable especial -$, la cual suele mantener el contenido de la línea de
entrada que se haya leído inás recientenieiite, cualquiera quc sea el
lugar de donde proceda. Si el coniando de entrada más reciente h e
<STDIN>, -$ iiiantendrá la lectura de una línea de la entrada
estándar y cualquier patrón que siga y n o especifique otro objetivo,
buscará esa Iíiiea. En el siguiente ejeniplo se lee una línea de la entrada
estándar y después busca en él el patrón /Dickens/.

A diferencia de GAWK, Perl n o lee autoniáticamente todas las

líneas de iiiia f~ieiitede entrada. Para leer las líneas de la entrada
estándar, usted tiene que usar explícitarilente el coinando read para
cada línea; por consiguiente, para buscar las líneas en la entrada
estáiidar, tiene que leer cada línea explícitamente con el comaiido
<STDIN> y después buscarla con una operación de búsqueda de
patrón. Usted puede hacer esto fácilmente con un bucle while.
En el siguiente ejemplo, el bucle while lee todas las líneas de la
entrada estándar y b&a el patróii /Dickens/. Una condición if se usa
con el patrón de búsqueda, /Dickens/ y el coniaiido print, de iiiodo
que se iiiiprimeii las líneas con el patrón.

print;
, 1
1

Concordancia d e patrones e n variables: =-

Para buscar el contenido de una variable para un patrón, usted puede
utilizar el operador =- con la operación de búsqueda de patrón. Usted
emplea el nombre de la variable como el operando izquierdo y la
 Capitulo 6: Perl ( 239

operación d e búsqueda d e patrón conio el operando derecho. En el

siguiente ejemplo se busca el patrón "Christrnas" en la variable $title.

Si usted fuera a leer datos d e una f ~ ~ e ndt ee entrada en una variable,

podría buscar esos datos usando el operador de concordancia, =-, y
una búsqueda de patrón en esa variable. En el siguiente ejernplo se leen
datos de la entrada estáildar a la variable $title. Después, se usa la
operación de búsqueda para verificar el patrón "Christn~as".

Usted puede utilizar una técnica d e esa clase para buscar archivos
línea por línea. Suponga que hay un archivo d e títulos llamado
newtitles e n donde cada línea ei el título d e un libro. El siguiente
progranla buscará todos los títulos con el patrón "Christnias"
leyéridolos uno por uno (una línea a la vez) y asignándolos a la variable
$title.la cual se biisca entonces.

-
whi l e ( $ t i t l e = < N T I T L E S >
l
i f ( S t i t l e =- /Christmas/ )
I
print $ t i t l e ;
1

La operación de concordancia d e patrón tiene un conjunto de

opciones con las que iisted puede calificar la búsqueda y las cuales se
presentan en la tabla 6- 13.
Las opciones se sitúan después de la barra oblicua de la operación
de patrón de búsqueda. Por ejeinplo, la opción i despiiés de la barra d e
cierre da instrucciones a la operación de concordancia para pasar por
alto si los caracteres están en iiiayúsculas o niinúsculas .
240 1 Fundamentos de programación
--
en Linux -

Operación de concordancia Descripción

de patrón
i Realiza una búsqueda de patrón sin tener
en cuenta mayúsculas o minúsculas
m Trata una cadena como líneas múltiples
S Trata una cadena como una línea única
x Extiende la capacidad de lectura de su pa-
trón con espacios en blanco y comentarios

Opciones de concordancia de patrón de Perl

El siguiente ejemplo busca las versiones en mayúsculas o minúsculas

d e "Christinas".

Perl soporta todo el rango d e expresiones regulares en sil proceso de

coiicordai~ciade patrón, incluyendo caracteres especiales extelididos.
.
Los caracteres especiales *, +, ?, { ), , ", $ y [ ] se pueden utilizar para
construir operaciones de búsqiieda complejas.

Prueba de-repaso
¿Cuáles son las dos piezas de información que usted necesita
para obtener una subcadena de una cadena?'

¿Cuál es la estructura de control que usted puede usar para

leer fácilmente los argumentos del script?1°

Funciones: sub
En su script I'erl, usted puede definir subrutinas, que le permiten
organizar mejor su programa. En lugar de iiria larga serie de eiiuncia-
dos, puede definir subrutinas separadas para tareas específicas. Las tareas

9 La posición inicial dentro de la cadena y el número de caracteres en la subcadena.

10 f w c n c l i .
 Capitulo 6: Perl 1 241
que usted desea realizar más de una vez no necesitan que el código esté
repetido en el programa: puede definir una subrutina para esa tarea y
llaniarla cuantas veces la necesite.
Las subrutiiias se definen con el comando sub, seguido por el
nombre de la subrutina y un bloque de enunciados. Dentro del bloque
de enunciados, usted puede tener los enunciados en Perl que desee. Las
subrutinas operan como lo hacen las funciones en los programas en C y
como los procedimientos de otros lenguajes de progranlación. Pueden
tomar argumentos y tienen paránietros con noinbres predeterminados.
Las funciones de Perl y los con~andosrelacionados se presentan en
la tabla 6-14.
El siguiente ejemplo define una subrutina llamada dispfile:

í
print "Please enter in name of file to be dispiayed: ";
chomp($filename = < S T D I N > ) ;
system("cat Bfilenamen):

Función o comando Descripción

sub nombre de la función; Declara una función.
sub nombre de la función { Define una función con el nombre de la función
enunciados;
1
& nombre de la función Llama una función con los argumentos
(listu de argumentos) especificados en lista de argumentos.
@- Contiene los valores de argumentos que pasa-
ron a la función actual; $- y un número de índi-
ce hacen referencia a un argumento, de modo
que $-[O] es el primer argumento.
$ #- Presenta el número de argumentos que pasaron
a la función actual.
\@nombre del arreglo Hace referencia al arreglo (usado en una lista de
argumentos para mantener la integridad d e un
arreglo).
my(1ista de objeto) Define la variable local restringida a una
subrutina o bloque.

Funciones de Perl y comandos relacionados

242 1 Fundamentos de programación
- --- en Linux

Usted puede definir subrutinas de Perl antes o después de los enun-

ciados principales en su script y resulta útil que ubique los enunciados
principales en uno de sus bloques. Sin embargo, si las subrutinas se
llaman en enunciados que se presentan antes d e la definición de la
subrutina, entonces deberá situar las declaraciones de las subrutinas en
el código antes d e los llan~adosde subrutinas. Las declaraciones de
subrutinas operan como las declaraciones de función en C . Están
formadas por el comando sub y el nombre de la subrutina, seguidos
por un signo de punto y coma sin ningún bloque de código. Usual-
mente, usted pondría declaraciones de subrutina al comienzo del script
de Perl seguidas por el bloque principal d e enunciados y después por
las definiciones de sus subrutinas. El siguiente ejemplo es una declara-
ción d e subrutina para disyJle.

1 SUD alspti ie:

En Perl, hay varias formas de llamar las subrutinas.Tradicionalniente,

una subrutina se llama con el nombre de la subrutina precedido por u11
ampersand (&). Por ejemplo, &dispfile llamaría la subrutina dispfilc.
Usted también puede emplear paréntesis en lugar del signo &. Si tiene
una declaración de subrutina precedente, si~nplementepuede usar el
nombre de la rutina misma. LJS sigulenteg llamadas de subrutina son
equivalentei, pero al htilizar el noinbre gólo se necesit~una declaración
de subrutina.

Las subrutinas pueden haber recibido argumentos y responder a

cllos con valores ante el eniiiiciado de llamado. Estos arguiiientos y
valores se presentan como listas. Los argumentos especificados en una
subrutina se ubican en una lista y se asignan al arreglo (6- que enton-
ces pasa a la subrutina. El arreglo (6- conteiidrá los arguiiientos para la
subrutina actual que se va a llamar. Para tener acceso a iin argumento
en particular, usted usa operaciones de arreglo o de lista p a n haccr
referencia a los ~leiiieiitosdel arreglo @,-, el cual se utiliza cn todas las
subriitinas para tener acceso a los argumentos de las mismas.
 Capitulo 6: Perl 1 243
Los argunientos se organizan en el arreglo @-contando a partir de
O y se hace referencia a ellos cuando son elementos de cualquier arre-
glo escalar. Al primer argun-iento se hace referencia con $-[O], al
segundo con $-[l] y así sucesivamente. El siguiente ejemplo de
subrutina, dispjleay,está diseñado para recibir como arguinento cl
nombre de un archivo. Usa $-[O] para acceder a un nombre de archivo
que se le pasó en el arreglo @-.

Los llamados de subrutinas podrían ser alguno de los siguientes:

i - n ~ s p r i e a r g r-myri l e - . ) ;
kdispfilearg " m y f i l e " ;

Para las constantes, la lista @-únicamente contiene valores. Sin

embargo, si usted usa una variable o un arreglo corno argumento,
entonces @- hará referencia a esos objetos. D e hecho, con variables y
arreglos, se iniplementa el llaniado por referencia. Esto significa que las
referencias a los elementos en el arreglo @,- hacen referencia a los
objetos originales. Los cambios hechos haciendo referencia a estos
objetos a través del arreglo @- cambiarin los objetos originales en la
función de llamada. Por consiguiente, si una variable de cadena se
utiliza como un argumento para una función, y ese argumento se
referencia a través de @-,y se asigna un nuevo valor en la subrutina,
entonces el valor de esa variable también se cambia en la función de
llainado.
Los valores de retorno se pueden especificar por medio del enun-
ciado return. Cualquier valor que se liste con él se ubica en una lista y
se regresa al enunciado de llainado. Si no hay u n eiiunciado return,
entonces el valor del últinio enuiiciado en la subrutina se usa como el
valor de retorno. Dado que dicho valor es una lista, esto significa que
una subrutina de Perl puede retornar rnás de un valor. Estos valores se
pueden retornar y asignar a una lista de variables.
244 1 -~
F u n d a m e n t o s d e programación e n Linux
-

Alcance
El nkcnrrcc le permite definir variables que esisten sólo dentro de una
subrutina o arcliivo. Quienes están faiiiiliarizados coii el alcance en
otros lenguajes de programación encontrarán algunas diferencias con
Perl. C o n la operación my, usted puede definir una variable local
conocida solamente para uiia subrutina.
La operación my restringe el alcance de una variable a la f~incióno
bloque dentro del ciial se definió. Una variable definida con my es
tt.ciiicainente una variable estática, aunque dentro de una subrutina, y
funciona conio una variable autoniática en C. Sin enibargo, si usted
define una variable con 13 operación my fuera d e cualquier subrutina
en la parte superior del arcliivo, entonces opera como una variable
estática de C. Una variable d e esta naturaleza se conoce eii todas las
subrutinas dentro de ese script d e Perl pero no en los deiiiás scripts que
pueden constituir u n progrania en Perl.
La operación my f~incionadentro de bloques, lo inisiiio que dentro
de subrutinas. Usted puede definir un bloque, sin hacer que foriiie
parte de una definición d e f~inciónni d e una estructura de control.
Cualquier variable que usted defina en 61 con la operación my sola-
mente se conocerá dentro de él. Debe definir una variable coii la
operación my dentro de un bloq~iey dcspuks seguirla con uiia
s~ibrutinataiiibién ddiiiida dentro de ese bloque, de nianera que así la
variable será visible para la subrutina.

Proyecto 6-2: Usar subrutinas

El programa myhtsub.pl reorganiza en subrutinas el programa rnyht.pl
creado antes.
whtsub.pl
Paso a paso
1. Cree una subrutina llamada searchfile, que realiza una búsqueda d e
un archivo d e texto para una cadena especificada, en este caso,
<TITLE>.
2. select-title decide si tomar el título del nombre del archivo o d e la
línea <TITLE>.
 Capitulo 6: Perl 1 245
3. Si select-title toma el título de la Iínea <TITLE>, debe llamar a la
subrutina get-title para analizar el título usando índice y operaciones
de subcadena.
4. Observe que search-file presenta dos valores. El primero es un valor
de O ó 1 que indica que se encontró el patrón y el otro es la línea que
contiene el patrón.
select-file recibe los tres argumentos, los cuales se asignan a varia-
bles locales (found, filename y titleline) asignando los valores del
arreglo @- a la lista de variables locales; search-file usa asignaciones
individuales para sus argumentos y variables locales, pero con la
misma facilidad podría usar una lista de variables y el arreglo @-. Por
ejemplo,

El siguiente es el script myhtsub.pl

..
-E-1
.i
:t.ib .:.$ar,,:h-fi 1 F ;
sub s s ? l e r t - t i e l ? :
..l.ib get-::irl+?:
p i - i r ~ t " HTiil \ \ ~ i f H E A E > \ , n ' T ! T l F'1.l~ Irid-x. ! T í T L E > \ i i < ! H E , A D > \ n < B O [ i Y i \ r i " :
p i , i i - , ~" t H l > l i i r l ~ u v f PTI:l 1:ile:~;Hl \,II":
up~ndir!CúTR. " . " ) ;
f r ~ t . ? d c l - i :,>?i
t ii"111k( r e i i d d ! I ~ ~ L E I F : )
I
i i ! - d ! d i ? ~ - i t \ i n i ,&& ! L $ J i r r ~ . l i n e =- l b \ , / ) )
I
p r i n t ",tiP'.Yd i I i~;iir~!~<I'l-~C \ n * ii l ':n";
n p ~ ~ i i d i r ( H I 1 I K ." L J i t r i . ; r n r * " ) :
f ~ : r c , ? ~ : l i: b f i l ? t i 1 ( r ~ ~ . . ~ : i ~ l i r ( l i E l )R ' ~

if ( .f " Lrli r i i ; , n c - i f f i 1--,n" && ( $ f i i p - n =- /.htrnI!$/) )

246 1 Fundamentos de programación en Linux

while i r ! - o u r i ~ == O ) b& (Shlii-1- - <HFILE>)

s u b select-t i t lo

sub oet title

1. iCuáles son los sinibolos que usted utiliza para leer la entrada de un
archivo?

2. Si un comando print no tiene argumento, jhay algún resultado?

3. jCómo se puede asignar una lista de valores a un arreglo?

I 4. ¿Se pueden eliniinar elenientos en u n arreglo asociativo?

5. iCóiilo se puede encontrar c u i l e ~son las cadenas que se usan para el

indice de un arreglo asociativo?

6. Si uii script intenta, pero falla, al abrir un archivo, jcómo se puede

terminar el prograina en ese plinto?
 Language)
-
Los objetivos de este capítulo son:
Definir variables Tcl y crear expresiones con~plejas

Administrar arreglos, arreglos asociativos, argumentos y listas

Controlar operaciones de entrada y salida de Tcl, administrando archivos

e interconexiones

Desarrollar programas coniplejos en Tcl usando estructuras de repetición y condicionales

Emplear procedin~ientospara organizar su progranla

Definir, buscar y dar formato a cadenas

Crear scripts de Expect para ejecutar de manera automática programas interactivos

Usar Expect para ejecutar automáticamente tareas en FTP

247
 ogramación en Linux
-"-

T cl es un lenguaje de coniandos de propósito general desarrollado

por John Ousterhout en 1987 en la Universidad de California, en
Berkeley. Originalniente se diseñó para adaptar aplicaciones y con el
tienipo se ha convertido en un lenguaje totalmente funcional. Igual
que con Perl y GAWK, usted puede escribir scripts en Tcl para desa-
rrollar sus propios progranlas, ya que es un lenguaje muy sencillo de
usar.
Tk y Expect son aplicaciones de Tcl que extienden las capacidades
del lenguaje. La aplicación T k permite el fácil desarrollo de aplicacio-
nes gráficas interactivas. Usted puede crear sus propias ventanas y
cuadros de diálogo con botones y cuadros de texto de su preferencia.
La aplicación Expect perniite una comunicación fácil con programas
interactivos como ftp y telnet.
A nienudo,Tk se utiliza junto con Tcl para crear aplicaciones gráfi-
cas. Con T k se crean los elementos gráficos, tales conio ventanas, y Tcl
realiza las acciones de programación, como la administración de la
entrada del usuario. Al igual que Java,Tcl y T k son aplicaciones
niultiplatafornia; un programa Tcl/Tk funcionará en cualquier platafor-
nia que cuente con un interpretador de Tcl/Tk. En la actualidad se
dispone de versiones de estos programas para Windows, Macintosh y
sistemas UNIX, incluido Linux. Usted puede escribir una aplicación
Tcl en Linux y hacerla funcionar en el mismo código en Windows o
Mac. Las nuevas versTones de Tcl y T k 8.0 incluso soportan una
interfaz gráfica de usuario (GUI), que se ve y se siente conio widgets
locales, usando ventanas similares a las de Mac en los Mac y a lai de
Windows, en Windows.

Nota
Los lengu tán organizados de acuerdo con diferentes
tipos de objetos gráficos, como ventanas, botones, menús y barras
desplegables. Dichos objetos se conocen como widgets. Para saber
más sobre el tema, véase el capítulo 8.

Tcl es un lenguaje interpretado que funciona, conio Perl, dentro de

su propio shell. El coniando para llamar al shell de Tcl es tclsh y
dentro de él usted puede ejecutar con~andosde Tcl.Tanibién es posible
crear archivos dentro de los cuales puede llamar el shellTcl y listar
 Capitulo 7: Tcl (Tool C o m m a n d Language)
-
)-
249

comaiidosTc1 (la lista de coiiiaiidos se explica en la sección "Listas", de

este capítulo), para crear de inanera efectiva u11 prograina Tcl. Una
ventaja significativa para el leiiguaje Tcl y sus aplicaciones es el hecho
de que son totalmente coiiipatibles con el lenguaje de prograniación C ,
y las librerías de Tcl se piieden incorporar directaiiiciite en los progra-
mas en C. Esto pcrniite que usted cree niuy rápidamente versiones
coinpiladas de prograinas en Tcl.
Cuando usted instalaTk y Tcl en su sisteina, también se iiistalan los
coiiiandos para las yá'yit~nstrrnrztiak~.Estas páginas son las que se presentan
en pantalla en el maiiiial de Liiiux en línea y a las cuales se ticne acceso
con el coiiiando man. Este coinaiido se utiliza con el coiiiandoTc1 o T k
para obtener iiiforniacióii detallada acerca de estos íiltinios. Por geniplo, el
coniando man switch presenta en pantalla la página inanual para el
coinaiido switch deTcl y man button presenta eii pantalla la inforiiia-
cióii sobre el widget button de Tk. Una vez que haya instalado Tk, iisted
puede I-iacer fuiicioiiar un prograiiia de deinostracióii ilamado w i 4 q ~que
prestvta todos los widgets d e T k que cstán disponibles. El progranla i.rii&ct
Lisa programas de iiiiicstra de Tcl/Tk y puede presentar en pantalla el
código f~ientcpara cada uno. Usted puede eiicontrar el prograina winyet
canibiaiido el directorio cic.irroi de Tk, conio se iniicstra a coiitiniiacióii:

(La forma tk* en este código compara el nombre del directorio qiie está
integrado por tk y su núnicro de vc-rsibii,coiiio tk8.3 parca la versibn 8.3).
Eii la vciitaiia Xterin dcl escritorio GNOME, iiigrese el coiiiaiido widget
para poiicr a fiiiicionar el progniiia de deinostraciciii. Usted taiiibitii puede
exaiiiiiiar los archivos deiiio por separado y inodificarlos coiiio desee. Si ha
iiistalado una vcrsión deTk por sil cueiita en el directorio /i.rsr//oc.ii//bii~y no
en /rrsr/l~iw,t.1 directorio rlernos se locdimrá en /wr/locnl/lih/tk*.

Extensiones y aplicaciones
E11 la actualidad, Scriptics, coi-iipafiía f~iiidadaen 1997 por Jolin
Ousterhout, desarrolla y soporta a Tcl y T k . Las vei-sioiies actiiales (al
 rogramación en Linux
m -e% - *

moniento de impriniir la edición en inglés de este libro) de Tcl y Tk son

8.3 y están disponibles en forma gratuita en el sitio Web de ScripticsTcll
Tk: http://dev.scriptics.com. En este sitio también se encuentra dispo-
nible amplia información de PostScript,Adobe PDF y formatos HTML.
La documentación de HTML se puede ver en línea. Las versiones de
paquete de R P M también se pueden encontrar en el sitio de distribución
de Red Hat en ftp.redhat.com.Usted necesitará los paquetesTcl y Tk
RPM, lo mismo que los paquetes de desarrollo de cada uno.
Tcl/Tk se ha ampliado a través de extensiones que aunientan las
capacidades del 1enguaje.Varias extensiones de uso común son TclX,
incrTcl y Oratcl, que se encuentran disponibles a través de enlaces en el
sitio Web de Scriptics. Ingrese a la página Tcl Resources y desde allí vaya
a la página Tcl Sofnvare;en este punto usted puede ingresar a la página
Tcl Extensions en donde aparecen las listas de las extensiones que están
disponibles actualmente (dev.scriptics.com/resoilrces/softu~are/extensions),la
mayoría de las cuales puede descargar e instalar gratuitamente.
TclX extiende capacidades como las de acceso a archivos y manejo de
tiempo y fecha, muchas de las cuales se han incorporado en versiones
recientes de Tcl.

[incr Tcl] soporta la iniplenientación fácil de widgets de alto nivel,

.
empleando una estructura de prograniación orientada por objetos.

BLT agrega widgets de gráficos y barras aTk.

Sybtcl y Oratcl iniplenientan interfaces de bases de datos a las bases
de datos de Sybase y Oracle.

TclDP suniinistra soporte para prograniación distribuida a través de

una red.

La extensión TrfCrypt agrega el encriptamiento que se retiró de la

versión estándar Tcl/Tk para hacerla exportable.

Nota -. e

Numerosas aplicaciones de Tcl/Tk, herramientas de desarrollo y

utilidades están disponibles en forma gratuita en varios sitios de
Internet. Usted puede conectarse a la mayoría de estos sitios a través
del panel de software de Tcl en el sitio Scriptics.
 Capítulo 7: Tcl (Tool C o m m a n d Language)

El shell y los scripts tclsh

Dentro del sheliTcl, puede ejecutar coiitandosTc1 en forma interactiva,ingrt~arl-
do los comandos en un prompt del shellTcl y ejecutándolos uno a uno, o
puede poner los comandos en un archivo descript y +xutarlos todos a la vez.
Ingrese el coinando tclsh para activar el shellTc1 con el pi-oinpt 'X,. Entonces,
puede ingresar comandos Tcl siniples y evaluarlos cuando presione ENTER.
Usted sale del shellTcl con el comando exit o presionando las teclas CTlU-D.

' $ms3- -

% s e t age 11
% p u t s Bage
11
%, e x i t
8

El comando tclsh se iniplenienta como un enlace al programa

actual trlsll. E ~ t enombre del programa consta de la forma t r l s l ~y el
número de la versión, como en el caso de trlsh8.3, para la versión 8.3.
Si su sistema no cuenta con LIII enlace para tclsh, tendrá que utilizar el
comando tclsh o inipleiiieiitar el enlace usted niisiiio.
Usted puede operar un script Tcl como un programa independiente
o conio un archivo que lee explícitaniente el coniarido tclsh del shell
Tcl. Este script lo leerá y e¿ecutará el siguiente comaiido:

Para crear un script independiente que f~iiicionemás como un

coniando, usted debe llamar el conlarido tclsh dentro del script. Puede
hacerlo asignando iin nombre de la ruta explícito para el comando
tclsh conio primera línea del script, como se muestra a continuación:

. Comandos de Tcl
El lenguaje de programación Tcl es ficil de usar. Sus enunciados c o n -
tan de un coiiiando seguido por argumentos; también cuenta con un
252 1
- Fundamentos de programación
--
en Linux
.-

completo conjiiiito de estructuras de control que incluye los bucles

wl-iile y for. Los coniandos se pueden terminar coi1 un sigilo de plinto
y coma (;) o con un cariícter de nueva línea. Usted puede considerar
un coii~aiidoTcl coiiio un Ilainado de f~inción,en dor-ide el nonibre
del coiiiarido hincioria coiiio un noinbre de fiinción, seguido por
al-g~~mentos para la f~inción.Sin enlbargo, a diferencia del llaiiiado de
f~ii-icióri,
no hay paréntesis ni comas que enmarquen los argumentos.
Usted sinipleinei-ite ingresa el nombre del coiiiando y sus argunieiitos,
separados solaniente por espacios. U n caricter de nueva línea despiiés
del í~ltiiiloargumento terminari el enunciado.
Usted puede ver con claridad las características de este formato eri el
comando set de asignación de Tcl. Para asignar un valor a una variable,
debe ingresar, pririiero, el colilando asignación set; después, el noinbre de
la variable seguido por el valor que se va a asignar. El iionibre del co-
mando, la variable y el valor vaii separados únicaniente por espacios. El
rctorno de carro a l final de la línea termina el enunciado; eii el siguiente
se asigna una cadena ~'llylaiila la variable myname y el siguiente
enunciado asigna el valor entero de 5 a la variable age.

Así como en GAWK y Perl, los tipos están determinados por el uso.
Una variable asignada a un entero se considerará un entero y una
asignada a una cadena será un arreglo de caracteres. Para los
lectores que estén familiarizados con Lisp, este formato de coman-
dos parecerá familiar.
---

Usted puede utilizar varios coiiiandosTc1 para realizar tareas del sisteiiia,
como detener un script (exit),cambiar un directorio de trabajo (cd) o
detectar errores (catch).Eri la tabla 7- 1 se presentan estos coiiiaiidos.

Expresiones
Lai cxprcsiorlcls tainbién se iiiaiiejan coino coiiiandos en Tcl. El coman-
d o expr se evalíia como una expresión y regreia su valor resultmte
 Capítulo 7: Tcl (Tool C o m m a n d Language)
.- - -

C o m a n d o Tcl Acción
catch Detecta y atrapa errores
cd Cambia el directorio d e trabajo
clock Regresa las cadenas d e tiempo y formato
de fecha
error Elimina u n error
eva l Evalúa c o m o u n comando una lista d e ar-
gumentos
exec Ejecuta u n comando Linux
exit Termina el programa y sale
pwd Retorna el nombre del directorio de trabajo
actual
info Consulta el estado del intérprete d e Tcl
trace Verifica los valores d e las variables
. .

Tabla 7-1 Comandos del sistema Tcl

coino una cadena.Toiiia coi110 sus arg~i~neiitos los operandos y opera-

dores d e una espresión.Tc1 soporta todos los operadores estáiidar
aritiiiéticos, d e comparación y lógicos. El resiiltado de una espresión
aritmética tendrá la iiiisiiia forma de sus operandos; así, por rjeiiiplo, si
los operaiidos son níimeros reales, el resultado será uii núniero real.
Usted puede mezclar operaiidos de diferentes tipos y Tcl los convertirá
para lograr la concordancia d e uno con otro. En el caso d e operandos
con iin níiinero real y iin entero, el entero se convertirá autoiiiática-
mente en i i i i ní~ineroreal. En el priinero de los sigiieiites en~iiiciados,
el comando expr evalúa la adicióii de 4 y 3. El enunciado que sigue
iniiltiplica 25 por 2.

El valor resultante que produce cualquiera de los comandos Tcl

siempre es una cadena. En el caso de operaciones aritméticas, el
, valor aritmético se convierte primero en una cadena, que presenta
después el comando expr.
254 1 Fundamentos de programación
- .
en Linux

Usted puede crear expresiones coiiiplejas usando paréntesis. Las

expresiones anidadas iiiás profundaiiierite se evalúan primero. En el
siguiente ejeniplo, se evalúa 25 * 2 y del resultado, 50, se restan 20.

I I wv
J LAI r YW c/1 I V VI\
~
r vi W V ~

3 Pregunta: ¿Pueda integrar comandos Tcl?

Respuesta: Sí. Usted puede cotribiiiar comandos integrando uno dentro de
otro. La integración se usa comúninente para asignar el resultddo de una
expresión a una variable. Esto iiivolucra dos comandos: el coniaiido set para
realizar la asignación y el coniaiido expr para evaluar una expresión. Usted
integra los coniaiidos coi1 paréntesis cuadrados ([ y 1). U n coi~iandointegrado
es otro coniando Tcl cuyo resultndo se eiiiplea conio un aiguliiento en el
comando Tcl más externo. El coiiiaiido integrado se ejecuta primero y su
resultado se usa como el a r p n i e n t o del coiiiaiido más externo.
El siguiente enunciado asigna el resultado de la operación arititiética 25 *
2 a la variable num. El coiiiaiida expr 25 * 2 está integrado dentro del
coniando set. l'riiiiero se ejecuta el coniando integrado y su resultado, 50, se
asigna a la variable num.
s e t num [ e x p r 25 * 21
-. -p
. ..
,Expresión integradq
-

Pregunta: puedo ejecutar comandos Linux dentro de un script de

Tcl?

Respuesta: Con el coniaiido exec usted puede ejecutar cualquier coinando

Liiiux dentro de un programa Tcl. El con~andoexec ejecutará un coniaiido
Liiius, esperando que terniiiie antes de coiitinuar con su programa. El resulta-
d o dei comando Linitx pasará su progrania a través de exec. En el siguiente
ejeniplo, el coinando exec ejecuta el coiiiando date de Liniis. La fecha se
asigna a la va~iablemydate. Después, el coniando 1s -1 se llevará hacia la salida
estáiidar (la pantalla) con el coitiando puts.
s e t mydate [ exec d a t e 1
p u t s [exec 1 s -11
 C a p í t u l o 7: Tcl (Tool C o m m a n d Language)

Variables
Tcl soporta variables numéricas y d e cadena, lo mismo q u e arreglos,
incluidos los iirre$os crsoíicrtivos, los cuales se estudian e n la siguiente
sección.Todas las variables cuentan con una cadena coiiio contenido.
Sin embargo, aunque el contenido d e una variable es una cadena, ésta
se puede usar coi110 u n valor a l t e r o o un valor real en una expresión
aritmética, considerando q u e la cadena consta de núnleros. Cada vez que
se einplea una variable d e esta clase c o m o u n operando en una opera-
ción aritniética, su contenido se convierte primero e n u n entero o en u n
valor real. La operación se realiza y después los valores aritniéticos y el
resultado que se obtiene por nledio d e expr se convierten en una
cadena. Esto significa q u e usted n o tiene que preocuparse por declarar el
tipo d e variable ni, incluso, por definirla.Todas las variables se definen
automáticamente cuando se utilizan por primera vez e n u n enunciado.
C o r n o hemos visto, a las variables se les puede asignar valores usan-
d o el comando set, el cual toma coino su arguniento el nombre d e la
variable y el valor asignado. El nombre d e una variable puede ser
cualquier conjunto d e caracteres alfabéticos o nuniéricos niás el signo
d e subrayado (-). La puntuación y otros caracteres n o se permiten.
Cuando usted necesita usar el valor de una variable dentro d e un
eniinciado, primero debe evaluarla; al hacerlo, se sustituye el nonibre coi1
su valor y anteponiendo el signo $ al nonibre de la variable se realiza dicha
evaluación. I'ara utilizar el valor d e una variable c o m o un operando en una
espresión, usted debe ei~aluarla variable precediendo el nonibre d e la
niisma con el signo $. Eii el siguiente cjerriplo, el valor 5 se asigna a la
variable mynum; cntonces, esta variable se evalúa en una expresión,
$mynum, s~iiiiinistrandosu i~alor,5, c o m o u n operando en esa exprcsión.

p-
ie-t rnynurn 5 .--
e x p r 1 0 * Srnynurn

Para q u e el valor d e una variable forme parte d e una cadena, sola-

mente nccesita evaliiarla deiitro d e esa cadena. El valor d e la variable se
coni~iertee n parte d e aquella. En el siguiente enunciado, el valor d e la
variable myname se utiliza c o m o parte d e una cadena. E n este caso, la
cadena seri " M y name is Lnrisa".
256 1 -
Fundamentos de programación en Linux
--

-
r 1
s e t m y s t r "My narne i s $rnynamen

Ciertos comandos están diseñados para f~incioiiaren variables. Pos

cjemplo, el coinando append conecta una cadena a una variable; el
coiiiando incr incrementar5 un entero y el comarido unset renioverá
l~ definición de una variable. En la tabla 7-2 se presentan los diferentes
coniandos que f~incionanen las variables.

Comando Descripción
set Asigna u n valor a una variable
global Declara variables globales
incr lncrementa una variable en u n valor entero
unset Borra variables
u pva r Hace referencia a una variable con u n alcance diferente
variable Declara espacio para variables
array Especifica las operaciones de acceso al arreglo, tales c o m o
las búsquedas
expr Ejecuta expresiones matemáticas
- ...- -. .- -

[ ~ a b l a7-21 Operaciones de asignación y variables

Prueba de'repaso
¿Qué tipo de valor produce una expresión numérica?'

¿Se pueden combinar operaciones de asignación y aritméticas?'

Arreglos
Loi elenientos de un arreglo son valores definidoi y asignados usando el
coniando set con un ai-g~imentoque se agrega para el índice. En el siguiente
ejemplo se asigna el número 23 al primer elemento del arreglo mynum.

1 Una cadena.
2 Si; use los operadores aritméticos de asigiiación. tales c o m o =+.
 Capítulo 7: Tcl (Tool C o m m a n d Language)
- .

Entonces, usted puede hacer referencia a los elementos por separa-

do, coino lo haría con una variable, precediendo el elemento con un
signo $, con10 se muestra a continuación:

Tcl taiiibién cuenta con arreglos asociativos, los cuales usan cadenas
como índices. Los eleineiitos de los arreglos asociativos son valores
definidos y asignados que emplean el coniando set con un arguinento
agregado para la cadena del índice, la cual se encuentra entre paréntesis
y se pone inmediataniente después del nonibre del arreglo y prece-
diendo el valor. Los siguientes enunciados agregan dos eleiiientos al
arreglo city con las cadenas del índice Napa y Alameda.

A los elementos de un arreglo asociativo se hace referencia al aiite-

poner un signo $ y colocando entre part.iitesis la cadena del índice:

TTFymqm &

Luego, utilice el coniando array para inanipular un arreglo, verifi-

cando ciertas características como su taiiiaño y sus índices, y si existe.
Inclusive, puede usar array para asignar de una vez todos los eleinentos
de un arreglo usando una lista. Este comando toma varias opciones que
especifican la acción que usted quiere realizar. C o n la opción exists,
puede ver si un arreglo está definido y con size puede ver cn pantalla
la cantidad de eleiiientos en el arreglo.

% array exists city

1 \,Opción
.- --

del comando array;

- - --
% array s i z e c i t y - -- - - -- --
258 1 Fundamentos de programación e n Linux

Las opciones get y names permiten que tenga acceso a valores del
elemento y del índice. Estas opciones pueden tomar u n argumento
agregado especificando un patrón que puede utilizar para recuperar
valores del elenlento o de los índices. La opción get presentará en
pantalla valores del elemento e índices, en tanto que la opción names
solamente presentarlí índices. Si n o hay ningún arguinento, se presentan
todos los valores de elementos o de índices.

z array get c i t y
Napa 34 Alameda 1 7
% a r r a y names c i t y
Napa Alameda
% a r r a y names mynum
1

1Nota
Usted puede buscar uno a uno los elementos del arreglo, con las
opciones startsearch, nextelement y anymore. Con la opción
donesearch termina su búsqueda.

Variables y arreglos especiales: argv y env

Cada vez que hace f~mcionarun script Tcl se configuran arreglos y
variables especiales para que las utilice en el progianla.Tc1 corifigiira
una variable argv que contiene los argunientos que usó en la línea de
comandos de UNIX cuando llaiiló su progrania. La variable especial
argc contiene la cantidad d e argumentos y argvO contiene el nonibre
de sil prograiiia.
Tcl también ciierita con un arreglo asociativo especial, llamado env,
que mantiene todas las variables de entorno desde su sheil de Linus. Usted
puede hacer referencia al valor de cualquiera de estas variables de entorno
con el nombre para el índice del arreglo env. Por ejemplo, $env(HOME)
le da el valor de la variable de entorno HOME; $env(PATH) provee los
directorios que se usan en las consultas de conmidos.
Listas
Tcl cuenta con un tipo de objeto que no se encuentra en la niayona de los
lenguajes de progran~ación:la lista. Una lista es un conjunto de palabras,
cadenas o números entre corchetes ({ )).Tcl incluye un conjunto de
comandos de lista flexibles que puede usar para manipular listas, cotnbi-
nándolas, separándolas o agregando y borrando elementos de ellas. En la
tabla 7-3 se tnuestran varios de los comandos de listas más comunes.

Comando Descripción
set lista valores Crea una lista y le asigna valores
lsearch lista patrón Busca u n patrón en los elementos de una lista
lindex lista índice Retorna el valor del elemento de la lista que
tiene ese índice
llength lista Retorna el número de elementos en una lista
lrange lista primero último Retorna u n subrango de la lista especificado
por primero y último
linsert lista índice lista de valores Inserta u n nuevo elemento en una lista des-
pués del índice
lreplace lista índice lista de valores Reemplaza el elemento del índice con u n
nuevo valor
lappend nombre de lista Adjunta nuevos valores a la lista
lista de valores
concat listas
. Combina elementos de varias listas en una
lista
list listas Combina listas en una lista mayor, cuyos ele-
mentos son las listas respectivas
split delim de cad Divide una cadena en una lista usando u n
delimitador para separar valores
join lista Une elementos de una lista en una cadena
lsort list Ordena la lista alfabética o numéricamente

Para definir una lista, sitúe un conjunto de palabras, números o cadenas

dentro de un par de corchetes. Usted puede asignar esta lista a la variable o
usarla con comandos que operen en listas. En el siguiente ejemplo se crea
una lista de tres palabras y las asigna a la variable weather. Observe que los
cotnponentes de la lista únicamente se separan con espacios.
260 1 --
Fundamentos de programación en Linux
-.

/p\
'Set weather Isun r a l n wlnd; l
a-

Para acceder y hacer f~incionarla lista, usted usa un corijuiito de

coiiiaiidos de lista. Muchos de ellos puedeii liacer referencia a uii
elenieiito en particular, d e acuerdo con su posición en la lista. Los
elenientos se organizan comenzaiido con O para el primer elenieiito, 1
para el seguiido y así siicesivaniente. En la lista weather, el índice para
sun es O, para rain es 2 y para wind es 2.
El coiiiaiido lindex regresa un eleinento de una lista eiiipleaiido su
índice.Toiiia dos arguiiientos, la lista y el índice para el eleiiieiito que
usted desea. Eii el siguiente eiiunciado, rain se obtiene de la lista
weather. El enunciado que sigue utiliza una lista definida esplícitanien-
te y obtiene el tercer eleiiieiito (índice de 2) de la lista, yellow.

' 7 i'nd6X -$weáther l---

l i n d e x (r-ed b l u e yellowl 2

El comando lrange obtiene un subcoiijunto de una lista. lrange

toiiia como sus argumentos una lista y el primer y el últiiiio eleiiieiito
del rango, coino:

" % ir a m a l h z ? i 2
r a i n wind

El coniando lsearch b u ~ c aeleiiieiitos d e una lista para un p a t r h

eipecífico y regresa cl índice del priiiier elenieiito que encuentra, y
que ciimple con el patrón.Toriia dos argiiiilentos: la lista para buscar y
el patrón. E11 el siguiente eiiunciado se busca el patrón wind eii la lista
weather, {sun rain wind). Este coiiiaiido retornará el valor de 2, el
índice del tercer eleiiiento, que es wind.

El coi~iandollength presenta el iiúmero de elementos en la lista. El

siguiente eiiuiiciado presenta 3:
 Capítulo 7: Tcl (Tool Command Language)
-

El coniaiido linsert inserta uno o niás eleiiieiitoc en una lista cn

una posición especificada.Toiiia tres al-gunientos: la lista, el índice en
donde se va a ubicar el nuevo primer elemento y los nuevos elementos
que se van a insertar. En el siguiente enuiiciado se inserta la palabra
oi.crr1~qcdentro de una li~tacomo ieguiido elemento (índice de 1). Se
regresar5 a la lista (red orange blue yellow}.

Usted puede insertar varios cleiilentos a la vez ingrcsándoloc como

arguiiientos para linsert. Los nuevos eleiiientos \c agregm comeiizando
desde el índice especificado. El siguiente enuiiciado agreg'i doi iiuevos
elementos a la licta weather coiiieiizai-ido con el tercer elenieiito (índice
de 2).El enunciado presenta la licta (sun rain storm hail wind).

El coniando lreplace reeii~plazaráeleineiitos de uiia lista en una

posicibn especificada con nuevos eleinentos. lreplace toma conlo sus
arguiiiciitos a la lista, un íiidice inicial, ~ i níndice fiiial y los iiiievos
elementos. En el siguiente enunciado se reeinplaza el seguido elei-iieii-
to, blue, con green (índice inicial de 1 e í~idiccfiiial de 1). Este enun-
ciado presentar5 la lista (red green yellow):

El coinando lreplace p ~ i e d ereemplazar varios eleineiitos a 13 vez. Si

el núii~erode eleinentos es inayor que el resto de la lista, ésta siiiiple-
mente se exticiide para incluir los nuevos eleinentos. El siguiciite
enunciado presenta la lista (red purple aqua tan}:
- .. - F

P
- 1% b l t ~ o w 1l 2 p u F p l e a q u i t a n
red p u r p l e a q u d t a n

El comando lappend anexa nuevos elementos a1 final de una lista;

toina coino sus argumeiitos el nonlbre de la lista y los elementos que
se van ;i agregar. Para agregar más eleineiltos, sólo especifiqiie el noni-
bre de la lista y los nuevos eleinentos. En el sigiiiente enunciado, los
262 1 Fundamentos de programación
--- en Linux -

elenlentos se agregan a la lista y el c o ~ n a n d olappend presenta la lista

{red blue yellow purple aqua tan):

8 ;6 ecno myrist
r e d b l u e y e l l ow
Xlappend m y l i s t p u r p l e aqua t a n
r e d b l u e y e l low p u r p l e a q u a t a n

concat combina varias listas en una.Toma como sus argumentos

cualquier cantidad de listas; despuks, presenta una lista que es una
coinbinación d e todas las demás. En el siguiente enunciado, concat
presentará una combinación de las dos listas cspecificadas como argii-
iiicntos, {red blue aqua tan):

red b l u e aqua t a n

El coniando list también coiilbina listas pcro protege las originales

dentro de la lista nueva. Usted puede anidar listas, contando con una
cuyos elementos son listas en sí inisiiios. Una lista de esta claie se puede
crear con el siguiente c o n ~ a n d olist. N o olvide que esto crea una lista
sólo con dos eleiiientos, mientras que en el ejemplo anterior, el co-

.
niando concat creó una lista d e cuatro elementos.
-*
v e ! laqua tan).
% echo $ l i s t
{red bluel (aqua t a n )

El coniando lsort organiza una lista alfabética o nuinéricainentc.

Por defecto, realiza una búsqueda alfabética. C o n la opción -integer
realiza una búsqueda numérica. El siguiente eniinciado presenta la lista
{aqua blue red tan). El enunciado que le sigue realiza un ordena-
miento nun~érico,presentando la lista (15 67 89 100).
I
m s o r t ~ r e n l u ea q u a t a n !
% l s o r t - i n t e g e r (89 15 100 671

Los coniandos split y join utilizan delimitadores para separar o

reunir elementos d e una lista. El delimitador puede ser cualquier
 Capítulo 7: Tcl (Tool C o m m a n d Language)

separador regular, como el signo de doi puntos (:). El comando split

genera elenientos al separar una palabra que contiene delimitadores. Los
deliinitadores se remiplazan con espacios, creando nuevos elenientos. El
comando split tonia como sus argumentos la palabra que se ha de
dividir y el deliinitador. En el siguiente ejemplo, siln:rairi:sform se divide
en una lista con trei elementos, {sun rain storm):
A-- - - -
mt sun : r a i n:'stoFm I

El comando join toma una lista y reemplaza los espacios con un

deliniitador específico, uniendo efectivaniente los elementos en uno
solo. El coinando join toma como ius argumentos la lista que se va a
unir y el delimitador. En el siguiente ejemplo, la lista (25 50 100} se
une en un solo elemento, con loi elenientos que la integran separados
por dos puntos (25:50:100):

Prueba de repaso
¿Se puede hacer un índice de un arreglo con nombres ordi-
nario~?~ -
¿Una lista de ítems podría contener c o m o uno de sus ítems a
otra lista o una operación que genera una I i ~ t a ? ~

Entrada y salida de Tcl: gets y puts

Tcl puede leer entradas desde la entrada estándar o desde un archivo,
con el comando gets y enviar datos hacia la salida estándar con el
comando puts. Para leer la entrada desde su teclado, utilice el c o n ~ a n d o
gets. Para leer desde el teclado, usted debe especificar stdin (por
entrada estándar, que es la clase de entrada que se lee desde su teclado)
con10 el primer arguinento del comando gets. Para poner la entrada

3 Sí; se llaman arreglos asociativos.

4 Sí.
264 1 Fundamentos de programación
-
. .
en Linux
-

en una variable, especifiqiie el noiiibre de ésta coiiio segundo argu-

iiiento. El siguiente coiiiaiido lee iina línea desde la entrada estándar,
stdin, y pone la entrada en la variable line:
" -

gets s t d i n l i n e

El coiiiando puts einiía una cadeiia hacia la salida cstiíndar o hacia

uii archivo.Toiiia coino su argiinieiito la cadena que va a salir. En los
siguientes ejemplos, ptits produce pi-iiiiero la cadeiia "Hello" y despi16s
la cadeiia que es el coiiteiiido de la variable line:
- p u t s "He1 1o "
-- ---
p u t s $1 i n e

Si usted desea usar una operación siiiiple puts para obtener el coiite-
nido de varias variablcs, debe hacer que tstas forineii parte de una sola
cadena. I'ara hacerlo, ponga las variables dentro de comillas dobles. Eii el
siguiente ejeniplo, firstname y lastname eiitraii a forniar parte de iiiia
sola cadena que entonces se puede obteiier con puts:
--> --,
p ü t s ' " 8 f i r s t n a m e $1 astnarne"

gets lee una línea dentro d e la variable especific,ida coiiio \u argii-

iiiento. Eiitonceí, usted puedc usar la vari~blepara iii~iiipill,irlo que \e
h y a Icído. Por ctjeiiiplo, eii el sigirientc rci-ipt rryqcts, eiliplcc line en
uii coiiiaiido puts para presciitar en paiit~llalo que ?e iiigresó:
. . - - - - Y --
# !/ u ' s r / b i n / ' t c ~ h
gets s t d i n l i n e
p u t s " T h i s i s what 1 e n t e r e d : $ l i n e W

U n ejemplo d e la ejeciicióii del script rrr)ycfs cs el siguiente:

il e i na
; 1 entered: lnris? anlj rlleina

Usted puede iisx el comando puts para eicribir datos cn cualqiiier

archivo o en 12 salida estáiidcir.Los iioiiibres de los iiianejadoi-cs de
 Capitulo 7: Tcl (Tool C o m m a n d Language) 1 265
archivo se ponen después del comando puts y antes de cualquier dato,
conio cadenas o variables. U n manejador de archivo hace referencia a
ilil arcliivo (los inanejadores de archivo se explican más adelante en la
sección "Manejo de archivos con Tcl"). Si no se especifica u11
manejador de archivo, puts lleva a la salida estándar. En los siguientes
ejen~plosse escribe la cadena "hello" y se lleva a la salida estándar. El
manejador explícito del archivo para la salida estándar es STDOUT.

puts STOOUT "hello"

I'ara obtener valores formateados, utilice loi resultados de 1111 co-

mando de forinato como el arpimeiito de un comando puts. El
coinando format realiza una operación sprintf en u n conjunto de
valores, forinateándolos de acuerdo con especificadores de conversión
en una cadena de forniato, conio:

wmrmat 9FmymRl -

Si quiere obtener más de una cadena o valor en la iiiisina operación

puts, puede eiilplear el conlando format para transformar primero los
valores en una sola cadena. El coniando puts cambiará sólo una cadena
sencilla. Eii el siguiente ejemplo, el contenido de las variables
$firstname y $lastname se obtiene como una sola cadena al usar
priinero el comando format con dos especificadores de cadena, "%S
%S", para convertirlos en una cadena:

m o r r n a t '"%S %'""c87i r s t n a m e $1a s t n a m e l

Interconexiones
C o n el coniando open se pueden crear iiitercoiiesiones que transfie-
ran el resultado de un comarido a la entrada de otrc) comando, en lugar
de acceder a los archivos reales. Despuks, puede utilizar los coniaiidos
puts o gets para extraer o introducir datos a una iriterconesión. Parn
especificar el noiiibre de una interconexión, me el síiiibolo 1 entre
corchetes, así: { 1 ).Taiiibiéii puede incliiir cualquier comando Linux
que desec en los datos de entrada o de salida. El niodo de arcliivo para
266 1 F u n d a m e n t o s d e programación en Linux
-

una interconexión puede ser escritura o lectura: se eniplea escritura para

intercoiiexiones en donde usted usaría puts para escribir, y lectura para
las interconesiones en donde se utilizaría gets para leer. Por ejeniplo,
para transinitir datos a la impreiora, usted eipeciticaría un nonlbre de
interconexión con el comando lpr, como: ( 1 lpr). El modo de archivo
sena w para escritura. Una vez que se ha establecido la conesiói~,usted
puede usar puts para escribir datos hacia la inlpresora con el niaiiejador
de archivo para esta interconexión. Este es un ejemplo:
Interconexión hacia el co-
-
mando de la impresora, Ipr
--- ------
I- 1
Ipr I w I
puts Sprinthandle "Hello world "

Estructuras de control
Tcl tiene un conjunto de estructuras de control sinlilares a lai que se
usan en los lenguajes de prograinación Perl, GAWI<,TCSH y C.Tcl
tiene bucles con los qiie puede repetir comandos y condiciorres que le
permiten elegir entre comandos especificados. En la tabla 7-4 se pre-
senta la lista de las estructuras d e control deTcl.
.
Estructuras d e control Descripción
if Prueba condicional que selecciona comandos y se
extiende con los bloques else y elseif
switch Estructura de selección
while Repite comandos
for Como se usa en los bucles en lenguaje C, repite
comandos
foreach Bucles a través de una lista o listas de valores
break Obliga a la salida del bucle
continue Pasa por alto el resto del bloque y continúa con la
repetición del siguiente bucle
l ~ a b i a7-41 Estructurar de control de Tcl

Las estructuras d e control realizarán pruebas con expresiones de

prueba, las cuales te encuentran entre corchetes. Por ejemplo, para
 Capítulo 7: Tcl

probar si el valor de la variable mynum es menor que 3, usted usaría la

siguiente prueba:

Tcl soporta los operadores de coniparación estáridar que se eiicuen-

tran en otros lenguajes, taler conio < para menor que, > para mayor
que, y <= para nienor que o igual a. El operador de igualdad es el
sigilo igual doble (==) (como en Pei-1 y en C) y no el signo igual
sencillo (=). Para probar si mynum es igual a 5, usted usaría:

Si usted necesita ejecutar u n coiiiando como parte de una expresióii

de prueba, puede usar paréntesis cuadrados para incorporarlo. Por
ejeiiiplo, para incluir un coinando gets en iina expresión while, usted
usaría la siguiente prueba:
-
w h i l e i cgeC ~ s ' h a n d l e m!

Asegúrese de seguir sieiupre la prueba con el corchete de apertura del

bloqiie de las estructuras de control, conio se mostró en el ejemplo
anterior. C o n frecuencia, lasestructuras de control en Tcl utilizan de un
bloqiie de comandos Tcl, los cuales van entre corchetes. El corchete de
apertura debe comenzar en la misma línea d e la estructura de control
que lo usa. En las siguientes líneas, varios coinandos Tcl se pueden
presentar eii lirta, cada uno en su propia línea. El bloque terinina con un
corchete de cierre en una línea. Literalmente, un bloque es un argumen-
to para 1111 comandoTcl. El bloque se pasa a un comando de una estruc-
tura de control y ésta ejecutará los comandos en ese bloque. El siguiente
es un ejemplo de un bloque sencillo utilizado para ~ 1 1 1conlando while.

' while [ S I <= 31 1

p u t s "Your name i s $mynamen
incr i 1
1
-1 Fundamentos de programación
268 - -- en Linux

Las estructuras de control if y else

La estructura de control i f permite seleccionar acciones alteri-iativas. El
coi-ilando i f toma dos argumentos: una expresión de prueba y u11
comaildo Tcl o bloque de comandos. Los dos van entre su propio par
de corchetes. La expresión d e prueba se usa para determinar si se
ejecutarán los comandosTc1. Si la expresión de prueba es verdadera, se
ejecutan los coinandos; si es falsa, se pasan por alto. La siguiente es la
sintaxis d e la estructura ifi
4

$f. (test-expresslonl 1
T c l commands

El script ijls que se presenta más adelante permite que usted liste los
archivos s e g h su tamaño. Si ingresa una S en el prompt, se listan los
archivos del directorio actual, seguidos por el núinero de bloques que
ocupan. Si ingresa algún otro carácter, la prueba i f falla y el script no
funciona. Observe que el corchete de apertura para el bloque de la estruc-
tura i f se localiza despuks de la expresión de prueba if, en la niisma línea:

p ú t s "Please e n t e r o p t i o n : "
-
gets s t d i n option
if ( B o p t i o n -= " s n l {
p u t s " L i s t i n g f i l e s by s i z e "
p u t s Cexec 1s -SI
I

El siguiente es 1111 ejemplo d e la ejecución del script @S:

Please e n t e r o p t i o n : S
L i s t i n g f i l e s by s i z e
total 2
1 monday 2 today

La estructura i f se utiliza con frecuencia para xrificar si ingresó el

número de argumentos apropiado para un script del shell. La variable
especial ARGC del script de shell contiene el riúrnero de argumentos
que el usuario ingresó.
 Capítulo 7: Tcl (Tool C o m m a n d Language)
-

Usar $ARGC en u i i ~operación de prueba perinite verificar si el

usuario ingreió el iiúiiiero correcto de argumentos. Si la cantidad ha
sido incorrecta, puede tener que terminar el script de shell. Puede
hacer esto con el comando exit. Este termina el script d e shell regre-
sando a una condición de salida; exit toma u11 argumento d e níimero:
O indica que el ccript terminó satisfactoriarnerite: Cualquier otro
argumento, como 1, indica que se presentó un error.
En el iiguiente ejemplo, el script ifaig sólo toma un arguniento. Si el
usuario no ingresa un argumento o ingresa niás de uno, la prueba if
será verdadera, se iinprimirá el mensaje de error y el script saldrá con
un valor de error.

p u t s " I n v a l i d number o f arguments "

exit 1
1
p u t s $1

El coinaiido if también tiene u n coiripoiiente else. A menudo, usted

necesita elegir entre dos alteriiativas con base en si la expresión de
prueba tiene éxito o no. El comando else periiiite una estructura if
con dos alternativas. Despuks de else siguen coiiiandos de Tcl. Si la
expresión de prueba de la estructura if es falsa, se ejecutan los coman-
dos que le sigueri a else. En este sentido, la estructura if-else se puede
considerar como una estructura de rrlnr$cnciÚrl; es decir, si la prueba es
verdadera, se toma una raniif cación de la acción; si es falsa, se toma
otra. N o olvide que la palabra clave else debe estar e n la riiisnia línea
del corchete d e cierre del bloque anterior, y ese mismo else debe estar
seguido por el corchete de apertura d e su propio bloque.

La siguiente es la sintaxis para la estructura if-else:

if {expresión de rueba) {
comandos cl
) else {
f
comandos Tcl
1
270 1 Fundamentos de programación en Linux
- ---

El script siguiente elsels ejecuta el c o m a n d o 1s para listar archivos

con dos opciones posibles: bien sea p o r tamaño o c o n toda la inforiiia-
ción del archivo. Si el usuario ingresa una S, los archivos se listaii p o r
tamaño; d e otro modo, se lista toda la información del archivo.

puts -nonewline "Enter S t o l i s t f i l e sizes, "

puts " o t h e r w i s e a l 1 f i l e i n f o r m a t i o n w i l l be l i s t e d . "
puts "Please e n t e r o p t i o n : "
gets s t d i n choice
i f I S c h o i c e == " S " ) 1
p u t s [ e x e c 1s - S ]
)else i
p u t s Cexec 15 -1 1

p u t s Goodbye

El siguiente es u n ejemplo d e la ejecución del script elsels:

Enter s to l i s t f i l e sizes. otherwise al1 f i l e information i s lísted.

Please enter option:
S
total 2
1 rnonday 2 today
5

La estructura elseif
La estructura elseif le permite anidar operaciones if-then-else; su
nombre deriva d e "else if". Al usarla, el shell p ~ i e d eelegir entre varias
alternativas. La primera se especifica c o n la estructura if seguida p o r
otras alternativas, c a d a ~ u n aespecificada p o r su propia estructura elseif.
La alternativa para la última estructura elseif se especifica con u n else.
Si la prueba para la primera estructiira if falla, el control pasará a la
siguiente estructura elseif. La prueba se realizará. Si falla, el control
pasará al siguiente elseif y su prueba se verificará. E ~ t eproceso coiiti-
núa hasta q u e el resultado d e una prueba sea verdadero. El elseif con
resultado verdadero ha ejecutado sus coinandos y el control pasa d e la
estructura if hacia el siguiente comando después d e la palabra clave-fi.
A continuación se presenta la sintaxis d e la estructura elseif N o olvide
q u e la palabra clave elseif d e b e estar e n la n ~ i s i n alínea del corchete
 Capítulo 7: Tcl (Tool C o m m a n d Language)
- -.

d e cierre del bloque anterior; c o m o e n ) elseif (expresión de

prueba) (.
if (expresión de prueba} (
comandos Tcl
) elseif (expresión de prueba) (
comandos Tcl
) else (
comandos Tcl
1
En el script clz.eijls se presentan dos formas posibles de listar archivos.
El último else está reservado para detectar entradas n o válidas, en este
caso una elección n o válida.

$!/usr/bin/tclsn
puts "s. L i s t Sizes"
puts "1. L i s t Al1 Inforrnation"
p u t ~" P l e a s e e n t e r o p t i o n : "
getz s t d i n choice
i f l B c h o i c e == " S " ) {
p u t s [exec 1 s -SI

l e l s e i f ($choice = "1") 1
p u t s Cexec 1s - 1 1
)else l
puts " I n v a l j d Option"
1
p u t s "Goodbye"

El siguiente es un ejemplo de la ejecución dcl script clsr~t1.s:

5 ./eiseitis
s. L i s t Sizes
1. L i s t A l 1 F i l e Inforrnation
Please e n t e r o p t i o n :
1
total 2
w - r - x 1 c h r i s w e a t l i e r 568 Feb 14 10:30 t o d a y
- r w - r w - i - - 1 c h r i s w e a t h ~ r 308 Feb 1 7 12:40 Monday
 gramación en Linux
m 8xW-s

La estructura switch
La estructura switch elige entre varias alternativas posibles. La selec-
ción se hace comparando el valor de una cadena con varios patrones
posibles. Cada patrón tiene su propio bloque de coniandos Tcl. Si se
encuentra una concordancia, se ejecuta el bloque asociado. La palabra
clave predeterminada señala un patrón que tiene concordancia con
todo. Si alguna de las otras comparaciones falla, se ejecuta el bloque
asociado con la palabra clave predeterminada. La estructura switch
comienza con la palabra clave switch, después sigue con las opciones
prefijadas con el signo - y después el patrón de la cadena que se ha de
comparar seguido por un bloque que contiene todos los patrones con
sus bloques. La sintaxis de la estructura se describe a continuación:
switch -opciones patrón-cadena {
patrón {
comandos Tcl
1
patrón {
comandos Tcl
1
predeterminado {
comandos Tcl
1
1
-
Las opciones especifican las capacidades de concordancia de patrón.
Esta estructura soporta las siguientes opciones.
Opción Descripción
-exact Usa concordancia exacta cuando se compara una cade-
na con un patrón. Está predeterminada.
-glob Cuando se compara una cadena con el patrón, utiliza la
comparación de estilo global.
-regexp Cuando se compara una cadena con los patrones, em-
plea la comparación de la expresión regular (es decir, la
misma que implementó el comando regexp).
-- Marca el final de las opciones. El argumento que sigue a
esta opción se tratará como una cadena, inclusive si co-
mienza con un guión -.

La opción -regexp le permite comparar cualquier expresión regu-

lar, mientras que -glob le permite usar el nombre del archivo de shell
que compara métodos. Con -glob, los caracteres especiales del shell *,
 Capitulo 7: Tcl (Tool C o m m a n d Language) 1 273
[ ] y ? le facilitan la con~paraciói~de gran parte de una cadena. C o n la
opción -regexp, usted puede conlparar cadenas alternativas coinplejas,
especificaiido niúltiples instancias de caracteres, al comienzo o al final
de una cadena, y clases de caracteres.
Una estructura switch se emplea con frecuencia para iinplenieritar
nienús. En el programa l.w/ioicc al usuario se le pide ingresar una opción
para listar archivos en diferentes formas. Observe la opción predeternii-
nada que advierte de una entrada no válida:

4) P r n a r a m t n a l l n w t h u~s P r t.n S P ~ P Tr ~i iff~r~nt.

puts " s. L i s t Sizes"

p u t s " 1. L i s t A l 1 F i l e I n f o r m a t i o n "
puts " c. L i s t C Files"
puts "Please enter choice: "
gets s t d i n choice
switch $choice (
S I
p u t s [ e x e c 1 s -SI
i
1 (
p u t s [exec k -11
1
c í
p u t s [exec 1s * . c l

puts " I n v a l i d Option"

1

El siguiente es un ejemplo de la ejecución del programa lsr/~oicc:

274 1 Fundamentos de programación
-
en Linux

5 Pregunta: En una estructura switch, ;

en el mismo cuerpo?

m--- r"-.." ". U' h"."" \ , ," "0" C"."" " '..-S r" y'"" ""C. .A"'""" ""'.W"> "U',

comparación de su patrón ejecutari el bloque para el siguiente patrón. Si el

siguieiite patrón tanibién tiene UII guión, se utiliza el cuerpo que sigue y así
sucesivarrieiite. Usar guiones en los cuerpos de entrada de switch hace posible
que usted coniparta un inisnio cuerpo entre varios patrones precedentes. I>e esta
i n l n ~ t - nn i i e i i ~
~ c n r r i f i r n rnti
r Cirilirl:~dn n t r n i w c q l t r r r i 3 r i v n c n l r ? iin hlnnii~& A n .
por ejeniplo, en casos de un carácter en rnay~sculasy nitiúsculas. En el siguietite
ejeiiiplo, una coniparación de una S (mayúmda) ejecutará el bloque para la s
(,m;.,m',w.,,l,,\ &",,;e,,+,-

Respuesta: Eiiiplear expresiones regulares en patrones le piiede dar m u c h ~i~iás

11 -1
. - - - -- -- 7 - -
A
'1' I 1 . 1
-- --
-.---.--u - ., - - -- , - - - -
..---e
1 '1' 1 ' 1 I 1

patrón, esto le permitirá efyecificar más de una posible coiicordancia. Por ejeinpl
con c 1 C se conipararh la C mayí~sciilay la c riiiiiúscula. En el siguierite ejeni
I h I , . ? .

switch s t r i n g - p a t t e r n pattern 1Tcl commandsl pattern

cwltch $choice 1 1 1s -1 1s I 1 s - S 1
 Capitulo 7: Tcl (Tool Cornrnand Language) 1 275

El bucle while
Los bucles de Tcl son while, for y foreach. El bucle while es el qiie
tiene más propósito general niientrai que for y foreach son niucho
más restrictivos. El bucle while repite comandos. En Tcl, este bucle
comienza con el coniando while y toma doi argumentos: una expre-
sión y un comando simple Tcl o un bloque de comandos Tcl. La
expresión va entre corchetes. U n bloque de coniandosTc1 coinieiiza
con un corchete de apertura en la niisina línea del coiilando while.
Después, las líneas siguientes contienei-i los coniandosTc1 que se repe-
tirán en el bucle. El bloque termina con un corchete de cierre, usiial-
mente en una línea. La sintaxis para el bucle while con un enunciado
Único se muestra aquí:
while {expresión ) {
comando Tcl
comando Tcl
1
La mayoría de los bucles requieren tres componentes pdra trabajar
de nianera apropiada: una iniciación, una prueba y un incremento.
Todos f~incionansobre una variable qiie se utiliza para controlar el
bucle. En el ~iguienteejemplo, el programa tcliriyloop señala al usuario
LIH nombre y luego lo miprime tres veces. La variable i se usa para
controlar el bucle. La variable se inicia primero antes de entrar el bucle;
desp&s, se pone a prueba en una operación relaciona1 con la expresión
de prueba del bucle para determinar cuándo detener el bucle. Eiitoil-
ces, la variable se iiicreimenta cada vez que se ejecuta éste. Cuando la i
llega a 4, la expresión de prueba del bucle es falsa y tste Fe detiene.

#!/usr/bin/tclsh
p u t s "Please e n t e r your name: "
g e t s s t d i n myname
set i 1
w h i l e { $<= i 31 1
p u t s "Your name i s $myname "
incr i 1
1

El siguiente es u11 ejeinplo de la ejecución del progranla tcliiqhop:

- Fundamentos de programación
276 - - en Linux
1
m m u
P l ea se
A l e i na
Your nal
Your nai
Your nal

Usted puede adaptar f3cilinente el bucle while para usarlo con

arreglos. Las variables que se usan para controlar un bucle también sc
pueden emplear al interior de éste para controlar el índice de un
arreglo. En el siguiente script, tcltitlearray, los elementos del arreglo title
se asignan al valor d e cada título. Después, se iiriprinie el conteiiido de
cada elemento usando un bucle for. Observe que la variable num se
utiliza durante el procesainieiito para hacerle seguimiento al eleniento
siguiente que se va a asignar; num rilantiene el conteo de eleiiiciitos
en el arreglo y se usa en el enlace superior en la expresión de prueba
del bucle for para verificar cuándo se detendrá el bucle.

IF! / u s r / ~ ni / t c I s n
a r r a y s e t t i t l e Il Tempest 2 I l i a d 3 Ravenl
s e t num 3
set i 1
w h i l e ( $<= i $numl {
p u t s $ t it l e ( $ i )
incri 1 *
1

El siguiente es un ejeinplo de la ejecución de tc1titlcnrr.q~:

Tempest
11 i a d
Raven

El bucle for
El bucle for realiza las mismas tareas del bucle while. Sin embargo,
tiene un forinato diferente porque toiila cuatro argunieiitos: los tres
primeros son expresiones y el últiino es un bloque de coiiiaiidosTcl.
Los tres primeros arguinentos son expresiones que incorporan loi
componentes d e iniciación, prueba e incremento de un bucle. Estas
expreiiones van entre corchetes. El último argumento, el bloque de
conlaildoi Tcl, comienza con un corchete de apertura y despuei conti-
núa con conlandos Tcl eii las líneas siguientes, teriiiiiiando con u11
corchete de cierre. Eita es la iintaxis:
for {expresiónl} {expresiónZ} {expresión3} {
comandos Tcl
1
La prinlera expresión suele reservarse para una iniciación de una
variable que se Lisa para controlar el bucle. Esta expresión se ejecuta
antes de que el bucle coniience realmente. La segunda expresión es la
de prueba, como una expresión relaciona1 que controla el bucle. La
tercera expresión se ejecuta dentro y al final del bucle. Usiialiiieiite, se
emplea para incrementar la variable que sirve para controlar el bucle. A
continuación de las expresiones va el bloqiie de coniandos de Tcl que
se van a ejecutar dentro del bucle. La tercera expresión se ejecuta
después del bloque de coniandos.
for {iniciación} {expresión de prueba} {incremento} {
comandos Tcl
1
En el siguiente ejemplo se muestra un bucle for simple. Observe
cómo el bucle for es mucho inás coinpacto que el bucle while.

Usted puede utilizar con facilidad el bucle for al igual que el bucle
while para adniiiiistrar arreglos. La variable que se emplea para contro-
lar un bucle también se puede usar dentro de éste para el índice de iin
arreglo. En el script tcltitlearray que sigue, los elemeiitos del arreglo title
se asignan al valor de cada títiilo. Entonces, el contenido de cada ele-
mento se iinprinie usando un bucle for. La variable i se eiiiplea para
controlar el bucle; comienza en 1 en la primera expresión de for y se
incrementa en la íiltiiiia expresión. El incremento tendrá lugar después
de la acción de iinprimir. La segiiiida expresión ei la expreiióil de
prueba que controla el bucle.
278 1 Fundamentos de programación
---
en Linux

- - -- .
m ---

#! / u ~ r / b l n / t c l s h
a r r a y s e t t i t l e 11 Tempest 2 I l i a d 3 Ravenl
s e t num 3
f o r ( s e t i 11 l $ i <- Bnumt l i n c r i l í
puts $ t i t l e ( $ i )
I

La estructura foreach
La estructura foreach se diseñó para hacer referencia secuencia1 a iina
lista de valores. Es siiiiilar a la estructura for-in del shell C. La estruc-
tura foreach toma tres argumentos: una variable, una lista y un bloque
de coiiiandos Tcl. Cada valor en la lista está asignado a la variable en la
estructura foreach.Al igual que la estructura while, la estructura
foreach es un birle. Cada vez que pasa el bucle, a la variable se le
asigna el siguiente valor de la lista. Cuando llega al final de la lista, el
bucle se detiene. Coino el bucle while, el bloque de comandosTc1 va
entre corchetes. La sintaxis para el bucle foreach es la siguiente:
foreach lista de variables lista de variables lista de variables .. .. {
comandos Tcl
1
En el ~ c r i p booklist
t el usuario ~implementeobtiene una lista de
títulos integr~dapor i a lista de valores que leyó el bucle foreach.
Cada título se aiigna consecutivainente a la variable booktitle.

W n ' i " n 1 t ~r srí"""""""""

f o r e a c h b o o k t i t l e [ l i s t Tempest I l i a d Ravenl 1
puts $booktit l e
1

El bucle foreach deTcl difiere de los bucles foreach en otros

lenguajes en que foreach de Tcl puede soportar a la vez muchas
variables y sus correspondientes listas. Por ejemplo, podría tener
dos variables con dos listas de valores, una para cada cual. La priinera
variable tomará los valores de la prirnera lista, en orden, y la segunda
los de la segunda lista. Si una lista es más larga que la otra, a la variable
de la lista más corta se le asigna un valor nulo para las repeticiones
 Capítulo 7: Tcl (Tool C o m m a n d Language)
--

adicionales. En el siguiente ejenlplo se utilizan dos variables: title y

author para hacer referencia de valores en dos listas diferentes:

foreach t i t l e (fempest I l i a d Ravenl author {Shakespeare Homer Poel I

p u t s "' I t i t l e t a u t h o r "
1

Los comandos break y continue

Los comandos break y continue se diseñaron para trabajar con bucles;
break dividirá iin bucle, continiiando con el comando next. El bucle
continue pasará por alto el resto del bloque de coiiiandos que se
ejecutan dentro del bucle y comenzará la siguiente repetición. Usual-
mente, estos coriiandos son parte de 1111 coniando if. Sólo en raras
ocasiones usted usará enunciados break en un bucle while o for;
break es no e s ~ r i ~ t i r r den
o el sentido de que permite iiiia condición de
salida diferente a la de la expresión de prueba de ese enunciado. Por
ejemplo, en el sigiiiente progranla, break obligará a una salida del
bucle cuando i es igual a 3:

'set 1 1
while í i >= 11 i

El enunciado continue está disellado únicamente para trabajar con

bucles. El enunciado continue pasa por alto el reito de los enunciados
en un bucle y comienza coi1 la siguiente repetición. Usted puede
coiisiderar continue conio un enunciado que salta por encima de los
deinás enuiiciados del bucle y continúa coi1 la siguielite ejecución del
bucle. En el ejeinplo que sigue se iiiipriine la repetición únicameiite
cuando i es un núriiero impar. En repeticioim pares continue pasa
por alto el enunciado printf.
280 1 Fundamentos de programación en Linux
7 \-e

c
while < fái 101 (
e-. 4 1

incr i 1
i f ( $ i %2 ==O) (
c o n t i nue
I
p u t s " T h i s i s an odd i t e r a t i o n $in
1

Manejo de archivos con Tcl

C o n Tcl usted puede acceder y administrar archivos con facilidad. En la
tabla 7-5 se presenta una lista de los con-iandosTcl para acceso a archivos.

Comandos para acceso Descripción

a archivos
file Obtiene información del archivo
open Abre un archivo
close Cierra un archivo
eof Verifica el final del archivo
fcopy Copia de u n archivo a otro
flush Vacía la salida de los buffers internos de u n archivo
glob Compara nombres de archivos usando los caracte-
res del patrón glob
read Lee bloques de caracteres desde u n archivo
seek Determina el desplazamiento de búsqueda de u n
archivo
tell Regresa al desplazamiento actual de un archivo
socket Abre una conexión de red TCPIIP
Comandos d e entradalsalida Descripción
format Le da formato a una cadena con especificadores de
conversión, como sprintf en C
Lee y convierte elementos en una cadena usando
especificadores de conversión, como scanf en C
gets Lee una línea de entrada
puts Escribe una cadena en la salida
. .. ..
[Tabla 7-51 C o m a n d o s de acceso de archivos y de entrada/ralida e n T C L
 Capítulo 7: Tcl (Tool C o m m a n d Language)
.

Los corimdos o p e n y close abririn y cerrarán el acceso a archivos.

El coinaiido o p e n se usa para crear un manejador de archivo para iin
archivo o iina intercoiiexión ( 1 ); eite comando toma dos argumentos:
la cadem del nombre del archivo y cl modo del archivo, y regresa 1' uii
i~ianejadordc archivo que se usa para tcncr acceso al archivo. La crrdpria
dcl noiii1)rc (ir1 aialiivo puede ser el nombre del archivo o una variable que
lo contenga. El modo del arrhivo es el grupo de permisos que usted usa
p x a abrir el archivo. Puede ser r sólo para lectura, w sólo para escritura
o a, íinicamentc para adjuntar. Para obtener permiso de lectura y escri-
tura 1' la vez, con el fin de sobreescribir y actualizar un archivo, usted
emplea a+ con el niodo del archivo. Cuando usa r+ obtiene pcrniiso
para lectura y escritura. La sintaxis para o p e n es la siguiente:
open cadena-nombre de archivo modo-archivo

Por lo coiiiún, usted ~itilizael comando o p e n en un comando set de

iliariera que puede asignar el inanejador del archivo que se obtuvo con
o p e n , a iina variable. Luego, puede usar ese inanejador en la variable, eii
otros comandoi de archivos para acceder al archivo. E11 el siguiente
ejemplo, cl usuario abre el archivo reports coi1 modo para lectura, r, y
asigna el inanej'idor de archivo qiie se obtuvo a la variable myfile.

7
[NombredPjrch i 3 L
s e t m y f i l e [open " r P p o r t s "
A
r]
Ogciones open para archivosJ
-- --. .-.

C o n frecuencia, el nombre del archivo se nlantendrá en una varia-

ble. Entonces, usted usa el signo $ con el iioinbre de la variable para
hacer referencia al nonibre del archivo. Eii este ejeijemplo, el nonibre del
archivo "reports" está en la variable filen:

ser t 1 r en=- r e p o r t s -
s e t m y f i i e rnpen $ f il e n r l

Después de haber teriiiinado de usar el archivo, usted lo cierra con

el comando close, que toma como argiinieiito al manejador d e archivo
del archivo q ~ i custed quiere cerrar.

m e ' $,y t i'l e

-
282 1 -
Fundamentos de programación
- ...-
en Linux

Al usar l o comandos
~ gets y puts, usted puede emplear un
nianejador de archivo para leer y escribir en un archivo específico. El
coniando gets toma dos argumentos: un nianejador de archivo y una
variable; por niedio del nianejador leeri una línea del archivo al que
hace refereiici'i y lo pondri en una cadena en la variable. Si n o se
especifica ningún nianejador de archivo, gets lee en la entrada e~tándar.
El siguiente coiiiando lee iiria línea de un archivo usando el manejador
en la variable myfile. La línea se lee en la variable line:

Se-ponen los datos de-

entrada
- de la variable 1

El coniando puts también toma dos argumentos: un nianejador de

archivo y una cadena. Este coniaiido escribirá la cadena en el archivo al
q ~ i ehace referencia el inanejador. Si no se especifica este íiltiino, puts
escribiri en la salida estándar. En el siguiente ejemplo, puts escribe la
cadena que se encuentra en la variable line, en el arcliivo al que hace
referencia el nlanejador que se encuentra en myfile. Observe que el
signo $ aparece antes de line en el coniando puts, pero no en el
coniando gets anterior. El comando puts opera en una cadena, niien-
tras que gets lo hace en una variable.
. Datos escritos en un archivd
.-.-
-

El siguiente script abre un arcliivo llamado rqmrts y lo presenta en

pantalla:
-
s e t reps Copen " r e p o r t s " r l
while ( [ g e t s $reps linell
I
puts $ l i n e
l
close Sreps

Usted puede emplear el coniando Gle para verificar ciertas caracte-

rísticas de los archivos, como si existen o si son ejecutables; así mismo,
 Capítulo 7: Tcl (Tool C o m m a n d Language)
--

puede verificar directorios. El comando file toma varias opciones,

dependiendo de la acción que quiera emprender. La opción exist
verifica si existe un archivo y la opción size indica el taniaiío. La
opción isdirectory determina si el archivo es un directorio, e isfile
revisa si es un archivo. C o n las opciones de ejecución, lectura y escritu-
ra, usted puede detectar si el archivo es ejecutable, si se puede leer o si
se puede escribir en él. La opción dirname presenta en pantalla todo
el nonlbre del directorio del archivo, y las opciones extension y root
name nluestran la extensión o el nombre raíz del archivo, respectiva-
mente. Las opciones atime, mtime y owned presentan en pantalla los
datos de tiempo de la última vez que se tuvo acceso al archivo, la hora

m e x i ' t s reps
-
de la niodificación y si es propiedad del usuario.
... - . .. .. -
file i s f i l e reps
file s i z e reps
fil e executable myreport

A iiienudo, los nombres de archivo se usarán corno argunientoc

para loi prograiiiasTc1. En este caso, usted puede usar la lista argv para
obtener los nombres de archivo. Dicho comando lista todos loi argu-
rnentos que se ingresaron en la línea de comandos cuando se llaiiió el
script de Tcl. Usted emplea el comando lindex para extraer un argu-
mento en particulx de la lista argv. Muchos programai utilizan n o n -
bres de archivo como argumentoi. Otros también espec~fican
opciones. llecuerde que el comando lindex establece el índice de una
lista a partir de O, de niancra que el primer argumento en la lista argv
se obtendrá así (asegúrese de anteponer el signo $ a argv):

/=lo de argumentos
- de- --
la línea de coman dos^

Si lo desea, usted puede hacer referencia a un argumento e11 la lista

argc dentro del coiiiaiido open. Aquí, la operación lindex queda
entre corchetes, en lugar del nombre de archivo de la lista argv. El
comando lindex presentará el nonibre del archivo de la lkta argv.
284 1 Fundamentos de programación e n Linux
--

Proyecto 7-1: Copia de archivos

El programa mycp es una versión sencilla del comando Linux cp que
copia un archivo en otro.

mycp Paso a paso

1. Detecte si el usuario ha ingresado dos argumentos: el primero será el
nombre del archivo fuente y el segundo, el nombre de la copia
(archivo de destino). Use la variable argc para detectar la cantidad de
elementos; si esta cantidad está errada, aparecerá un mensaje de
error. Emplee el comando exit para terminar el programa.
2. Asigne el primer argumento a la variable sourcefile y el segundo a la
variable destfile.
3. Abra el archivo fuente (variable sourcefile) para lectura y asigne el
manejador de archivo a la variable shandle.
4. Abra el archivo de destino (variable destfile) para escribir, y asigne el
manejador de archivo a la variable dhandle.
5. En un bucle while, utilice el comando gets para leer una Iínea del archivo
fuente en la variable line con cada repetición. Después, use el comando
puts para escribir la Iínea de la variable line en el archivo de destino.
6. Aparece un mensaje sencillo señalando que se ha copiado el archivo.
7. Cierre los archivos h e destino (dhandle) y fuente (shandle).
El siguiente es el contenido del programa mycp:

i f l$argc != 21 1
puts "Please enter two filenames\nm
exi t 1
1.
set sourcefile [ lindex Bargv O 1
set destfile [ lindex Bargv 1 1
ser shandle [ open Bsovrcefile r 1
i ~ dth a n d l ~Copen Bdestfile w 1
w h i l e ICqets Sshandle l i n ~ l )1
puts I d h a n d l e d l i n ~
1
 C a p í t u l o 7: Tcl (Tool C o m m a n d Language)
-

' p ü t s ' " f ' c o u e coPTed''to - $ d ' e s t m

c l o s e $dhandl e
c l ose $ s h a n d l e

Procedimientos de Tcl: proc

El coiiiando proc le periiiite crear siis propios coiiiaildos d e Tc1 para
usarlos dentro d e i i r i pi-ograiiia. D e hecho, usted emplea este coiiiando
para crear nuevos procediriiientos, niuy siniilares a los procediiiiientos
o fiiiiciones q u e crea e n otros lenguajes d e prograniación. Usted
puede considerar u n coniarido proc c o i i ~ odefinir uii coiiiaido Tcl, d e
iiiaiiera inuy seiiiejante a coiiio defiiiiría una f~iiiciórieii C . E11 la tabla
7-6 se preseiita la lista d e los coiiiaridos d e procediiiiiento d c Tcl.
El coiiiando proc toina tres arguiiientos: el noinbre del iiuevo
procediiiiieilto, los argunieiitos q u e el procediiniento toiiiará y u n
bloque d e coiiiaiidos q u e el pi-ocediniierito ejecutará. Los arguiilentos
soii variables q u e recibirán los valores q u e se les pasaron cuando se usó
el procediniieiito. Los argiiiiientos se ponen después del nombre del
procediii~ientoentre corchetes. U n corchete d e apertura coiiiienza
coi1 el bloque d e coiiiaiidos d e Tcl para este procediinieiito. La siiitasis
para el coiiiando proc es la siguiente:
proc nombre del procedimiento { argumentos } {
comandos Tcl
1
E n el siguiente ejeiiiplo se iiiipleiiieiita el coiiiando lsearch deicri-
previaiiiente e n este capítulo:

myseárch"'~ r n y l i s t p a t T i
-
set i O
s e t . l e n C l e n g t h $myl i s t l
w h i l e l $i< B l e n 1 {
i f I r l i n d e x $ m v l i s t $il
== $ ~ a t )
286 1 Fundamentos de programación en Linux

Comando Definición
proc Define un procedimiento Tcl
return Regresa un valor de un procedimiento
source Lee y ejecuta comandos Tcl en otro archivo
uplevel Ejecuta un comando en un alcance diferente

Comandos de procedimiento de Tcl

El comando string de Tcl

El coinando string de Tcl se emplea para realizar diferentes operaciones
en cadenas.Tonia varias opciones, dependiendo de la tarea que q~iiera
desarrollar. Usted puede buscar, crear subcadenas u obtener la longitud
de una cadena. La opción se ingresa coino una palabra que sigue al
coinando string. Los argumentos variarán de acuerdo con la opción que
usted escoja. En la tabla 7-7 se muestran los comandos de cadena de Tcl.
C o n el coinaildo string match, se pueden realizar operaciones
bisicas de búsqueda en una cadena; aunque este conlando no soporta las
expresiones regulares, sí lo hace con los caracteres especiales *, ? y [ ]
para comparación simple de patrones como cuando se usa en el sl-iell
para comparar el nombre del archivo; string match toma dos argu-
nientos: el patrón que se va a comparar y la cadena que se va a buscar,
coino se muestra en este ejemplo:

s t r i n g match report* Sfname

--
El comando string range regresa una subcadena de una cadena
específica.Toma tres argumentos: la cadena y los índices inicial y final. La
cuenta comienza en O. El término end se usa para que el archivo final
copie autoináticamente el resto de la cadena, conlo se muestra en el
ejemplo siguiente. El primer ejemplo presenta "ave" y el segundo, "ven".
- . .
s t r i n g range 3 end
 Capitulo 7: Tcl (Tool Command Language) 1 287
Comando Descripción
binary Hace conversiones entre cadenas y datos binarios
regexp Compara una cadena usando expresiones regulares
regsub Realiza sustituciones empleando patrones con expresio-
nes regulares
split Divide una cadena en elementos de lista
string Realiza operaciones en cadenas
subst Realiza sustituciones en una cadena

Operaciones de cadena en Tcl

El comando string index prescrita iin solo carácter de una cadena

en iin íiidice específico.Toina dos argiiiiieiitos: la cadena y el índice del
carácter que se va a presentar. En el siguiciite ejeiiiplo aparece el quiii-
to carácter d e la variable mystring:

El coinando string length regresa a la longitud de la cadena:

r
s t r i n g lenqth $mystrinq

El patrón de expresione> regularei que coiiipara cacienas se

iiiiplcmeiita con el coiiiando regexp, que cuenta con capacidades
coiiipletas de coriiparación de expresiones regulares, siniilares a egrep.
T o m ~dos argumentos: el patrón d e la expresión regular y la cadena
que se va a buscar. Muestra 1 si eiicuentra el patrón en la cadena y O en
caso contrario. En el siguiente ejemplo se busca cualquier núnicro cri
mystring:

El c o n i ~ i i d oregsub es el coniando de iiiititucióii dc Tc1. Coiiiparn

una espre4ión rcgiilar conio regsub pcro desp~iéircviiiplaza la cadena
coniparacla con uiia cadena de reeniplao específic~,poniendo la
cadciia coiiipletli inodificada en una nueva variable. El comando
regsub toiiia cuma argiimcritos: los doi primeros son iguales a los Jc
regexp: el patrón d e la expresión regular y la c d e n a por biiscar. El
288 1 Fundamentos de programación en Linux
- -. - -

tercer argumento es l a cadena d c reemplazo y e l cuarto es l a variable

en donde se colocar,?l a cadena modificada. La sintaxis es la siguiente:

regsub patrón cadena cadena de reemplazo variable

Si e l patrón n o se encuentra e n l a cadena, presenta u n O:

'
regsub mi'ikn$mystring yogurt newstring-- - '

Proyecto 7-2: Operaciones de archivo

El programa fileops presenta en pantalla un menú de tres opciones para
operaciones en un archivo: copiar un archivo, borrar un archivo y reem-
plazar un archivo.
f i 1 eops
Paso a paso
1. Defina tres procedimientos, uno para cada operación. Por simplici-
dad, los comandos Linux se usan para realizar la operación actual.
Por ejemplo, el comando cp se emplea para copiar un archivo.
Recuerde que el comando exec le permite ejecutar un comando
Linux dentro de un script de Tcl:
exec cp $sourcefi 1 e $destf i1 e
2. Define un procedimiento copyfile en donde al usuario se le indica un
archivo fuente y después un archivo de destino. Utilice el comando
gets para leer la respuesta del usuario. Use el comando cp para
copiar el archivo.
3. Defina un procedimiento erasefile para indicar un archivo que el
usuario quiera borrar. Utilice el comando rm para retirar el archivo.
4. Defina un procedimiento renamefile para indicar el nombre original
de un archivo y después el nuevo nombre que el usuario quiere darle.
Use el comando mv para cambiar el nombre del archivo.
5. En la parte principal del programa, cree un menú que presente la
lista de las tres operaciones de archivo. La selección del usuario se lee
dentro de la variable elegida, la cual se usa después en una operación
switch para detectar la opción. Llame los procedimientos correspon-
dientes de acuerdo con estas condiciones. Si el usuario selecciona la
cuarta opción (Quit), el comando exit terminará el programa
El contenido del programa fileops es el siguiente:
 Capitulo 7: Tcl (Tool Comrnand Language) 1 289

# F u n c t i o n t o copy a f i l e
proc c o p y f i l e { t I
puts " F i l e t o Copy: "
gets s t d i n s o u r c e f i 1e
puts "Name o f f i l e : "
gets stdin destfile
exec cp $ s o u r c e f i l e $ d e s t f i l e
1
# Function t o erase a f i l e
proc erasef i l e { 1 i
p u t s " F i l e t o Erase: "
gets s t d i n e f i l e
exec r m e f i l e
I
# The Rename f u n c t i on
proc renamefile { 1 l
p u t s " F i l e t o Copy: "
g e t s s t d i n origname
p u t s "Name o f f i l e : "
g e t s s t d i n newname
exec mv $ origname $ newname
I
# Main menu
puts " F i l e Managemenf O p e r a t i o n s \ n \ n U
puts "1. Copy a f i l e . \ n U
puts " 2 . Erase a f i l e . \ n W
puts " 3 . Rename a f i l e . \ n W
puts "4. Quit.\n\nW
puts -nonewline "Please e n t e r choice: " ; f l u s h s t d o u t
gets s t d i n choice
switch $choice I
1 I
c o p y f i1 e
1
2 1
e r a s e f i 1e
1
2, (
renamef i 1e
1
4
290 1 Fundamentos de programación
- -
en Linux

ex1 t
1
default [
puts " I n v a l i d Option"
1

Expect
La aplicación Expect agrega varios coiiiandos a los scripts de Tcl que
usted puede utilizar para interactuar automáticamente con cualquier
prograina en Liilux, inás una utilidad que le indica respuestas. Por
ejemplo, el procediiniento login para diferentes sisteinas que usan ftp o
telnet se puede programar autoiliáticanieilte con un script Tcl, usando
conlandos Espect. Usted puede informarse más acerca de Expect en
www.expect.nist.gov. Los comalidos Espect están disellados para
trabajar coi1 cualquier prograina interactivo. Los coinaildoi esperan una
respuesta de un programa y después envían la respuesta especificada en
el script Tcl. Usted puede eliminar el script con un coimildo sencillo
CTRL-D, e iiiteractuar con el programa directamente.
Tres coniandos blísicos Espect agregados a los scriptsTc1 son send,
expect e interact.El coina~idoexpect esperara para recibir una cadena,
o valor de l a i aplicacioiiei, con la que uitcd está interactuaiido. El co-
inando send eiiviard una cadena a esa aplicacióii. El comando interact
lo ileva a una interacción directa con la aplicación, terminado el script
EspecdTcl. En el siguiente script, expect ie usa para realizar un login
anbiiimo con cl progrania.pp. El comando spawn coniienza dicho
programa. Se supone que la dirección de iiiteriiet del sitio FTP sea un
argumento de este script, y, como tal, se inaiiteiidi-á en la lista argv
-
#!'/üsr/bln/expFct
spawn f t p
5end "open $ a r q v \ r V
e:'prct "1 i ~ g i n ":
send "eiioriyriiciu::,\rm
~ x p ? r t" w i i r d : "
s r n d " r j r h 1 p i I - t i 1 r t 1 i-.mytrek.corn"
intrract.
 Capítulo 7: Tcl (Tool C o m m a n d Language)

Para hacer f~incionarco~ilaiidosde Espect, usted debe ingresar

priniero el shell de Expect. Eri el script precedente, dicho shell se llanló
con el comando #!/usr/bin/expect.
El comarido expect puede toinar dos argumentos: el patrón por
esperar y una acción por realizar si se compara el patrón. El coniando
expect tanibiéri puede toinar conlo su argumento un bloque d e
arguiilentos de patrón/acción. E11 este caso, expect puede comparar
patrones alternativos, ejecutando la acción solamente para el patrón
que la recibe. Por ejeiiiplo, el coinando ftp puede presentar una cadena
de "connection ref~ised"en lugar de una cadena "nanie". En ese caso,
usted querrá enviar este inensaje y salir del script de Expect. Si quiere
realizar más de una acción para un patrón, puede marcar las accioiies
entre corchetes, separadas por signos de punto y coma. Un ejemplo de
este coniando expect es como sigue:

expect I
"connection refused" I p u t s " F a i l e d t o connect"; e x i t l
"nameH p u t s " c o n n e c t i o n s u c c e s s f u l "
l

Otro comando útil en Expect es timeout, que usted puede fijar

.
para un determinado níimero d e segundos, y después verificar con
expect el tiempo d e terminación. Para establecer el núinero de segiiil-
dos para dar lugar a una terminación, usted utiliza set para asignar el
número a la variable timeout. Para que el comando expect detecte
un tiempo de terminación, use la palabra tirrrtoirt como patrón de
dicho con~ando.C o n la terininación, usted puede agregar una acción
para que la redice el uhell. En el siguiente ejeniplo se ha agregado un
tiempo de teriiiinación al script de Tcl:

send "open Bargv"

expect I
t i m e o u t l p u t s "Connection t i m e d o u t " : e x i t 1
" c o n n e c t i o n r e f u s e d " { p u t s " F a i l e d t o connect": e x i t l
"namen p u t s " c o n n e c t i o n s u c c e s s f u l "
l
I 1. ¿Cómo se organiza una lista de núnleros?

2. ¿Qué operación usaría para leer un registro que consta de una línea
que tiene campos separados por un delimitador de dos puntos?

l 3. ¿Cómo se abre un archivo para lectura y escritura?

4. ;Qué estructura de control lee artículos en varias listas a la vez,

asignando en orden cada una a una variable?

l 5. ¿Podría diseñar un script que baje automáticanmite archivos de un

sitio FTP?
 .
Los objetivos de este capitulo son:
O Aprender a crear interfaces gráficas de usuario c o n T k

0 Definir objetos como botones, barras desplegables y cajas de listas

0 Organizar y ubicar objetos en las ventanas de Tk

Crear scripts de Tk usando comandos de Tcl

0 Asociar una acción con un evento particular que tiene lugar en un objeto

O Iniplementar menús y referencias utilizando etiquetas T k

 amación en Linux

L a aplicación T k extiende las capacidades de Tcl con coniandos para

crear y administrar objetos gráficos conlo ventanas, iconos, botones
y campos de texto. Los comandos T k crean objetos gráficos empleando
el X Window System; ésta es una manera más fácil de programar
objetos X Windows que usando directamente la caja de herraniientas
X11. C o n Tk, usted puede crear con facilidad sofisticadas interfaces de
usuario basadas en ventanas, para sus programas.
T k opera bajo el X Window Systeni, dentro del cual T k utiliza su
propio shell, llaniado el shell wish, para ejecutar los coniandos de Tk.
Para operar programas en Tk,

1. Inicie su X Window Systen-i

2. Inicie el shell wish con el coniando wish. Esto abrirá una ventana en
donde podrá operar los coniandos Tk.

Si está empleando una interfaz gráfica de usuario, conio Open Look

o Motif, X Windows se inicia autoniáticaniente. Observe que usted
también puede ingresar el comando wish desde una ventana Xterni.
El lenguajeTk está organizado de acuerdo con diferentes tipos de
objetos gráficos conio ventanas, botones, menús y barras desplegables.
Dichos objetos se conocen como widpts.
En lugar de programar explícitamente el código de T k para crear una
interfaz gráfica de usuario (GUI), usted puede usar un constrilctor GUI de
Tcl/Tk. Un constructor GUI genera el código Tcl/Tk para una interfaz
de usuario que usted puede emplear luego en un programa Tcl/Tk. Este
constructor GUI del programa X Windows tiene su propia GUI con
ventanas, menús e iconos que puede usar para crear con facilidad widgets
de GUI con opciones de menú o sencillas operaciones con el ratón.
Con un constructor GUI, crear y configurar un widget es tan siniple
conio hacer clic sobre el icono de la paleta y arrastrarlo hasta una cuadrí-
cula, o conio elegir las opciones que desee en una barra de herraniientas.

ios constructores CUI de Tcl/Tk

gratuitos, tales como Visual Tcl, SpecTcl, VisualClPSY y XF, los cuales
se pueden bajar desde sus respectivos sitios Web. Usted puede encon-
trar enlaces con estos sitios en la página CUI Builder's del sitio Web de
Scriptics, la cual se localiza a través de la página Tcl
? 4-v
 Capítulo 8: Tk 1 295

El shell wish y sus scripts

Dentro del shell wish, usted puede ingresar comandos en forma
interactiva y ejecutarlos 11110 a uiio, o puede situar los comandos en un
archivo de script y ejeciitarlos de una vez. Usualrilente, los comandos
T k se ponen en un script que se acciona con la llainada del comando
wish. Los scripts d e T k , al igual que los de Tcl, suelen tener la exten-
sión .tcl. Por ejemplo, un script T k llamado rnydir.1~1 se leería y ejecuta-
ría con el coinando siguiente, que se ingresa en una ventana Xterm.

Para crear un script independiente que opere más coi110 un comando,

usted debe llamar el comando wish dentro del script. Por lo general, el
coinando wish abrirá una ventana interactiva en el shell T k cada vez que
se ejecute. Para evitarlo, llame a wish con la opción -f, con10 se presenta:

_a Nota
Cuando se crea un script independiente, asegúrese de cambiar los
permisos con el comando chmod para permitir la ejecución. Enton-
ces, puede ingresar el nombre del script para operar el programa.
Puede conocer más sobre este tema en el capítulo 2 de este libro. 1
C
- b . ,

$ mydirl

Widgets de Tk
U n tipo de w d g e t Fe con~iderauna clase y cada clase de widget tiene su
propio cotnnrrdo de clasc para crearlo. El coinando correspondiente creará
una rmtancia en particular de esa clase de widget, es decir, un widget
particular de cse tipo. Por ejemplo, usted puede crear un botón con el
coiiiando button o una ventana con el coinando window. Los objetos
gi-áfico~,como botones y marcos (que se estudian más adelante en la
~ección"Marcos y etiquetas"), también se conocen a inenudo conio
En la tabla 8-1 se presenta la lista de los widgets disponibles en Tk.
1%-~dgets.
 programación en Linux
-

Widget Propósito
Button Un botón para hacer clic
Canvas Una ventana para dibujar objetos
checkbutton Un botón de verificación
Entry Un cuadro de entrada
Frame Un widget simple cuyo propósito primario es actuar como un
espacio o contenedor para distribuciones complejas de pantalla
lmage Una imagen para presentar dibujos
Label Un rótulo
Listbox Un cuadro con una lista de elementos elegibles
Menu Una barra de menús
menubutton Un botón de menú para acceder al menú
Message Un área de mensaje que se usa para crear y manipular widgets
de mensaje
radiobutton Un botón excluyente
Scrollbar Una barra de desplazamiento
Text Una caja de texto que se puede editar
Scale Una escala

En programas en Tk, el comando class toma como su argumento el

nombre del widget,seguido por las opciones de configuración con sus
valores. En la tabla 8-2 se presenta una lista de varios de los comandos
Tk usados.

Operaciones de evento Descripción

bind Asocia scripts de Tcl con eventos X
bindtags Conecta comandos con etiquetas
selection Permite la selección de objeto o texto con
un ratón
Operaciones de ventana
destroy Cierra una ventana Tk
toplevel Selecciona una ventana del nivel más alto
wm Establece características de ventana
up level Se traslada al nivel anterior de ventanas
 Los con~andosde Tk emplean un formato similar a los de Tcl. Usted
ingresa un comando de clase Tk en una línea seguido por sus argu-
mentos; sin embargo, los comandos de Tk son más complicados que los
con~andosde Tcl. Los comandos de la interfaz gráfica requieren una
cantidad significativa de información acerca de un widget para confi-
gurarlo correctamente. Por ejemplo, si un botón requiere un nombre,
el texto se presentará en pantalla y la acción que realizará. Muchos
comandos de Tk pueden tomar varias opciones que indican diferentes
características de un widget. Con esas opciones usted puede presentar
imágenes en widgets (-image), establecer colores de fondo y de primer
plano para los widgets y determinar en dónde se presenta la información
en un widget (posición relativa). En la tabla 8-3 se presenta una lista de
varias opciones que comúnmente usan los widgets de Tk.

Opciones del comando Tk Descripción

-activebackground Especifica el color de fondo que se debe utilizar para
dibujar elementos activos.
-activeborderwidth Especifica el ancho del borde de tercera dimensión
alrededor de elementos activos.
-activeforeground Especifica el color de primer plano que se debe utilizar
para dibujar elementos activos.
-anchor Especifica cómo se presenta la información en el

. widget; debe ser uno de los valores n, ne, e, se, S, sw,

w, nw o center.
-background Indica el color de fondo normal que se debe utilizar
cuando se presenta el widget.
-bitmap Selecciona el mapa de bits para presentar en el widget.
-borderwidth Establece el ancho del borde tridimensional alrededor
del perímetro del widget.
<ursor Determina el cursor del ratón para emplear en el
widget.
4isabledforeground Especifica el color de primer plano que se debe utilizar
cuando se dibuja un elemento desactivado.
-font Determina la fuente por emplear cuando se escribe
texto dentro del widget.
-foreground Especifica el color de primer plano normal que se debe
utilizar cuando se presenta el widget.
-geometry Especifica la geometría deseada para la ventana del
widget.
 gramación en Linux

Opciones del comando Tk Descripción

-highlightbackground lndica el color que se debe presentar en la región
con iluminación transversal, cuando el widget no
tiene el enfoque de la entrada.
lndica el color que se debe utilizar para el rectán-
gulo con iluminación transversal que aparece alre-
dedor del widget, cuando tiene el enfoque de
entrada.
lndica el ancho del rectángulo iluminado para
dibujar alrededor del perímetro del widget, cuan-
do tiene el enfoque de entrada.
Especifica una imagen que se ha de presentar en
el widget.
Determina el color del fondo en el área cubierta
por el cursor de inserción.
Determina el ancho del borde tridimensional alre-
dedor del cursor de inserción.
lndica la cantidad de milisegundos que el cursor
de inserción debe permanecer en " o f f en cada
ciclo intermitente.
Inserta la cantidad de milisegundos que el cursor
de inserción debe permanecer en "on" en cada
ciclo intermitente.
Inserta un valor que indica el ancho total del
cursor de inserción.
Crea un deslizador que se puede arrastrar para
ajustar un valor.
justifica múltiples líneas de texto que se presentan
en un widget.
Orienta los widgets que se pueden ubicar por sí
mismos, como las barras de desplazamiento.
Especifica cuánto espacio extra solicitar para el
widget en la dirección X.
Especifica cuánto espacio extra solicitar para el
widget en la dirección Y.
Especifica el efecto tridimensional que se desea
para el widget.
Especifica la cantidad de milisegundos en que un
botón o tecla se debe mantener presionado antes
de que comience la repetición automática.
Determina la cantidad de milisegundos entre las
repeticiones automáticas.
 Capítulo 8: Tk
-

Opciones del comando Tk Descripción

-selectbackground Especifica el color de fondo que se ha de utilizar cuando
se presentan en pantalla artículos seleccionados.
Especifica el ancho del borde tridimensional.
Establece el color de primer plano.
Identifica la cadena que se ha de presentar dentro del
widget.
Determina el color por usar para las áreas rectangulares
en los widgets, tales como barras de desplazamiento y
escalas.
Especifica el índice entero de un carácter que se ha de
subrayar en el widget.
Determina la longitud máxima de la línea para el despla-
zamiento de palabras.
-xscrollcommand Comunica con las barras de desplazamiento horizontales.
-yscrollcommand Comunica con las barras de desplazamiento verticales.
Opciones de botón
xommand Especifica un comando Tcl para asociarlo con el botón
-selectimage Indica la imagen por presentar en pantalla cuando se
elige el botón de verificar.
Determina la altura del botón.
Determina el color de fondo que se ha de usar cuando se
selecciona el botón.
Especifica uno de los tres estados para el botón excluyen-
te: normal, activo o desactivado.
La variable global indica si este botón se selecciona.
Determina el ancho del botón.

Opciones estándar de T k (contituración)

En el siguiente ejemplo se crea un botón usando el coniaiido

button que toma coino sil primer argumento el nombre del widget
del botón. Entonces, las opciones definen varias características. A la
opción -text le sigue una cadena que será el texto que se presente e n
pantalla con el botón. La opción -command va seguida por el co-
iiiando que el botón ejecuta cuando se hace clic e n él. Este comaiido
button presentará un botón que contiene el texto "Click Me".
Cuando usted hace clic en el botón, el shell T k terminará su ejecución.
300 1 Fundamentos de programación en Linux

Para configurar una interfaz de trabajo, usted debe definir todos

los widgets que sean necesarios para realizar una tarea dada. Alg~inos
widgets están diseñados para administrar otros; por ejemplo, las barras
de desplazamiento están diseñadas para adiiiinistrar ventanas. Otros
widgets, coiiio los campos de entrada de texto, pueden interactuar con
un programa en Tcl. Una opción en el rneníi puede hacer que parte
de un programa Tcl f~incioiie.
Los widgets están organizados jerárquicamente. Por ejeinplo, si usted
q ~ ~ i econfigurar
re una ventana para la entrada de datos, podría ser
necesario crear un niarco, dentro del cual puede haber widgets de
campo de testo, lo niisnio que botones. Los iiombres del widget
reflejan esta jerarquía. Así, el widget (campo de texto) que se encuentra
dentro de otro widget (el inarco) está prefijado con el nombre del
widget n ~ á sexterno. En este ejemplo, entonces, si el nombre del niarco
es report y usted quiere llamar al campo de entrada de texto monday,
el campo de entrada de texto tendrá el nombre report-monday.U n
punto separa cada nivel en la jerarquía. De manera silnilar, un botón al
que usted quiere llaiiiar ok y está dentro del marco report se nombra-
ría coino report.ok.
Una vez que usted ha creado sus widgets, debe definir su geoiiietría,
la cual determina el tamaño de cada widget en relación con los otros,
su forma y su ubicación en la ventaiia.Tk tiene tres adiniiiistradores de
geometría: pack, pla;e y grid.
Administrador de geometría Descripción
pack Forma paquetes de widgets uno junto a
otro
place Ubica los widgets en posiciones dentro
del marco
grid Ubica los widgets en una cuadrícula de
filas y columnas

Sus widgets no se pueden presentar en pantalla hasta no haber

deterniinado la geoiiietría. En el siguiente ejemplo se determina la
geometría del widget .mybutton usando el comando pack.
 Capítulo 8:Tk

Una línea de código de Tk puede ser muy larga y usted tal vez quiera
dividirla en dos o más líneas en su script para facilitar la lectura. Sin
embarao. Dara dividir en dos una línea de códiao única. debe Doner

Prueba de repaso
¿Cuáles son los diferentes administradores de geometría para Tk?'
¿Cuál es el comando que usted usa para llamar a Tk?'

egunte a los expertos

-
regunta: ¿Cuál es la diferencia entre los comandos de 1a geometría?
..
-
tcs uno al lado del otro, toniaiido sólo la cantidad de espacio necesario en un niarco
o una ventana para ajustar los widgets. Usted puede agregar n i b espacio, en caso de
. . . . ..
ser necesario. ci cumaiiao ae geoniecna place ie perniire uoicar uii wiuger en un
lugar en particular del marco. El comando de geornetría grid le permite configurar
una c a d a siiidar a una celda, eti donde usted puede poner widgets.

Pregunta: ¿Cukndo usaría una cuadricula?

1 - Respuesta: Una cuadrícula es útil para organizar widgets con uii f ~ r m a t oen
I particular. Por ejemplo, si usted quiere configurar un estilo de forn~ulariocon

1 pack. place y grid.

2 wisli.
302 1 Fundamentos de programación en Linux

cuadros de entrada y botones, puede usar una casilla para situar los widgets en
diferentes partes del forniulario. Para hacer referencia a una celda en particular de la
cuadrícula, debe especificar fila y colunina.

1 Pregunta: &&no se usa el comando place?

Respuesta: El comando de geometría place es práctico cuando quiera situar un
widget en un determinado punto de la ventana o niarco que esté alejado de los
demás widgets.Aui1que pack y grid están uno cerca del otro, usted puede usar
place para poner el widget en cualquier parte especificando las coordenadas x y y.
Por ejemplo, podría usar place para poner un botón OK en una esquina, lejos de un
widget de texto que aparece en la imitad de la pantalla.

birüiday
docl .txt
doc2.1xt--
doc3.txt
inig4.gif
nionday
niydiri

-- .- - . - -.

1~ i ~ u 8-1
r a 1 Cuadro de lista de Tk y barra de desplazamiento para mydirl
--
5

Proyecto 8-1: Presentar un directorio

El siguiente programa mydirl es un programa simple en Tcl/Tk que presenta
una lista de archivos y nombres de directorios en un cuadro de lista de Tk
con una barra de desplazamiento adjunta. En la figura 8-1 se presenta este
cuadro. Un cuadro de lista le permite presentar en pantalla una lista de
mydi r 1 elementos que se pueden desplegar con facilidad y seleccionar con el ratón.
Usted puede adjuntar una barra de desplazamiento para acomodar ele-
mentos que deben contar con más ítems que se ajusten en el tamaño del
cuadro de lista determinada.

Paso a paso
1. Defina la barra de desplazamiento usando el comando scrollbar:
asígnele el nombre .scroll y únala con el comando .list yview. Esto
le da instrucciones a la barra para que quede unida en forma vertical
al cuadro de lista, sobre el eje y.
 C a p i t u l o 8: Tk ( 303

2. Defina el cuadro d e lista con el comando listbox, asígnele el nombre

.list y la capacidad para desplegarse e n el eje y c o n el widget .scroll.
El cuadro d e lista aparecerá "sumergida" (sunken) con la altura y el
ancho especificados.
..~ ~
3
l i ~ t b o x.list ? r c r o l l '.scroll s e t " -relí.f sunken -wihh 15 - h e i g h t 15 - s e t i r l d yes

3. Cree los dos objetos (la barra d e desplazamiento y el cuadro d e lista)

con el comando pack y sitúelos al lado izquierdo d e la ventana,
desde d o n d e se extenderán para llenarla. Su p u n t o d e anclaje queda
al lado izquierdo (occidente) d e la pantalla, c o m o se indica con el
código w que sigue. El cuadro d e lista, .list, se sitúa primero, segui-
da p o r la barra desplegable, .scroll.

4. Realice una prueba if d e Tcl para determinar si el usuario ingresó u n

argumento cuando se llamó el programa. La prueba if verifica si
aparece u n primer elemento e n la lista argv, en donde se mantiene
cualquiera d e los argumentos. Si n o se detectan argumentos, se usa
el directorio actual, representado p o r el punto. Este directorio se
asigna a la variable dir.
5 . Complete el cuadro d e lista con una operación f o r e a c h d e Tcl. Utilice
el comando Is del shell, c o m o se ejecutó el comando exec, para
obtener la lista d e archivos y directorios.
6. Sitúe la lista d e archivos y directorios e n el cuadro d e lista con la
operación insert d e Tk para el objeto .list. El comando insert t o m a
una posición y u n valor; éste último es u n nombre d e archivo que se
fija e n $i, que se sitúa al final d e la lista:

7 . Una la combinación CTRL-C al comando e x i t para permitirle al

usuario cerrar fácilmente la ventana.
El script mydirl es el siguiente:
304 1 Fundamentos de programación en Linux
--

# L r r d t n a s c r o l l b a r and l i s t b o x
s c r o l l b a r . s c r o l l -command " . l i s t y v i e w "
l i s t b o x . l i s t - y s c r o l l " . s c r o l l s e t " r e l i e f sunken -width 15 -height 15 - F t g r i * l vilc
pack . l i s t . s c r o l l - s i d e l e f t - f i l l h i ~ t b- e x p a n d y e s - a n c h o r w

F Ii % e r e n t e r s a d i r e c t a r y argument ii-e t h a t , o t h e r \ . i i r ~ u ; i c u r r i r i t 1dir6it.r:r.y

ii i Sargc > O ] t h e i i I
s e t d i r [ l i n d e x 'Largv 0 1
1 else I
i ~ d ti r " . "
I

Eventos y uniones
U n programa T k ei un evento dirigido, lo ciial iignifica que ciiando
fiinciona eipera que ocurra algo, conio un inovimieiito con el ratón o
con el teclado, para r&lizar una acción. U n evento con el ratón puede
ser un clic, un doble clic o, incl~iiive,subir o bajdr el r ~ t ó nUn
. evento
o n~oviniicntocon el teclado puede ier presionar una tecla de control
o una coiiibinación de teclas o presionar la tecla E N T E R al final de loi
datos d e entrada. Cuando el programa detecta uii evento en particular,
toma una acción que puede ser otra operación gráfica, conio presentar
en pantalla otro nienú o puede ser la ejecución de un prograili'l en Tcl,
Perl o un ihell.
Las acciones están conectadas explícitamente a eventoi dados usail-
d o el conlando bind, el cual toma como iui argunientoi el nombre de
u n objeto o clase, el evento por conectar y la acción que ie ha de coiiec-
tar con cie evento. Cada vez que ocurre el cvento dentro de ese objeto,
se ejecuta IJ acción eipecificada.A continuacióii se preieiita un ejemplo
de una entrada conectada. El evento de presionar la tecla CTRL-C
realizará la acción de destruir todoi loi widgets, terminando el progrdiria.
 Capitulo 8: Tk 1 305

Usted usa el corilando bind para unir eventos en un objeto d e T k con

un coiiiando Tcl que desea ejecutar. En cierto sentido, está dividiendo su
programa Tcl en segmentos, cada uno de los cuales va conectado a un
evento en un objetoTk. Cuando ocurre un evento en un objeto Tk, se
ejecuta su conjunto de coinandosTcl asociados. Otros coinandosTk, lo
mismo que los comandos Tcl, se pueden asociar con un evento unido a un
objeto Tk. Esto significa que usted p~iedeanidar objetos y sus eventos. Los
con~andosTclejecutados por 1111 eventoTk pueden, a su vez, incluir otros
comandos y objetos T k con eventos conectados a otros conlandosTc1.
Un evento puede ser cualquier niovin~ientocon el teclado que se
activa al niomento de presionar una tecla o que se activa con el ratón
cuando se hace clic en uno de sus botones. U n evento está representa-
do en código T k como un p a t r h dc cvcrifo. Por ejemplo, presionar la
tecla de retroceso (DACKSPACE) es un evento representado por el
patrón de evento <CTRL-H>. Los patrones d e evento van entre
paréntesis angulares, < >. U n clic con el botón del ratón se representa
como <Button-l>. Para reflejar una secuencia de eventos, conlo un
doble clic, usted ingresa un modificador antes del evento; por e~eniplo,
el patrón de evento para el doble clic es CDouble-Button-l>, en
donde Double es el modificador para el evento Button-l. En la tabla
8-4 se presenta una lista de patrones para eventos en T k .
Las uniones so11 los componentes operacionales clave d e un programa
en T k , pues ellas detectan los eventos que lo dirigen. U5ted puede consi-
derar un programa e n T k conlo un bucle infinito que biisca continua-
mente la presencia de eventos específicos (uniones), y cuando detecta
uno de ellos, coi110 en el caso de un clic dcl ratón o cuando se opriiiic
una tecla de control, el programa ejecuta las acciones unidas a ese evento.
I

Usted puede considerar las uniones como múltiples puntos de

entrada, en donde comienzan diferentes partes del programa. Las
uniones no emplean exactamente la misma estructura utilizada
por un programa tradicional jerárquico y secuencial. Una unión
_ - - .. _-._. -_ _ -_ ----A_- _ _ _ . _ . _ __ _
comienza .
su propia secuencia -1-
ae comanaos o- su
.
propio programa
de organizaciones. Esto significa que para trazar el flujo de control
para un programa en Tk, usted comienza con las uniones, cada
una de las cuales tiene su propia ruta o su propio flujo de control.
 ogramación en Linux
m w s * - S

Secuencia de patrones Descripción

de eventos
<oprimir tecla> Cualquier tecla
<modificador-modificador- Secuencia de eventos, tal como presionar
tipo-detallo una tecla CTRL o hacer clic con el ratón
Modificadores de patrones de eventos
Control Tecla CTRL
Shift Tecla SHIFT
Lock Mayúsculas fijas
Alt Tecla ALT
Meta, M Combinación de teclas
Buttonl, B1 Primer botón del ratón
Button2, 82 Segundo botón del ratón
Button3, 83 Tercer botón del ratón
Button4, 84 Cuarto botón del ratón
Button5, B5 Quinto botón del ratón
Modl, M1 Modificador 1
Mod2, M2 Modificador 2
Mod3, M3 Modificador 3
Mod4, M4 Modificador 4
Double Eventos repetidos dobles, como doble clic con el ratón
Secuencia del patrón de evento
Triple Eventos repetidos triples como tres clics con el ratón
Tipos de eventos
ButtonPress, Button
.Presionar un botón del ratón; valor predeterminado
para el modificador Button
ButtonRelease Liberar un botón del ratón
Destroy Destruir un widget
Enter Entrar a un widget
KeyPress, Key Presionar una tecla
KeyRelease Liberar una tecla
Leave Salir de un widget
Motion Trasladar un widget
Detalles de eventos
Para Buttons El número del botón; si no se da ningún
12345 número, todos los botones concuerdan. Si se omite el
tipo de evento, se usa el valor predeterminado de
ButtonPress.
Button-1 es lo mismo que Button ButtonPress-1
Keypress Representación del símbolo de la tecla correspondien-
te; por ejemplo, A, COMMA, SHIFT-R
 Estas acciones pueden ser cualquier comando Tcl/Tk o una serie de
comandos. Usualmente, estos comandos llaman funciones que pueden
realizar operaciones complejas. Cuando termina la ejecución de esos
comandos, el programa reinicia la revisión de otros eventos unidos. Este
escaneo continúa indefinidamente hasta que por fuerza se rompe con un
comando exit o destroy, como se hace con la unión CTRL-C.
El programa ntydir2, que se presenta en la figura 8-2, ilustra funcio-
nes y uniones de objetos. Aquí, el programa mydirl se amplía con la
posibilidad de presentar en pantalla dos cuadros de listas: una para
directorios y otra para archivos, cada una con su propia barra de des-
plazamiento. El cuadro de lista del directorio se denomina .listdir y su
barra de desplazamiento, .scrolldir.Tanto los cuadros de lista, como las
barras de desplazamiento, primero se definen y después se crean; en
este caso, .listdir y scrolidir van primero, de manera que aparecerán
en el lado izquierdo de la ventana.

La función listdirsfunc de Tcl se define después para completar los

dos cuadros y toma como argumento un directorio. El con~andoc d
cambiará a ese directorio, suministrando la capacidad de presentar
listados de distintos directorios. Después, una prueba de isdirectory
verifica los directorios, ubicándolos en el cuadro de lista .listdir.
308 1 Fundamentos de programación
-- - en Linux

proc I i s t a i rsTunc 0 1 r í
. l i s t d i r d e l e t e O end
. l i s t d e l e t e O end
cd f d i r
foreach i [exec 1 s - a 1 í
i f [ f i l e isdirectory $ i l I
. l i s t d i r i n s e r t end $ i
l else (
. l i s t i n s e r t end b i
1
t
1

Después de la definición de esta f~incióiisigue un llainado de fuil-

ción. La f~inciónlistdirsfuncs se debe llamar una vez para coinpletar
el cuadro d e lista con el contenido del directorio actual.

# Display d i r e c t o r i e s a n d f i l e s t h e f i r s t time
1 is t d i rsfunc $di r

Ahora, hay una ririióri con el objeto Jistdir. U n doble clic en el

botón izquierdo del mouse, Double-Button-1, está unido a un 11,ima-
d o d e la función listdirfuncs para el cuadro de liita .listdir. Esta
f~inciónhace que cualquier doble clic en .listdir Ilanle la tiinción
listdirsfuncs. c o n l o iio hay unión con el cuadro de lista . M , u n
doble clic sobre e l l ~no tendrá cfecto.

m d i ' r '¿ b ~ e - ~ u t t o no ~ n t 1r
t
1 i s t d i rsfunc $i

Dos acciones se unen a .listdir con el doble clic y se encuentran

entre corchetes; para que se ejecute inái de una acción con una unión,
usted debe colocarlas dentro d e corchetes. La primera acción es una
operación para obtener el nombre del directorio seleccionado del
cuadro de lista. Cuando usted hace doble clic en un eleniento de un
cuadro de lista, lo seleccioiia. La operación [selection get] presentará
el elemento seleccionado; en este caio, un nombre d e directorio que se
aiigna a la variable i. Esta variable se emplea corno un argumento en el
llainado d e f ~ ~ n c i ódne listdirsfunc, la segunda acción. Estai dos accio-
nes ilustran cómo puede obtener valores y paiarloi como argumentoi a
 Capitulo 8: Tk 1 309
una f~inción,todo dentro de una unión. I'riinero, usted obtiene los
valores, asignándolos a las variables y después usa el contenido de estas
variables como argumentos en el llanlado de f~inción.
El contenido del script niydii.2 es el sigiiiente:

9rus r7Bii7wi~fi-- f
# Create scroll bar and list box for directories
scrollbar .scrolldir -command ".iistdir yview"
listbox .listdir -yscroll " .scrolldir set" -reliefanken -width 15 -height 15 \
-setgrid yes
pack .listdir .scrolldir -side left -fill both -expand yes -anchor w
# Create scroll bar and 1 ist box for files
scrollbar .scroll -coirimand ".list yview"
listbox .list -yscroll ".scroll set" -relief sunken -width 15 -height 15 -s~tgridyes
pack .list .scroll -side left -fill both -expand yes -anchor w
/¡ Check to see if an argument was entered
i f Sargc>O lset dir [lindex Sargv 031 else lset dir ' . " I

# Function to list separate and list directories and files.

#Current e n t r i e s are f ir s t del e t e d
proc listdirsfunc dir 1
.listdir delete O end
.list delete O end
cd Sdir
foreach i lexec 1s -a 1 1
i f Cfile isdirectory Sil f
.l istdir insert end Si
I else I
.list i n q r t end $i
I
t

# Display directories and files the first time

listdi rsfunc Sdir
irset up Dinaings ror rne Drowser. uirecrories are muna ro rne wowje aouoie-ciic~
bind al1 <Control -c> ldestroy . 1
bind .listdlr <Double-Button-l>
I s e t i [setection getl listdirsfunc Sil

Prueba de repaso
0 2 Los programas en Tk son eventos dirigido^?^

O ¿Cómo se ejecutan las tareas?'

3 Si.
4 Las acciones están unidas a eventos con operaciones biiitl.
310 1
- Fundamentos de programación
---
en Linux

Ventanas
Uno de los coiiiponeiites báiicos de un prograiii'i en T k ei la vcrrtarra.
Usted puede crear taiitai ventanas coi110 quiera, abrikndolas y cerrándolas,
lo nusiiio que agre@dolei widgets conio inenús, barras de herramientas y
barras de desplazar~iiento.C o n el coniando wm puede configurar dife-
rente$ características para las ventanas conio título, taniaño y nombre del
icono.
El pi-ograma rriydw.3 tnuestra cómo crea usted otra ventana con sus widgcti
propios, lo mismo que cóii~oacceder a archivos ( v h e figm 8-3).La fiinción
dispfle crea una ventana separada para presentx el testo de un archivo.
I'rimero, se define la variable de ventana, w, con el nonibre .dispf, así:
, . -.
s e t tr . d i s p f

Ilespu6s se habilita la caja de cierre para ccrr'ir la ventana. El co-

mando toplevel le dn a la ventana su propia n~eiiloria,creando la
ventana. El coinando wm se utiliza para definir el title (título) de la
ventana (Ilisplay File) y asignar el iconname (DisplayFile).

i E::::
hng4.gY The L i n m o p e r a t i n q s y s t r n h a s become a v i a b l e
: ilionflay a l t e r n a t ~ v cEor myone m t h a P C I t bririqa
a 1 1 t h e power and f l e x i h i l i t y o € a Unix
mydirl
w o r k s t a t i o n ar w e l l a s a complete s e t o €
Intcrnet applications m d a f u l l y functional
1
1
deaktop m t e r f a c c i A l 1 o € t h i j cari e a s i l y be
i n s t n l l e d on any PC o r w o r k s t a t i n n T h i s buak
1
'. deeigned n o t o n l y t o he a cninplete
referente ori Liriux, h u t a l s o t o p r o v i d e c l e a r
m d d e t a i l e d e x p l a n a t i o n s o € Linux feaiJirs5
No p r i o r h o w l e d q e of Unix is assuned. L i m
i x m o p e r a t i n q systoi* mycine can u s e . !
The jecond e d i t i o n o € t h i s book i d e n t i f i e s
f o u r major Linwr t o p i c s ; Environments. t h e
'
I n t e r n e t , S e r v e r s , Applicaticins. m d
h d a i n i s t r a t i o n . Por Envircinnents. Linux h a s :

Ventanas de Tk

'~at~ti I C I ~
t o p l evel
wm t i t l e
wm iconna
 Capitulo 8: Tk 1 311
Dentro de esta ventana se define un marco llaniado .buttons. El
comando button define el botón dismiss conio parte de este niarco:
.button.dismiss. El texto que se niiiestra en pantalla dentro del botón
es "I>isniiss". El comando que se ejecuta cuando se hace clic en el
botón es destroy $w, que destruirá la ventana. El marco que n~antieiic
el botón se ~ibicaen el centro de la pdrte inferior de la ventana.

Se define una barra de deiplazaniicnto para el testo. Luego, el

coniando text define un cu,~dropara el texto, 11'1rnada .dispf.disptext,
en la que .dispf es el contenido de $w. Por lo general, a u n cuadro de
tcxto se le pueden definir variai opcionei como el borde, una barra de
deiplazamiento y la opción de ocultar parcialnientc las palabras.

Despiiés, se llama la f~inciónLoadFileText para leer el archivo

especificado dentro del cuadro de testo. LoadFileText toma dos
argumentos: la ventana y el nombre del archivo. Observe que debido a
que hay dos argumentos, éstos deben ir entre corchetes. El archivo se
abre con la operación [opzn $filename], regresando a iin ID archivo
que se asigna a la variable fid con el coniando set. Un biiclc while que
pone a prueba la terminación del archivo ![eof $fid] lec el testo del
cuadro $w.disptext. Este conlando read lee testo cn bloques dc
10,000 caracteres a la vez. La operación insert pone el testo en el
objeto $w.disptext presentándolo en la pantalla. I>espui.s, el comando
$fid cierra el archivo.
m
-n.difmnsert end c r e a d '$f~"d"i"ooodl'-

Luego del código para la fiiición dispfile sigue el código que

define y crea valores para la ventana principal. EnTcl/Tk, las funciones
se deben definir antes de que se pueda hacer referencia a ellas en el
programa. Por esta razón, las definiciones de la función se ponen al
comienzo del programa, y la parte principal del programa hacia el final.
-1 Fundamentos d e programación e n Linux
312 -. -.-

El título y el nombre del icono se definen luego para la ventana

principal, a la cual se hace referencia por medio de uii punto. Cuando
se define una característica de la ventana principal, entonces el punto
(.) representa el nombre de la ventana.

I1esput.s de definir y crear los cuadros de lista y las barras de despla-

zamiento para la ventana principal, se define la función selectfile. Esta
función recibe conio su argumento un noinbre de archivo y lo pone a
prueba para asegurarse de quc sea un archivo legible. Después, la
ftinción llama a la función dispfile para crear una ventana y presentar
el archivo en pantalla. Al final del prograi-iia se agrega otra unión, esta
vez para el cuadro de lista .list para archivos. La imióli .list llania la
fiinción selectfile que, a su vez, llama a la funcibn dispfile. La opera-
ción [selection get] obtiene el nombre de archivo seleccionado desde
el cuadro de lista y lo asigna a $i, que luego pasa a selectfile. Cuando
el usuario hace doble clic en LIII noiiibre de archivo en el cuadro de
texto del archivo, se abrirá Lina ventana y presentará el nonibre del
archivo. Sin embargo, cuando el usuario hace doble clic en un nombre
de directorio, el contenido de ese directorio se presenta en pantalla en
los respectivos cuadres de lista. Observe que el misino evento, el doble
clic, está unido a dos operaciones muy diferentes; el resiiltado esti deter-
minado por el objeto en donde ocurre el evento.
El contenido del script m1dii.3 es el siguiente:

$ i ~ i r l c t i o nt o D i r p l a y a f i l i . A window w i t h i t . 5 w n
I,! tixi box, rol 1 lh,ir, a n d 1 ; u t t o r i s
pror d i s p f i l r file 1
,i! , r e a t e d i s p l d y uiriílow, \rri:idow t i t l e . l i i d i c o n r i m ? .
 --
Capitulo 8: Tk 1-
313

t o p l e v e l fw
wm t i t l e $w ' D i s p l a y F i l e "
wm iconname %w 'Di s p l a y F i l e W
-

Marco wbuttons en la ventana de alto

il C r e a t e d i s p l ay window b u t t o n s nivel creada, llamada .buttons
frame I w . buttons-- -
- -
oack $ w . b u t t o n s - s i d e b o t t o m - f i l l x :¡la. dy - 2m
b u t t o n $ w . b u t t o n s . d i s m i s s - t e x t D i s m i s s -command " d e s t r o y $w"
pack >w.buttons.dismisst-side l e f t -expand 1 I,I L-+&, Uamado
SS se crea en
ii C r e a t e s c r o l l b a ~ .co w.buttong
s c r o l l bar $w.srro'
pack $ w . s c r o l l - s i d e r i g h t - f i l

i! C r e a t e t e x t b o x t o d i s p l a y t e x t
t e x t $ w . d i s p t e x t - r e l i e f sunken - b d 2 - y s c r o l l c o m m a n d \-
" 8 w . s c r o l l s e t " - c e t g r i d 1 - h e i g h t 30 - w r a p word - w i d t h 80
pack $ w . d i s p t e x t - e x p a n d yes - f i11 b o t h Obsi
/una línea separada
-
1
# Open t h e f i l e and r e a d i n t h t~9 < t
LoadFi 1e T e x t $w b f i1e -)me el archivo especificadol
1 -- -
/enla caja de texto - -
J
# C r e a t e window t i t l e f o r m a i n window.
# M a i n window i s r e f e r e n c e d w i t h a p e r i o d .
if A l s o c r e a t e i c o n name 111rm a i n window __ . .

t i t 1 e . *My F i 1 e I.l?ria 1ir''-~ítul~

!iilli y nombre de icono
wm iconname .
"MFileManaiir" para la ventana principal
-- . - - -- -
-
A

# C r e a t e d i r e c t o r y 1 i q t b o x and s c r o l l l d r
s c r o l l b a r . s c r o l l 4 i t - ~ m i r i a i i d" . l i s t d i i y v i e w "
l i s t b o x . l i s t d i r - y s c r ú l l " . s c r u l l d i r s e t " -reliaf z u n i e n \
w i d t h 1 5 - h ~ i g h t1 5 ; r t g r - d y r s
pack . l i s t d i r . s r r o l l d i r - s i d ~l e f t - f i 1 1 t i o t i i \
-2xpand yes - a n r h o r w

fi C r c a t e f i l e l i 5 t b o x an!d s c r o l l b a r
s c r o l l b a r . s c r o l l - c ~ m m a n d" - 1 i s t y v i e w "
l i s t b o x .li s t - y : s r r ~ l l " . s c i , o l 1 5 - t " - r e 1 ieF s u n k p n \
- w i d t h 15 - 1 i e i g h t 15 - s u t g r l d ye;
pack . l i s t . s c r o l l - 5 i d e l e f t f i l l b u t h \
-exparid yr!, - a n r h n r w
wm m i i i s i : ! ~ . 1 1

# F u n i t i o n t o s e l e r t a f i : e f o r di;pl,?y
proc s e l ? r t f i l ? i d i i f i l c t :Verifica si I
-. .-. ---- .---I
i f / L f j l e i s t j l s f , f i l < ] I t h r n 1-~existeelarchivoi
.

di:7pfile $ i i l e
1 y -t 1
p11t:\
<~, ,,
.l 11,~, , -.
~ -
...
-~- -
- . . -.
~

Llamado a di>pFilc
-. -
para-presentar
. -el_ archivo!
. . 1
- -

m \ " b f i l e \ , " jL;ri't ~4 c i i t . e ~ - t , ~ wr ~ r r s q ~ u h r f i l p ' '

314 1 Fundamentos de programación
-
en Linux
-

,
i f $argc>O l s e t d i r [ l i n d e x Bargv 011 e l s e I s e t d i r "."I
# F u n c t i o n t o d i s p l a y f i 1-5 and d i r e c t o r i e s
pi'nc l i s t d i r s f u n c d i r I
. l i s t d i r d e l e t e O end
. li s t d e l e t e O erid
cd $ d i \ -
set n d i r [exec pwdl
f o r e c c h i Cexec 1.: - a 1 I
i f [ f i l e i s d i r e c t o i y Bil 1
. l i r , t d i r i r i s c r t t n d $i
1 else I
. l i s l i n c e i t end $i
1 ,u; coFdo-ble c l r l
1 st.lectfilc para presentar
1 len pantalla un archivo
1 i s t d i rsfi.lnc $ d i r
# S@t olj b i n d i n g s f r ~ rt h e d i r e c t v i . i e s and f i l c : . .
b i n d a l 1 I C o n t * r n l - c ; l J ~ s t r n y. 1
b i n d . l i s t <Double-Eiil-.tan-J ? l s e t i [ s c - i e c t i o n g e t l \
selectfile ddir s i \ .
\CjlisrdinCunrparapresenta
- -
:Une con doble clic a
b i n d . l i $ t d i r <Doiible-Button-1, l s e t i [ r e l e c t i o n ~ e t l
1 i s t d i r s f u n c $i l
wparita1!auri.b;_i_~~,

Marcos y etiquetas
En lugar de crear distintas ventaiias para diferentes operaciones, usted
puede usar mnrcos que se pueden presentar en pantalla en una sola
ventana. Cuando se elige una nueva operación, ella reemplaza a la que
se estt' presentando en ese n ~ o i ~ ~ e nEn
t o efecto,
. todas las operaciones
tienen su propio iiiarco que, cuando se elige, se presenta en la parte
inferior de la ventana. Cuando se termina la operación, el niarco
desaparece, contrayendo, eii consecuencia, la ventana principal. En la
figura 8-4 se presenta un ejemplo de algunos marcos en una ventai~a.
Las ctiqiretas le permiten seleccionar los elementos presentados en
pantalla para ubicarlos en una ventana, simplemente haciendo clic en
ellos con ei ratón. Las etiquetas le periniten crear selecciones de nienú
sencillas usando cualquier objeto que se muestre en su ventana. En la
figura 8-4, el menú principal es sólo tres líneas de testo, que coinienza
con los números 1 , 2 y 3. Pasando el ratón sobre una de estas líneas
cambia el color de fondo de la 1ínea.Al hacer clic en una línea, ésta se
selecciona y se ejecuta la acción asociada con ella. Las líneas de texto
operan conio un menú debido a las etiquetas. Cualquier texto en un
cuadro se puede niarcar con etiquetas. Una etiqueta puede definir
características del texto mismo, como fuente, tamaño, color o fondo, y
una etiqueta también puede estar unida a acciones, tal como los even-
tos de teclado. Con las etiquetas, el texto de un programa en Tk puede
funcionar conio un hiperenlace en una página Web: cuando usted hace
clic en determinado texto, puede ejecutar una función.

S~mpleFile Operations - 0 1

Move the rnouse over a Line and clickwith the l e t bunon

2. Erase a (ile.

3.Renarne a Me.

Fik in Cnpy: d o c l M

Nenane of Tile: preface

Prueba de repaso .
0 ¿Qué comando se utiliza para determinar las características
de una ventana?=
0 ¿Qué comando define una caja de texto?6

O ¿Qué característica usaría para implementar un menú en Tk?'

5 El comando wiii.
6 El comando text.
7 Las etiquetas se usan para implementar un menú
316 1 Fundamentos de programación en Linux
- --

A Proyecto 82: Crear un administrador de archivo

El script myfilemgr es una aplicación más completa que ilustra cómo se
puede organizar un programa en Tcl/Tk en archivos de script separa-
dos. Esto es útil para archivos de aplicación muy grandes, pues le
myf i1 emgr permite distribuir una aplicación grande en varios archivos más peque-
ños, cada uno con un script TclJTk. El programa myfilemgr se divide en
tres archivos separados: myfilemgr, dispfilej dispimage. El script dispfile
es una versión en Tcl/Tk de la función dispfile en el programa mydir3 y
presenta un archivo de texto. El script dispimage presenta un archivo
gráfico que le muestra cómo definir, rotular y crear una imagen para
presentarla en una pantalla. Cada script crea su propia ventana por
separado. En la figura 8-5 se muestra cómo el programa myfilemgr
puede presentar imágenes y texto.

lPigura8-51 El programa File Manager o administrador de archivos

Paso a paso
1. Cree una ventana principal con una barra de menú con la cual un
usuario puede elegir una opción quit para salir del programa. Prime-
ro, defina un marco para la barra de menú, llamado .menuBAR y
ubíquelo en la parte superior de la ventana.
2. Después, defina un botón de menú para el menú File, llamado
.menuBAR.file usando el comando menubutton.
 Capítulo 8: Tk
-

3. Defina un menú llamado .menuBAR.file.m para este botón. Utilice.el

comando menu. Asegúrese de agregar el comando Quit a este menú.
llh,
frame . m e n u ~ ~ r
pack .menuBAR s i d e t o p - f i l l x
nenubutton .menilBAR.file - t e x t F i l e -mnu .menuBAR.file.m m d e r l i n e O -re1i e f sunken
menu .menuBAR.file.m
.inenuBAR.file.m add command l a b e l " Q u i t M -comrnand " e x i t " - u n d e r l i n e O
m c k .menuBAR.file - s i d e l e f t

4. En la ventana principal cree un cuadro de entrada de texto para

presentar en pantalla el directorio actual y permitirle al usuario entrar
allí otro directorio. Utilice el comando entry para definir el cuadro de
entrada de texto. Con la opción -textvariable dir conecte la variable
dir al cuadro de texto, poniendo en ella el contenido de dicha varia-
ble. Use el comando label para definir un rótulo que se ha de ubicar
junto al contenido de la variable dir.
.
m e 1 * .€ 0 7 ~ a m i d. i r l a l - ' t e x f "Di'?ectoryl'
e n t r y . t o p f r a m e . d i r n a m e - w i d t h 30 - t e x t v a r i a b l e d i r

5. La introducción de un cuadro de entrada de texto y de rótulos encima

de los cuadros de lista complican la organización de la ventana princi-
pal. Para ubicar correctamente los cuadros de texto en la ventana por
debajo de los rótulos, lo mismo que la posición para el cuadro de
entrada y los rótulos en h parte superior de la ventana, defina tres
marcos para cada cuadro de lista: .files para archivos, .dirs para
directorios y .topframe para el cuadro de entrada y los rótulos. El
cuadro de lista del archivo se llama ahora .files.list y el cuadro de lista
del directorio es .dirs.listdir. Todos los marcos de los cuadros de lista
tienen su propio rótulo en la parte superior.
6. En la función selectfile, llame los scripts dispname y dispimage. Use una
operación if con el comando regexp para verificar la extensión de un
archivo, para determinar si es un archivo de imagen o de texto; luego,
llame los scripts apropiados. El comando source ejecuta un script Tcl/Tk.
Por lo común, los scripts residen en un directorio predeterminado. Defina
la variable progdir en este programa para que contenga el nombre de
ruta de ese directorio predeterminado. En la operación source, emplee el
comando file con la operación join para combinar el nombre de ruta con
el nombre del script, informando el lugar en donde se localiza el script. El
siguiente ejemplo es la operación source para el script dispimage:
. ..
tfiTe
m

%urce j o i n icrogdir
318 ( Fundamentos de programación
- en Linux
-=

El contenido del script myfilemgr es el siguiente:

# T h i s s c r i p t generates a d i r e c t o r y f i l e browser, which l i s t s

# t h e w o r k i n g d i r e c t o r y and a l l o w s y o u t o open f i l e s o r
# s u b d i r e c t o r i e s by d o u b l e - c l i c k i n g , i n c l u d i n g g i f p i c t u r e s .
i.
# The s c r i p t c a l l s t w o s e p a r a t e s c r i p t s c a l l e d d i s p f i l e and
# d i s p i m a g e . A menu b a r i s added t o q u i t t h e a p p l i c a t i o n .
% The ' i s t b o x e s and s c r o l l b a r s have been p l a c e d i n t h e i r own
1 trame t o p o s i t i o n them w i t h a h i g h e r d i r e c t o r y name franie.
#
# C r e a t e m a i n window t i t l e and i c o n name
wm t i t l e . "My F i l e Manager"
wm icruiname . "MFi leManagern
# C r e a t e menubar f o r F i l e and Oui t
frarne .menuBAR
p a c k .m?nuEAR - s i d e t u p - f i l l x
n e r i u h u t t o n .menuBAR.file - t e x t F i l e -menu .rnenuBAR. f i 1 e . m \
- u n d e r l i n e O - r e l i e f sunken
menu .meni~BAR.file.in
.rnenuBAR.fi 1e.m add comniund - 1 a t i i l "Oiii t " \

pack .meiivYAR.filo - s i d c
# C r e a t e t i t l e and d i r e c: t o r y t e x t b o x f o r p a t h name
t raac . topfrarne
pack . t o p f r a m e - s i d e t o i1
l a b e l . t o p f r a m e . t i t k - 1: e x t "My F i lerrianager"
l a b q l .t o p T r r i m i . d i r l a b e ' I - t e x t " D i r e c t o r y "
e i i t r y . t o p f rame.dirnome - w i d t h 30 -. - t e x t v a r i a.b l -
e d- i r
p a c k . t o [ i i r a m e . t i t l e -:ide tcip
p a c k . ttopframe.di r l a t e l . t o p f r a r n e . d i r n d m - s i d e l e f t
O C r e a t e a s c r o l l b a r and l i s t b o x f o r D i r e c t o r i e s
# i n t h e i r own f r a m r , . d i r s
f ! . ? r n ~ d rs
i
p a c k . d i r s - s i d e l e f t - f i l l x -pady 2m
label .dirs.dirns -text "Directories"
5 c r o l l n a r . d i r s . s c r o f l d i r -comman81 " . d i r s . l i s t d i r yvit8t:"
l i s t b o x . d i r s . l i s t J i r -yscroll " .dirs.scrolldir set" \
- r e l i e f s i ~ i i k t . n -i.ridth 15 - h e i g h t 15 - ; ~ t g r i d ye:;
pack . d i r s . d i 1-ns - s i d e t a p
pack .di!-:..;ci-olldir . d i r ? . l i : , t i i i r .:Id? rigl-it. \
- f j l l brbtli -e~p..tn(lp 5 - 8 ~ n c 1 1w1 ~ ~ ~
P L r e a t i a s c r o l l b a r d n d l i s t t ~ u xí o r F i l e s
i/ i n t i i e i r clwn Franic, . i i l ~ ' i
 Capitulo 8: Tk 1 319

pack . f i l e s - s i d e r i g h t - f i l l x -pady 2m
label . f i l e s . f i l e n s - t e x t "Files"
s c r o l l h l a r . f i l e s . s c r o l l -command " . f i l e s . l i s t yview'
listbox . f i l e s . l i s t -yscroll ",files.scroll set" \
i e l i e f runken - w i d t h 15 - h e i g h t 15 - s e t g r i d yes
pack . f i l e s . f i l e n s - s i d e t o p
pack . f i l e s . l i s t . f i l e s . s c r o l l - s i d e l e f t \
- f i l l b o t h -expand yes -anchor w
wm m i n s i z e . 1 1
// D i s p l a y a t e x t f i l e u s i n g d i s p f i l e and d i s p l a y a g r a p h i c
!/ f i l e u s i n g dispimage. Cal1 t h e separate d i s p f i l e and
// dispimage s c r i p t s w i t h t h e source command. p r o g d i r needs t o
# h o l d t h e f u l l p a t h name f o r these two s c r i p t s .
proc s e l ~ r t f i l el d i r f i l e l I
global progdi r
if ( \
[regexp ( \ . g i f S l \ . t i f f $ l \ . b m p S
S f i l e 1 = 11 \
t hen
source [ f i l e j o i n S p r o g d i r dispimage 1
) e l s e i f I [ f i l e i s f i l e S f i l e l l then (
source [ f i l e j o i n S p r o g d i r d i s p f i l e 1
I else I
puts stdout \
" \ " $ f i l e \ " i s n ' t a directory or regular f i l e "
I
1 -
#Set d i r when program f i r s t s t a r t s
i f Bargc>O l s e t d i r [ l i n d e x $argv O 1 1 e l s e l s e t d i r " . * l
JL r z l l 4h- A:---+ A - . . l:-&h-., ..:&h A:---L --.. --A +
h
.. r:l-
r I I I LIIY U I r ~ L L UyI I I ~ L U U A w I L r I U I r r L w r y r1a111e ~ I I UL I I V r I l e
l i s t b o x w i t h f i l e name. The l i s t b o x e s a r e d e l e t e d b e f o r e
b e i n g f i l l e d . n d i r h o l d s t h e complete p a t h name o f t h e
c u r r e n t d i r e c t o r y and i s used t o f i l l t h e .topframe.dirname
textbox
proc l i s t d i r s d i r (
. d i r s . l i s t d i r d e l e t e O end
. f i l e s . . l i s t d e l e t e O end
cd S d i r
f o r e a c h i [pYec 1s -a 1 l
i f Cfiie isdirectory S i l 1
. d i r s . l i s t d i r i n s e r t ~ n $i
d
t rlss I
. f i l e s . l i s t i n s e r t end B i
I
1
320 1 Fundamentos de programación en Linux
- ---

s e t n d l r texec pwdl
.topframe.dirname d e l e t e O end
.topframe.dirname i n s e r t O S n d i r
I
W i f a user e n t e r s i n a d i r e c t o r y i n t h e .topframe.dirname
# t e x t b o x . t h i s commdnd w i l l c a l 1 l i s t d i r s f o r i t
proc g e t d i r I 1 I
s e t d i r [.topframe.dirnarne getl
listdirs $dir

# T n i t i a l y f i l l i n g o f t h e d i r e c t o r y and f i l e l i s t b o x e s
l is t d i r s $ d i r

7. Defina el script di$irnoge para presentar una gráfica. Tk puede definir

dos tipos diferentes de gráficas: fotografías y mapas de bits. Las
fotografías cubren más imágenes, como gif o ppm, y los mapas de
bits suelen ser iconos. Una vez que se ha determinado el tipo, el
comando image crea el objeto de imagen dándole el nombre de
imageName (usted puede especificar el nombre que desee).
8. Después, configure ese objeto de imagen para el archivo respectivo.
Defina un rótulo en la ventana, $w.image, con el comando label. Con
la opción -image, identifique el objeto imageName. Cree el rótulo
$w.image con el comando pack; presente el archivo de la imagen.
El contenido del script dispimage es el siguiente:

?! S c r i p t t o d'íspPay a gryp'hfc Tma-ga.e-- p6Ro

4

set w .pict
c31ch Idestroy Bwl
t 3 p l evel b!
 Capítulo 8: Tk

wm t i t l e Sw " D i s p l a y Imagen
wm iconname I w " D i s p l aylmage"
# C r e a t e b u t t o n f o r q u i t t i n g window
frame $ w . b u t t o n s
pack $ w . b u t t o n s - s i d e b o t t o m - f i l l x -pady 2m
.#ui.rv,i vi. i " u * u " i i d . ..b i W d b rLr\* u i v4c. L W i i i i i i U i i U UL., r i "J ,.v.

3ack $ w . b u t t o n s . w c l o s e - s i d e l e f t -expand 1
% D e t e r m i n g image t y p e
i f [regexp (\.bmp$) B f i l e 1 {
s e t imagetype b i tmap
1 else I
s e t imagetype p h o t o
1
// C r e a t e image w i t h name imageName. Then c o n f i g u r e t h a t
1 image name w i t h t h e s p e c i f i e d image f i l e . Then c r e a t e a
1 l a b e l i n t h e window f o r t h a t image name.
!/ PacL t h l~a b e l t n d i s p l a y t h e image
image c r e a t e $ i m a g e t y p e imageName
imageName c o n f i g u r e - f i l e $ f il e
1 a b e l $ w . image - image imageName
pack $w.image - s i d e t o p - a n c h o r w

El contenido del script dispfile es el siguiente:

ri S c r í p t f o ddispTay t h e c 3 n t e n t s o f a f i l e .
set w . t e x t
catch Idestroy $ w t
t o p l e v e l $w
m ti t l ? $w " D i s p l a y F i l ? "
:AII iconname $w "tii qpl ayFi 1e"

/\ Create q i i i t buttnri
f. r.a-...-
r n ? Bw hiit tnnq
-,..-..-..-..-
pack $ ~ . b t i t t o n s - s i d e bottom - f i l l x -pady 2m
b u t t o n $ ~ w . b u t t o n s . q u i t - t e x t O u i t -command " d e s t r o y $ w "
pal:k $ w . b u t t o n s . q u i t - s i d e l e f t -expand 1
// C r e a t i d i s p t e x t frame and s c r o l l b a r f o r d i s p l a y i n q t ~ x
t ~ x Bw.disptext
t rr1i;f sunkeñ - M2 \,
- y i c r n l lconimaiid " $ N . s c r o l 1 z e t " - s ~ t l g r j d\
322 1 Fundamentos de programación en Linox

pack $ w . s c r o l l - s i d e r i g h t - f i l l y
pack $w.di s p t e x t -expand yes - f i l l b o t h
# Function t o load a t e x t f i l e
p r o c LoadFi 1e T e x t iw i n f i1 ename 1 1
s e t f i d [open $ f i l e n a r n e ]
$ w i n . d i s p t e x t d e l e t e 1.O end
while {![eof $ f i d l l í
$win.di s p t e x t in s e r t end [ r e a d Sf i d 100001
I
close Bfid
1
 O /
valuacron
1. ¿Están organizados jerárquicamente los objetos gráficos de Tk?

2. ¿Puede utilizar con~andosTcl para controlar operaciones en Tk?

3. ¿Como haría para que un determinado objeto responda ante un

evento como lo hace un botón a un clic hecho con el ratón?

4. Aunque la niayoría de los programas funcionan ejecutando sus

enunciados en forma secuencial, ¿cómo está dirigido un programa
en Tk? ¿Cómo se seleccionan las operaciones para la ejecución?

5. 2Cónio puede presentar en pantalla diferentes objetos en el niisnio

espacio de una ventana, en vez de usar una ventana diferente para
cada conjunto de objetos? (por ejemplo, emplear un menú localiza-
do en la parte superior de una ventana para seleccionar diferentes
operaciones, donde cada uno de dichos objetos se presenta en el
niismo espacio de la ventana en donde se eligió).
Los objetivos de este c a ~ í t u l oson:
Desarrollar interfaces de usuario para el escritorio de GNOME

Compilar aplicaciones de GNOME

Aprender a implementar objetos gráficos en GNOME, como ventanas

y botones

Emplearlas librerías de GTK+ para administrar operaciones básicas

Administrar la interacción de objetos de programa usando slots y señales

Aprender a administrar objetos como menús, barras de herramientas

y cuadros de diálogo
 amación en Linux
S

1 G N U Network Object Model Environment (entorno de mode-

E los de objetos en red de GNU), conocido como GNOME, ofrece
un entorno poderoso y fácil de usar que, básicamente, consta de un
panel, un escritorio y un conjunto de herramientas GUI con los cuales
se pueden construir las interfaces del programa. Está dirigido no sólo a
ofrecer una interfaz consistente, sino también una plataforma flexible
para el desarrollo de aplicaciones poderosas.
El acceso a G N O M E es gratuito, bajo la G N U Public License, sin
que tenga restricciones. Se puede obtener directamente en
www.gnome.org. G N O M E utiliza la arquitectura denominada
Common Object Request Broker Architecture (CORBA, o arquitec-
tura común de intermediario de solicitud de objetos), que permite
interconectar los componentes del software, sin importar el lenguaje en
que estén implenlentados o la clase de máquina en donde funcionen.
La implementación de C O R B A en G N O M E se conoce como
ORBit.
Los componentes fundamentales del escritorio de G N O M E son un
panel para iniciar programas y funcionalidad del escritorio. Normal-
mente, en el escritorio se encuentran otros componentes que cumplen
con las condiciones de GNOME, como son un administrador de
archivos, un programa para navegar (browser) en la Web y un adminis-
trador de ventanas. G N O M E cuenta con librerías de herramientas
GUI G N O M E quedos programadores pueden usar para crear aplica-
ciones; de los programas se puede decir que son compatibles con
GNOME, si usan botones, nienús y ventanas que se ajusten al estándar
correspondiente.
GTK+ es el conjunto de widgets que utilizan las aplicaciones de
G N O M E y su aspecto se derivó originalmente de Motif. U n conjun-
to de widgets es el grupo de objetos de GUI disponibles para usar en
un escritorio: botones, ventanas y barras de herramientas son ejemplos
sobre el particular. Este conjunto está diseñado sobre la base de dar
poder y flexibilidad; por ejemplo, los botones pueden tener rótulos,
imágenes o alguna combinación de ellos. Los objetos se pueden con-
sultar en fornia dinámica y modificar en tiempo de ejecución. GTK+
también incluye motores de estilo que le permiten al usuario cambiar
el aspecto de las aplicaciones que utilizan estos widgets. Al mismo
tiempo, el conjunto de widgets GTK+ sigue siendo pequeño y
eficiente.
 Capitulo 9: GNOME (-
329

El conjunto de widgets de GTI<+ es totalinentc gratis bajo la

Library General I'ublic License (LGPL), que le permite a los progra-
madores usar el conjunto de widgets con software bajo licencia o con
software d e acceso gratuito. El conjunto de widgets tainbikn iclentific'~
a un atnplio conjunto de uniones de leiiguaje de prograiiiación que
iiicluyeii a C++, I'erl, Python, Pascal, Objective-C, Cuile y Ada. La
parte dc iiiteriiacioiialización tiene soporte completo y permite el uso
de aplicaciones basadas en GTI<+ con otros conjuiitos de caracteres,
como los de los idiomas asiáticos. La finción de arrastrar y soltar se
encuentra en los protocolos X D N D y Motif, y permite realizar esas
operaciones con otros conjuntos de widgets que soportan estos proto-
colos, como Qt y GTI<+.

&a
5-uge.~g,n
Aunque se desarrolló en ANSl C, en otros lenguajes hay wrappers
disponibles para las librerías de GNOME y CTK+, así como para la
mayoría de los lenguajes, incluidos Ada, Scheme, Python, Perl,
Dylan, Objective-C y, por supuesto, C++.

e Nota - -- .
Las aplicaciones de CNOME hacen uso de las librerías CNOME,
CTK+, así como de las librerías CNU. Para conocer descripciones
detallidas de las funciones, definiciones y estructuras que contienen
estas librerías, se recomienda usar la amplia documentación disponi-
ble en developer.gnome.org. La sección de documentación incluye
tutoriales detallados, manuales y trabajos con amplia referencia a las
API de CNOME, CTK y CDK.

Eri esencia, los programas que trabajan con G N O M E gon prograinas

en C que coiitierien funciones de G N O M E y GTI<+, las cuales inaiie-
jan las operaciones del escritorio G N O M E para un programa. Cuando
hace programación para G N O M E , usted emplea un amplio conjunto
de funciones y estructuras que se encuentran e n ~iiucliaslibrerías. Estas
estructuras y funciories constituyen los diferentes coinporientes que van
eii una aplicación G N O M E .
 gramación en Linux
6 . - S

Este capítulo puede suministrarle una visión general de esas librerías

y la manera como puede usarlas para crear programas en GNOME.
Aunque la programación en G N O M E no es tan fácil conio en Tk,
requiere solamente el uso de unas pocas funciones básicas para crear
interfaces de usuario simples. Usted puede considerar las funciones de
GTK+ como operaciones de bajo nivel y las de G N O M E como
operaciones de alto nivel, fáciles de usar. Por lo común, las funciones de
G N O M E incorporan varias funciones de GTK+, haciendo que las
tareas con GUI sean relativamente fáciles de prograniar. En esencia, un
progrania en G N O M E es un programa en C con funciones de GTK+,
lo mismo que de GNOME. Debido a que las funciones de GTK+
manejan las diferentes operaciones básicas de GNOME, este capítulo
comienza estudiando la prograniación básica en GTK+ y después
estudia los programas en GNOME.
Las librerías de GNOME ofrecen las funciones de más alto nivel
que se usan en aplicaciones GNOME. Por debajo de ellas están las
librerías de GTK+, que constituyen el juego de herramientas desarro-
llado para el G N U Image Manipulation Program (GIMP). GTK+ está
integrada por las librerías GIMP Toolkit (GTK) y GIMP Drawing Kit
(GDK).
GTK contiene las funciones y estructuras para administrar widgets y
.
tareas de interfaz del usuario. A estas funciones y estructuras se puede
tener acceso directamente en cualquier programa en GNOME. De
hecho, una aplicación en G N O M E es un programa GTK con funcio-
nes de la librería de GNOME. Las funciones y estructuras de GTK son
objetos de programa de C + + , ambos diseñados para usarlos en un
progrania con estilo C + + .
GDK contiene funciones de nivel más bajo que se usan para conec-
tar GTK con las librerías Xlib, las cuales contienen funciones que
realizan las operaciones actuales del X Window Systeni. GTK y
GNOME también usan funciones estándar de C suniinistradai por la
librería Glib. En la tabla 9-1 se presentan los diferentes coniponentei de
GNOME.
Las aplicaciones de G N O M E también emplean ORBit e Indib
(Image Library). Con ORBit, los programas pueden localizar y solicitar
servicios desde un objeto, inclusive uno localizado a través de una red;
por ejemplo, un editor podría solicitar el uso de una hoja de cálculo.
 Imlib contiene funciones para administrar imágenes en varios formatos,
permitiendo que usted presente en pantalla, aumente, guarde y cargue
imágenes en su programa.

Prueba de repaso
¿Cuál es el conjunto de widgets que usa GNOME?'

;Qué significa GNOME?2

Componente de CNOME Descripción

Librerías de CNOME Contiene funciones de CNOME de alto nivel
CTK (CIMP Tool Kit) Contiene widgets y funciones CUI
CDK (CIMP Drawing Kit) Ofrece un wrapper de bajo nivel para Xlib
Xlib Permite operaciones con X Windows
Clib Contiene la librería CNU C de funciones estándar

Librerías GNOME
Las librerías G N O M E hacen posible que las aplicaciones de GNOME
tengan la misma clase de interfaz GUI y que su aspecto sea muy simi-
1ar.Aunque una aplicación G N O M E es un programa GTK con fun-
ciones de librería de GNOME, la librería ofrece varios widgets
complejos de alto nivel, lo mismo que muchas operaciones simples que
no se encuentran en las librerías GTK+. En la tabla 9-2 se presenta la
lista de las librerías de GNOME.
libgnoriie y libgnomeui son las dos librerías principales que se
necesitan para cualquier aplicación en GNOME; libgnome es un
conjunto de funciones diseñado para ser independiente de cualquier
juego de herramientas GUI en particular. Estas funciones se pueden

1 GTK+.
2 Entorno de modelos de objetos en red de GNU.
 ación en Linux

usar en cualquier clase de programa, sea que tenga o no una interfaz en

la línea de comandos, y son independientes de cualquier juego de
herramientas GUI en particular. La librería libgnomeui contiene
funciones que permiten operaciones con la interfaz GUI. Esas funcio-
nes están unidas a un conjunto de herramientas GUI en particular,
como el de GTK. Es posible crear una librería libgnomeui que esté
unida a un conjunto diferente de herramientas GUI.

Librería Descripción
libaudiofile Lee una amplia variedad de formatos de
archivos de audio (AIFF, AIFC, WAV y
NeXTISun).
libgdk-imlib Incluye funciones para cargar múltiples
formatos de archivo (JPEC, CIF, TIFF, PNC,
XPM, PPM, PCM, PBM y BMP).
libgtk Esta es la librería CTK. Las aplicaciones
CNOME están totalmente escritas usando
libgtk para todos los elementos CUI (boto-
nes, menús, barras de desplazamiento,
etc.).
libgnome Incluye rutinas de utilidad para el entorno
del escritorio CNOME, tales como rutinas
para configuración, ayuda, manejo de tipos
mime (por multipurpose lnternet mail
extensions o extensiones multipropósito de
correo en Internet) y administración de
sesiones. Esta librería es independiente de
cualquiera de las cajas de herramientas
CUI.
libgnomeui Incluye extensiones de juegos de herra-
mientas para el conjunto de widgets CTK+
destinados a crear cuadros de diálogo y de
mensaje, barras de menú, barras de herra-
mientas, líneas de estado, etc. También
incluye iconos para los cuadros de diálogo,
entradas de menú y botones; y suministra
 Capitulo 9: GNOME / 333
Librería Descripción
el widget canvas de CNOME para la fácil
creación de interíaces complejas, como li-
bretas de direcciones, aplicaciones de calen-
dario y hojas de cálculo. Esta librería depen-
de del juego de herramientas y en la actuali-
dad se usa en el CTK+ Toolkit.
libgnorba Una librería para usar la implementación
ORBit de CORBA con GNOME.
libzvt Una librería que contiene un widget de ter-
minal.
Contiene funciones gráficas usadas por
GnomeCanvas.

La librena libgnome suministra muchas rutinas de utilidad relacio-

nadas con el entorno del escritorio de GNOME. Entre las capacidades
que ofrece están el soporte para el archivo de configuración para
aplicaciones que manejan información persistente, soporte para
metadatos (datos unidos a objetos de archivo, como el icono que
aparecerá en pantalla para Un tipo de archivo en particular) y soporte
para cargar documentos de ayuda en el programa de navegación de
ayuda de GNOME.Tanibién cuenta con una interfaz, de manera que
las aplicaciones de GNOME pueden hablar con el administrador de
sesión de GNOME. Finalmente, hay rutinas para configurar la manera
como G N O M E y el administrador de archivos G N O M E manejan
diferentes tipos de mime. En la tabla 9-3 se presentan algunas de estas
funciones.
La librería libgnomeui contiene las funciones y estructuras que
usted necesita para crear las interfaces de usuario de G N O M E para sus
aplicaciones, y estas funciones están unidas a la caja de herramientas de
GTK+. Esta librena contiene un grupo de extensiones para el conjun-
to de widgets de GTK+ y los programadores pueden crear con facili-
dad cuadros de diálogo y de mensaje, lo mismo que barras de menú,
barras de herramientas y líneas de estado. Los programadores cuentan
con un extenso arreglo de iconos para usarlos en cuadros de diálogo,
entradas de menú y botones, y debido a que todas las aplicaciones de
GNOME usarán libgnonieui para crear estos elementos GUI comunes,
se garantiza la consistencia visual. Similar en muchas formas al canvas

Categorías de función
de la librería CNOME Descripción
gnome-config Ofrece acceso simple a los valores de
configuración.
gnome-defs Contiene definiciones CNOME para en-
laces con C++.
gnome-exec Permite la ejecución de programas des-
de aplicaciones CNOME.
gnome-help Contiene rutinas para presentar ayuda
en pantalla.
gnome-history Mantiene el seguimiento de documen-
tos usados recientemente.
Ofrece soporte para localización e
internacionalización.
gnome-mime-info Contiene rutinas para obtener informa-
ción unida a un tipo MIME.
gnome-paper Contiene las dimensiones del papel y las
. conversiones de unidades para impre-
sión.
gnome-popt Contiene el analizador de los argumen-
tos de línea de comandos.
gnome-regex Contiene la implementación caché para
la expresión regular.
gnome-sound Incluye rutinas para activar sonidos para
aplicaciones CNOME.
gnome-triggers Contiene un mecanismo jerárquico de
señales para eventos de aplicación.
gnome-url Permite iniciar visualizadores para docu-
mentos basados en sus URL.
gnome-lib Inicia la librería libgnome.
de T K , el canvas de G N O M E ofrece un marco de referencia para crear
libretas de direcciones, aplicaciones de calendario y hojas de cálculo.
En la tabla 9-4 se presentan varias clases de las funciones que usted
puede encontrar en esta librería.
Las aplicaciones GUI requieren uso extenso de imágenes para crear
una interfaz de usuario amigable y có~noda.Tradicionalmenteha sido
dificil cargar todos los formatos comunes de archivos gráficos en
aplicaciones X11. La librería libgdk-irnlib trata este tema al ofrecer
funciones poderosas y adecuadas para cargar múltiples formatos de
archivo (JPEG, GIF,TIFF, PNG, XPM, PPM, PGM, PBM y BMP).
Estos archivos se convierten en una representación interna R G B de 24
bits y existen funciones de utilidad para ajustar a escala, lo mismo que
reproducir desde el R G B de 24 bits hasta diversas tonalidades de color
(con fusionado si se desea). Los archivos de entrada de imágenes se
llevan internamente a la nlemoria caché por medio de libgdk-itnlib
para mejorar el desempeño en aplicaciones que emplean imágenes de
manera repetida.

Categorías de función
de la interfaz de usuario Descripción
gnome-app-helper Permite la creación simplificada de
. menús y barras de herramientas.
gnome-app-util Incluye funciones de utilidad para mani-
pular widgets del contenedor
CnomeApp.
gnome-canvas-util Incluye funciones auxiliares del canvas.
gnome-dialog-util Ofrece funciones de conveniencia para
hacer cuadros de diálogo.
gnome-dns Ofrece una interfaz para resolver nom-
bres de dominio que no están en blo-
ques.
gnome-geometry lncluye funciones de utilidad para la
geometría de ventanas.
 mación en Linux

Categorías de función
de la interfaz de usuario Descripción
gnome-icon-text lncluye funciones de enrollamiento de
texto para titular iconos.
gnome-init Inicia librerías de CNOME.
gnome-mdi-session lncluye rutinas que ofrecen las opciones
de guardar estado y restauración en
CnomeMDI.
gnome-popup-help Contiene un sistema de ayuda
contextual para CtkWidgets.
gnome-popup-menu Incluye rutinas para anexar a los widgets
menús contextuales que aparecen cuan-
do se hace clic con el botón derecho del
ratón.
gnome-preferences Contiene rutinas para buscar y traer ins-
trucciones y para determinar preferen-
cias en CNOME.
gnome-startup lncluye rutinas internas para administrar
la sesión.
gnome-types Contiene algunos tipos globales usados
por las librerías CNOME.
gnome-winhints . Contiene rutinas para manejar indicacio-
nes específicas del administrador de
ventana de CNOME.
gtkcauldron Produce cuadros de diálogo gtk/
CNOME a partir de cadenas de formato.

La librería libgtk es la librería GTK Toolkit. Es un conjunto de

widgets con calidad profesional que es superior en muchos aspectos a
otros conjuntos. Las aplicaciones G N O M E están escritas en su totali-
dad usando libgtk para todos los elementos GUI (botones, menús,
barras de desplazamiento, etc.). La librería libgnorba presta soporte
para operaciones CORBA, tales como la obtención de referencias a
objetos y la solicitud de nuevas instancias de objetos; libzvt es una
librería sencilla que contiene un widget de terminal; libart-lgpl
contiene funciones gráficas que se pueden usar con el widget
GnomeCanvas.

Prueba de repaso
¿Tiene GNOME su propio administrador de ventana^?^
¿Cuáles son las dos librerías que se necesitan para cual-
quier aplicación de GNOME?4

GTK+ consta de un extenso conjunto de funciones para widgets de

diferentes tipos, como menús, botones y ventanas.También soporta
uniones que asocian eventos GUI, como clics con el ratón, sobre objetos
(tales como botones).Verifique la documentación en línea para la GTK
API en los sitios Web www.gtk.org y developer gnome.org. La
documentación incluye una amplia lista de todas las funciones de
GTK, lo mismo que un tutorial detallado sobre programación en
GTK. Se recomienda que usted emplee esta documentación. Debido a
restricciones de tamaño, en este libro se presenta sólo una breve intro-
ducción y la lista de varias funciones comunes de GTK. Además, revise
los archivos de cabecera de GTK para una declaración detallada de
diferentes funciones y estructuras, que incluyen sus argumentos y
valores de retorno.
En cualquier programa de GTK se necesitan varias funciones y
componentes básicos. Primero, debe incluir, por lo menos, el archivo
de cabecera 2tk.h. Pueden ser necesarios otros archivos de cabecera de
GTK, dependiendo de los widgets y las funciones que esté usando.
Después, tiene que definir apuntadores para los widgets que trate de
definir y usar; luego, tiene que iniciar la librería GTK con la función
gtk-init. Una vez que lo haga, puede definir sus widgets empleando
funciones GTK y asignar las direcciones respectivas a los apuntadores
- - --

3 No.
4 libgnome y libgnomeui.
338 1 Fundamentos de programación
-
en Linux

definidos previaiiieiite. 1:kspuk piiede usar f~iiiciones(;TI< para espe-

cificas accioiies y atributos o para los widgets, coino la prcsentacibii cii
pantalla. Por ejeiiiplo, un evento de cierre de cuadro (delete-event)
está conectado a la ventaiia y n la fiiiicióri gtk-mai~i-quit, de modo
que cuando ~ i i iisuasio
i lince clic eii la casilla Close de la veiitana, el
gtk-main para
prograiiia tcriiiiria. Fii~aliiieiite,usted utiliza la f~iiiciói~
opera- los widgets.
El sigiiieiite programa 1)nsc.r define u11 progi-niiia siiiiple eii (;TI<
q ~ i cpresenta eii paiitalla Liiia vciitaiia seiicilla:

El archivo de cabecera xtk.1) incluye defiiiicionei de vc~siables,

inacroi y fiincioiics de GTK; windowl ic dcfinc como ~ i i apiiiitador
i
hacia iin'i eitriictura dciioiiiiiiada GtkWidget. LJ ejtructurJ actual
d o n d e se señala estará detei-iniiinda nicís adelante por la fiiilcibn qiic sc
iise para crear una estructui-a dad'i. La fiincibii gtk-init crea coilfigiira-
ciones iniciales, c o m o el mapa visual y d e color predeterminado, y
desp~iésllaina a la fiinción gdk-init para iniciar la librería G T K y
verificas :irg~iinentosd e G T K . La fiincibn gtk-window-new crea iina
nueva estructura d e ventana, presentando d e nuevo su direcciOn, la cual
se asigna entonces al apiintador d e la veritana.Aliora, la ventaiia está
sellalando a la estriictura d e ventana d e G T K . El argumento
GTK-WINI~lOW-TOI>-LEVEL pondrá la ventana bajo conti-o1 del
adiilinistrador d e ventanas, ~ i s a n d olos predeteriiiinados d e Cstc para
prcscntar Liiia ventana. Entonces, la fiincióii gtk-widget-show pre-
seiita e n pantalla la veiitam; observe c p e el apuntador de 1;i ventana sc
usa coino el arguilieilto para estd fiincióii. Fiiialiiiente, la fiiiicióii
gtk-tiiain coniienza el proceso interactivo, esperando q u e sucedan
eveiitos conio selecciones d e botones y clics con el rat6n.
Usted coiiipila u11 progranla cii (;TI<+ ciiiplcando el conipi1:idor gi.1-
y 13s librerías GTI<+. Parn especificar dichas librerías eii la líiica d e
coinandos, ~isted~itilizael corilando gtk-config q u e deteriiiiiia las
opciones del conipilador ncccsarias para coinpilai- ~ i i prograiiia
l

GTI<+.

gtk-config es iin programa clue se debe ejecutar cii la línea d e

coiiiandos. I'ara hacerlo: iistecl marca el prograina y siis arguiiieiitos coi1
coniillas invertidas, las ciialcs son opcradoi-cs clc slicll q u e se Lisail para
~ j e c u t a rcii la líiica d e coiiiandos L ~ I I coiiiando liiarcado con estos
signos y regresx los valores nl iiiisnio sitio en csa líiica. Usted p ~ i e d c
coiisiclerar esta operación c o m o el fiincioiiaiiiierito d e Liiia iiincro,
sustitiiyciido los valores q u e riiuestra por el coiiiaiido ejecutado. En este
caso, el coiiiando gtk-config coi1 los argiiniciitos cflags y libs poiidrlí
en la línea d e coiiiandos los indicadores y librerías del coiiipiladoi-
<;TI< q u e ~istednecesite para el coiiiaiido gcc. El coiiinndo gcc se
cjccuta luego con esos indicadores y librerías.

-,- - --
--v--. - --- ..., -- - ---- --
gcc he1lo.c -o hello 'gtk-confiq --cflags --libs'
 ramación e n Linux
e#.*, "* *

Las librerías de uso niás común se presentan en la tabla 9-5.

Librería Descripción
CTK (-lgtk) Librería del widget CTK
CDK (-lgdk) wrapper Xlib
gmodule (-lgmodule) Extensiones en tiempo de ejecución
Clib (-lglib) CTK está construido sobre Clib y siem-
pre lo necesita
Xlib (4x1 1) Lo usa CDK
Xext (-IXext) Memoria compartida con mapas de
pixeles y otras extensiones X
math (-lm) Librería de funciones matemáticas

Las clases de lenguajes de prograniación que se usan en la progra-

mación en GTK+ se pueden organizar por categorías como tipos
fundamentales, incorporados y objeto. Los tipos fundamentales son
básicos, tales conlo clases de progranias estándar en C y los tipos de
clase base para GTK+, conio GTK-TYPE-OBJECT. Los tipos
fundamentales los define autoniáticaniente gtk-init. Los incorporados
incluyen algunas enunieraciones básicas, indicadores y estructuras
conio GdkWindow; estos son tipos que GTK+ no necesita entender
para usarlos. Los tiposobjeto están integrados por tipos GtkObject
registrados.

Señales y eventos
La prograniación en GNOME funciona como otra prograniación en
GUI, orientada por eventos. En programas de esa clase, usted define
primero los objetos que el usuario puede operar y después inicia la
función de interacción que continuamente verifica ciertos eventos,
conlo clics de ratón y selecciones de menú. Cuando se detecta un
evento de esa clase, se pasa a su función apropiada para el nianejo. Por
ejemplo, si un usuario hace clic en el botón OK, se detecta ese clic y el
control se traslada a una función configurada para nianejar un clic en
 Capitulo 9: GNOME 1 341
un botón O K . Cuando la función ha terminado, regresa el control al
programa de interacción.
GTK agrega u n nivel de sofisticación adicional. Cuando se preseii-
tan eventos en ciertos widgets, el widget emitirá una señal que despuks
se usa para ejecutar iina f~inciónasociada con esa señal y ese objeto.
Por ejemplo, cuando usted hace clic en u n botón Close, el widget de
este botón detecta el evento de clic en el ratón y emite una señal "con
clic", la cual se detecta y permite que se ejecute la acción
asociada.
Usted tari1bit.n puede, si lo desea, asociar iin evento directamente
con una función. Para este trabajo, el programador tiene que conectar
una serial en un objeto dado con una función particular. Las fiincioiies
asociadas con iina sella1 en particular por lo coinún se conocen como
inaiiejadores o f~iiicioiiesde retrollamado (callbacks). Cuando se emite
una señal, se llaman sus nianejadores o contestadores. Este proceso se
denomina "einisión". Observe que las señales a las que se Iiace referen-
cia aquí de ninguna nianera son como las seriales que se usan en los
sisteinas UNIX.
Para asociar iin evento en particular con la función que usted quiere
que se ejecute ante una sella1 dada, use las fiinciones gtk-signal-
connect o gtk-signal-connect-object. Cuando se detecta la señal,
su f~inciónasociada se ejecut;~de nianera automática. La fiincióri
gtk-signal-connect se ufiliza para funciones de llamado, a las cuales
usted puede pasar argumentos, inientras que las fiinciones
gtk-signal-connect o gtk-signal-connect-object se usan para
f~incioiiesde llamado que no requiere ningún argumento. En la sintaxis
del siguiente enunciado, gtk-signal-connect, object es el GtkObject
que usted definió, como en el caso de iin botón; name es el nombre
de la señal, que puede ser un clic con el ratón; func es la función que
usted quiere ejecutar cada vez que ociirra un evento con este objeto, y
func-data es cualquier argumento que se pasa a esa f~inción.

m i O n n e ~m to b J e c t , -llame,
G t k S i g n a l Func f u n c , g p o i n t e r func-data ;
342 1
- Fundamentos de programación
-- en Linux

Cuando se detecta una scílal para el objeto especificado, se llama y

ejecuta la f~inciónasociada reti-ollamado, como se niuestra en la sintaxis
del siguiente enunciado:
v o i d ca 1 lback-func( Gtkoidget *widget. gpointer ca-l 1 b a c k d a t a ) :

T'or consiguiente, para asociar un clic eii un botón coi1 la f~inción

hello, ustcd usaría el siguiente enunciado gtk-signal-connect:

~ ~ q n i l - c o n n e c?%TK-OB~;~CT
t (rnybutton'), " c - f i'ckedm .
GTY-SIGNAL-FUNC (hello), NULL);

El oL?jeto es m y b u t t o n , clicked es la seiial del clic y hello es un;i

f~inciónque el prograniador escribió para ejecutarla ciiando se detecta
esta señal. GTK-OBJECT y GTK-SIGNAL-FUNC son macros
que realizan operaciones de verificacióii y difiisi0n para asegurarse de
que los objetos se pasrin con los tipos apropiados.
Ciertos o b ~ e t o stienen señales que se pueden asociar con ellos. Por
ejemplo, el objeto de botón se puede asociar con una sefial clicked o
iina señal e n t e r . La sciial clicked ocurre cuaiido u11 ~isuariopresiona y
luego suelta el botón del ratón, mientras que iina señal e n t e r ocurre
cuando el usuario mueve el puntero del ratóii sobrc el objeto de
botón. Las seiíales del'botón son las siguientes:

pressed: el botón del ratón se presiona cuando el puntero está

sobre el botóii.

released: el botóii del ratóii se libera cuando el puntero está

sobre el botón.

clicked: cl botón del ratón Fe presiona y se libera ciiando el

pLiiitero está sobre el botón.

e n t e r : el puntcro del ratóii se traslada sobre el bot611.

leave: el puntero del ratóii se retira del botóii.

 Capitulo 9: GNOME 1 343

egunte a los expertos

'i'
Pregunta: ;Puedo asociar más de una función de retrollamado
con un objeto y su señal?

Pregunta: Después de asociar una fiinción de retrollamado

con un objeto, ;puedo separada más tarde?
Respuesta: Sí puede, pero tiene que hacer referencia a la etiqueta
para esa hnción. El valor de retorno de la fuilción
-*- - * - - .. r - 1 ' 1 ' r L-
gr~-signai-connecc es una eciquera ue iueilciricacioii
L

para esa runcion. "

Guarde este valor en una variable de tipo gint. Si usted desea Peparar
mis adelante esa funciótr del objeto y la señal, use la f ~ ~ n c i ó n
~ t ko i m a l disconnect ron la etiniict,~de irl~ntifir~i-ihiiv el o h i ~ t n

void gtk-signal-disconnect( GtkObject * o b j e c t ,

g i n t i d 1:

En el si.guieiite
- cieimplo, la f~mciónmyfunc está asociada con un clic con
v .

t:1 ratón en el objeto buttonLSu etiqueta de identificación se guarda e n

.. " , .
1a variable myfuncid, la cual se usa en la fuilcióii gtk-signa-
.,
aisconnect para separar myrunc ae ia operacion de c m con ei raton.
. 1. I .

g i n t myfuncid;

myfuncid = gtk-signal-connect (GTK-OBJECT ( b u t t o n l ) .

" c l i c k e d " , GTK-SIGNAL-FUNC ( m y f u n c ) . NULL):
g t k - s i g n a l - d i s c o n n e c t (GTK-OBJECT ( b u t t o n l ) , m y f u n c i d ) ;

Pregunta: ;Puedo separar a la vez todas las funciones que

puedan estar asociadas con un objeto?
Respuesta: Sí, puede hacerlo. La furición gtksignal- handlers-
destroy separar5 todas las CUiicioncs asociadas y señales de un objeto en
.
particular:
.
gtk-signal-handlers_dectroy(GtkObject *object);
344 1 Fundamentos de programación
--~ en Linux

Usted también puede utilizar las f~incionesd e conexión de la señal

para conectar eventos directamente a un objeto y función, en vez de
usar señales. Los eventos son mei.isajes transmitidos a través del servidor
X11 para indicar la presencia de clics con el ratón y selecciones de
meníis. En la función gtk-signal-connect, usted usa cl nonibre del
evento y no la señal. Las f~incionesd e retrollan~adopara eventos inclu-
yen un argumento agregado para el evento.
El tipo para este parámetro puede ser GdkEvent o uno de otros
tipos d e evento, los cuales se presentan e n la tabla 9-6.

c a i iYac~--et, tiaktvent *event .a

gpointer callback-data 1:

Por ejeniplo, para asociar un button-press-event con un botón

OK, usted usaría "button-press-event" como el nombre de la señal.
El siguiente ejemplo asocia un evento button-press-event en un
botón con la f~inciónbutton-press-callback:

GTK-SIGNAL-FUNC( buttongress-cal1 back) , NULL) ;

La f~incióride retrollan~adoque se usa para la conexión d e la señal,

en este caso, button-press-callback, tendría el tipo de evento
GdkEventButton para su argumento de evento.
--
-
statíC9iñfb;tton_press_;álibacklGtklidgel *wi dget .
GdkEventButton *event, g p o i n t e r d a t a 1;

El ejemplo 5iguiente asocia un clic en la casilla Cloie de una venta-

na con la f~inciónclose-win. El objeto es mywindow, delete-event
es el evento d e la casilla Close y close-win es una f~inciónque el
prograinador escribió con el código que se ha de ejecutar cuando este
evento ocurra. Cuando u n usuario hace clic e n la casilla para cerrar la
ventana, se llama a la función close-win.
Tipo de evento Señal GtkWidget
CDK-DELETE "delete-event"
CDK-DESTROY "destroy-event"
CDK-EXPOSE ex pose-even t"
CDK-MOTION-NOTIFY "motion-notify-event"
CDK-BUTTON-PRESS "button-press-event"
CDK-2BUlTON-PRESS "button-press-event"
CDK-3BUlTON-PRESS "button-press-event"
CDK-BUlTON-RELEASE "button-release-event"
CDK-KEY-PRESS "key-press-event"
CDK-KEY-RELEASE " key-release-event"
CDK-ENTER-NOTIFY "enter-notify-event"
CDK-LEAVE-NOTIFY "leave-notify-event"
CDK-FOCUS-CHANCE "focus-inevent", "focus-out-event"
CDK-CONFIGURE "configure-event"
CDK-MAP "map-event"
CDK-UNMAP "unmap-event"
CDK-PROPERTY-NOTIFY "property-notify-event"
CDK-SELECTION-CLEAR "selection-clearevent"
CDK-SELECTION-REQUEST "selection-request-event"
CDK-SELECTION-NOTIFY
CDK-PROXIMITY-IN
. "selection-notify-event"
"proximity-inevent"
CDK-PROXIMITY-OUT "proximity-out-event"
CDK-CLIENT-EVENT "client-event"
CDK-VISIBILITY-NOTIFY "visibility-notify-event"
CDK-NO-EXPOSE "no-expose-event"

Las señales están almacenadas en una tabla global. Usted puede crear
sus propias señales con la función gtk-signal-new y después gtk-
signal-emit para tener un objeto que emita una señal; gtk- signal-
new regresará u n identificador para la nueva señal. Usted puede usarlo
con gtk-signal-emit para que su objeto emita esa señal.
 e programación en Linux
-m,*ss

Prueba de repaso
O ¿Qué función se utiliza para conectar objetos con
acciones?'
-
O ¿Qué función se emplea para desconectar objetos de

Funciones GNOME
Los programas en G N O M E se constriuyen sobre -prograni
-
que cuentan con funciones de GNOME para facilitar la creación de
interfaces que sean consistentes con el estilo del escritorio de
G N O M E . Para crear un progrania simple en GTK, usted comienza
con las definiciones de objetos G T K para sus widgets en G N O M E y
después utiliza las funciones de G N O M E para iniciar el programa y
definir sus widgets. Las funciones de G T K como gtk-signal-connect
se emplean para asociar eventos GUI con objetos, en tanto funciones
G N O M E como gnome-app-create-menus crean menús. En un
progrania en G N O M E usted debe incluir una función de iniciación
llamada gnome-init, que ubicará al comienzo. Para crear una ventana
primaria para su apli?ación, use gnome-appnew.
El siguiente ejemplo muestra el uso de las funciones gnome-init y
gnome-app-new. La priniera de ellas asunle los argumentos iniciales
que el usuario debe entrar cuando el programa comienza, lo niisiiio
que una aplicación ID y el número de versión. Las variables especiales
argc y argv administran los argumentos iniciales del usuario;
gnome-app-new toma como argumentos el título que usted desee
mostrar en la ventana de la aplicación y el nombre del objeto de
aplicación y presenta la dirección del nuevo objeto que, en este ejeni-
plo, se asigna al apuntador app, el cual va dirigido a un objeto del tipo
GtkWidget.

5 gtk-signal-connect.
6 gtk-signal-disconnect.
 Capitulo 9: GNOME (-
347

gnorne-init ( " " . " 0 . 1 " . a r g c . a r g v ) :

app = gnorne-app-new ( " H e l l o - W u r l d " , " H e l l o A p p " ) :

Las fuiicioiies de GTK niaiiejan otras operaciones, c o i i ~ opresentar

widgets en pantalla y activar la interfaz iiiteractiva;
gtk-widget-show-al1 presentará e11 pantalla un widget y los que éste
contenga; gtk-main iniciará las operacioiies intei-activas, detectando
eventos GUI conio clics con el ratón y uso de teclas, y ejecutando las
f ~ ~ n c i o n asociadas.
es

gtk-widgef-showmpS-:
gtk-main O ;

Compilación de programas GNOME

I h d a la amplia cantidad de librerías involiicradas en la creación de
aplicaciones GNOME, el coniando conipilador que cuenta en su lista
con todas estas librerías e indicadores, puede ser iiiuy complejo de
coristruir. l'or esta razí%i, GNOME ofrece el script gnome-config.
Usted puede poner una llaniada en este script coiiio un arguineiito
para la operación del cornpilador, en caiiibio de listar en forma nian~ial
las librerías c indicadores de GNOME; gnotne-config toma dos
opciones, - -cflags y - -1ibs. La priiiiera generará todos los
indicadores que ustcd necesite, iiiicntras que la segunda genera la lista
de librerías GNOME necesarias. Usted debe especificar las librerías que
desea utilizar, tales conio gnoiiieui y giioiiie, conio se presenta a coiiti-
nuación:

Para la operación del coiiipilador, usted poiidría la operacií>n

gnotne-config entrc coiiiillas invertidas para ejecutarla:
348 1 Fundamentos de programación en Linux
-

Para simplificar l a situación, usted puede poner esta operación e n u n

Makefile, o archivo de co~npilacióri,e n donde l a coinpilacióil se realiza
por separado del eiilazamiento. Para compilar, iisted usaría un script
-
gnome-config con la opción -cflags y para los enlaces, emplearía
l a opción - -1ibs. En e l siguiente ejemplo, las macros CFLAGS y
LDFLAGS se usan para qiic contengan los resiiltados de compilación
y enlace. Observe e l liso de las conlillas invertidas en el código.

CFLAGS='gnome-config - - c f l a g s gnome g n o m e u i '

LDFLAGS='gnome-config - - l i b s gnome g n o m e u i '

a l 1: bookrec

bookrec: f i 1 e . o ca1c.o
c c $(LDFLAGS) m a i n . 0 - o b o o k r e c
main.0: main.c
c c $(CFLAGS) m a i n . c
fi1e.o: fi1e.c fi1c.h
c c B(CFLAGS1 f i 1 e . c

Proyecto 9-1: GNOME Hello

El programa hello1.c es una aplicación CNOME sencilla en el tradicional
"Hello World". El programa crea una ventana simple con un botón que
presenta en pantalla un mensaje en la salida estándar de su ventana
terminal. Cuando el usuario hace clic en el cuadro Close
he1 1 01.c (delete-event), la ventana se cierra.
Las funciones CNOME comienzan con el término "gnome", mientras
que las funciones CTK comienzan con "gtk". Observe que la función de
iniciación es una función CNOME: gnorne-¡nit. Como se explicó previa-
mente, los programas en CNOME están dirigidos por eventos: usted
define primero sus objetos, tales como ventanas, después configura los
atributos y luego une las señales de eventos, como clics con el ratón,
con objetos como ventanas y con las funciones que procesan estos
eventos. Con frecuencia, esas funciones se conocen como funciones de
retrollamado.
Para compilar este programa, usted puede utilizar el siguiente co-
mando de compilación en una ventana terminal de CNOME; luego,
simplemente hellol para ejecutarlo. La opción -o especifica el nombre
del programa, en este caso hello. Asegúrese de usar comillas invertidas
para el segmento gnorne-config. La siguiente ilustración muestra la
ventana y el botón CNOME.
 Capitulo 9: GNOME 1 349

=
[zHello ADD - O XP

11 1 Flle Edil Settinys Help 11

Paso a paso
Defina dos funciones de contestador de llamado: hellomessage y
closeprog; hellomessage sólo presenta un mensaje de texto senci-
llo, "Hello World"; closeprog llama la función gtk-main-quit para
finalizar el programa.
En la función principal, defina dos apuntadores GtkWidget: app y
mybutton. El primero de ellos debe ser un apuntador para la
ventana principal de la aplicación y mybutton para un objeto de
botón sencillo.
Cree una función gnome-hit para iniciar la interfaz CNOME.
Cree un objeto de botón usando la función gtk-button-
new-with- label y asigne la dirección respectiva al apuntador
mybutton, como se muestra en la siguiente línea de código. El
botón se presentará con el rótulo "Click Me".
mybutton = gtk-button-new-with-label("C1ick Me");
Cree un widget para la ventana de la aplicación usando la función
gnome-app-new y asigne la dirección respectiva al apuntador
aPP.
Utilice gnome-app-set-contents para poner el botón en la venta-
na de la aplicación.
Use gtk-signal-connect para conectar la aplicación con una señal
delete-event, la cual se presenta cuando el usuario hace clic en la
casilla para cerrar la ventana. Con esta acción ejecuta la función
closeprog, que debe utilizar gtk-main-quit para terminar el pro-
grama.
350
- Fundamentos d e programación e n L i n o x
-

8. Emplee gtk-signal-connect para conectar el b o t ó n al evento d e

clic c o n el ratón (clicked) y determine esta acción para ejecutar la
función hello. Cada vez que el usuario haga clic e n el botón, e n
pantalla debe aparecer "Hello World", e n la salida estándar.
9. Use la función gtk-widget-show-al1 para presentar la ventana d e la
aplicación y el botón q u e contiene ahora.
10. Use gtk-main para iniciar la interfaz interactiva.

El contenido del programa hello7.c es el siguiente:

g-print ello W o r l d \ n W1:

l
g i n t c l o c r - p r o g í G t k W i d g e t *wjdgel. G d k E ? . ~ r i t ' c v ~ r i t .
gpointer data 1
1
~jtk-main-qiii t ( ) :
1
i n t rnain( i n t a r g c . c h a r 'argvC1
l
h t k \ d i d r i r t *app;
titkWidge~%ybutrc~n;

qricinie-init ("". "0.1". argc. argv):

m y b u t t o n = gtk-button-new-with-label ("Cl ick ~ e "):

app = giiome-app-new .
( e el l o - ~ o r l d " "He1 l o !ipp" );

.
gnoiiie-dpp..s~t-ci~iitents (GNOME-APP ( a p p ) n i y l l i i t t o t i ) :
.
g i k-sigrirrl-rcii-in~?ct (GTt.'-OH,lECT ( a p p ) " r l r l .t.?-eveiit" .
GTK-'iICi!r,L-TUNC ( c l o s c p r o g ) .l!lJLL) :
g t l -signal-coniiwt (GTK-OBJECT ( m y b u t t o n 1 . " c l i c k e d " ,
GTK-SIGNAL-FUNC ( h e l l o m e s s a g e ) . NULL):
gtL-widget-shbw-al l w);
qtk-rnnin ():
Los widgets GNOME App,
Toolbar y Menu
El widget GnomeApp es el widget básico para las aplicaciones
GNOME. Es la ventana principal que contiene menús, barras de
herraniientas y datoi. Usted usa la función gnome-app-new para
crear un nuevo widget GnomeApp.Esta función tonla conio argu-
mento el nonibre de la aplicación.
Para agregar elementos, conlo barras de herramientas, menús y
barras de estado al widget, eniplee la función apropiada. Por ejeniplo,
para agregar un nienú, use gnome-app-set-menus y para añadir una
barra de estado, gnome-app-set-statusbar. Para agregar una sola
barra de herraniientas, use gnome-app-set-toolbar y para añadir
varias, gnome-app-add-toolbar. En la tabla 9-7 se presenta un lista
de los widgets de GNOME.
Con las funciones gnome-app-helper usted puede generar
autoináticaniente menús y barras de herramientas utilizando estructu-
ras GnomeUIInfo. Para barras de herramientas y menús, usted puede
crear las estructuras GnomeUIInfo adecuadas con los valores apropia-
dos y después usar gnome-app-create-menus para crear menús y
-
gnome-app-create-toolbar para crear barras de herraniientas.

Widgets y objetos Descripción

CnomeAbout Cuadro Acerca de, para una aplicación.
CnomeAnimator Animaciones sencillas para aplicaciones
CNOME.
CnomeApp Contenedor CNOME de alto nivel.
CnomeAppBar Widget Statusbar/Progress/Minibuffer.
CnomeCalculator Widget de calculadora.
CnomeCanvas Motor genérico para gráficas
estructuradas.
CnomeCanvasltem Widget para crear y administrar un ele-
mento canvas.
CnomeCanvasCroup Funciones y estructuras para unir un
elemento canvas a un grupo.
 ramación en Linux
% b \ - m

Widgets y objetos Descripción

CnomeCanvasLine Línea de canvas.
CnomeCanvasPolygon Polígono de canvas.
CnomeCanvasRE Rectángulo de canvas y clase base de
elipse.
CnomeCanvasRect Rectángulo de canvas.
CnomeCanvasEllipse Elipse de canvas.
CnomeCanvasText Objeto de texto de canvas.
CnomeCanvaslmage Imagen de canvas.
CnomeCanvasWidget Widget de canvas.
CnomeClient Rutinas para suministrar soporte de ad-
ministración de sesión en su aplicación.
CnomeColorPicker Widget para seleccionar colores.
CnomeDateEdit Widget de entrada de fecha y hora.
CnomeDEntryEdit Edición de objetos para "dentries"
(archivos de escritorio).
Cuadros de diálogo transitorios
(aparición instantánea).
CnomeDockBand Widget para implementar bandas de
acoplamiento.
CnomeDockltem Widget acoplable.
CnomeDock Widget que soporta widgets movibles y
separables.
CnomeDruid . Widget principal del sistema druid.
Widget virtual que define la página del
CnomeDruidPage
sistema druid.
Un widget CnomeDruidPage para el
inicio de un DRUID.
CnomeDruidPageStandard CnomeDruidPage estándar.
CnomeDruidPageFinish Un widget CnomeDruidPage para la
terminación de un DRUID.
CnomeEntry Widget de entrada con seguimiento de
historial.
Widget de entrada para nombres de
archivo.
Botón que presenta en pantalla la fuente
actual; con clic se selecciona una nueva
fuente.
Widgets y objetos Descripción
CnomeCuru Obsoleto; se usa CnomeDruid.
CnomeHRef Un botón de enlace.
CnomelconEntry Selecciona un icono.
CnomelconTextltem Elemento de canvas para títulos de texto
que se pueden editar en listas de iconos.
Lista de iconos con títulos, con edición
opcional de títulos.
Presenta lista/selección de iconos.
Widget de browser para contenido de
archivo.
Clase hija de interfaz abstracta para múl-
tiples documentos.
Hijo genérico de CnomeMDI.
lnterfaz CNOME para múltiples docu-
mentos.
CnomeMessageBox Rutinas para presentar cuadros de mensajes
CnomeNumberEntry Línea de entrada para ingresar un nú-
mero.
CnomePaperSelector Selector de papel.
CnomePixmapEntry Selecciona imágenes grandes.
CnomePixMap Presenta y carga imágenes (mapas de
pixeles).
CnomePropertyBox - Cuadro de diálogo estandarizado para
manejar la configuración.
Cuadro de diálogo que presenta
puntajes altos.
lconos predeterminados para barras de
herramientas, menús y botones.
Widget de reloj de texto, capacidad en
tiempo real, modos de contador progre-
sivo y regresivo.
Widget analógico para selección de nú-
meros.
CtkPixmapMenultem Widget especial para menús de CNOME.
CnomeDockLayout Widget para guardar y recuperar la dis-
tribución de un widget CnomeDock.
CnomeProcBar Barra de proceso de CNOME.

conttnuacton
 de programación en Linux
-a-- w

Para entradas d e m e n ú únicas, u s t e d p u e d e usar m u c h a s macros. En

l a tabla 9-8 se presentan las macros d e m e n ú d e GNOME.

Macros d e l m e n ú Archivo Descripción

GNOMEUIINFO-MENU-NEW-ITEM Elemento "Nuevo" del menú (usted
(label, hint, cb, data) debe asignarle un nombre y descrip-
ción aquí)
GNOMEUIINFO-MENU-OPEN-lTEM(cb, data) Elemento "Abrir" del menú
GNOMEUIINFO-MENU-SAVE-lTEM(cb, data) Elemento "Guardar" del menú
GNOMEUIINFO-MENU-SAVEAS-ITEM(cb, data) Elemento "Guardar como" del menú
GNOMEUIINFO-MENU-PRINT-lTEM(cb, data) Elemento "Imprimir" del menú
GNOMEUIINFO-MENU-CLOSE_ITEM(cb, data) Elemento "Cerrar" del menú
GNOMEUIINFO-MENU-EXIT-lTEM(cb, data) Elemento "Salir" del menú
Macros del m e n ú Editar
GNOMEUIINFO-MENU-CUT-lTEM(cb, data) Elemento "Cortar" del menú
GNOMEUIINFO-MENU-COPY-ITEM(cb, data) Elemento "Copiar" del menú
GNOMEUIINFO-MENU-PASTE-ITEM(cb, data) Elemento "Pegar" del menú
GNOMEUIINFO-MENU-SELECT-ALL-ITEM Elemento "Seleccionar todo del
(cb, data) menú
GNOMEUIINFO-MENU-CLEAR_ITEM(cb, data) Elemento "Borrar" del menú
GNOMEUIINFO-MENU-UNDO-ITEM(cb, data) Elemento "Deshacer" del menú
GNOMEUIINFO-MENU-REDO-lTEM(cb, data) Elemento "Rehacer" del menú
GNOMEUIINFO-MENU-FIND-ITEM(cb, data) Elemento "Encontrar" del menú
GNOMEUIINFO-MENU-FINDAGAIN-ITEM Elemento "Encontrar otra vez" del
(cb, data) menú
GNOMEUIINFO-MENU-RE~CE-ITEM(C~, data) Elemento "Reemplazar" del menú
GNOMEUIINFO-MENU-PROPERTIES-ITEM Elemento "Propiedades" del menú
(cb, data)
Macros del m e n ú Configuraciones
GNOMEUIINFO-MENU-PREFERENCES-ITEM Elemento "Preferencias" del menú
(cb, data)
Macros del m e n ú Ventanas
GNOMEUiiNFO~MENU~NEW~WINDOW~ITEM Elemento "Nueva ventana" del menú
(cb, data)
GNOMEUIINFO-MENU-CLOSE~WINDOWWITEM Elemento "Cerrar ventana" del menú
(cb, data)
Macros del m e n ú Ayuda
GNOMEUIINFO-MENUABOUT-ITEM(cb, data) Elemento "Acerca de" del menú
Macros del árbol del m e n ú
GNOMEUIINFO-MENU-FILE-TREE(tree) Menú "Archivo"
 Capítulo 9: GNOME

Macros del menú Archivo Descripción

CNOMEUllNFO-MENU-EDITJREE(tree) Menú "Editar"
CNOMEUIINFOpMENU-VIEW-TREE(tree) Menú "Ver"
CNOMEUIINFO-MENU-SEnINCS-TREE(tree) Menú "Configuraciones"
CNOMEUIINFO-MENU-FILES-TREE(tree) Menú "Archivos"
CNOMEUIINFO-MENU-WINDOWS-TREE(tree) Menú "Ventanas"
CNOMEUIINFOpMENUpHELP-TREE(tree) Menú "Ayuda"
Macros generales del menú
CNOMEUIINFO-ITEM(labe1, toolip, cb) Agrega un elemento del menú con el
rótulo que usted fije
CNOMEUIINFO-SEPARATOR Inserta una línea separadora del menú
CNOMEUIINFO-END Especifica el final del menú

Tabla 9-8 Macros del menú GNOME (coritirirr<ición)

C o n la tiiacro GNOMEUIINFO-ITEM iisted puede agregar uii

eleniento a un nieiiú. La tiiacro G N O M E U I INFO-(ZEI~AI<AT01<
agrega una línea sepradora y la iiiacro GNOMEUIINFO-ENI.)
especifica el final d e un riieiiíi. En el siguiciitc <jcniplo, label es el
testo del rótulo, tooltip es la ayuda coiitextual qiie aparecerá en
pantalla cuando se poiic el puntero sobre un eleinento. sin presionarlo,
y callback es la fiincibii cliic. se ejccutaciiaiido el usuario hace clic
sobre ese elemci~to.Usted .puede agregar otro arguiiiento para una
inirigui de icono si dcscn que aparezca un icono en el elemeiito del
menú. Usuali.iiciite cs una iinagcii .xpm.

l)x-a especificar una tecla aceleradora par'i uri eleiiiento en particu-

lar, iisted simpleiileilte subraya previariierite la letra en el label segí1t.i la
tecla que desee usar. Una tecla aceleradora es una tecla alternativa que
usted puede emplear para teiicr acccso al eleiiiento del menú. Por lo
coiiiún es una tecla ALT. Eii el sigiiicntc cjeiliplo, el eleilieiito del
nienú tetidri uii rótulo de Exit con la "s" subrayada para indicar qiie
usted puede iitilizar una combiilacióri de ALT-tecla X para acceder a
ese elemento.
-----A- -----
GN-~MÉÜ-ITNFO~ITEM~~~E~X~~~* ,- "Exi t t h e p r o g r a m e , exi t f u n c )
356 1 Fundamentos de programación
- -
en Linux

La macro GNOMEUIINFO-ITEM genera los valores que se

deben uiar e n la estructura GnomeUIInfo. Usted puede asignar estos
valorei a dicha estructura. En el siguiente ejemplo se crea un menú
integrado por un arreglo de estructuras GnomeUIInfo y se utilizan
niacros GnomeUIInfo para asignar valores a todas las estructuras
GnomeUIInfo de este arreglo. En el ejemplo, se crea uri solo menú
Archivo con dos entradas, iiiia para Abrir (Open) y otra para Salir
(Exit). Habrá un separador d e línea entre ellos.

' Gn6meUTfñ-Fo 'f-il[menÜtl = 1

GNOMEUI INFO-ITEM( "-Open" , " O p e n a d o c u m e n t " , openfunc) .
GNOMEU I 1NFO-SEPARATOR.
GNOMEUIINFO-ITEM("E-xit", " E x i t t h e p r o g r a m " , e x i t f u n c ) ,
GNOMEUI INFO-END
1;

Se siirilinistraii varias niacros para elementos estándar del menú,

con10 las entradas guardar (Sdve) y abrir (Open) en un menú Archivo,
las ciiales toman como sus argumentos la funcióii que se va a ejccutar
cuando se elige el elemento (cb) y cualquier imagen de icono que
~istedquiera mostrar para la entr'ida (data). La sintaxis de estai macros
cs la siguiente:
GNOMEUIINFO-MENU-OPEN-ITEM(cb, data)

El siguiente ejemplo crea el inisnio menú Archivo del ejemplo

anterior, pero Lisa niacros especializadas para crear cada eleiiiento. Aquí,
la niacro GNOMEUIINFO-MENU-EXIT-ITEM crea la entrada
salir (Exit) para el menú:

nom me^^ -1.

GNOMEUIINFO~MENU~OPEN~ITEM(openfunc),
, GNOMEUIINFO-SEPARATOR,
GNOMEUIINFO-MENU-EXIT-ITEM(exitfunc1.
GNOMEUIINFO-END
1:

Para los subnienús y inenús que agregue a su barra d e tnenús, usted

utiliza la niacro GNOMEUIINFO-SUBTREE(labe1,tree) en
donde tree es el arreglo de las estructuras GnomeUIInfo que se van a
usar para ese subniei~ú.
 - ---
c a p i t u l o 9: GNOME 1 357
En el siguiente ejemplo se asigna el menú Archivo definido antes
y un menú Editar a una barra de menús. D e nuevo, estas son estructu-
ras GnomeUIInfo para las cuales las inaci-os generan valores. Observe
el empleo d e subrayados en los rótulos para designar teclas ALT para
acceder a los inenús.

m n f o - - J = 1 1
GNOMEUIINFO-SUBTREE("J1LE". file-menu).
GNOMEUIINFO-SUBTREE("-EDIT", edit-rnenu),
GNOMEUIINFO-END
1;

Para menús en particular en una barra de ineiiús, usted LISJ lai

macroi dc árbol de ineilú que se presentan en la tabla 9-8. El argumen-
to tree es el arreglo de estructuras GnomeUIInfo para el iilenú. Por
ejemplo, el menú Archivo se puede agregar a la barra de iiieiiú con el
enunciado siguiente, eii donde tree es el arreglo de las estructuras
GnomeUIInfo para el iiieiiíi Archivo.

El siguiente ejeniplo es uiia versión reescrita de la asigriación de la

barra de inenús usando macros especializadas para los nienús Archivo
y Editar: .
mom'ommm= l
GNOMEUIINFO-MENU-FILE-TREE(fi1e-menu, NULL),
GNOMEUIINFO-MENU-EDIT_TREE(edit_menu. NULL),
GNOMEUIINFO-END
1:

Una vez que ha definido sus nieriús, puede crearlos empleando la

función gnome-app-create-menus, que tonla coi110 argumentos la
estructura de la aplicación GNOME y el apuntador hacia las estructu-
ras GnomeUIInfo que usted está usando para su barra de inenús. Eii
el ejemplo anterior, este apuntador fue el nombre del arreglo
menubar.A su vez, todos los elenientos que constituyen el arreglo
inenubar hacen referencia a un arreglo GnomeUIInfo para su nieriú:
358 1 Fundamentos de programación en Linux
-- - .

Proyecto 9-2: Menús Archivo y Editar

El programa que se crea en este proyecto implementa una aplicación
GNOME con dos menús y una barra de herramientas. Los menús Archi-
vo y Editar se implementan junto con una barra de herramientas que
cuenta con un botón Exit, como se muestra en la siguiente ilustración:
mymenu. c

File
-

4
Exit

Menu Example

Paso a paso
1. Defina dos funciones de retrollamado: copy-func y openfunc. En
este programa deben presentar un mensaje mientras que en un
programa completo realizarían operaciones de archivo y copiar.
.
2. Defina un menú Archivo con dos elementos, uno para abrir (Open)
y otro para salir (Exit). Cree en el menú Archivo un arreglo con el
nombre file-menu. Utilice la macro CNOMEUllFO para crear los
elementos del menú, que serán los elementos del arreglo file-
menu.
3. Defina un menú Editar con un elemento para copiar (Copy). Cree
en el menú Editar un arreglo con el nombre edit-menu. Use la
macro GNOMEUllFO para crear el elemento del menú, que será un
elemento del arreglo edit-menu.
4. Defina una barra de menús con dos menús: Archivo y Editar. Cree
en la barra de menús un arreglo con el nombre menubar. Use la
macro GNOMEUIINFO-MENU-FILE-TREE para agregar los menús
a la barra, convirtiéndolos en elementos del arreglo menubar.

5. Cree una barra de herramientas con un botón llamado Exit.

 --
Capitulo 9: GNOME ( 359

6. En la función principal, cree tres apuntadores para widgets: app,

button y label.
7. Defina la ventana Aplicación con la función gnome-app-new y
asigne la dirección de la misma al apuntador app. Utilice una
función gtk-signal-connect para unir un delete-event (clic en el
cuadro Cerrar) en la ventana Aplicación a la función gtk-main-quit,
para terminar el programa.
8. Cree un rótulo con la función gtk-label-new y asigne la dirección
al apuntador label. Ponga el rótulo en la ventana Aplicación con la
función gnome-app-set-contents.
9. Use gnome-app-create-menus para poner la barra de menús y sus
menús (menubar) en la ventana Aplicación (app).
10. Emplee gnome-app-create-toolbar para poner la barra de herra-
mientas (toolbar) en la ventana Aplicación (app).
11. Utilice gtk-widget-show-all(app) para presentar en pantalla la
ventana Aplicación con sus menús y barra de herramientas.
12. En la función gtk-main comienza un bucle infinito que revisa cons-
tantemente cualquiera de las señales unidas (como selecciones de
menú y barra de herramientas) y ejecuta sus funciones asociadas.
El contenido del programa mymenu.c se presenta a continuación:
-L

' #i ncrud: i;'iGin~. h>

s t a t i c v o i d copv-func (GtkWidget * h u t t o n , gpointer d d ~ a )
I
g - p r i r i t ( "Copy o p e r a t i a t i \ n " ) :
1

s t a t i c v o i d opeti-func (GtkWidqet * b u t t o n , gpointer data

l

GnorneUIInfo f i l e - m e n u C 1 = I
GNOMEUI I M F O ~ M E ~ l U ~ O P € ~ l ~ I T E M ( o ~ ~ NULL)
ennf~~nc, .
GNOMEUI INFO-MEMU-EXII-1 I E H [ g t k - m a i n - q u i t , N U L L ) ,
GNOMCU 1 1 NFO-END
1:
t - ---FA 1
GnomeUIInfo menubarCl = t
GNOMEUIINFO-MENU-FILE-TREE(fi1e-menu),
GNOMEUIINFO-MENU-EDIT_TREE(edit-menu),
GNOMEUIINFO-END
1;
GnomeUIInfo t o o l b a r C l
GNOMEUIINFO-ITEM-STOCK("Exit","Exit
-t the application",
k~gG
m
t,nM
~taqiuiOMEk_G
gm
t,nM
_taqiuOME_STOCK_PXIMAP_ESXT,)O
ICKKPXIMAP_EXT,)I
GNOMEUI INFO-END
i;
int
rnaiti(itit argc, char * a r g v [ l )
I
G t k l d i d g e t *app;
Gt!.Ni d g e t * b u t t o n :
GtkWi d g e t *l a b e l ;

gi-~ome-ii n i t ("inpnu-;ampl e " . " 0 . 1 " . a r g c . a r g v ) ;

/' C r e a t e a Gnomr app w i d q e t * /
app = grioiiic-app-new ("i.4enu-App", "My Gnorne Ht.tiu" ;
gtk-si gnal-c'tint.ct (GTK-OBJELT (app) , "del ete-event" ,
GTK-SIGNAL-FUNC ( g t k m a i n - q u i t ! . MULL):
1 a b e l = gtk-1 abel-new( "Meiiu Exampl e " ) :
gnoni~-app-set-contents ( GFlOME-AFJP ( a p p ) , 1 a b e l ;

/ * c r e a t e t h e menus and t o o l b a r * /
gnome-app-create-menus (GNOME-APP ( a p p ) , meniibar);
gnome-app-create-tool b a r (GNOME-APP ( a ~ ~ p t) o. o l b a r ) ;
gtk-widget-show-all(app1;
qtk-main O ;
r i t u r n 0;

Iconos de GNOME
La librería libgnoineui ofrece un amplio conjunto de iconos para
~isarloscon elementos del menú y barras de herraniientas. En la tabla
9-9 se presentan algunos de los iconos más comunei.Tambiin se
cuenta con los botones más utilizados para elernentos estándar como
los botones OK y Cancelar.
 Capítulo 9: GNOME

lconos de la barra de herramientas Descripción

#define CNOME-STOCK-PIXMAP-NEW "New" El icono Nuevo
#define CNOMELSTOCK-PIXMAP-OPEN "Open" El icono de archivo Abrir
#define CNOME-STOCK-PIXMAP-CLOSE "Close" El icono de archivo Cerrar
#define CNOME-STOCK-PIXMAP-SAVE "Save" El icono de archivo Guardar
#define CNOME-STOCK-PIXMAP-CUT "Cut" El icono de la operación de edición Cortar
#define CNOMELSTOCK-PIXMAP-COPY "Copy" El icono de la operación de edición Copiar
#define CNOME-STOCK-PIXMAP-PASTE "Paste" El icono de la operación de edición Pegar
#define CNOMELSTOCK-PIXMAP-UNDO "Undo" El icono de la operación de edición Deshacer
#define CNOME-STOCK-PIXMAP-RED0 "Redo" El icono de la operación de edición Rehacer
#define CNOME-STOCK-PIXMAP-PROPERTIES "Properties" El icono Propiedades
#define CNOME-STOCK-PIXMAP-PREFERENCES "Preferences" El icono Preferencias
#define CNOME-STOCK-PIXMAP-HELP "Help" El icono Ayuda
#define CNOMELSTOCK-PIXMAP-PRINT "Print" El icono lmprimir
#define CNOME-STOCK-PIXMAP-SEARCH "Search" El icono Buscar
#define CNOMELSTOCK_PIXMAP-BACK "Back" El icono del botón Atrás para el browser
#define CNOME-STOCK-PIXMAP-FORWARD "Forward" El icono del botón Adelante para el browser
#define CNOME-STOCK-PIXMAPLFIRST "First" El icono del botón Primero para el browser
#define CNOME_STOCKLPIXMAP_LAST"Last" El icono del botón Último para el browser
#define CNOMELSTOCK-PIXMAP-HOME "Home" El icono del botón Inicio para el browser
#define CNOME-STOCK-PIXMAP-STOP "Stop" El icono del botón Detener para elbrowser
#define CNOME-STOCK-PIXMAP-MAIL "Mail" El icono Correo
#define CNOME-STOCK-PIXMAPTRASH "Trash" El icono Papelera
#define CNOME-STOCK-PIXMAPTRASH-FULL "Trash Full" El icono de Papelera llena
#define CNOME-STOCK-PIXMAP-MIC "Microphone" El icono Micrófono
#define CNOME-STOCKLPIXMAP-CDROM "Cdrom" El icono Cdrom
#define CNOME-STOCK-PIXMAPABOUT "Abbut" El icono Acerca de
#define CNOME-STOCK-PIXMAP-QUIT "Quit" El icono Salir
Colección de iconos para menús
#define CNOME-STOCK-MENU-SAVE "Menu-save" Un icono del elemento Cuardar del Menú
#define CNOME-STOCK-MENU-REVERT "MenuLRevertn Un icono del elemento Reversar del Menú
#define CNOME-STOCK-MENU-OPEN "Menu-Open" Un icono del elemento Abrir del Menú
#define CNOMELSTOCK-MENU-CLOSE "Menu-Close" Un icono del elemento Cerrar del Menú
#define CNOME-STOCK-MENU-QUIT "Menu-Quit" Un icono del elemento Salir del Menú
#define CNOME-STOCK-MENU-CUT "Menu-Cut" Un icono del elemento Cortar de Menú
#define CNOME-STOCK-MENU-COPY "Menu-Copy" Un icono del elemento Copiar del Menú
#define CNOMELSTOCK_MENU_PASTE"Menu-Paste" Un icono del elemento Pegar del Menú
#define CNOME_STOCKLMENU_ABOUT"Menu-About" Un icono del elemento Acerca del Menú
#define CNOME-STOCK-MENU-PRINT "Menu-Print" Un icono del elemento lmprimir del Menú
#define CNOMELSTOCK-BUTTON-HELP "Button-Help" Un icono del elemento Ayuda del Menú
#define CNOME-STOCK-BUTíON-UP "Button-Up" Un icono de botón Arriba
#define CNOMELSTOCK_BUTTONLDOWN"Button_Down" Un icono de botón Abajo

l ~ a b l a9-91 Iconos más comunes para barra de herramientas, m e n ú y botones

362 1 Fundamentos de programación en Linux
En el programa anterior, para cl botón Esit cc usó un icono inuy
coniún. El iionibre de ese icoiio es GNOME-STOCK PIXMAP-
EXIT. Para una entrada en iiiia barra de iconos, se usa la inaci-o
GNOMEUIINFO-ITEM-STOCK.

Si desea utilizar iin icono coinúri para algo diferente a un objeto

GnomeUIInfo, usted necesita generar u11 widget para 61. Por eso,
eiilplee la fiiiición gnome-stock-pixmapwidget que toma como
argnriientos una dirección de una ventana y el nombre de un icono.
Usted pasa la dirección del widget de la ventana y la cadena que con-
tiene el nombre del icono. La siiitasis para la tuiicióii es la siguiente:

5-ug'e 7 ~ ~
e 7~~ li a
Si está creando manualmente elementos de menú, puede utilizar
gnome~stock~menu~item para crear un elemento de menú con
un icono especificado. Para los botones más comunes, puede usar
gnome~stock~buttons.

Para un menú, uckd usaría elemeritoc r' iconos iniu pquelios, que
tienen el t6rnlino MENU en ellos. Úwlos para el argumento dc dato,
del icono en las iiiacros del menú y del icono. Por ejeiiiplo, para la
entrada Copiar (Copy) el1 el menú Editar del prograiiia anterior,
podría eiiiple'~rla, iilstrucciones q u c ue preientan a contiri~i~ición,
t.11
donde GNOME-STOCK-MENU-COPY es un icono Copiar inis
peque" para usarlo en meriús.

Cuadros de diálogo
C o n las f~iiicionesde diálogo GNOME, usted puede crear fácilniente
cuadros de diálogo inodales y no modales. Aiinque estos últiinos
tienden a ser mis ainigables con el usuario, los cuadros de diálogo
 Capitulo 9: GNOME 1 363
modales son más ficiles de programar. Para crear uii cuadro de diálogo,
~istednecesita definir un widget GnomeDialog utilizando la f~inción
gnome-dialocnew. Esta f ~ i n c i ó tonla
~ i coiiio sus argunientos el
título del cuadro de diálogo y cualquier botóii que quiera presentar.
I'ara usar botones más coiiiunes, usted puede eiiiplear coino argumen-
tos cualquiera de las definiciones de GNOME-STOCK-BUTTON.

En u11 cuadro de diálogo iiiodal siiiiple, usted usa la fiincióii

gnome-dialog-run-and-close para ejecutar el cuadro de diálogo.
U n cuadro de diálogo iiiodal espera que el usuario haga clic en un
botón o en el cuadro Cerrar (Close) de la ventaiia. Después presentará
el número del botóii seleccioiiado (ó -1 para iin cuadro Cerrar).
Si usted tiene un cuadro de diálogo en donde el usuario necesita
hacer clic en varios botones, puede usar la fiiricióii gnome-dialogrun
que 1 1 0 cierra aiitoiiiáticariierite el cuadro de diálogo con el clic en el
priiiier botón. En cambio, presenta el níimero del clic del botón y se
iiiantieiie en pantalla. Usted puede utilizar dicho níimero para ejecutar
cualquier operaciónque haya asociado con el botón y después llaiiiar
de nuevo a gnome-dialoerun para el siguiente clic del botón.
Una manera efecti\~ade nianejar esta situación es poner gnome-
dialog-run r11 un bucle y salir del n~isinocuando el usuario haga clic
en un botón Quit o en iin cuadro Close. Ilesput.~,emplee la función
gnome-dialog-run para cerrar el cuadro de diálogo.

Gt,kWidget ' r n y d i a l o g :
i n t drex;
i n t dclose;
/*Create a new d i a l o g , Be sure t o i n c l u d e t h e NULL on the end*/
m y d i a l o g = gnorne-dialog-ncw("My D i a l o g " ,
GNOME-STOCK-BUTTON-OK,
GNOME-STOCK-BUTTON-APPLY,
GNOME-STOCK-BUTTON-CLOSE,
NULL) ;
364 1 Fundamentos de programación en Linux

g v -
dclose = 0:
while (dclose != 1 ) i
dres = gnome~dialog~run(GN0ME_DIALOG(mydialog)):
swi t c h ( d r e s {
case O : /* OK b u t t o n */
case 2 : / * Close button * /
case -1: / * Close box * /
dclose = 1:
break:
case 1 : / * Apply b u t t o n * /
g-print ("User pressed Apply");
break
1
1
/ * close dialog * /
gnome~dialog~close(GNOME~DIALOG(dlgl);
1

Para un cuadro de diálogo n o iiiodal, usted debe unir la señal del

clic con el cuadro de diálogo y darle a éste la f~iiicióride administrar
el valor mostrado para un botón en el que se hace clic. Usted usa la
f ~ ~ n c i ógtk-signal-connect
n para conectar la operación del clic
(clicked) con los botones de diálogo e n su ciiadro de dirílogo y el
resultado pasa a una función que usted define para administrar los
5
resultados.

También hay varios cuadros de diálogo especializados como cuadros

de nieimjcs, cuadros de diálogo de propiedades y cuadros de diálogo
d e archivo. U n cuadro de diálogo GnomeMessageBox f~iiicionade la
misma manera que L I I ~cuadro de diálogo GnomeDialog. Inicialmeri-
te, un cuadro d e diálogo se configura con un rótulo y uii icono deter-
minados por el tipo de meiisaje. Eii la tabla 9-10 se preientan los
diferentes tipos de cuadros de mensaje.
Usted crea u11 cuadro de rncnsaje empleando la fiinción
gnome-message-box-new, que toma coino argui~ientosel testo
del mensaje, después el tipo de cuadro y luego loi botones que usted
quiere presentar en él, siendo el últiino argumento NULL.
 C o n el cuadro de diálogo GnonieT'ropertyBos, usted puede crear
ca-jas de diálogo del tipo notebook para diferentes propiedades, opcio-
nes o configiiraciones de una aplicación. Este cuadro de diálogo tiene
páginas con tabulaciones en donde usted puede hacer cl'ic para presen-
tar en pantalla diferentes clases de propiedades. Usted puede crear un
cuadro de diálogo de propiedad con la fiincióil gnome- property-
box-new, que configura un iiotebook y cuatro botones: OK, Aplicar,
Cerrar y Ayuda. OK y Aplicar llainarán la fiinción que usted configure
para administrar las respuestas seleccionadas por el iisuario, también
conocida coiiio rrinncjndor. dc srln-&h. Además, O K cerrará el cuadro de
diálogo. Cerrar sinipleinente cerrará el cuadro de diálogo y Ayuda
llanlarlí la función ayuda que usted configura para este cuadro d e
diálogo. Usted puede agregar páginas a su cuadro de diálogo de propie-
dad empleando la f~incibiignome-property-box-append-page
que tonia con10 sus argumentos el núniero de la página y el rótulo.
Cada vez que el usuario hace un cambio en uno de los widgets del
cuadro de diálogo, usted usa la función gnome-property- box-
changed para marcar el cuadro de diálogo coi110 cainbiado. Esto da la
opción de que los botones Aplicar y OK llanieii al irianejador de
aplicar para activar los cambios.

Cuadros de mensaje Descripción

#define GNOME~MESSAGE-BOX-I~FO "info" Cuadro de Información
#define GNOME-MESSAGE-BOX-WARNING "warning" Cuadro de Advertencia
#define GNOMEpMESSAGE-BOX-ERROR "error" Cuadro de Error
#define GNOME-MESSAGE-BOX-QUESTION "question" Cuadro de pregunta
#define GNOME-MESSAGE-BOX-GENERlC "generic" Cuadro de mensaje genérico

Cuadros de mensaje

Entradas
Usted emplea los widgets GnomeEntry para ingresar testo, nonibres
de archivo, imágenes, iconos o datos numéricos. Estos widgets le per-
miten entrar una línea de información como las que se usan en los
forniularios. U n cuadro se presenta con un ciirsor en su interior e n
donde usted puede escribir su entrada. A la izquierda hay u n rótulo
366 1 Fundamentos de programación en Linux
-

para el cuaclro. Esta clase de widget también se conoce como iin cua-
dro d e tcxto.
El widget GnomeEntry se Lisa para contencr testo. I'riinero. iistcd
crea este widget con la hncióil gnome-entry-new, la cual toma
como argumento iina cadena de identificación para este objeto. U n
oljeto GnomeEntry contiene 1111 objeto GtkEntry que tiene el
texto real. Para niodificar el texto, usted tiene que emplear el apunta-
dor directamente hacia el objeto de testo GtkEntry;puede coiisegiiir
este apuntador iisando f ~ ~ n c i o n gnome-entry-gtk-entry.
es El si-
giiientc ejemplo crea uii widget GnomeEntry utilizaiido dos apurita-
dorei, myentry y mytextentry, para hacer refereiicia al widget misiiio
y a los controles del testo. I'riiiiero se definen los apiintadores
myentry y mytextentry. Despues, la función gnome-entry-new
crea un widget GnomeEntry y sil dirección se asigna a myentry.
Entonces, la fiinción gnome-entry-gtk-entry obtiene la dirección
del eleiiiento en el widget myentry que contiene el texto que el
iisuario eiitrará. Esta direccióii se asigna al apuntador mytextentry.
- - -
r ~ t k W % g e t" v i n t r y ;
GtkWidget * m y t e x t e n t r y ;
m y e n t r y = gnorne-entry-new("text1"):
rnytextentry = gnome-ent ry-gtk-ent r y ( GNOME-ENTRY (rnyentry) 1 ;

El widget GnomeFileEntry fiinciona col110 el wiclgt

GnomeEntry excepto en que t a n l b i h agrega un botón 13rowse y
aceptará una archivo que haya sido arrastrado desde el adiiiinistrador de
archivos. Usted crea iin widget GnomeFileEntry con la fiinción
gnome-file-entry-new. Emplee gnome-file-entry-gtk-entry
para obtener un apuntador para acceder al texto usado para el rioiiibre
de archivo. I'ara coiisegiiir ese texto, usted puede utilizar gnome-
file-en try-get-fiill-patli.
GnomePixmapEntry es otro widget de entrada de texto basado
en GnomeFileEntry. Presenta un cuadro preliminar para una iriiageii
seleccionada. Use gnome-pixmap-entry-new para crear una nueva
entrada y gnome-pixmap-entry-gtk-entry para acceder al objeto
GtkEntry. Usted puede usar gnome-pixmap-entry-get-filename
para obtener el noiiibre de archivo d e mapa d e piseles.
 C a p i t u l o 9: GNOME 1-
367

C o n el widget GnomeIconEntry, usted puede seleccionar y

presentas iconos. Sc basa en el widget GnomeFileEntry, y e n esencia,
agrega u n botón q u e niuestra u n icono.Al hacer clic e n el botón se
presenta una lista d e inxígenes del directorio d c esc icono. Use
gnome-icon-entry-new para crear una entrada para i i i i nuevo icono
y gnome-icon-entry-gtk-entry para acceder al objeto GtkEntry.
C o n gnome-icon-entry-get-filename usted puede obtener el
nombre completo del icono.
C o n el widget GnomeNumberEntry usted puede ingresar níime-
ros c o n doble prec-isión. GnomeNumberEntry esta integrado por
1111 widget GnomeEntry y u n botón q u e llaina u n cuadro d e diálogo
c.on una calculadora. El usuario puede emplear la calc~iladora,y el
resultado se iitilizará para actualizar la entrada del número. Usted usa
gnome-number-entry-new para crear u n cuadro d e diálogo d e
entrada d e núinero y gnome-number-entry-gtk-entry para acce-
der a Gtkentry. Use gnome-number-entry-get-number para
obtener el valor. P a n entradas d e números siniples, iisted usaría el
widget GtkSpinButton.
C o n el widget GnomePixmap, usted puede imnejar c o n facilidad
iniágciies. G N O M E emplea la libi-el-ía d e imigcncs Inilib q u e dispone
d e niiiiierosas fiinciones gnome-pixmap, las cuales operan coiiio
fiiiiciones d e alto nivel, pcrniitiendo q u e usted pueda n ~ a n e j a rficil-
niente imágenes sin t e n e r j i i e iiiaiiejar e n fornia directa las complejas
fiinciories d e Iiiilib. C o n la f~iiicióng n o m e ~ p i x m a p ~ n e w ~ f r o m ~ f i l e
iisted ~ x i e d ecargar iina iinagen y crear 1111 tvidg-et pixiiiap. El
g n o m e ~ p i x m a p ~ n e w ~ f r o m ~ f i l e ~ a trealizari
~ s i z e la inisnia opcra-
ción, pero le dará taniaiio a escala a la iinagen. Las fiincioiies
gnome-pixmap-load realizarán operaciones sobre u n widget
pisniap existente.

Canvas de GNOME
U n canvas e i u n ~ v i d g e td e trazado grifico m u y poderoso y ficil d e
iis,ir. Contiene soporte p r C igrifica5 Xlib y iumizado d e bordei. Ustcd
crea u n widget ccinvcisc o n la f ~ i n c i ó ngnome-canvas-new. D e b e
asegur'irse d c iitili~arel niapa viiu~ily d e color apropiado. I',ira cito,
368 1 Fundamentos de programación
- -
en Linux

usted puede usar gtk-widget-push-visual y gtk-widget- push-

colormap. Si quiere activar la opción d e suavizado de bordes, emplee
la f~iilcióngnome-canvas-new-aa para crear el widget canvas. Dicha
opción ofrece más capacidades de preseiitación eii pantalla que las
operaciones estándar. En el siguiente ejeinplo se inuestn la creación de
un objeto carivas para grríficas Iiillib.

gtk~widget~push~visual(gdk~imlib~get~visua1~~~;
gtk~widget~push~colormap(gdk_imlib~get~colormapO~;
canvas = gnome-canvas-new0;
gtk-widget-pop-visua10:
gtk-widget-pop-colorniap( );

Use la fuiición gnome~canvas~set~pixels~per~unit para coiifi-

gurar la escala del caiivas, gtk-widget-set-usize para especificar el
tamaño del widget y gnome-canvas-se-scroll-region para confi-
gurar la región por desplegar.
Para poner objetos en el caiivas, usted define objetos Gnome
CanvasItem y los ubica en grupos. El grupo predeterniiiiado es el
grupo raíz, al cual usted puede acceder con la funcióii gnome-
canvas-root. .
Usted crea un elemento del carivas con la f~incióiignome-
canvas-item. Esta fuiición tonia como su argumento al grupo padre
para el objeto y el tipo de objeto, seguido por varios atributos, como
ubicacióii y color, y el íiltirno argumento en NULL. Diferentes tipos
de objetos tendrán diferentes conjuntos de atributos. Por ejemplo, el
rectángulo que se rnuesti-a en el siguiente ejeniplo tiene dos conjuntos
de dimensiones x,y,junto con atributos de sombras y color.

1
-nva5 *inyfanvas;
GnomeCanvasItern * c i t e m l ;
cíteml = gnome~canvas~item~new(gnome~canvas~root(mycar~~~a~~,
GNOME-TYPE-CANVAS-RECT,
" x l " , 1 . 0 , " y l " . 1.0. " x 2 " . 23.0, " y 2 " . 20.0.
"fill-color". " b l u e " , NULL):
 Capitulo 9: GNOME 1 369
Para cambiar cualquiera de estos atributos, usted usa la función
gnome-canvas-item-set. Esta función toma como su primer argu-
mento el apuntador para el elemento del canvas, mientras que los
demás argumentos son los atributos, tal como los listaría para
gnome-canvas-item-new. Se dispone de numerosas funciones para
realizar operaciones en objetos, tales como la función gnome-
canvas-item-move que mueve un objeto y la función gnome-
canvas-item-hide para ocultarlo.

Prueba de repaso
¿Cuál es la manera fácil de crear entradas de menú para
un menú?'
¿Cuáles son las funciones que usted utiliza para crear
cuadros de d i á l o g ~ ? ~

O /
valuacron
1. ¿Cómo llama las 1i)erías de GNOME cuando compila un
programa en GNOME? ¿Cómo lo hace con los programas
en GTK?

2. ¿Se puede asociar más de una función con un objeto o señal

en particular?

I 3. ¿Qué función usaría para conectar un menú a una ventana?

4. i G N O M E ofrece operaciones para acceder a diferentes tipos
de datos?

7 Use las macros GNOMEUIINFO-MENU.

8 Las funciones gioiiir-dinlog.
Los objetivos de este G P í t d o son:
O Desarrollar interfaces de usuario KDE

O Compilar aplicaciones de KDE

O Aprender a implementar objetos gráficos de KDE, como ventanas y botones

Usar las librerías de Q t para administrar operaciones básicas

0 Programar la interacción de objetos usando slots y señales

Aprender a manejar objetos como menús, barras de herramientas y cuadros de

diálogo
 gramación en Linux
s*xM"\ 3

K DE (K Desktop Environment) está organizado en un modelo de

objetos en C + + con objetos en C++ que contienen funciones
con las cuales usted puede modificar el objeto. Muchas de las funciones
son heredadas de las clases de KDE de alto nivel, mientras que otras
están definidas para un tipo particular de objeto. En un programa en
KDE usted define un objeto y después usa sus funciones públicas y
privadas para modificarlo. Por ejemplo, puede crear un objeto de
menú y después emplear las funciones de dicho objeto para agregarle
nuevos elementos de menú. KDE utiliza la caja de herramientas de Qt,
desarrollada por Troll Tech (www.trolltech.com). Esta caja de herra-
mientas se usa en realidad para presentar y administrar objetos GUI,
como botones y ventanas. La caja de herramientas Q t opera de manera
muy similar a la caja GTK+ de GNOME.
Debido a que las aplicaciones en KDE son programas en C + +
orientados por objetos, emplean un conjunto de clases de objetos
organizados en forma jerárquica que se encuentra en las librerías
KDE y Qt. Las clases más bajas de la jerarquía heredarán nliembros
(funciones) de clases KDE predefinidas más altas, y usted puede crear
sus propias clases y heredarles funciones. KDE usa la Q t Toolkit y en
la actualidad se basa directamente en el1a.A diferencia de GNOME,
en donde las funciones de nivel más bajo las administra cualquier caja
de herramientas, KDE se basa de manera exclusiva en la Q T Toolkit.
Hoy en día, la progra'nlación en KDE es esencialmente progranlación
en QT.
La programación en KDE y en Q t se fundamenta en un amplio
número de conjuntos de clases, cada uno de los cuales tiene un núme-
ro significativo de funciones miembro que administran los objetos de
esa clase. Dentro de las limitaciones por el tamaño de esta obra, se
mencionan bastantes de estas clases. Para un listado completo de las
clases de interfaz de usuario en KDE, consulte la documentación que
se encuentra en developer.kde.org. Este sitio incluye tutoriales
detallados y materiales de referencia completos para la API KDE al
igual que documentación de KOM (KDE Object Manager) y material
de referencia de Qt.Todas las clases se describen en detalle y se dan las
declaraciones por tipo de clase, incluidas las declaraciones y definicio-
nes de sus funciones miembro. Además, consulte los archivos de cabe-
cera de KDE y Qt. Los archivos .h contienen un con~pletolistado de
 las clases de KDE y Qt, junto con comentarios detallados que descri-
ben sus funciones miembro.
U n widget, como una ventana o un botón, es sólo un objeto. Usted
puede definir un objeto de ventana usando una clase de ventana KDE
o Qt, o un botón con una clase de botón KDE o Qt. Existen diferen-
tes clases que puede utilizar, dependiendo del tipo de ventana o botón
que desee. Para crear un widget complejo, como una ventana que
contiene otros widgets (quizá barras de herramientas y menús), usted
definiría los subwidgets como hijos del widget principal. Cuando usted
define una barra de herramientas, especifica un objeto de ventana en
particular como el padre. U n subwidget puede, a su vez, tener sus
subwidgets propios, sus propios hijos. Por ejemplo, una barra de menús
puede tener una ventana como padre y menús individuales como hijos.
Cuando usted declara un objeto en C + + , usualmente incluye
argumentos, además de la clase y el nombre del objeto. Estos argumen-
tos se pasan a una función especial llamada constructor, que se ejecuta
cuando se define el objeto, con lo cual se realiza cualquier operación
de configuración o iniciación que resulte necesaria para el objeto.
Para los widgets, uno de estos argumentos suele ser la dirección del
widget padre. Por ejen~plo,una barra de herramientas se definirá con
uno de sus argumentos, que es la dirección de un objeto de ventana
que es el padre. Si el widget es un objeto de alto nivel que no tiene un
padre, el argumento es NOLL. Con una serie de definiciones de objeto
simple, usted puede crear con facilidad un widget complejo.

Librerías KDE
U n programa en KDE simplemente es un programa en C + + que usa
objetos cuyas clases están definidas en las librerías KDE y Qt. Usted
emplea el compilador g + + en sus archivos de código fuente como lo
haría con cualquier otro programa en C + + ; g + + es la forma en C + +
del compilador gcc de C. Existen varias librerías en KDE, cada una con
un extenso conjunto de clases. En la actualidad hay dos versiones de
estas librerías: la que corresponde a la versión KDE 1.l.y las de la
versión más reciente KDE 2.0. La mayoría de los programas necesitará,
por lo menos, las librerías kdecore y kdeui. Esta última contiene las
clases de la interfaz de usuario de KDE para los widgets de KDE
 rogramación en Linux
---m &

(véase tabla
10-1).La versión 2.0 de KDE también incluye la suite
KOffice. Para con~pilarprogramas que toman ventaja de los cornpo-
nentes de KOffice, se usan las librerías KOM.

Widget Descripción
DialogBase Una clase base que ofrece la funciona-
lidad básica necesaria para casi todos los
cuadros de diálogo.
La clase KDE Panel Applet.
La clase base de la cual se derivarán dife-
rentes widgets de iconos de autoriza-
ción que en realidad hacen algo.
KButton La clase que suministra botones activos
de presión que, al soltarlos, regresan a
su estado original.
Un widget contenedor para botones.
Botón que, al presionarlo, presenta en
pantalla o permite al usuario la selección
de un color.
KContainerLayout Un widget alternativo para manejar la
distribución.
KCursor Un wrapper QCursor de Qt que permite
contar con cursores "temáticos".
Un widget para seleccionar fechas.
Un cuadro de diálogo con soporte ex-
tendido sin modo.
KFontChooser Un widget para la selección interactiva
de fuente.
KCradientSelector Un widget selector de gradiente.
KlconLoaderButton Un botón que usa KlconLoaderDialog.
KlconLoaderDialog Un cuadro de diálogo para la selección
interactiva de iconos.
KKeyButton Un botón que, al presionarse, parece
como una tecla.
KLed Un widget redondo del tipo LED.
KLedLamp Un widget con lámpara LED y estilo CDE
(entorno común de escritorio).
Widget Descripción
KLineEdit Un widget de entrada de Iínea KDE.
KLineEditDlg Un cuadro de diálogo para que los usua-
rios entren una sola línea de texto.
KMenuBar Una barra de menú de libre ubicación.
KMessageBox Un práctico cuadro de diálogo
MessageBox.
KNumCheckButton Un tipo diferente de botón Verificar.
KPopupMenu Un menú desplegable que tiene como
primer elemento un título descriptivo.
KProgress Un widget indicador de progreso.
KRadioCroup Una clase para un grupo de botones
excluyentes en una barra de herra-
mientas.
Un widget de regla.
Un selector con valor unidimensional
con contenidos trazados por la clase
derivada.
KSeparator Un separador estándar horizontal o ver-
tical.
KStatusBar Un widget de barra de estado KDE.
KStatusBarltem Una clase interna para usar en
KStatusBar.

. Una clase interna para usar en

KStatusBar.
KTMainWindow Una ventana principal KDE de alto nivel.
KToolBar Una barra de herramientas de libre ubi-
cación con opción de autoajuste de ta-
maño.
KToolBarButton Un botón de barra de herramientas.
KToolBarltem Un elemento de barra de herramientas.
KToolBoxManager Una clase para el manejo propio de la
ventana.
Una ventana anterior de KDE de alto
nivel.
Un administrador unificado de la acción
de la interfaz del usuario.
QXEmbed Qt incorporado.
376 1 Fundamentos de programación en Linux

Aplicaciones y widgets de KDE

Para crear una aplicación 1<1lE, usted siiiiplemeiite crea un objeto del
tipo KApplication en sil prograiiia, antes d e que defina ciialquier otro
objeto d e KDE. LJ declaracióii de clase para KApplication Fe en-
c u e n t r ~eii el archivo kr~pp.ll.La definición de 1111 objeto d e KApplica-
tion toma como arguiiientos a argc y argv, que operan coiiio lo
liaceii en los programas en C, haciendo referencia a cualquiera de los
argiiiiientos de la línea de coniandos que el usuario ingrese. En el
siguiente ejemplo se define LIII objeto de aplicación Ilaiiiado myapp:

Las declaraciones para difereiitei clases de objjctos de KDE y Qt

están localizadas eii archivos de cabecera separados. Cada vez que
defina un objeto d e un tipo en particular, asegúrese de incluir el arclii-
vo de c'ibecera que ticne su declaración de clase. Por ejemplo, para
crear una veritaiia principal de la aplicación, usted usa la clase
KTMainWindow y necesita incluir el archivo klriininivirldu~ii.

.
Los archivos d e cabecera ta1iibit.n so11 de extrema utilidad co111o una
fuente de referencia, ya que ellos presentan en lista las funciones niiem-
bro para una clase en particular e incluyen conientarios detallados que
describen todas las fiinciones y su uso. Los archivos de cabecera se
ubicarán en el directorio includc d e KDE. En la actualidad, para R e d
Hat, el directorio irxliide estáiidar es /l,isr/incli.rde. Eii OpenLinus y otras
distribuciones puede ser el directorio especial d e KDE, c o i i ~ o/ o p /
kdc/includ~.
Para que usted defina una ventana principal para su aplicación,
emplee la clase KTMainWindow. En el sigiiiente ejeiiiplo se define
un objeto de ventana principal llariiado mywin.

m n d o w mywin; . -
 Capitulo 10: KDE 1 377
Si usted crea una aplicación en la cual la ventana principal es la
interfaz primaria, y qiiiere que la aplicación se cierre cuando se cierre
la ventana, tiene que hacerlo en el cvidget principal para la aplicación.
I'ara hacer esto, usted utiliza la fuiición setMainWidget del objeto de
aplicación. El widget principal podría ser cualquier widget que desee.
Asegíirese de pasar la direccibn del widget; para ello, debe aiiteponer el
operador de dirección: el signo de ampersand (&). En el siguiente
ejemplo se establece el widget principal para la ventana mywin. Se
pasa la direccióii del widget mywin: & mywin.

lidget, como en el progra-

ma ae los elempios que se presentan más adelante en este capítu-
lo, solamente n'ecesita pasar el apuntador, sin usar el operado
1
dirección. Un apuntador ya contiene la dirección.

Cuando define un widget, tanibibn estará definiendo cualquiera de

sus fiinciones miembro que se encuentran en su declaración de clase.
.
Consulte la docuii~entaciónde developer.kde.org para obtener una
descripción coiilpleta de todas las declaraciones de clase de KDE,
incliiidas las fiinciones miembro. Muchas de esas funciones están dise-
ñadas para permitirle cambiar las características de presentación en
pantalla de un widget, coino su color o tamario inicial. Por ejemplo,
para controlar el tamaiio de presentación del widget KTMain-
Window, usted usa la función setGeometry, coino se muestra a
continuación:

Usted tiene que dar instrucciones explícitas a ICDE para mostrar

cualquier widget que desee presentar en pantalla. Para h;icerlo, utiliza la
inieiiibro show de su widget. Por ejemplo, para preientar la
f~iiiciói~
ventana mywin, uitcd ejccuta la f~iilciónshow, como se prewnta aquí:
378 1 Fundamentos de programación en Linux
-- - .-

Una vez que ha definido todos sus cvidgets y ha hecho las niodifica-
ciones correspondientes, puede hacer fiincioii~rla aplicación. Para ello
utilice la f~inciónexec del objeto de KApplication:

Cuando el usuario cierra la aplicación, el control regresa a la f~iil-

cióii principal, la cual puede terminar (i1 prograina. Usualmente, el
enuiiciado de retorno coi1 la f~inciónexec contendrá cualquiera dc los
errores que exec pueda presentar.

En el siguiente progranla se crea una aplicación KLIE sencilla que

presenta en pantalla una ventana. En la figura 10-1 se inuestra la venta-
na de este programa.

#i ncl u d e <ktmainwi ndow. h>

int main( int a F g c , c h a r **argv )e--Define aplicación
I
I
iiiyapp
K A p p l i c a t i o n mv?pp( a r g c , a r g v 1: --
KTMai nWi n d o w mywi n :
1
niywin.setGeometry(100.100.200.100)
Define ventana inywin
myapp.setMainWidgetí&mywin);
mywin.show0;
return m y a p p . e x e c 0 ;
1 -
 Capitulo 10: KDE 1 379
Prueba de repaso
¿Los programas e n KDE están escritos e n C++?'

¿Qué clase se utiliza para definir la ventana principal d e

una aplicación?'

íi

Ventana en KDE

1 1 -
YU I I V U L/I I V r / W A
Y V I W V d

P Pregunta: ¿Cómo puedo compilar un programa en KDE?

Preaunta: ;Oué
*. .
basa si amrece el error de aue el c o m ~ i l a d o rn o
pudo encontrar un archivo de cabecera (.h)?
J

Respuesta: Usualineiite, esto significa que el coiilpilador n o sabe en qué

, . .. . . , ----
s.. - .
parte de su sistema estdn localizadas las Iibrenas K U b o Vt. I'uede usar la
opción -1 para especificar un directorio para archivos de cabecer~,y la opción
-L para especificar el directorio que contiene Ias librerías. Por ejemplo, si sus

1 - Iloptlkdelincl u d e 1

1 Sí.
2 KTMainWindow.
380 1 Fundamentos de programación
---
en Linux

clon a e arcnivos a e cabecera y mreriasc

Respuesta: Si, muchos sistemas tendrin que configurar las v'lriables de shell
KI)EI>II< y QTDIK. La primera de ellas contiene los nombres de la ruta para
los comandos KDE. cabeceras v librerías, mientras que QTIJIR coritet-idrá los
nombres de ruta para Qt. Para especific;~ r los archivos de cabecera para KDE,
usted usará la siguiente opcióri:
-I/$KDEDIR/include
a -..-' :.--t..:- ..1 -:
= ~KDEDIR. Si egta variable de sliell
..l. C
C l u C l u l r CI S I ~ "9 a l ~ de
~ S C ~ L I I C SUT

no eitrí definida, puede hacerlo asignando el titio (si lo cabe) de los coinpo-

k11 Ked Hat Liriux, las librerías de Q- t para

- la versión 6.0 se encuentran en
el directorio /usr/lib/qi y las librerías de KDE están niezcladas con otras
librería5 en el directorio /usr/lib. Usted rio tendrá que especific.ir una librería
. - -- .- . . .. . . .'. . . - . -. . .
de KlJh; y. para Qt- especihcara rl directorio /risr/lrh/ql. kii la actualidad,
Caldera Operitinux, jiinto con otras distribuciones, define Ias librerías d e
KDE en el directorio /opt/kdc.
k n el siguierlte ejemplo, las Iibrerias de KLIk y de V t estan esyeciticadas en

gtt - IBKDEDIR/include -L$KDEDIRJl i b -IbQTDIR/include -L$QTDIR/li h s

.
Pregunta: iCómo co&guro las especificaciones de esta librería
y este directorio en un archivo de compilaciÓn?
Respuesta: Recuerde que un archivo de cornpilacióii está coiifigurado para
compilar un programa compuesto de varios nrchivos con códigos fuente
..? -. . 8 . , .
diferentes. Iodos los archivos se conipilan por sep~radoy, despues, las veriiories
campiladas se coiiibinan rnediarite el encadenador (Linker) en urr arcliivo de
aplicación que se puede ejecutar. Para conipilar los arcliivos en código f~ieiite,
necesitar5 especificar los archivo5 de cabecera, como se iiiuestra aquí:
g++ - c - I $ K D E D I R / i n c l u d e -1BQTDIR m a i n . c p p
Para crear tina aplicación con el encadenador, debe especiticar el directorio
de la librería de KDE y especificar las librerías de K1JE que desee usar, junto
con la librería de Qt. En este ejemplo se utilizan las librerías kdecore y kdeui.
Ellas son la librería iiúcleo de KIIE y la libreria de la iriterfaz de usuario de
VI\E f-l.
nuLi. V C
..- l . 1:l. -,...:-2.-
c5 l a U U I C I ~ C LIC
I
<3&
VL.

g++ -1iBKDEDIRllib -1BOTDIRllib -1kdecore -1kdeui -1qt - o myapp mait1.0 mydata.0

Señales y slots
KDE y Q t usan señales y slots para permitir que un widget se coniuni-
que con otro. Señales y slots son funciones niienibro definidas en una
clase que tienen capacidades especiales. U n objeto emite las señales
cuando se activa con algún evento que ocurre en él. Por ejemplo,
cuando un usuario hace clic en un objeto de botón, éste emitirá una
señal clicked que podrá recoger otro objeto configurado para recibirla.
U n objeto de esa clase tendrá slots diseñados para recibir la señal. U n
slot es una función niienibro que se ejecuta cuando el objeto recibe
una señal determinada.
En efecto, los slots funcionan como manejadores de eventos y las
señales se pueden considerar conio eventos; sin embargo, KDE y Qt no
operan conio GUI estándar dirigidas por eventos. Por el contrario, el
proceso del nianejo de eventos se iniplenienta cuando se envían nien-
sajes y los reciben objetos. En vez de concentrarse en el procesaniiento
de un evento cuando éste ocurre, los objetos manejan sus propias tareas
de eventos cuando éstos se presentan, sea recibiendo o enviando seña-
les. U n widget de KDE emite una señal cuando ocurre un evento en él
o cuando cambia de estado por alguna razón. Existen varias señales
posibles; entre las más comunes están las de activated y clicked. Así,
cuando se presenta una señal activated en un widget de un eleniento
del menú, la función de procesamiento ejecutará la función correspon-
diente para ese eleniento. Por ejemplo, dada una ventana con un menú
que tiene un eleniento Exit, cuando un usuario hace clic en dicho
eleniento en el menú Archivo deberá ejecutarse una función para salir
del progrania. El eleniento Exit eniite una señal que, entonces, recibe el
objeto de ventana principal, el cual ejecuta la función slot asociada
con el eleniento Exit.
La conexión entre la señal que eniite un objeto hacia una función
slot en un objeto que la recibe se crea con la función connect del
objeto, la cual configura una conexión entre una determinada señal en
un objeto dado con una función específica del slot en otro objeto. Su
prinier argumento es el objeto, el segundo la señal y el último es la
función de retrollaniado. Para especificar la señal, usted asigna la niacro
SIGNAL en el nonibre de la señal, con los parámetros respectivos.
Para la función del coniando de contestador de llamado, usted usa la
niacro SLOT. Con las operaciones connect también puede conectar
-1 Fundamentos d e p r o g r a m a c i ó n en Linux
-
382

una seíial a varios slots y varias seiiales a un solo slot. En el siguiente

ejemplo, la sefial clicked cii el objeto buttonhi cstrí concct~da1' la
fiinción del slot rnyhello en cl objeto niywin:

Objeto al que se hace referencia

cuando se presenta la señal

la señal

Las clases coiupiiestas por varios ~vidgets,conio la ventana de una

aplicación, con fi.ec~iciiciatendráii coiiesiones desde las señales de los
difereiites widgets hacia el widget principal. Las operaciones connect
iisualn~eiitese sitúan con la declaración d e clase del widget principal
para conectar seíiales desde siis subwidgets hacia sí misino. En este caso,
el widget principal (objeto) se puede hacer referencia con la referencia
del apuntador this de C++, el cual siemprc alude a la clase que se va a
declarar, como se mueitra a coiltiniiación:

1cut75tyúo- -
Cualquier clase q u e incluya slots o señales también debe incluir una
referencia especial denominada QOBJECT. Esto permite q u e el
preprocesador del compilador de metaobjetos (que se describe a
continuación) configure cualquiera d e las señales y slots declarados
e n la clase. . -- 7

Compilador de metaobjetos: MOC

Auiique el código para ingresar fuilciones d e seiíalei y de sloti, lo
mismo que para hacer lai conexionei, puede parecer siii~plep x a el
programador, en realidad req~iiereiina codificación en C++ mis
coinpleja. El conipilador d e nictaobjeto~( M O C , por Meta-Object
Compiler) debe procesar previamente las funciones de señal y slot para
generar el código en C + + que puede inlplementar el proceso de
conexión del nlensaje entre la señal y el slot. Después, usted puede
incluir el resultado del M O C en su archivo de código fuente para
conipilación. Esto significa que debe poner en archivos de cabecera
separados las declaraciones de clase para cualquier clase que tenga
señales y slots. Luego, puede procesar previamente estos archivos de
cabecera e incluir el resultado en el código fuente.
Usted no puede combinar las definiciones de la función miembro
con la declaración de clase. Para compilar, el M O C primero tiene que
procesar la declaración de clase antes de que se pueda combinar co-
rrectamente con las definiciones de la función miembro. Para esto se
necesita ubicar la declaración de clase en un archivo separado de las
funciones niiembro, de manera que el M O C pueda hacer el procesa-
miento previo y por separado de la declaración.
En la tabla 10-2 se presenta la lista de las diferentes opciones del
MOC.

Opción Descripción
-o archivo Escribe la salida en archivo y no en STDOUT
-f Obliga a la generación de un enunciado #include en el
resultad% Esta opción sólo es útil si usted cuenta con ar-
chivos de cabecera que no sigan las convenciones
estándar de asignación de nombres.
-1 No genera un enunciado #include en el resultado. Enton-
ces, usted deberá pasar #include al código metaobjeto en
el archivo .cpp.
-nw No genera ninguna advertencia.
-Idbg Escribe información depurada de lex en STDOUT.
-d bg Trata todos los miembros que no son señales como slots,
para los propósitos de depuración interna.
-p path Hace que el MOC anteponga path/ al nombre de archivo
en el enunciado #include generado.
-q path Hace que el MOC anteponga path/ al nombre de archivo
de los archivos #include en Qt, en el código generado.
384 1
7
Fundamentos de programación
-
--
en Linux

Para declarar una clase que contiene sellales o slots, priniero debe
declarar la clase en u11 archivo de cabecera conlo rriyo.j.li. Usted n o
pone las definiciones de ningiina de las fiinciories niienibro en el
archivo de cabecera, sino solamente la declaración de la clase. Observe
que esa dcclaracióii incluirá declaraciones de las fiinciones niienibro,
estructiiras y variables. En un archivo de código f~ienteseparado usted
pondri la definición de las funciones miembro, como irr)whj.(pp. La
definición de una función niienibro es el código actual para la fuiicióri.
Para que estas defiiiiciones queden compiladas correctamente, tiene
q ~ i eincluir la versión procesada previaniente por el MOC: de la decla-
ración del objeto y no la declaración real propianiente dicha. Para
generar las versiones que el M O C Iia procesado previamente, usted usa
el arcliivo de cabecera d e la declaración de clase y el coinaiido m o c ,
coiiio sigue:

En el archivo particular del código fiiente, en donde usted está

definiendo f~incionesinieinbro para este objeto, incluirá la versión
M O C del arcliivo de cabecera que contiene la declarnción del objeto, y
n o el archivo d e cabecera niisiiio. I k modo que e n el archivo de
código fuente r r i ) d j . c ~ qusted
) incluirá iri)d,j.nzol-,y no nr)lobj.li.
Sin embargo, para cualquier otro archivo de código f~ienteen el
cual esté generando un objeto de esa clase, por ejemplo con una ope-
ración new, usted sólo incluye el archivo de cabecera y n o el archivo
M O C . D e manera que para cualquier archivo de código f~ienteen
donde usted únicaniente necesite la declaración de clase, incluye el
archivo de cabecera, tal con10 nr)lo6j.h.
Por ejemplo, suponga que en el arcliivo rrtain.cyy se genera como
una variable un objeto myobj, mientras que en un archivo n i ) d j . r p y
hay definiciones de f~incionespara f ~ ~ n c i o n niiembro
es de la clase
myobj. Además, suponga que la definición de clase para myobj está en
el archivo de cabecera rrr)~l~j.lr y la versión M O C de myobj.h está en el
archivo myohj.nroc-.En el archivo m a i r i q p , usted incluirá el archivo
nqlo4j.h (no m)wbj.rrioc),pero en el archivo rrr)lobj.rpp incluiría el archivo
1 ~ p 6 rrwc
j . (no ~ ~ r p h1 2 )j. .
 Capítulo 10: KDE
.- -

& 30
Proyecto 10-1: Una ventana KDE
hellowin.cpp es un programa simple que presenta en la ventana princi-
pal un botón y después un cuadro de mensaje con "Hello World" cuan-
do se hace clic. La clase Hellowin tendrá dos slots declarados: myhello
.
he11owi n cpp
(para presentar el mensaje) y myexit (para salir del programa). La
declaración también deberá incluir QOBJECT, que es un objeto especial
que usa KDE para conectar los objetos de la barra de herramientas de
QT. La declaración para Hellowin se pondrá en el archivo de cabecera
hel1owin.h y todas las definiciones de la función miembro se ubicarán en
el archivo hellowin.cpp.
Para compilar este programa, debe procesar previamente el archivo
de cabecera hel1owin.h con el MOC. Después, puede compilar el archivo
hellowin.cpp. Observe que este archivo deberá incluir el archivo
hellowin.moc y no el archivo hel1owin.h. Las operaciones de compilar se
muestran a continuación:

compilador g++ de C++

'moc -o ~ e l 1 o w i n . m ~ l o w i n .
g++ - 1 kdecore - 1 kdeui - 1 q t - o he1 1 owi n he1 1 owi n . cpp

Dependiendo de su sistema, es posible que necesite especificar la ubica-

ción de las librerías de KDE y los archivos de cabecera que, por lo co-
mún, se encuentran en un Elirectorio de KDE especificado en la variable
del sistema, KDEDIR. Use la opción -L con el directorio /lib para especi-
ficar las librerías, y las opciones -1 con el directorio /include para los
archivos de cabecera, como en -L$KDEDIR/lib y -I$KDEDIR/include. Si
KDEDIR no se configura, entonces verifique con el administrador de su
sistema o con su manual de distribución Linux, la ubicación de las
librerías de KDE y los archivos de cabecera. Un ejemplo de la operación
de compilación que especifica la ubicación de los directorios include y
lib de KDE, se presenta a continuación:
 e programación en Linux

Nota
: Una mejor forma de organización sería poner las definiciones de la
función miembro en uno de sus propios archivos de código fuente
separados, dejando la función principal en su propio archivo de
código fuente. En este caso, usted incluirá hel1owin.h con la función
principal y hellowin.moc con las definiciones de la función miembro.

El objeto KMsgBox manejará la presentación del mensaje "Hello

World". Esta clase implementa un cuadro de diálogo simple con mensa-
jes y varios botones, si usted los desea. Además de un cuadro de diálogo
con un mensaje simple, KMsgBox también soporta cuadros de diálogo
con botones Sí y No, y con botones Sí, No y Cancelar. Asegúrese de
incluir kmsgb0x.h. Para cuadros de diálogo Acerca de, usted puede usar
KaboutDialog.

Paso a paso
1. Cree el archivo de cabecera hellowin.h, que contendrá la definición
de clase para la clase Hellowin.
2. Incluya archivos de cabecera que contengan definiciones de clase
para objetos como ventanas, botones y cuadros de mensaje. En este
caso, incluya el archivo de cabecera para la ventana principal,
ktmainwindow; para un botón, use qpushbutt0n.h y para un cuadro
de mensaje, kmsgb0x.h.
3. Defina la clase Hellowin, derivada de la clase KTMainWindow. Dé a
la clase Hellowin dos slots (funciones) llamadas myhello y myexit.
Defina dos apuntadores para botones: buttonhi y buttonExit.
4. El archivo myhello.cpp mantendrá el programa principal. Comience
por incluir archivos de cabecera y el archivo hellowin.moc, el cual
debe generar por separado el preprocesador MOC.
5. Defina una función constructora para la clase Hellowin,
Hellowin::Hellowin. Cuando se define un objeto de esa clase, esta
función se ejecuta automáticamente.
6. Cree un objeto de botón usando QPushButton y asígnelo al apun-
tador buttonhi. Determine el tamaño y después preséntelo en
pantalla. Se conecta al slot myhello de modo que cuando se haga
clic en él, se ejecuta la función myhello.
 --
Capitulo 10: KDE 1 387
7. Cree otro objeto de botón usando QPushButton y asígnelo al
apuntador buttonExit. Determine el tamaño y después preséntelo
en pantalla. Conéctelo al slot myexit de modo que cuando se haga
clic, se ejecute la función myexit.
8. Defina una función closeEvent para la clase Hellowin. Esta función
simplemente terminará el programa llamando la función kapp-
>quit.
9. Defina la función myhello para la clase Hellowin. Esto presentará
en pantalla un cuadro de mensaje separado con el mensaje "Hello
World".
10. Defina la función myexit para la clase Hellowin y determínela para
cerrar la ventana Hellowin.
11. En la función principal, defina una KApplication llamada myapp.
Defina un objeto Hellowin llamado mywin. Después, determine el
tamaño del objeto.
12. Use la función setMainWidget para myapp para situar el objeto
mywin en la ventana principal de la aplicación.
13. Emplee mywin.show para mostrar esa ventana.
14. Use myapp.exec para operar la aplicación.

El código para el archivo hel1owin.h se muestra a continuación. En la

figura 10-2 se presentan laventana principal con sus botones Exit y
Hello y la ventana hello que muestra este programa.

--

[ ~ i ~ u r1 a0 4 Ventanas y botones de KDE

388 1 Fundamentos de programación en Linux

- -
7iincciu <kápp.hj .
'-

Binclude (ktmainwindow,h>
# i n c l ude (qpushbutton. h>
# i n c l ude (kmsgbox. 11)

c l a s s H e l l o w i n : pub1 i c KTMainWindow
I
0-OBJECT
public:
Hellowin O:
v o i d c l oseEvent(QC1oseEvent * l ;
public slots:
void niyhello0;
void m g c x i t 0 ;
private:
12PushButton " b u t t o n h i ;
dFiishButton " b u t t o n E x i t ;
I;
El siguiente es el código para el archivo hellowin.cpp:

#ii i c l ude ( k t ~ a i n w ndow.

i h>
#i r i c l ude (qpiicllbi~tton.h>
i i i n c l ude "he1 1o:iiin.moc"
ilinclude (kmsgbox. h>

H e l l o w i n : :He1 1owi [n, ! : KTlld

{
bu t t ori h i = nei! QPushButtin( " H e l l o " , t h i s ) ;
b u t t r i i ~ ih - > r ~ t G e o m ~ t r y ( 4 5 , ,50,25);
30
b u t t o i i l i i -::51iow( 1:
conrvc t(b11t konhi , SIG!lhL(cl i c k e d ( 11, t h i s , SLOT (myhel l o ( 1 ) ) ;

b u t t o n E x i t = new QPushButton( " C x i t " , t h i s ) ;

b u t t o n E x i t->setGeometry( 105,30,50,25) ;
b u t t o n c x i t - > s h o w ( 1;
connect(buttanExit, SIGt~!AL(clickedO), t h i s , YLOT(inyexit0)):
1 '
 Capitulo 10: KDE 1 389
F .
vnid H e l l o ~ ~ ! i n : : m y h ~ l l o O

KMsgBox: :message(O. "Important ","He1 l o World!" 1:

v o i d Hello!.iiri::niyexitO
1
cl ose( 1 ;
I
i n t m i n ( i n t a r g c , char **argv
1
K A p p l i c a t i o n myapp ( a r g c , argv, " H e l l o W o r l d ! " 1:
He1 1 o ~ ! ni myk;i n;
m y i n . setGeometry( l 0 0 , 1 0 0 , 2 W , 1 0 0 ~ ;

Menús
Para crear i~ieiiús,usted crea una barra de nieiiíis dc KDE y desput.5 lc
agrega iiieriús Q t con los clciiieiitos correspondientes. Necesitará
incluir el archivo de cabecera c l p o p i ~ ~ ~ / i ~para
c r ~ ~los
~ . nienús
li y el archivo
de cabecera kiireri~rl~nr.lr
para la b'irra de nieníi, como se muestra a
contiiiuacióii:

Después, usted definc un objeto de barra de iiieníi, o iin apuntador,

y hace lo niisino para sus menús. La clase para una barra de menú es
KMenuBar y para u11 nie~iíies QPopupMenu. En el siguiente ejeiii-
plo se definen apuntadores para una barra de nieníi y iin iiieiiú:

Define un apuntador para un tipo

de objeto KMeriuBar-
--y . ---- -
QPopupMenu * m y f i l e r n e n u ;
 1
- Fundamentos de programación
390 - - - . en Linux
.-- -

Si usted definió apuntadores, puede crear los objetos de nienú y

barra de menú con la operacióii new, conio se presenta aquí. KMenu-
Bar toma conio arguiiiento a su padre. Cuando se define iina claie
conio una ventana, en donde usted quiere que la clase misina sea el
padre, use el apuntador this.

[crea un objeto KMcriuDar

i
2y asigna su dirección a
" myniefiuba r = n
.
1
m y f i l e m e n u = new QPopupMenu;

Entonces, usted puede agregar el nieníi a la barra de incnú con la

f~incióniiiieinbro insertItem de la barra de menú. El priiner argu-
niento es el rótiilo que usted quiere presentar en la barra de ineiiú para
el nienú, y el segundo argiiinento es la dirección del objeto d e nienú.
El siguiente ejemplo agrega myfilemenu a mymenubar:

l~nsertaun menú Archivo en la barra de menú 1

Ilespués de agregar eleinentos a u n nienú en particular, einplee la

función inieiiibro imertItem del objeto de inenú. Su priiner argu-
niciito cs el rótiilo que usted quiere presentar en pantalla para el ele-
mento y los dos argulneiitos siguientes son referencias para una
fuirción de slot que se ha de ejecutar cuaiido el eleinento eiiiita iina
seiíal (esto es igiial a los arguiiientos de slot en la f~inciónconnect). El
segundo arguniento para insertItem es la dirección del objeto que
contiene la fiincióii del slot y el tcrcer arguniento es la fiinción del slot
que se ha de ejecutar en ese objeto.
En el siguiente ejemplo se crea un elemento Esit en el menú
myfilemenu y se conecta a la fuiición del slot myexit en el objeto
corriente (iiidicdo por el apiintador this):
Función que se va a ejecutar
 Capitulo 10: KDE 1 391

Barra de estado y barra de herramientas

La barra de estado de KTIE es KStatusBar. Para crear una barra de
estado, usted crea un objeto KStatusBar y asigna la direccióii a un
apiiritador que desee usar para hacer referencia al objeto. KStatusBar
toma conio argumento la dirección de su padre. Eii el siguiente ejeni-
plo el padre es la clase que se está defiriieiido, 1' la cual se lince refereii-
cia con el apuntador especial this (coiiiúiiiiiente usado para
subwidgets).

--
Para fijar el texto que usted quiere preseiitar iiiicialnieiite en la barra
de estado, use el inétodo insertItem de la clase KStatusBar. Éste
toma conio primer argumento el texto que usted quiere presentar y
coiiio segundo argiiiilento un identificador. Para cambiar el iiiensaje de
la barra de estado, eiriplee la f~inciónchangeItem.
- - -

s t a t u s b a r - > c h a n g ~ I t e m ( " M y New H e l l o P r o g r a m " , O ) ;

P x a unir 1'1 barrd dc estado al objeto de veritm'i, use la f~incióil

setStatusBar dc la c l KTMainWindow.
~ Ésta toma como argii-
iiieixos la dirección del objeto de barra de estado y iiri identificador.

Después, para presentar cii pantalla la barra de estado, utilice la

f~iiicióiishow.

Para crear una barra de lierrariiientas, usted define uii objeto

KToolBar, asig~iandosu direccióii a un apuntador que desee usar para
hacer referencia al objeto. En este ejeiiiplo, el usuario crea 1111objeto de
barra de herraniientas y asigna si1 dirección a mytoolbar:
-
mytool b a r =- n e w ~ ~ o o í ~ a r i t1 ;h i s -
392 1 Fundamentos de programación
- ..
en Linux

Para una barra d e herrainieiitas, uited tanibién debe ~diiiinistrarloi

icoiios que quiera usar cil ella. Para cargar iconos, use un objeto
KIconLoader, que puede crear con un iiiétodo getIconLoader,
coino se muestra a contiil~iacióix

El objeto KIconLoader cargara y llevará J 1,i meiiioria cachb loi

icoiloi de Id barra de herrainieiitai, buscáiidoloi cil directorioi de
iconos de I W E especificado\.AsegÚreie de incluir el archivo d c
cabecera kicorllnadcc 11.
Para agrega- un botón a la barra de herraiiiientas, emplee el iilétodo
insertButton que toiiia como su piirner arguiiicnto el icono que
uited quiere usar p x a el botón. I'ara este arguineilto, tiene que cargar
priiliero el icorio que usa el iiiktodo loadIcon del objeto KIcon-
Loader. Este inktodo to111~como su q u i i l e i l t o el rioiribre de xchivo
del icorio. En el iiguieiite cjcniplo se carga el archivo para el icorio
Exit:

El seguiido argumento ei el ideiltificador de coiiiando, el tercero ei

uii indicador que señala si el botón esti activado y el último es el texto
de ayuda seleccionado. En el siguiente ejemplo se agrega un botón Exit
a una barra de Iierramieiitas con la fraie "Esit program".

" Exi t Program" ;

Resulta útil permitir soporte internacional mediante el enrollamiento

del texto de ToolTip en la función klocale->translate, como:
klocale->translate("Exit Program")
 .-
Capitulo ~ oKDE
: 1 393
I'ai-J coiiectar 1111 icoiio eii la barra de hcrrainieiitai con iina fiiiicióii
de slot del objeto, iisted eiiiplea la fiiiicióii addconnection del objeto
de barra de hcrraiiiientas, qiie toma coino primer ,irguineiito el identi-
f i a d o r del icoiio en la b~rr'ide herraiiiiciitas. El icleiitificador es el
iiúinero que usted usó coino seguiido argiiineiito con la fiiiicióii
insertButton ciiaildo agregó el icoiio J la barra de herr'~inieiitas.Los
'lrgiiiiientoi restantes so11 siinilnrci a los de la fiiiicióii connect: la wial,
cl objeto qiic contiene la fiincióii dcl ~ l o yt la fiiiicióii del slot.
>r. -------m--

mytoolhar->;iddConn~cticin(D,~ I G N ~ u c thfs,
~ O S) L,O T ( m v ~ x i f 0

Utilice iina operación insertButton para cada botón que quiera

agregar. Una vez qiie haya aiíadido un botón, eniplee la f~incióii
addToolBar del objeto KTMainWindow para agregar la barra de
herramientas a la veiitana. Después, use la f~iiicióiisetBarPos del
objcto de barra de herrainieiltas para ubicarlo y el inétodo show para
preseiitarlo en pantalla.
-+-. -
addTool B a r ( tool bar) :
toolbar->setBarPos(K
tool bar->show( 1 ;

Prueba de repaso
¿Qué función utilizaría para crear un elemento en un
menú?3

Proyecto 10-2: Menús y barras

de herramientas de KDE
Este proyecto ilustra el uso de widgets complejos. El programa
he11owi n2. cpp hellowin2.cpp crea una ventana con una barra de herramientas, menús y

- -

3 ín\~wItc~111
4 Una función iiiieinbro en un objcto, diseñada para qiie se ejecute cuando el objeto recibe
iina señal especificada.
 ramación en Linux
w wq-w "
.
"
=
e

una barra de estado. La barra de herramientas tendrá dos iconos, uno

para salir del programa y otro para presentar en pantalla el mensaje
"Hello World". La barra de estado presentará una descripción del pro-
grama y la barra de menú tendrá un menú Archivo con entradas para
presentar el cuadro de diálogo "Hello World" y también para salir del
programa.

Paso a paso
1. Cree el archivo de cabecera hel1owin.h que mantendrá la definición
de clase de la clase Hellowin.
2. Incluya archivos de cabecera que contengan definiciones de clase
para objetos, tales como ventanas, botones y cuadros de mensaje.
En este caso, incluya el archivo de cabecera para la ventana princi-
pal, ktmainwindow.h; para un botón use qpushbutt0n.h y para un
cuadro de mensaje, kmsgb0x.h.
3. Defina la clase Hellowin a partir de la clase KTMainwindow. La
clase Hellowin deberá tener dos slots (funciones) llamadas myhello
y myexit. Defina varios apuntadores para objetos KDE, incluidos
apuntadores para botones (buttonhi y buttonExit), un apuntador
para una barra de menú (mymenubar), un apuntador para un
menú (filemenu), un apuntador para una barra de herramientas
(mytoolbar) y un apuntador para una barra de estado
(mystatusbar). La clase también necesita contener una función
constructora quase ejecuta cuando se define (Hellowin) y una
función para terminar el programa (closeEvent).
4. El archivo hellowin.cpp contendrá las definiciones de función para la
clase Hellowin. Incluya archivos de cabecera y el archivo
hellowin.moc, el cual debe generar por separado el preprocesador
MOC.
5. Defina una función constructora para la clase Hellowin,
Hellowin::Hellowin. Cuando se define un objeto de esa clase, esta
función se ejecutará automáticamente.
6. En la función constructora, cree un objeto de barra de herramientas
usando la clase KToolBar. Después, haga una imagen del mapa de
pixeles que sea accesible para usarla en la barra de herramientas.
Cree un objeto KlconLoader con un apuntador myloader que
contenga su dirección. Luego, con la función loadlcon en ese
objeto cargue una imagen (stamp.xpm) en un objeto QPixmap,
llamado hellopic.
 7. Cree un botón en la barra de herramientas mytoolbar con la ima-
gen stamp.xpm que se encuentra en hellopic. El texto para el botón
debe ser "Hello window".
8. En la función addconnection del objeto mytoolbar asocie un clic
del ratón (clicked) con el slot myhello de la clase Hellowin y el
primer botón de la barra de herramientas (stamp.xpm).
9. Otra imagen, llamada exit.xpm, se coloca entonces en el objeto
exitpicQPixmap. Con esta imagen cree otro botón en la barra de
herramientas con el rótulo "Exit program". La función
addconnection se asocia con una señal clicked y la función
myexit, la cual sacará el programa.
10. Ponga la barra de herramientas como flotante, o de libre ubicación,
y agréguela al objeto Hellowin con la función addToolBar.
11. Defina una barra de estado y asigne la dirección al apuntador
mystatusbar. lnserte un mensaje simple: "My hello program".
12. Cree un objeto de menú con QPopupMenu y asigne su dirección
al apuntador filemenu. lnserte dos elementos, uno con el rótulo
"Hello" y el otro con "Exit". Subraye la "H" en el elemento Hello y
la "x" en el elemento Exit.
13. Cree una barra de menú llamada mymenubar. lnserte en ella el
objeto de menú filemenu y póngale el rótulo "FILE".
14. Defina la función close~vent,la cual llama a kapp->quit para
terminar el programa
15. Defina la función myhello para la clase Hellowin y establezca que
presente en pantalla un cuadro de mensaje separado con el mensaje
"Hello World".
16. Defina la función myexit para la clase Hellowin y configúrela para
cerrar la ventana Hellowin.
17. Cree el archivo main.cpp, el cual incluirá la función principal del
programa. Comience por incluir archivos de cabecera y el archivo
hellowin.moc, el cual tiene que generar por separado el
preprocesador MOC.
18. En la función principal, defina una KApplication llamada myapp.
Cree un objeto Hellowin con el nombre mywin, llamando al mismo
tiempo su función constructora Hellowin. Determine el tamaño del
objeto.
396 1 Fundamentos de programación en Linux
- - - -

19. Con la función setMainWidget para myapp haga del objeto

mywin la ventana principal de la aplicación.
20. Determine que mywin.show presente esa ventana.
21. Con myapp.exec ponga en funcionamiento la aplicación.
Luego sigue el código para el archivo hellowin2.h. En la figura 10-3 se
muestran las ventanas que presenta este programa, incluida la barra de
menú con el menú Archivo, la barra de herramientas con los botones de
ventana Exit y Hello, y la bárra de estado.

Hello Worldl
Iviy hello program

Menú, barra de herramientas y barra de estado de KDE

T*
7
wl +-k***&* tfe 1 1 OW'i 2 ,-, h'c"-*TTtT*T**k**'*>-*-k/--
i b i n c l ude <kapp. 6?
# i n c l u d e <ktmaitiwindow. h >
#i ncl u d < ~ q p u s h b u t t o n . h>
# b i n c l u d ~<kmenubar.hy
# i n c l u d ~( k t o o l b a r . h>
j b i n c l ude < k s t a t u s b a i . h>
# i n c l ude <qpopuprnenu. h>

c l a s s H e l l o w i n : pub1 ic KTMai nWi ndow

i
Q-OBJECT
publ i c :
He1 1 owi n ( ) :
v o i d c l o s e E v e n t Q C l oseEvent * ) ;
p u b l ic s l o t s :
v o i d myhell o( 1:
void rnyexit0;
private:
QPushbutton *he l o b u t t o n :
 Capitulo 10: KDE 1 397
on;
K M e n u B a r *myrnenuba r :
Q P o p u p M e n u *filemenu;
KTool Bar *niytool b a r ;
KStatusBar *rnystatusb a r ;
1;
El siguiente es el código para el archivo hellowin2.cpp.
. . .

He1 1 owin: : He1 l n w i n ( 1 : K T ~ i a i n \ ~ l i r ~ d o) w (

I

irytool bar->iii;ertButtaiiihel i ~ i p i c . 1 , TRiiE, "He110 window", 0 ) :

OPixmap e x i t p i c = m ~ ~ l c ~ a & r - > l n . ~ d I ~ .xpm", n r ~ ( " ~O , ~ O~ )i : t

mytool b a r - > i n s e i 7 t B u t t o n ( e x ít p i c , O , TU![, " E x i t Frl~ g r a m " , O);
r n y t o o l b a r - ) a d d i o n n e c t i o n ( O , SIiEIAL(c1 i c k e d O ! , t h .i s , SLOT(rnytx
n y t o o l bar->setEaiPos(KToolBar: : F l h d t i n g ) ;
~ d d T o o l B d r ( i n y t o o 1b a r , O j :
iiytool bar->show();

n y s t a t u s b a i = new K S t a t u s B a r ( t h i s 1 ;
n y s t a t u s b a r - > i n s e r t I t e i i i I " Y v tiel l o r;rugram", O ) :
j e t S t a t u s l a r (m::statusbar);
nystatusbar->:hok!í 1:

f i 1 emenu = new QPopupPenu( i :

filemenu->inscit,Item("&Hello". thi;, SLOT(myhello( 1 ) ) ;
f i l e r n e n u - > i t i c ~tiI t e r i i ( " [ h i t " . t l i i s , C,LDT(niyexi t ( 1 ) 1;

nymenubar = ne!:: I(l-leniiP,i'( tlii s 1 :

nyinenubar->inr;ert!tem( " Z F I L E " , fi1eii:enu);
I
398 1 Fundamentos de programación en Linux

' v o i d H~llowin:: ~ T o s e E v e r i t ~ O t ' i o s e E v e n t

I
*)
-

void Hellowin::niyhe?ioO
1
KMsgBox: :message(O,"World Message","He1lo World! "1 ;
1
void Hel1owin::niyexitO
[
clase( 1 ;
t
Este es el código para el archivo main.c:
- -- -

-ap JiY -
jkinclude <ktmainwindow.h>
#incl ude "he1 lowin2. h"
int main( int argc, char **argv
I
KApplication myapp( argc. a r g v , "Hello World!" 1 ;
Hellowin *mywin = new H e l l o w i n O :
mywin->setGeometry(l00,100,200,100):
myapp.setMainWidget( mywin 1;
mywin->showO;,
myapp.exec0;
return O ;
1

Para compilar el programa es mejor usar un archivo makefile como el

que se presenta a continuación.
-CI

7 l T " C Z ~mnc ~ ~ .
-L$KDEDIR/lib -1kdecore -1kdeui -iqt
g++
-o hellowin2 rna1n.o hell~~ih!inZ.o
hellowin2.0: hellowin2.cpp
g++ -c -I/$KDEDIR/include -I/$QTDIRlinclude he1 li~b~in.cpp

he1 lowin?.moc: he1 1 owin2.h

moc hellowin2.h -o hellowin2.moc
 --
Capítulo lo: KDE 1-
399

i-Nota --

Observe que el archivo MOC se crea con una entrada a los archivos
de cabecera en el makefile.

Programación
Eii Id actualid~d,I W E se basa clircctaiilerite e n Q t Toolkit. Uwiido sólo
objetos d e Q t , ustcd puede crear una interfaz con una opcióil de ver y
x n t i r siiiiilar a KIIE. Usted puede crear iiii,i aplicaci0i-i Q t . e i n p l e ~ n d o
hiicaniente objetos y librerías dc Qt. Esta seccióii ofi-ccc u i ~ ii-itroduc-
i
ción básica para la pi-ograiiiación en Q t . E11 developer.kde.org y
www.trol.com se encuentra docuiiieiltacibil i-iiuy detallada y tiitoria-
les sobre pro~;i-aili~~~ióii en Qt. Es recoilieildablc que coiisulte estas
detcill~dade pi-ogr~iiiaci6i-ieii Qt y
f~ientcsp'ir<l ~ 1 1 1 ~prewi~t~icibil
1
rcferciici,i~API.

Aplicaciones Qt
U n progr;iim en Qt es 1111 programa eii C++. Las librerías de Qt
ofreccn definicioiles aiilplias d e clases Qt con las cuales usted puede
dcfiiiir objetos de Qt en su progrnnin Qt.T.in1bién puede usar estai
5

clases para crear las suyas propias, hcredaiido las capacidades predcfii-ii-
das d e sus padres. La tabla 10-3 preseiita un listado de los widgcts de
liso iiiás coiriíin en Qt.
Widget Descripción
QCheckBox Un cuadro de verificación con u n rótulo de texto.
QComboBox Una combinación de b o t ó n y lista de presentación
contextual.
QFrame La clase base d e widgets q u e puede tener u n
marco.
QLabel U n rótulo que presenta en pantalla u n texto está-
tico o u n mapa d e pixeles. #

QListBox Una lista d e elementos que se pueden seleccionar

para sólo lectura.

-Tabla 10-3 Widgets comunes de Qt

---
 se crea c o n una entrada a los archivos
d e cabecera e n el makefile.

Programación en Qt
En la actualidad, KDE se basa directamente en Qt Toolkit. Usando sólo
objetos de Qt, usted puede crear una interfaz con una opción de ver y
sentir similar a KDE. Usted puede crear una aplicación Qt, empleando
únicamente objetos y librerías de Qt. Esta sección ofrece una iritroduc-
ción básica para la progran~aciónen Qt. En developer.kde.org y
www.trol.com se encuentra documentación muy detallada y tutoria-
les sobre programación en Q t . Es recomendable que consulte estas
fuentes para una presentación detallada de prograniación en Q t y
referencias API.

Aplicaciones Qt
U n programa en Q t es un programa en C++. Las librerías de Q t
ofrecen definiciones amplias de clases Qt con las cuales usted puede
-
definir objetos de Q t en su programa Qt.Tanibit.n puede usar estas
clases para crear las suyas propias, heredando las capacidades predefini-
das de sus padres. La tabla 10-3 presenta un listado de los widgets de
uso niás común en Qt.
Widget Descripción
QCheckBox Un cuadro de verificación con un rótulo de texto.
QComboBox Una combinación de botón y lista de presentación
contextual.
QFrame La clase base de widgets que puede tener un
marco.
QLabel Un rótulo que presenta en pantalla un texto está-
tico o un mapa de pixeles. s

QListBox Una lista de elementos que se pueden seleccionar

para sólo lectura.
400 I. Fundamentos de programación en Linux
-

Widget Descripción
QListView Una vista de lista/árbol.
QMainWindow Una ventana de aplicación típica, con una barra de
menú, algunas barras de herramientas y una barra
de estado.
QMenuBar Una barra de menú horizontal.
QPopupMenu Un widget de menú contextual.
QProgressBar Una barra de avance horizontal.
QPushButton Un botón de presión con un rótulo de texto o de
mapa de pixeles.
QRadioButton Un botón excluyente con un rótulo de texto.
QScrollBar Una barra de desplazamiento vertical u horizontal.
QSizeCrip Una casilla en la esquina para ajustar el tamaño de
una ventana de alto nivel.
QSlider Un deslizador vertical u horizontal.
QStatusBar Una barra horizontal ajustable para presentar men-
sajes de estado.
QTextBrowser Un programa de navegación con bastante texto
y navegación simple.
QTextView Un visualizador de texto sofisticado, con muchas
opciones de formato en una sola página.
Una barra de herramientas simple.
-
Tabla 10-3 Widgets comunes de Qt (coritinrrnción)

Para crear una aplicación eii Qt, iisted tieiic que def i-iir L I I I objeto
QApplication.Todas las aplicaciones dcbcii contar por lo iiiciios coi1
iin objeto Q A p p l i c a t i o n que sc Lisa para adiiiiiiistrar características de
la aplicación, coiiio la Fiieiitc y el cursor. Para incluir la declaracicíii dc
clase de Q A p p l i c a t i o n en su prograiiia, sólo necesita iiicluir cl progra-
lila p p p l i d o r r . h.

Luego, piicde optar por iiicluir varios objetos cri su aplicación,

conlo ventanas, botones y iiieníis. l - > mdefinir 1111 objeto en particular,
iistcd primero dcclara la clase; despiibs, aiiiique tradicioiialii~eiitedecla-
i-aría iiiia variable, dcifiiic i i i i o1)jcto dc esa clasc. Eii téi-iiiiiios qiic iio
soii c k <:++? piicdc coiisidcrar la r-/(irc.coiiio el lipo y i i i i ohjctc~coiiio
iiii,i i ~ r ~ i ~ i de
h l rese tipo.
Qt oficcc iiiiiiicros;is dcclai-acjoiics dc cLise, cada i i i i a ii1)icada cii su
propio archivo de c;il)ccei.:i. I'arn declarar i i i i a clasc, iistcd ticiic que
iiicliiii- dicho ni-chivo. Por ejciiiplo, p a n declanir QPushButton (1111
botóii), iiicliiyn el arcliiw c~l)r~slrb~l~~orr.lr.
. -
/iiAicl ude ( q p u s h b u t t o n . t i >

Widgcts: tales coiiio bototies, autoiiláticaiiicritc iiiipleiiici1t;ii-iii1

características pi-edtwriiiiiiadas coi] las cualcs piiedeii ii-iaiiteiier sil propia
coiidiciOii de ver g sentir. Usted piicdc iiiodific;ii-estas cCirac.terísticascoi1
cl caiiibio de aspectos, coriio cl color o el texto por picsciitar.
<:iiaiido ustcd dcfiiic uii objeto tic widget, taiiibii.ii ticric qiic.
suiiiiiiisti-;ir coriio arciiiiieiito el iioiiibre qiic cpicrc darle al objeto y al
piidi-c tic1 widgct. Si no es parte de otro widget, ciitoiices piiedc iisai-
NULL, O, para indicar que iio tiene padre. Los arguiiiciitos se pasnii a
un,i fiiiici0i-i coiistsiictora qiic se ejecutará piir;i rcaiimr ciertas opei-a-
cioiles de iiiiciacióii eii el w i d g t t I'or qjciiiplo, la siguiente defiiiicibii
dcl widgct dcl botOii mybutton pi-escritas5 cii pantalla "Click Me" c
indicar5 qiic iio ticiic padre:
C

QPushButton inybutton( " ~ic'k'

l M;", O :

En csciicia, i i i i pi-ograriia eii Q t t,s un prograiiia cii C++. de iiiodo

que iistcd defiiie siis clases y ciia1cliiicr;i de las fiinciones iiiieinbro y
despii6s defiiie 13 fiiiicicíii pi-iiicipal eii doiide coiiiiei~zael prograiiia. Es
ahí cii doiidc iistcd poiic la dcfiriición para su objcto QApplication.
Esta dcfiiiicióii tiene que presciitiirsc niitcs qiic la dc ciialcliiier;r de los
deixís \vidget Q t (objeto); para la dcfiriicibri del widgct QApplica-
tion, usted iiicliiyc los al-giiiiiciitos (argv, argc), los cii;iles tiei-icii In
i i ~ i s i i i ;fiiiic.ioiialidnd
~ conio cii otros piogaiiias eii (:++. Otros widgcts
toiiiaráii difci-ciitcs coiijiiiitos de cii-~iiiiiciitos.
El sigiiieiite deiiiplo ciefiiic cl \vidgct QApplication Ilainado
myapp y i i i i \vidgct de botóii Ilnriiado mybutton.
402 1 Fundamentos de prograrnición en Linux
..-

-CZ-tion myapp( at-qc. f i 5 v );

Q P i i s h B i ~ t t o i i r n y b ~ i t t o n ( " r l i c4 Me" , O ); A---
Para crcar un widget en el widget principal dc la aplicación, usted
eiiiplea la f~iiicióiiiiiieiiibro s e t M a i n W i d g e t del objeto QApplica-
tion. El widget principal es el que usted usará para controlar el cierre
de la aplicación. Ciiando usted cierra el widget priiicipal, cierra la
aplicación. Us~~aliiiciite, el widget principal es la vciitaila principal de la
aplicación, de modo que al cerrar esa ventana se cerrará la aplicacióii.
El argumento para esta f~incióiies la direccicín del widget, CILIC usted
puede obtener con el operador &.

Una vez que ha definido sus widgcts y cambiado alguiia de las

c'~r,ictcrísticac,debe especificar que el widset se va a niomar en panta-
lla y para ello utiliza la funcicín miembro s h o w del widget. Eii el
siguiente ejemplo se presentará el botón m y b u t t o n :

Cuaiido haya terniinado de construir su aplicación y dc especificar

los widgets que va a presentar, entonces puede trasladar cl control n Qt
para dirigir la cjccución de 1;) aplicación con la f ~ i n ~ i óriiienibro
n exec
dcl widget Q A p p l i c a t i o n . Esta fiinción ponc en fiiiicionainicnto la
aplicacibn y muestra eii paiitrilla todoc los widgets. Qt administrar5 los
eventos, llaniarido el widget apropiado que estí. coiiectado a aquéllos.
Ciiando el ustiario cierra el v\iidgct principal dc la aplicaci6n, el control
regresa al programa. Entonces, usted puede tcriniiiar el progrania con
i i r i enunciado final de r e t u r n eii la f~incióiiprincipal.

- - . u - - -- - = - -- - - . -

myapp.exec0;
return O :
 Capítulo 10: KDE
- --

El siguiente programa ilustra la estructura básica d e 1111 programa

en Q t .

1
w n c i u d e < q a p p l i c a t i o n . h>
.
# i n c l ude q p u s h b u t t o n . h.

i n t main( i n t argc, char **argv 1

i
Q A p p l i c a t i o n myapp( a r g c , a r g v 1;
QPushBiitton m y b u t t o n ( " C l i c k Me". O 1 ;
m y b u t t o n . r e s i z e ( 1 0 0 , 30 1 ;

Señales y slots de Qt
Por tradición, las cajas de herraiiiientas dc GUI utilizan 1111 tipo de
evento que activa las f~iilcionesd e retrollaiiiado. Ciiando ocurre uri
evento, se ejecuta sil f~iiiciónd e retrollarnado asociada.
Q t reeiilplaza este niétodo con uri sistema de seíiales y slots. El
proceso dc activación del evento se vuelve a formular como u n proce-
so de coinuiiicación de i~l'ensajeentre dos objetos. Dado que son
siinpleinente meiisajes de comiinicación, las seiiales y los slots piiedeii
ser niuy fiiertes y pueden tonlar un variado número dc arguiileiitos de
diferentes tipos; usted puede conectar cualquier cantidad de seíiales al
inismo slot. Las seíiales y los slots se piicdeii iisar en cualquier clase que
se herede de la clase Qobject, coino es el caso de Qwidget. Cualquier
objeto piicde coiitener señales para enviar mensajes y slots para
recibirlos.
Cuando se presenta iin evento e n u11 widget, eiiiitirá iiria señal. Eso
es todo lo que hace. N o configura una conexión hacia otro objeto.
Para poder recibir un iiieiisaje d e una señal, un objeto debe contar con
iin slot, el cual es simpleniente una fiinción inieinbro que se ejecuta
cuando el objeto i-ecibe una sehal. Desde el piinto de vista conceptual,
los slots se usan para obtener inforinacióil acerca de Lin cainbio en
404 1 F u n d a m e n t o s d e p r o g r a m a c i ó n en L i n u x
-- -

otros o-jctos. Un slot iio sabe si cvi ic:iliJnd hay algiiiia seiinl c.oiicctacia
:i él y 1111<1sefial iio s ~ b si c hay algíiii slot qiie Iri reciba.
Usted iitiliza la fiinc-ióii connect para configurar una coiicsióii
entre uiia seiinl en u i ~ol?jeto y i i i i slot en otro. l'iiccie coiicctar tai.it;is
sciiales cwiiio qiiiern hacia 1111 iiiisiiio slot y iina sciial st. puede conectar
a ciialcliiier cantidad dc slots.Todos los objetos tienen seiiales para
eiiviar iiicnsajcs y slots para recibirlos. Las fiiiicioiies connect coiifigii-
i-ai-iii una c u i c s i ó i i eiitrc dos objetos, c o i i ~ c t a n d oiiiia sena1 d e iiiio
c o n uii slot e n otro.
Eii el sigiiieiite cjciiiplo, la seli;il cliclted para cl objeto mybutton
csti coiicxtada 31 slot quit del objeto myapp:

Ciiai-ido uii cveiito ocurre en i i i i objeto, la operación eniit iisn la

fiiiici6ii signal par;i ciivini- i i i i iiiciisiijc. (:iinndo i i r i objeto emite iiiia
seiial, los slots cmiicctados a clla sc qjccutaii d e iiiiiicdiato. Los slots
siiiiplciiiciite w i i fiiiicioiic< iiiieiiibi-o cn iiria c l ~ s cqiie dificrcii 5610 cil
q u e piicdeii estiir coiiectndos n iiiia seiial.TaiiibiCii se conocen coiiio
fiiiicioiics regulares. Usted puede disponer dc slots protected, private
o public y, d c csc iiiodo, coiitrolar los objjetos cliit' piick111 tencr scki
les coiiccudas a ellos.
.. .
.
privste siynals:
v o i d niysignal();
piivatc slots:
v o i d niyslotl( 1:
v o i d inyslot20;

En i i i i n dcfiiiici6n d e clase.. el prcpi-occwdoi- M()(: rcciiiplazar5 los

ti,riiiirios sigii,il y slot por c-ódigos iiccptablcs para el coiiipilador d e
C++. El MOC ticiic q u e pi-occsnr pi-cviaiiiciite ciia1qiiiei;i dc los
archivos d c c . d i g o fiiciitc' qiic c.oiitciigaii clnscls coi1 definiciones dc
sigiial y d e slot. Adciiiás, cii,ilcliiier clase w i i slots y sc17alcs ticiic qiic
iiicliiii- cl tí'riiiiiio Q-OBJECT cii sii dec~1~rac~ióii d e clase; por lo
geiici-al, el MO(; lo Iiacc., al igiial qiic taiiibii.ii geiicra el código cliic
inicia cl iiictaobjcto. Estc coriticiic los iioiiibres dc todas las sclialcs y
slots iiiieiiil)i-os.jiiiito coi1 apunt;te~oreshncia estas fiiilcioiics.
 C a p i t u l o 10: KDE 1 405
Ventanas
I'arn crear iiii;i ventana de aplicacióii, iisted lisa la clase Qmain Window.
Eri el sigiiieiite ejeiilplo se crea iina niieva ventana d e aplicaciOn y se
asigiia sil dirección al apiintadoi- m w :
- O ~ a i n w f i i d o w*
- - -
rnywin = n& ~~ain~indow;
- - -

Uii ~ v i d g c tQMainWindow incliiyc v,iri.ij fiincioiicj niicinbro par,)

est<\blcccrciifcrciitei caraitcríitica~.<:o11 el iiiienibro setcaption, iijtcd
1 - 7 1 1 ~ coiifigiirnr
~1~ cl títiilo d c la vcntaii,i
r. -- .- - -
rnywin - > S e t c a p t i o r i ( "My ~ocuinent-"- :

I':ii-a q11e s i l r\plicac.iOii cicrrc ;\iitoiiiáticaiiici~tcciiaiicio sc cicrrc la

íiltiiiia vciltnnn qiie haya nbicrto, piiede coiiectar la seiial lastwindow
Closed del widget d e aplicaci6n ~l slot quit, conio se niiiestra a conti-
niinción:
406 1 Fundamentos de programación
- -
.- ..
en Linux
.

Herencia en objetos
Usted coiistruye una interfaz eri Qt usando objetos que pone en
estructuras jerárquicas, con objetos iilenores que depeiideii d e un
objeto iiiayor. Por ejeinplo, una ventana sería 1111objeto mayor que, a su
vez, tendría objetos menores, como iiienús, barras de herrainieritas y
barras deslizadoras dependientes de ella. El objeto mayor es el padre y
los objetos nienores son sus 11iJos.Cuando iisted crea uii widget mayor,
conio eii el caso de una ventana, tan-ibién puede crear widgets menores
de barras de herraiiiieritas, para unirlos a la ventana. Puede hacer esto
convirtiendo al widget ineiior -coiiio eii el caso de una barra de
herrailiieiitas- en un hijo de un widget iilayor (como la ventana). U n
widget hiJo p ~ ~ e daesu
, vez, ser padre de sus propios widgets hijos. Al
construir una interfaz, usted pone los widgets en una estructura jerrír-
qiiica de widgets padres y sus hijos.
Para crear un widget coiiiplejo, como una veiltaila coi1 sus hijos
depuidientes, usted primero define el widget padre. Ilespués, cuando
define un widget que desea que sea un hijo de ese padre, pone la
dirección del widget padre conio un arguilieilto en la definición dcl
widget.
En el siguiente ejeiiiplo se define un widget de l>otón con el i i o n -
bre quit y se le convierte eri hijo de un cvidget d e ventana. Ahora, el
widget d e ventaiia induye el widget botón. Observe que el operador
& se usa para obtener la dirección del widget padre.

El widget de ventana incluye ahora al widget de botón. Observe

que el operador & se usa para obtener la dirección del widget padre.
Cuando usted presenta en pantalla el widget padre, todos los \vid-
gets hiJos aparecen automáticaiiiente. En el ~iguienteejciiiplo, la fun-
ción iiiiciribro show pard el widget ventail~tailibiéii "mostrará" el
botón mybutton:
 . -
Capitulo 10: KDE ( 407

En cl siguiente programa se muestra un botón como hijo d e una

ventana. En la figura 10-4 se deipliega la ventana que muestra el pro-
grama junto con el botón Click Me.

Click M~A
-

Ventana y botón en Qt

iiit rriainí i n t i i r r l c . rtiüv * * r-i f .'J ' J )

i
U A r ~ p li c , i i [ C I ~ Ir,i,;~p~~( afile, ~ji.gy ) ;
+fn;wi11, = 1 1 ~ ~W
~I'!,J~I~,\/~II~~II~:I : ~ai~~!~i~i~ow:
í1Pu:IiBiittnn m,!l?iitto~i! " C i i ~ - kMe", m w i n ) :

Widgets de distribución
C o n los widgets de distribución usted puede ubicar ficilmente los
widgets hijos (coino botones o testo) en u n widget padre (como una
~ ~ - i t a n a ) . A d e n idel
á s posicionaniento, los widgets de distribución
ofrecen tamaños predeterminados, ajuste de tamaíío y actualización de
la presentación en pantalla d e los widgets. Hay disponibilidad de varios
widgets del tipo ficil d e usar. QHBox sitúa los widgets en una fila
horizontal, QVBox los ubica verticalmente en una columna y QGrid
los pone en una tabla. Para lograr un control más preciso, puede utilizar
QGridLayout, QHBoxLayou t y QVBoxLayout.
408 1
- Fundamentos de programación en Linux

Prueba de repaso
¿Se puede crear una interfaz de usuario con la barra de
herramientas de Qt únicamente?'
0 ¿En qué clase de relación están organizados los widgets
de un programa en Qt?'

Cómo crear sus propios widgets

La crcacióii de sus propios widgets es una siiiiplc cuestiOn dc definir
una clase que cuiiipla con las coiidicioiies de Qt y desyiiés crear uii
objeto de esa clase. Uiia clase así tieiie q ~ i ederiwrse dc una clasc base
eii Q t , corno QWidget. Usted cspccifica una derivacibn de esta índole
por nicdio de la clasc base de Q t para su nueva clase. En el siguieiite
cjeiiiplo, el usuario crea una clase MyWidget, dcrivr'iiidola de la clnsc
QWidget. Mywidget heredai-l f~iiicioncsiiiieiiibro y variables de la
clase QWidget.

Usted puede declai'.ir ciialesquiern de los iiiiciiibros píiblicos o

privados, incluidas fi.iiicioiies y variables, qiic desee parii sii clase. Por lo
coiiiíin, las definiciones de las fiiiicioiies riiienibi-o se porieii despues de
la definicibn de clase.
Uiia f~iiicióiiniieiiiliro coiiiíiii qiic se eiic-uciitra eii la iiiayoría de
clases es la coiistructora. Esta fiiiicibn tieiie el iiiisnio noiiibre de la
clase y se Ilaiiia autoiriáticameiite cuando se defiiic un objeto de esa
clase. Usted puede coiisiderar una fiiiición coiistructora coino uiia clasc
clc fiiiici0ii dc iiiiciaci6ii qiie se c~iic;ii-gade cualquier tiirca inicial cic
coiifig~~racicíii que q ~ i i mrealizar cii i i i i iiucvo objeto dc esta clasc. En
el siguieiitc cjeiiiplo, iina f~incicíiiconstriictora se declar'i cii la clasc
MyWidget.

5 Sí.
6 Jerárquicaniente. padre-hijo.
 . --
Capitulo 10: KDE
-
1-
409

--
c l a s s -MyWi-dgift -:-p u b l i c OWidget
(
pub1 i c :
MyWidget( QWidget *parent=O, c o n s t c h a r *narne=O 1:
1;

En las fiiiicioiies coiistructoi-as pai-n siis propios widgets eii Q t : ustcd

iiecesita incluir uii argiiiiiciito pirri la direcciOii del widgct qiic qiiiere
que sea el padre. El predetei-minado es NULL, O. Si el padre es NULL,
aiitoiii5ticaiiiei1te se coiivierte eii uii widget de nlto nivel y ya iio cs uii
hijo dc. otro. El seguiido nrgiiiiierito es el iioiiibre qiic Ic va a dar a1
widget en particulnr d e la clase que estl crcaiido. Eii cambio de escribir
el código para maiicjar el padre y el iioinbre, puede pasarlo a la coiis-
tructora QWidget que hei-cda sil clasc. I'ara hacer esto, ponga la fiiii-
cióii coristructora QWidget coii sus arguiiieiitos en la funcióii
coiistructora dc su clase, uiiiéiidole después los argiiiiiciitos de la
f~iiicibii.
-=- - .. --- -

k f i i d g e t : : ~ . ~ b J f d ~ eOWidget
t( *parent. c o n s t c h a r *name
: QWidget( p a r e n t , n a m e 1

EJI la fuiicióii constriictora, usted poiidría las defiiiicioiics dc cual-

quier objeto hijo que desee crear para su widgct. Por qjeniplo, si est5
ci-cando i i i i widget de vcirtaiia, escribir5 una f~iiicióiicoiistructora pai-a
la veiitaiia. en doiide defiiiirl coiiipoiieiites coiiio i i i i iiieiiú, barras de
herrainiei-itas o 1ina barra d t x estado. Usted piicdc coiifigiirar caracteris-
ticas para estos widgets, coiiio taiilaiio y color, y taiiibiéii deteriiiii~ar
coricsiones de selides y slots ciiaiido sea iiecesai-io.
El siguielite cjeiiiplo es uiia defiiiiciOii de la fiiiicióii c-oixtructora
para mywidget:
-- - -- .-
MyWidget : :@kldgetl OWidget *p<reiit. c o n s t c h a r * ame
: QWidget( p a r e n t , name 1
i
QPushButton * q u i t = new QPushButtoti( " í l u i t " , this,
q u i t - > s e t F o n t ( QFont( "Times", 18, QFont::Bo d ) )
contiect! q u i t , SIGNAL(c1 i c k e d í ) ) , qkpp, SLOT qui ti
1
410 ( Fundamentos de programación
- --- -
en Linux

Suponga q u e desea construir sil propia ventana d e aplicacibn con

los meníis y las barras d e herramientas q u e diseñe. QMainWindow
sólo suministra una ventana sin ninguna característica. Para crear una
ventana d e aplicacibn c o n sus propios ~iienús,barras d e herramientas y
otros widgcts, definirá una nueva clase d e ventana para usted y le dará
la herencia d e la clase QMainWindow. Sil niieva clase d e ventana
incluirá los miembros d e QMainWindow, lo iiiisnio q u e cualquier
clase niieva q u e usted defina e n ella.
En el siguiente ejeniplo se crea una nueva clase d e ventana llamada
MyAppWindow, q u e se basa en la clase QMainWindow:

r l d s s MyAppWi ndow: pub1 ic QMsi nbli ndow

Q-OBJ ECT
publir:
MyAppWindow O ;
- M y A p p W í ndow ( ;
proter.ted:
v o i d c l o s e E v e n t ( QCloseEveiit* ;
p r ivate s lots:
void newfile0;
void openfile0;
private:
QTool B a r * m y t o o l b a r ;
QMenuBar *mymenubar;
1;

La clase MyAppWindow se basa en QMainWindow y heredará

sus niiembroi públicos. La clase incluye una fiinción constructora y una
destructora para configurar la ventana y para elimiilarla.Tanibiéli tiene
una barra d e herramientas y una barra d e m e n ú , declaradas c o n i o
mieinbroi privados. Esta definición d e clase incluye slots q u e se ejecu-
tarán cuando u n determinado objeto emita una señal. Por ejemplo,
cuai-ido u n usuario selecciona u n elenlento New e n un m e n ú o hace
clic e n u n b o t ó n New e n la barra d e herramientas, se ejecuta la fiin-
cibn (slot) newfile.
 Capitulo 10: KDE 1 411
El rót~ilo"private slots" no es ~ i ntérmino de C++. Debe ser proce-
sado previamente por el MOC para generar uii código legible en
C++. Para indicar que esta clase tiene términos e n MOC, el término
Q-OBJECT se p ~ i s oen la definición d e clase.
Es posible que en su widget principal d e la aplicación necesite hacer
referencia a acciones. Por ejeniplo, si convierte una ventana en el
widget principal de su aplicación, es posible que desee cerrar la aplica-
ción solamente haciendo clic en el botón Quit de la barra de heri-a-
mientas de la ventana. Para hacer esto, tiene que conectar el botón
Q u i t a la fiiiición quit de la aplicación. Esto implica crear L I conexión
~
de sella1 clicked desde el botón hacia el slot quit de la aplicación. Sin
embargo, el widget de ventana no sabrá el nombre del widget de
aplicación. Para manejar este problema, Q t crea un ap~intadorespecial
llamado qApp que hace referencia al widget d e aplicacióii del progra-
ma. El widget de ventana usará qApp para liacer referencia al widget
de aplicación y su función quit.
En el siguiente ejemplo, la f~iiicióticonnect conecta una sella1
clicked a ~ i r botón
i Q u i t de la barra de l-ierramientas d e la ventana con
la fiincióil (slot) quit d e la aplicación. C~iaiidoel usuario haga clic en
el botón Q u i t de la barra d e herrainientas de la ventana, toda la aplica-
ción se cerrará.

Cuadros de diálogo
Para crear L I cuadro
~ de diilogo simple, usted puede usar el widget
QMessageBox y, entonces, p ~ i e d egenerar cuadros d e diálogo con
diferentes características empleando las f~inciones(métodos) niienibro
QMessageBox. Por ejeiiiplo, si sólo desea presentar en pantalla 1111
mensaje, sin recibir ning~inainformación por parte del ~isuario,enton-
ces puede utilizar la fiincióii about del widget QMessageBox. Senci-
Ilaiiieiite, tome el objeto padre, el tít~ilodel inensaje y el inei~sajecoino
los al-gumentos. Usted p ~ i e d eusar secuencias de escape para nuevas
líneas y tabiilaciones: \n y \t.
412
7
1 Fundamentos de programación en Linux
, .

- - --.-- - - - - -. --. - - -.-- --

OMessageEox: :about( t h i s . "Qt t4pssaae b m pvample" ,
";bis example d e n r w t . r a t e s r i v p l e use o f " ,
" i h e message box." ) ;

Para ciiadros de diálogo en donde quiera que el iisiiario seleccioiie

uiio dc wrios botones, use la fiincibii information del o b ~ c t o
QMessageBox, qiie toiixi coimo argiiiiicntos: el objcto padre c p c le
correspoiida, c.1 títiilo, cl testo del mensaje y los botones qiic usted
cliiicra presentar en pantalla. Para separar líneas e11 el niei~sajc,ponga
cada líiiea en su propiacadena.
Eii el sigiiieiite e~llciiiplose crea 1111 ciiadro de iiieilsaje siiiiple con
dos líiicas dc texto y ti-cs botoi~cs:C>K, Cancel y Apply.
. - A -

OVe;?ageBox:: i r i f o r m a t i h í t h i s , "'Save n d i c e " ,

"The dociinierit has b ~ e nchanged s i n c e "
" t h ~l a s t save.". " O K " ,
" C a n c e l " , "ApplyU,O, 1

El ciiadi-o rlc irieiisajc iiiostrari t.1 iiúiiiero del botbn seleccioiiado.

Eiitonccs, piicdc iitilizai- este resultado parn elegir la nccióii qtic desec.
realizar, c.oiiio sc iiiiicstra a coi~tiiiti;icióii:

r?s = UMtssagefirix.: :infirm~tion( t h i s , "ave r1oticem,

" ~ I I Pd o c l i i ~ i ~t i a~si ~beeti clialiged s i n c e "
"tli? last s a v c . " , "OK".
"Cancel" ."Appíya,0. ! )
CiEvaluación
1. ¿En dónde puede encontrar una lista coinpleta de todas las
declaraciones de clase de KlIE y sus funciones inieinbro?

2. ¿ Q u é clase de objeto necesita definir sieinpre, priinero, en un

prograniri eii KDE? ¿Cuál arcliivo de cabecera coiltieile la
definicióii de clase del objeto?

3. 2Necesit;i las librerías Qt y KI>E para coiilpilar uil prograina

en KLIE?

4. ;Cóiiio se coiiiunica un objeto KlIE con otro?

5. ;Para qut. se usa el preprocesador MOC?
6. ¿ Q u é objetos utilizaría para crear un conjunto de iileilús pnr:i
una aplicación?
Apéndice
 Respuestas
a las evaluaciones
418 1 Fiindarnentos de programación en Liniix
- --

Ca~ítulo1: Introducción
I

a la programación en Linux
l . ;Cuáles ton lai cuatro categorías geiicrales de la prograiiiacióii e11
Liii~ix?
Lenguajes de programación de shell, lenguajes de alto nivel,
programación para interfaces gráficas de usuario (GUl) y progra-
mación estándar utilizando llamados al sistema.

2. ;I'~iede crcar progrnnias con aplicacioiies tipo GUI sin escritorios

de progrniii;icibi~.como GNOME y 1<1lE?
Sí; use Tk con Tcl.
3. ;Cuál leiigiiaje de prograiiiacibii ~itilizaríapara c r c ~ filtros?
r
GAWK.

4. ; Q ~ i étareas de prosi-aiiiacióii 1-ccliiiereiique ustcd conozca otro

leiiguajc?
Para la programación en GNOME se requiere que usted conozca
C, y en KDE se requiere que conozca C++.

Ninguna; fue creado por Linus Torvalds.

Capítulo 2: Scripts del shell BASH

1 . ;Cóiiio yiicdc opcrar ~ i i script
i del ihell UASH desdc el shell
TCSH?
Llame al shell BASH al comienzo del script con la siguiente instruc-
ción:

2. ;Qiié lccrí,i LIII c o n i ~ i l d oread

en la eiitrada dcl script dc ~ i n
slicll si el arguiiicnto dcl icript es *?
El comando read leería todos los nombres de archivo y de directo-
rio en el directorio de trabajo actual. Cuando se usa en la línea de
 A p é n d i c e A: Respuestas a las evaluaciones
.. -
109

comandos, el * es u n operador d e comparación d e nombre d e

archivo que comparará y generará una lista d e todos los nombres
d e archivo y d e directorio. Esta lista se convierte en los argumen-
tos del script.

3. ;Podría asignar el testo de varias línea5 a un') variable?

Sí, marcando el final d e cada Iínea con una barra invertida (\);
literalmente marcando el carácter d e nueva Iínea. Todas las líneas
se leen c o m o una Iínea.

4. ;Cónio referencia wrios arguiiientos de un script coiiio un

arguinento único?
Con la variable especial $*, la cual contiene una lista d e todos
los argumentos q u e el usuario ingresó. $# es el número d e argu-
mentos.

5. ¿Usted p u d e definir vxiablcc globales?

N o c o m o tales. Usted puede exportar una variable, generando
una copia d e ella y su valor en u n subscript. Sin embargo, al
cambiar el valor d e la copia n o se cambia el valor del original.

6. ¿CuCíles la diferencia entre = = y =?

= = se utiliza para comparar valores numéricos y verificar si son
iguales, mientras q u e = se usa para comparar cadenas con el fin
d e determinar si son Jas mismas.

Capítulo 3: Estructuras de control

del shell BASH
l . ;Se puedeii anidar estructuras if?
Sí; use el comando elif, en lugar d e else, seguido p o r la nueva
estructura ¡f. Emplee else e n la última estructura ¡f.

2. ;C:óino se puede iinplenieiitar una seleccióii predeterniinada en

~ i n aoperación case?
Use la palabra clave default en lugar d e case para la última entrada
en la estructura case.
420 1 Fundamentos dc prograniación en Linux
-. -

3. ¿(:óino podríci Icer los .u-giiiiieiitos cle u11 script, lino a uno,
proc.esxicdo iiiio a la vcz?
Emplee la estructura for con una lista vacía. Automáticamente
leerá los argumentos que el usuario ingresó.

4. ~ Q L
c oI~ i~i ~ i i dpodi-í.1
o 115.1i' para dctcctai- ~iitoniríticailiciitr
opcioiicj qiic sc I-iay~iliiigreiado en la línea de coiiiandos?
Utilice un comando if, como se muestra abajo, con una prueba
para verificar si el valor de $# es cero. $# es el número de argu-
mentos que el usuario ingresó.
if [ $11 e q O 1
t h f:r i
e c h o No a r q u m e r i t r e n t e r e d
ixil; 1
fi
5. ;Su p r o ~ r a ~podría
n ~ cjcciitar a1gíii-i coiii~iidodcspi1í.s de qiic cl
iisiiL1riolo tci-iiiiric con la coiiibinacibii CTl<L-C?
Sí; usted puede atrapar este evento con el comando trap y des-
pués obtener una lista de los comandos que quiere ejecutar
cuando ocurra el evento. En el siguiente ejemplo se atrapa el
evento CTRL-C (2) y se ejecuta un comando echo para presentar
en pantalla un mensaje seguido por un comando exit para termi-
nar el programa.
tr,al:, ' e c t i o " G o o t l b y e " ; e x i t l. ' 2

Capítulo 4: Programación
del shell TCSH
1. (Jiií: coinaiido se utiliza para leer la eiitrada en 1111script del
shell TCSH?
Llame el shell TCSH al comienzo del script con el siguiente códi-
go. No olvide que todos los scripts del shell TCSH deben tener un
símbolo # en la primera columna de la primera línea del script.
 Apéndice A: Respuestas a las evaluaciones [-
421

2. ;Se puede hacer referencia de iiria vez ;i niúltipli~eleinentoc de

u n arreglo?
Sí, usted puede hacer referencia a un conjunto o rango de ele-
mentos. El primer ejemplo que sigue hace referencia al rango de
elementos desde 3 hasta 7 (3, 4, 5, 6 y 7), y el segundo ejemplo
hace referencia a los elementos individuales 2, 7, y 9.

3. ;Cóiiio piiede detcrnii~iarcl níiniero de argiinientos que un

u c u ~ r i oentr'i en la línea de coiii;indos ciiniido esti operando un
~ript?
Use la variable especial #argv que contiene el número de argu-
mentos que el usuario ingresó.

4. ;Chino cc define una v'iri,ible a l~ que se puedc haccr rcfcrcncia

en los subchells?
Defina la variable con el comando setenv y no con el comando
set. Esta variable la conoce, entonces, cualquiera de los subshells y
su valor puede cambiar en ellos.

5. ;Cuál es la diferencia entre los operadores =, = = y =M?

El signo = es un operador de asignación, el doble signo = = es un
operador de comparación que se usa para determinar si dos
operandos son iguales, y la forma =- es un operador de compara-
ción de patrones que verifica si existe un patrón en una cadena o
en una variable.

6 . ¿Cbiiio verificaría usted 5i el xgiiiiieilto que iiii iis1i:irio siii i i i i i i s -

tr'i ri uri script c~ iiii iioiiibi-c de dii-t.ctorioi
Emplee el comando if para probar el argumento con el operador -d.
if ( d $argv[ll then
e c h o a r g u i n e n t is a d i t - e c t o i - y
etidi f
422 1 F u n d a m e n t o s de programación e n Linux
- .

Capítulo 5: GAWK
1. ¿Se pueden usar espresiones reg~ilaresen las espresiones de
prueba?
Sí.
2. ;Cuál es la diferencia entre los símbolos -, = e = =?
- verifica un patrón en un campo; = se usa para asignar valores a
las variables; = = es una prueba d e comparación que se utiliza en
estructuras d e control para probar la igualdad.
3. ¿Para trabajar con qué clase de arreglos está disellad,i la estructura
dc control for-in?
Con arreglos asociativos.
4. ~ Q Lf~inción
I ~ podría utilizar para asignar cada palabra en un;i
oración a un eleiilento presente en un arreglo en una operación
siniplc?
La función split.
5. ¿Cuál variable especial de GAWK utilizaría para crear una opera-
ción GAWK que presentara desde la cuarta hasta la ukptinia Iínca
de un archivo?
Emplee la variable NR (el número del registro actual) con el
operador coma (,) y especifique los números del rango al comien-
zo y al final del registro, como en NR==l, NR==3 para los regis-
tros 1, 2 y 3.

Capítulo 6: Perl
1. iCiiálei son loi iíniboloi que se utilizan para leer la entrada de
~ i narchivo?
Ponga el nombre del archivo entre los signos < y >.
2. Si un coiiiando print 110 tieiie argiimento, ?hay algún resultado?
El resultado es el contenido d e la variable $-, usualmente el
registro actual que se ha leído.
 Apéndice A: Respuestas a las evaluaciones
-.

3 . ¿ C ó m o se puede asignar una lista d e valores a u n arreglo?

Usted puede asignar simplemente la lista de valores al arreglo en
una operación de asignación única. También puede asignar
valores a un rango de elementos o a un conjunto de elementos,
como se muestra a continuación:

4. ¿Se puede11 eliminar eleinentos e n u n arreglo asociativo?

Sí; se emplea la función delete, así:

5. 2Cóino p ~ ~ e encontrClr
de cuilei son las cadenas q u e se usan para
el índice d e u n arreglo asociativo?
Con la función keys.

6. Si uii script intenta pero falla e n ~ b r i Lr I ~ I archivo, jcóino p i ~ e d e

terminar el prograiila c i ~
cic punto?
Use una estructura if para comprobar esto, junto con un operador
not (!) en la función open. La respuesta será verdadera si la opera-
ción open falla y regresa a O. Si es verdadera, ejecuta un comando
.
die para terminar el programa.
if (!(open ( R E P S , " < Bfilen"))) {
die "Can't open $ f i l e n U ;
1

Capítulo 7: Tcl (Tool Command

Language)
1. ¿ C ó m o se organiza una lista d e n ú n ~ e r o s ?
Utilice la función lsort con la opción -integer:
lsort i n t e g e r (89 4 5 100 67 )
424 1 Fundanientos de programación e n Linux

;Qi~í'operación iisaría para leer iin registro que consta de iiiia

Iíiiea que tienc campos separados por i i i i deliiiiitador de dos
puiitos?
Una operación split. En este ejemplo, sun:rain:storm se divide en
una lista con tres elementos {sun rain storm}.
s p l it s u n : r a i n : s t o r m :
2Cóiiio se abre iiri archivo para lectura y escritura?
Use la opción r+ con el comando open, así:
s e t m y f i l e [ o p e n $ f il e n r + l
; Q i é estnictnrudc: coiitrol lee artíc-iilos en varias listas a la vez,
asigiimdo cii oi-den cadci una a i i i i n variable?
La estructura foreach, como se muestra en el ejemplo siguiente:
f o r e a c h l c i t y v a l i n d e x v a l l i C h i c a g o 4 NewYork 7 LA 31
1
s e t b c i t y ( in d e x v a l ) c i t y v a l
I
;I'odría diseñar iiii script qiie baje autoiiiiíticaiiit.~itearchivos de
iin sitio FTI'?
Sí; con un script expect.

Capítulo 8: Tk
1. ;Los objetos griíficos dc Tk están organizados jeriírqiiicaii~ciitc!
Sí.
2. il'iiede utilizar coiiiaiidos Tcl para controlar operacioiies en T k ?
Sí. Las funciones Tk están diseñadas para llamarlas desde un script
Tcl.

3 . ;l'iicdc hacer qiie dctertiiiiiado objeto respoiida ante

1111 iiii
evciito, tal como iin botón ante u11 clic con el ratón?
Una el objeto a la acción de clic con el ratón usando el comando
bind.
 Apéndice A: Respuestas a las evaluaciones
- -
1 425
4. Aiiiiq~iela niayoría de los programas fuiicioiia ejecutando sus
eiiunciados en forma secuencial, ¿cómo está dirigido un progra-
ma en T k ? ¿Cómo se seleccionan las operaciones para la ejecu-
ción?
Un programa en Tk está dirigido por eventos. Las operaciones de
unión conectan las acciones a los objetos. Por ejemplo, haciendo
clic en un objeto se ejecutará una función que se ha unido a ese
objeto con un clic del ratón.

5. ¿ C ó m o puede presentar en pantalla diferentes objetos en el

misnio espacio de una ventana, en lugar de utilizar una ventana
diferente para cada coiijunto d e objetos? (por ejemplo, usar un
menú localizado e n la parte superior d e una veiitaiia para selec-
cionar diferentes operaciones, en donde cada uno de dichos
objetos se presenta en el niisnio espacio de la ventana eii donde
se escogieron).
Use marcos que se presentarán en pantalla en el mismo lugar de
la ventana. Un marco se une a una entrada de menú, usualmente
una etiqueta, y después se llama y presenta en pantalla cuando se
hace clic en la entrada. Al hacer clic en una entrada del menú de
otro marco se borrará el anterior y se presentará el nuevo.

Capítulo 9: GNOME
1. ¿Cómo llama usted las librerías d e G N O M E cuando compila un
programa en G N O M E ? ¿ C ó m o lo hace con los programas en
GTK?
Para CNOME usted emplea el programa gnome-config con las
opciones - - cflags y - -Lbs:

Ponga todo el llamado dentro de comillas invertidas para ejecutar-

lo en la línea de comandos:
gcc he1 1o.c - o he1 l o 'gnome-config --cflags --1 i b s ' gnome gnomeui

Para CTK, utilice el programa gtk-config:

ytk-config --cflags --1 ibs
426 1 Fundamentos de programación en L i n u x
- --
2. ¿Puede asociar más de una f~incióncon un objeto o sena1 en
particular?
Sí; se ejecutan en forma secuencial.

3. ¿ Q u é función usaría para conectar u n iiieiiú a una ventana?

Una vez que haya definido un componente, como una barra de
menú para menús, debe conectarlo a una ventana. Use la función
gnome-app-create-menu para hacerlo:
gnome-app-create-menus (GNOME-APP ( a p p ) , menubar);
4. iGNOME ofiece operaciones para acceder a diferentes tipos de
datos?
CNOME suministra estructuras y funciones para acceder a texto,
imágenes y números. Estas funciones terminan con el término
entry, como gnome-number-entr~gtk-entry, para acceder a
números, y gnomefile-entry-gtk-entry, para acceder al texto
de un archivo.

Capítulo 10: KDE

1. ¿En dónde puede encontrar iina lista con~pletade todai las
.
declaraciones de clase de KDE y sus fiinciones mien~bro?
En developer.kde.org.

2. 2Qiié clase de objeto necesita definir siempre, primero, en iin

programa en KDE? ¿Cuál archivo de cabecera contiene la defini-
ción de clase del objeto?
El objeto KApplication. Su definición de clase se localiza en el
archivo de cabecera kapp.h

3. ¿Necesita las librerías Qt y KDE para compilar un programa en

KDE?
Sí.

4. ¿ C ó m o se comiinica un objeto K11E con otro?

A través de señales y slots. Las señales se emiten cuando ocurren
eventos en un objeto. Los slots son funciones definidas en un
objeto KDE que se ejecuta cuando se reciben esas señales.
 Apéndice A: Respuestas a las evaluaciones 1 427
5. 21'ara qué se usa el pi-eprocesador MOC?
El compilador de metaobjetos genera un código para manejar las
conexiones de signal y slot.

6. ~ Q L I ~ ~itilizaríapara crear un conjuilto de iileilús para

objetos
uiin aplicación?
Los objetos KMenuBar y QPopupMenu.
 Caracteres especiales

! (operador N O T lógico) # (signo de número)

GAWK, 161 shell BASH, 36,39
Perl, 218-220 shell TCSH, 95,97-99
shell BASH, 59 # variable, 68
!= operador (no es igual a) #! variable, 39
GAWK, 158,159 #argv, variable, 119
Perl, 203 $ (signo de dinero)
shell BASH, 59,63 GAWK, 146
shell TCSH, 114 Perl, 191, 197,202,208
!- operador, 114, 162 shell BASH, 41,42,43
" (con~illasdobles) shell TCSH, 96,100
Perl, 200,20 1 Tcl, 255
shell BASH, 43-44 $ operador, 41,44,50
shell TCSH, 96 $n, variable, 5 1,149
430 1 Fundamentos de programación
--
en Linux

$# variable especial, 52,68,241 *= operador, 204

$#argv, variable, 119 + (+-no iiiás), 36, 145, 203
$* argunierito especial, 79 + operador (adición), 59
S* variable especial, 5 1,52 ++ (operador incremento), 167
$O variable especial, 5 1, 149 ++ operador, 203
$< operador, 98 += operador, 204
$? variable especial, 63 +> operador, 198
$@ argiiinento especial, 79 , (operador coma), 1 O3
$@ variable especial, 52 - (guicíii), 274
$- variable especial, 103, 194,228, - (~igno menos), 36, 203
243 - oper;idor (~ustracción),59
'%I (signo de porcentaje), 59, 157-1 58, -- (operador dcci-enmito), 167
203 -- operador, 203
%= operador, 204 -= operador, 204
& (3iiipersand), 42,241,242 . (operador dot), 233
& operador, 59,402,406 . (síinbolo dc plinto), 35, 42, 144
&& operador / operador ( d i v ~ ~ i ó n50
),
GAWK, 161 /= operador, 204
I'erl, 2 18-220 ; (punto y coma), 148
shell BASH, 70-71 GAWK, 148,179
' (comilla sencilla) I'erl, 19 1
GAWK, 170
I'erl, 200, 20 1
. Tcl, 252
< (cínibolo menor que)
shell BASH, 43-44 Perl, 193,203
shell T L S H , 96 ~ h e l EASH,
l 42,59
( ) parí-iitesis Tcl, 267
arreglos del T L S H , 99-1 O L < > (iiianejdoi- nulo de archivos),
Perl, 242 196
Tcl, 254 << operador, 49
* (asterisco) << opcrador (I'erl), 200-202
GAWK, 144,145 <= operador (iiienor que o ig~iala),
Perl, 203 59, 203, 207
-
shell UASH, 42 - (signo i g ~ i ~ l )

Tcl, 272 GAWK, 158

* carácter especial, 7 2 , 7 8 l'erl, 203, 204
* operador (niultiplicacióri), 59 shell BASH, 59,60,63,64
** operador, 203 == operador
 Índice 1 431
GAWK, 138,159 / operador (OR lógico), 59
Pcrl, 203, 2 1 8 1 1 (operador OR lógico)
shcll UATH, 39 GAWK, 161
shell TCSH, 1 14 I'erl, 21 8-220
=- operdor, I 14,238-239 shell UASH, 70-7 1
> (sínibolo mayor que) - (virg~ililla),162
I'erl, 193, 198,203,218
shell HASH, 42,59
Tcl, 267
>= operador ( m ~ y oquer o igual a),
59,203 about, fiinción, 41 1
>> operxior, 182 activated, señal, 38 1
? (signo de interrogación), 42, 145 ,idministrador de archivo, 316-322
Tcl, 273 administradores de geoinetría,
@ (como símbolo), 207-2 1 O 300-301
@, coimndo, 94, 105-108 adiiiinistradores de ventanas, 23
@- arreglo, 241,242,243 alcance, 244
[ ] (paréntem cuadrados) alias, 206
GAWK, 144,143,162 ainpersaiid (13)
shell BASH, 64 KDE, 406
Tcl, 367,273 k r l , 242
\ (barra invertida)
I'erl, 204
. shell BASH, 42
AND, operador (&&)
rliell BASH, 43-44 GAWK, 161
shell TCSH, 96 l'erl, 2 18-220
Tk, 301 shell DASH, 70-71
' (coiiiilla invertida) aplicacióii, editor, 14
GNOME, 347 aplicaciories
I'erl, 200, 20 1 de software, 14
sliell BASH, 45-46 de Tcl, 249-25 1
sliell TCSH , 96 de Tk, 249-250
{ ) (corchetes) editor, 14
Perl, 240, 24 1 Expect, 10,290-291
shell BASH, 42 GNOME, 329,331-337,348-350
Tcl, 259,267 GTK, 346-347
1 (barra vertical), 42,59, 145,265 KDE. 376-399
1 carácter especial, 73 Qt, 399-403
432 1 -
Fundamentos de programación en Linux
p.--

que se pueden ejecutar, 6 shell TCSH, 99-1 08

appeiid, comando, 256 Tcl, 256-258,276
apuntador app, 346 asterisco (*)
archivos GAWK, 144,145
copia de, 284-285 Perl, 203
cuadros de lista de, 307-309 shell UASH, 42
de iiistr~~ccióri
de GAWK, shell TCSH, 128-1 29
170-171 Tcl, 272
estructura de, de Linux, 22-23 AT&T Uell Labs, 18,lC)
operaciones de, 288-290 AUX, sistema, 20
organización de, 22-23,24 AWK, utilid~d,140
uso de, con GAWK, 142, ayuda en línea
182-186 GAWK, 9
argc, argumento. 376,401 Linus, 7
argc, variable, 258,268,346 sliell BASH, 7
arguine~itos shell TCSH, 8
del sliell TCSH, 94-97,101- 108,
119-120
GAWK, 154-1 55 --

KDE, 373
shell UASH, 50-52,617-68,7840 barra invertida (\)
Tcl, 276,283 l W , 204
5
tree, 357 shell BASH, 43-44
argv, aiguinento, 376,401 shell TCSH, 43-44
argv, m-eglo Tk, 301
Perl, 226 barra vertical ( l), 42, 59, 145,265
ihell TCSH, 101- 108 buras de desplazaiiiiento, 307,312
Tcl, 258 barras de e\tado, 39 1-393
al-gv,coiiiando, 283 barra\ de herrariiientai
argv, variable, 258,346 GNOME, 360-361
argv0, variable, 258 KDE, 39 l-399,406
array, comando, 256,257 UASH, progr,iinaciói~del shell,
arreglos 33-9 1
escalarei, 210,212-214,216 drgmmitos, 50-52.67-68,78-80
especiales, 258 ayuda en línea, 7
GAWK, 167-168,174 bucles, 73-84
I'erl, 207-2 17,226 condicioiies, 66-73
 Índice 1 433

constantes, 5 1 bucles
descripción, 7-8,22,34-35 de Perl, 221-228
estructiiras de control, 61-91 de Tcl, 266,275-280
herramientas de prograniación, do-until, 22 1
34 GAWK, 175-177,178,180-181
operaciones aritmtticas, 58-60 $he11 BASH, 73-84
operador de asignación, 41 shell TCSH, 125-1 35
operar scripts en shells diferentes, bucles infinitos
39-40 shell BASH, 80-8 1
permisos, 36-40 shell TCSH, 131-132
scripts ( I ~ WBASH, scripts del button, comando, 295,299,311
shell) Button, widget, 296
variables, 41 -50,5556
variables de entorno, 55-56
UEGIN, patrón, 162-1 63
Uell Labs, 18, 19
Uerkeley Software Ilistribution. Vénsa C++, código, 382
1JSl-1 C++, l e i i g ~ ~ ~6,j 7,
e , 12- 13
binary, con~ando,287 C + + , modelo de objetos en, 372
bind, con~ando,296,304-306 C++, programa de, 330
bindtags, coiiiando, 296 C , lenguaje, 6,7, 18, 112,164,249
botones C, programa en, 12,329
GNOME,360-361 C-shell, 22
KDE, 385-389,406-407 cadenai
Tk, 295,296,299,311 . coniparación de, 03
Bouriie Again shell. Ví.riie UASH de signos, 42-44
Bouriie, shell, 22 GAWK, 150, 168,169
break, coiiiando Perl, 200-203,214,236
I'erl, 227 sliell BASH, 42-46
sliell BASH, 80-81 Tcl, 255,286-288
sliell TCSH, 131-132 Caldera OpenLinux. Vénse
Tcl, 266,279-280 OpenLinux
breaksw, palabra clave, 116,121, cariipos, 146
122-1 23 canvas de GNOME, 367-369
BSII (Berkeley Software Canvas, widget, 296
Distribution), 19 caracteres, 42-46
BSD de UNIX, 19
434 1 Fundamentos de programación
- en Linux

cardcterei especiale5 coniilln sencilla (')

con coiiiill~i,42-44 GAWK, 170
cii coiiiaiiclos Liiiux, 48 Perl, 200, 201
GAWK, 142-14.3 shell IIASH, 43-44
iliell UASH, 42-44,48,71 shell TCSH, 96
caracteres inarcadoi, 43-44 comillas dobles (")
c s e , palabra clave, 13 6 I'erl, 200, 201
cdtcli, coiiiando, 253 shell UASH, 43-44
cd, coinaiido, 253 shell TCSH, 96
CI)E (Coiiiiiioii llesktop Coninioii Ilesktop Envii-oninent
Enviroiiiiient), 20 (CIIE), 20
CGI, prograiiiación en, 202 Coinnion Object Request Uroker
chdir, coniando, 233 Architecture (CORBA), 328
checkbutton, widget, 296 coiiipilador de nietaobjetos (MOC),
chniod, coii~anclo 382-384,404
Ikrl, 190 coiiipiladores, 6
shell UASH, 36-38 coiicat, coniando, 259,262
shell TCSH, 97 condiciones
Tk, 295 de shell BASH, 66-73
clionip, función, 205-206,233,236 del sliell TCSH, 1 1 5-1 24
clasi, coiiiando, 296 GAWK, 141,158-164
clicked, seiial, 342,38 1,404 Perl, 228-231
.
clock, coiiiarido, 253 Tcl, 266
cloie, coiiiando conjunto de widgets, 328
Perl, 193 connect, fu~ición,381,390, 393,404,
Tcl, 280, 281 41 2
closedir, coniando, 233 constantes
coiiiaiidos lógicos GAWK, 151,156
Perl, 218-220 shell BASH, 51
sliell UASH, 70-71 constantes aritméticas, 146
coiiimdos. l/i'nsc coinaridos constantes de cadena, 146, 168
cspecíficoi constructores, 373
comentarios, 36 contiiiue, coiiiando
comilla invertida (') l W , 227-228
l'erl, 200, 201 sheH BASH, 80
iliell BASH, 45-46 shell TCSH, 130-13 1
$he11TCSH, 96 Tcl, 266,279-280
 Índice 1 435
controles de b l o q ~ ~227-228
e,
COlXUA (Coiiimon Object ILeq~iest
Uroker Architccture), 328
echo, coiii~iido
COI\BA, operaciones, 336
~licllBASH, 47-50, 85, 86
corchetes { )
shcll TCSH, 96-98, 130
I'erl, 240,241
cleincnto\ del arreglo, buscar 105,258
diel1 BASH, 42
elif, estructura, 69
Tcl, 250, 267
else, coniaiido. 268-270
cuadro^ de dillogo
elw, palabra clave
GNOME. 302-365 \
sliell UASH, 66.67
Q t , 41 1-412
\he11 TCSH, 1 18
cuadros de li\ta, 307-309,312
Tcl, 269
cuadi-oi de iiiei-isaje,36.5
elseif, eitri~ctura,Tcl,270-27 1
ciiadríciilas, 300, 301
elsif, estructura, I'erl, 228,229-230
código binario, 6
emisión, 341
eiiiit, operación, 404
D eii línea, ~ y ~ i Vbaw
d ~ .Ay~idaen línea
ENI), p~tróii,102-1 03
cndif, pa1,ibi-a cLive, 1 16
DAl\I'A (Ikfeiise Advanced
e n & \ , palabra clnvc, 12 1
Ilesearch Projects Agency), 10
eiiter, señal, 342
llebiai-i Lin~ix,20
entrada e\tándar (STI)IN), 193-194,
Defeiise Advaiiced IlesearcR l'rojects
203-264
Agei-icy (llAllI'A), 19
Eiitry, widget, 296
dclete, operación, 220,228
env, arreglo, 2.58
deliniitadores de cniiipo, 148-1 49
eof, coiiiaiido, 280
destroy, coniaiido, 296,307
eq, operador, 203-204,218
die, corriando, 220,228
error, coiiiaiido, 253
directorios
e s x , palabra clave, 71
del sisteiiia, 24
escritorio\, 22
descripción, 22,23
especificadorcs de conver~ión,
Perl, 232-233
154- 155
raíz, 23
estructura caw, 6 2 , 7 1-73
Tk, 302-304, 307-309
estructiiras de control
dispfile, fiiiiciór-i,31 O, 3 12
del shell BASH, 61-9 I
do, pnlnbra clave, 74
del shellTCSH, 112-1 15,116,
done, palabra clave, 74
125
436 1 Fundamentos de programación en Linux
- -

de$cripción,8 filtros, 9,140,184

GAWK, 171-181 tlush, coinando, 280
I'erl, 191,217-235 for, bucle
Tcl (Tool Comiiiarid Lang~iage), GAWK, 175-177
266-280 l'erl, 221-224
etiquetas,Tk, 314-315 Tcl, 275,276-278
eval, coniarido, 253 for, estructura
evaluación, 41,48 shell BASH, 62,73-74.78-80,81
eventos Tcl, 266
GNOME, 340-346 for-m. bucle
GTK, 345 GAWK, 177-178
Tk, 304-309 shell IIASH, 78-80,81,85
eventos con el teclado, 304 for-in, estructura, 73-74,78-80,81
exec, comando, 253,254 foreach, bucle
exec, fincióii, 378,402 Perl, 221 ,225-227
esit, coniarido Tcl, 275,278-279
shcll IIASH, 68-69 foreach, eitruct~ir~i
d ~ e lTCSH,
l 1 19-120 sheUTCSH, 112-113,127-129,132
Tcl, 251,253,269 Tcl, 266,278-279
Tk, 307 forniat, coniando, 265,280
expect, aplicación, 10,248,290-291 Fraine, \\.idget, 296
cxpect, comando, 290,291 Free Software Foundatioii, 16
export, coiilando, 53,Srí FS, variable, 149
expr, coinaiido, 253,254,255 ftp, comando, 291
expresiones funcióii(es)
GAWK, 160,175 addconnectioii, 393
I'erl, 202-207 addToolBar, 393
shell TCSH, 117-13 8 GAWK, l46,lSl-lS8
Tcl, 252-254 G N O M E , 329,343,346-350
GTK, 337
funciones de retrollamado
(callback5), 341,343

false, coniando, 80-81

fcopy, comando, 280
fr, ~.mlabraclave, 66,67
file, coiiiando, 280,282 G + + , coinpilador, 373,370
FILENAME, variable, 149 gawk, coinando, 141-1 42
 Índice 1 437

GAWK, in?triiccióii, 141-142, 164 glob, coniando, 280

gawk, palabra clave, 185 glob, operaciones, 206
GAWK, prograniación, 13% 186 global, coinarido, 256
archivos de instrucción, 170-171 gniodule, librería, 340
arguinentos, 1 54-1 55 G N O M E , canvas de, 335
arreglos, 167-1 68, 174 G N O M E , escritorio de, 23-25,328,
ayiida en líne'~,9 333
bucles, 175-1 77, 178, 180-181 G N O M E , programación en,
búsquedas de patrones, 142-1 45 327-369
caracteres especiale?, 142-1 45 aplicaciones, 329,331-337,
condiciones, 14 1, 158-164 348-350
constante?, 151, 156 canvas de, 367-369
descripción, 8, 140 conipilación de programas,
estructuras de control, 171-181 347-348
f~iiiciones,146, 151- 158 coniponentes, 33 1
f~iricionesde cadena, 1.5 1-153 cuadros de diálogo, 362-365
operaciones aritniéticas, 164- 167 código fuente, 328
operaciones de asignación, 164- 1 67 descripción, 6, 11,328-331
5cripts de, 184-1 86 entradas, 3 6 5 3 6 7
segniento patrón, 158- 164 eventos, 340-346
uso de archivos con, 182-1 86 funciones, 329,343,346-350
varinbles, 145-1 30 GTIC+, 11- 12,337-340
GAWK, utilidad, 9 GUI, herraniieritas, 328
gcc, coiiipilador, 339 iconos, 360-362
GDK (GIMP Drawing Kit), 331 librerías, 330-337,347
GI>K (GNU Image Mariipulation iiiacros del nienú, 354-355
I'rogrmii), 331 seiiales, 340-346
GIIIC, librería, 340 gnonie-init, f~inción,346
ge, operador, 203-204 giioiiie-stock-buttoiis, función, 362
getline, enunciado, 180-1 81 giioine-stock-pisiiiak>-wi Jget,
gets, coiiiando, 263-266,280,282 función, 362
GIMP ( G N U Iniage Manipulation GnonieApp, widget, 351
l'rograni), 330 GnomeEritry, widgets, 365-366
GIMI' I h w i n g Kit (GDK), 331 GnonieFileEntry, widget, 366
GIMPTool Kit (GTK), 331 GnomeIconEntry, widget, 367
glib, librería, 331,340 GnorneNumberEiitry, widget, 367
438 1 Fundamentos de programación
- --
-
.
en Linux
--

GiiomeI-'ixniap, widget, 367

Giioiiiel'isiiiapEntry, widget, 360
GiioiiieUIInfo, estructuras, 35 1 ,
350-357
G N U Iiiiage Manipulation Prograni
(GIMP), 330 Here, docuniento, 47
G N U Netivork Object Model Here, opernción, 49-50
Environinent, 328 herencia en objetos, 406-407
GNU, librerías, 329 HTML, coniandos de, 202
GNU, licencia pública de, 6, 16,328
GNU, proyecto, 16
GNU, sitio Web de, 7
GNU, software, 6-7
grep, fiiiición, 21 4 if, comando
grep, operacibn, 21 2 Perl, 228,229
grid, adiniiiistrador de geoiiietría, shell UASH, 66-67
300-302 Tcl, 268
gt, operador, 203-204,- 18 if, estructura
GTK GAWK, 178-1 79
eventos, 345 Perl, 228-231
f~~iicioiies,337 sliell BASH, 62,66-70
librería, 336,340 shellTCSH, 1 1 2-1 13,116-1 17,
programación, 337 ' 119-120
programas, 347-348 Tcl, 266,268-270
GTK (GIMI'Tool Kit), 331 if-else, estructura
GTK API, 337 GAWIC, 179
GTI< Toolkit, librería, 336 Perl, 228-230
GTK+, 10-1 1,328-331,338-340 Tcl, 269-270
GTK+, caja de herramientas de, 329, if-then, estructura
333 sliell BASH, 66-70
GTI<+, conjunto de widgets, 328, sliell TCSH, 1 17-1 20
365 Iniage Library (Inilib), 330
GtkObject, 341 Iiiiage, widget, 296
GUI de TcVTk, constructores, 294 Imlib (Iniage Library), 330, 367
GUI, constructores, 294 iiicr, coinando, 256
GUI, herraiiiientas en GNOME, 328 indes, función
GUI. vro~ianiaciónen. 4.325-413
, A -2 , , GAWK, 151-152
 Índice ( 439

I'erl, 23.3, 236, 237 widgets, 372-399, 406-413

info, coiiiaiido, 253 kdecore, librería, 373
iiifoniagic Linus, distribucióii, 27 KIIEIIIR, variable de shell, 380
iiiforniatiori, fiinción, 41 2 kdeui, librería, 373-375
iiisertI3uttoii, función, 392, 393 kernel, 22
insertltem, f~inción,390 Kerniglian, Briaii, 140
interact, comando, 290 keys, operación, 2 16
iriterconesiones KIconLoader, objeto, 392
l'erl, 198- 199 KOffice, suite, 374
shell UASH, 85-88 K O M (KIIE Object Manager), 13
Tcl, 265-266 KOM, librerías, 374
interfiz de usuario, 14 Korii, shell, 22
interfk gráfica de usuario. Viare GUI I<statiisB,ir,widget, 39 1
intérpretes, 6

Label, widget, 296

join, comando, 259,262-203 lappend, coiiimdo, 259, 26 1
join, operación, 2'12 last, con~ando,227, 230-23 1
length, fiinción, 151-152, 161,
235-237
let, coiiiaiido, 58-60
LGPL (Library Ckneral Public
I< Ilesktop Erivironiiieiit.V,a\e KIIE License), 11,329
KApplication, objeto, 370 libart-lgpl, librería, 333
KIIE (K Lksktop Eiivironmeiit), libaudiofile, librería, 332
23-25,371-413 libgdk-irnlib, librería. 332,335
KDE Object Manager (KOM), 13 libgnome, librería, 332,333
KIIE, librería, 12 Iibgnomeui, librería, 332-333, 360
KIIE, programación en, 12-1 3 libgnorba, librería, 333,336
aplicaciones, 370-399 libgtk, librerí,~,332, 336
argumentos, 373 Library Gcnernl Public Liccrise
clase5 de, 12,377 (LGPL), 1 1,329
coiiipilar prograiiias, 379, 380 librería5
descripcibn, 6,372-373 GDK, 330-33 1 , 340
librerí~s,12,373-375,380 GNOME, 330-337,347
440 1 Fundamentos de programación en Linux

GNU, 329 Tk, aplicación, 10,293-323

GTK, 330-33 1,330,340 Linusl>l>C,distribución, 27
GTI<+, 329,339 list, comando, 259,262
I<l>E,12,373-375,380 listas
Qt, 12,380, 399 de Tcl, 259-263
libzvt, librería, 333,336-337 Perl, 207-21 7
lindex, coiiia~ido,259, 260,283 Listbox, widget, 290
liiisert, coiiiando, 259, 201 listdir\fuiic, función, 307-309
Linux Ileiigth, coiiimdo, 259
anatomía de, 22-24 LoadFileTest, función, 3 1 1
comandos, 45-46,254 loadlcon, iiitkodo, 302
descripción, 14-1 7 Ipr, coiiiando, 266
distribuciones de, 25-28 Irmge, coniando, 259, 200
entornos, 22,23 Ireplace, comando, 25'9,261
estructura de archivos, 22-23 1s coniando, 67,270
la llegada de, 20-21 lwarcli, comando, 259,260,285
iiiaiiual en Iíiiea de, 7 kort, coniando, 259, 262
memoria, 21 It, operador, 203-204
recursos de, 28-32 línea de con~andoi
Tcl y, 248 de l'erl, 188- 189
UNIX y, 15 descripción, 22
ventajas, 30 sliell UASH, 50-52
Liiiux, prograiiiacióii e11 sliell TCSH, 102-103, 105
categorías, 36
GAWK, 8,139-186
GNOME, 11-3 2,327-309
(.;Ul, 4, 325-41 3
introduccicíii a la, 3-32 Mac-OS, sisteinas basados eii
leiigiiajes de alto nivel, 137-323 Liii~ixI>I'C;,27
PerI, 9, 187-246 Tcl y, 248
Qt, 399-4 13 UNIX, versiones para, 20
shell, 1-1 35 iiiakefile (archivo de coiiipilaciGn),
shell LIASH, 7-8.33-91 348,380
shell TCSH, 8,03-135 riiaii, coniaiido

Tcl, 10, 247-292 sliell UASH, 7

tipos de, 5-13 sliell T(:SH, 8
 índice 1 441

Tcl, 249 N
Mandrake Liiiiis, distribucióii, 28
nianejador(es), 341
NAWK, 140
de archivos, Perl, 192-199
ne operador, 203-204
de directorio, 232
new, operacióii, 390
nulo de archivos (<>), 196
newfile, función, 410
riianejo dc archivos, coiiTcl,
nest, comando, 227
280-285
iiext, enunciado, 180
inarcos,Tk, 3 14-31 5
NF, variable, 149
matti, li breria, 340
Novell UnixWare, 20
nlcnu, widgets, 296,351-357
NK, variable, 149-1 50, 157, 163
nienubuttoii, widget, 296
nueva línea, carácter de, 252
iiienú(s)
nLiiri, variable, 174
GNOME, 351 -362
iiíimeros de las seíiales, 91
icoiios de G N O M E para,
360-361
KlIE, 389-399
niacroi del, 354-355
selecciones de, 31 4
okjetoi de GNOME, 3.5 1-353
shell UASH, 72
OFS, variable, 149
Message, widget, 296
OMFT, v'iriablc, 140
nietacaracteres, 7 3
Open Groiip, consorcio, 23
Minis. 20
Open Software Foundation (OSF),
ilikdir, coi-iiando, 233
19-20
M O C (coinpilador de ii~etaobjetos),
open, coniando
382-384,404
Perl, 193, 196. 198,220
niodificador de ubicación de
Tcl, 266, 280, 281
decinialcs, 158
Opeii-Look, 20
Motif, protocolo, 20, 328,329
OpenLinus, 26
MULTICS (MULTiplesed
operacibn
Iiiforriiation Coniputing Systeiil),
each, 216
18
iiiy, 24 1 , 244
nidtitarea, 13
pop, 212,213
iriiiltiiis~~ario,caractcrístic:is de. 15
p~ish,2 12, 213
iiiyfuiic, fiinción, 343
iiiiihifi, 2 12, 213
inyobj, objeto, 384
opcrnciones aritiiiCticas
ináquiiias l>owerl>C,27
GAWK, 164-167
- Fundamentos de programación
442
- en Linux
.---

Perl, 203,204 GAWK, 161

ihell UASH, 58-60 l'crl, 2 18-220
shell TCSH, 105- 1 08 shell UASH, 59
opermoiies de cndeiia, 63, 21 8 operador 01< lógico ( 1 ), 59
operacionei increinento, L 67 operador O K lógico ( 1 1 )
operdciones relacioiialec GAWK, 1 G 1
GAWK, 158- 16 1 Perl, 21 8-220
$he11LIASH, 59 shell UASH, 71
5hell TCSH, 107 operadorei
operador de Perl, 203-204,218
adición (+), 59 GAWK, 159
coiiia (,), 163 shell UASH, 59
de divisióii (/), 59 operadorei de expreiión, 59
de inódulo ('X), 59, 203 OR, operador ( 1 1 )
de ni~~ltiplicación (*), 50 GAWK, 1 61
de iuitraccióri (-), 59 l'crl, 2 1 8-220
decremento (--). 167 shell BASH, 70-7 1
dot (.), 235, 236 01113it, 328,330
incremento (++), 107 ORS, vari~ble,149
le, 203-204 OSF (Operi Softw'irc Foiiiidation),
opeiador ANL) lógico (&&) 19-20
GAWK, 161 Oiisterhoiit,John, 10, 248,249
l'erl, 2 18-220
shcll UASH, 70-71
operador ANI lógico (&), 59,406
operador de mgnación
GAWK, 164-1 67 pack, administrador de geometría,
l'erl, 203-205 300, 301-302
iliell BASH, 41 paréntesis ( )
he11 TCSH, 106 arreglos TCSH, 99-1 O 1
opeilidor lógico NOT (!), GAW K, 1 O 1 Perl, 242
operador mayor qiie o igual J (>=), Tcl, 254
59,203 paréiitesjs ciiadrados 1 1
o p e r ~ d o inenor
r que o i g d a (<=), CAWK, 144, 145, 162
59, 203, 207 shell UASH, 64
oper,idor no es igiial (!=), 59 Tcl, 267,273
operador N O T lógico ( 1 ) patrones
 índice ( 443

en I'erl, 237-240 Practica1 Extraction and llcport

GAWK, 141-145,158-104 Language. I 4 k e l'erl
patrones de evento, 303-306 print, comando
patrones de rango, 103 GAWK, 143,183-184
perl, coniando, 188-1 89, 100 I'erl, 191, 193, 194-1 95,201,205,
l'erl, lenguaje, 188,233-235 238
I'erl, prograniación eri, 187-246 printf, coiiiando, 193, 195
arreglos, 207-2 1 7 proc, coniando, 285-286
biicles, 22 1-228 progr.iniacióii. Mnsc Liniis,
concordancia de patrones, programación en
237-240 proyectos
descripciím, 9, 188 bucles básicos, 76-77
entrada y salida, 192-1 96 copia de archivos, 284-285
errores de sintaxis, 191 crear un adniiriistrador de archivo,
estructuras de control, 191, 3 1 6-322
2 17-235 entrada del usuario, 47-48
expresiones, 202-207 exportar variables, 56-57
f~iiicionesde cadena, 235-237 índice de páginas Web, 82-84
índices, 233-235 índices con el shell TCSH,
listas, 207-2 17 133-133
iiiaiiejadores de archivos, 196- 199 índices con Perl, 233-235
operaciones con la línea de GNOME Hello, 348-350
coiiiaiidos, 188-1 90 ' iiienús Archivo y Editar, 358-360
operadores, 203-204, 21 8 iiieiiús con switch, 121-1 24
perriiisos de archivos, 197 iiieiiús y barras de herraiiiientas
scripts, 188, 190- 192 de KDE, 393-399
sub, función, 240-246 operaciones de archivo, 288-290
usos de la, 4 presentar uii directorio, 302-304
variables, 191,202-207,238-240 scripts de GAWK, 184-1 86
periiiisos usar subru tinas, 244-246
l'erl, 197 ventana IWE, 385-389
sliell UASH, 36-40 Public Iloiii~iiiKorii, sliell, 22
place, adiiiiriistrador de geoiiietría, . punto y coma (;), 148
300, 30 1-302 GAWK, 148, 179
POSIX (Portable Operating Systeiii I'erl, 19 1
Interface for Computer Tcl, 252
Environrrients), 21 p~its,coniando, 263-260,280, 282
444 1
- Fundamentos de programación
- en Linux
- - 7

pwd, coniando, 253 sliell UASH, 47-50, 86-87

páginas manuales, 188, 192 shell TCSH, 07
Tcl, 280
readdir, coiiiaiido, 232
recursos. V4il.w Sitios Web
lied Hat Linus. 25-26
QApplication, objeto, 403,402 redireccioiianiie~~to, 85-88
QApplication, widget, 40 1, 402 redo, coiiiarido, 228
QMessageUox, widget, 41 1 referencias, 206-207
Qt, aplicnciones, 399-403 regesp, con~ando,287
Qt, cajade Iierraniientas, 12,372, regsub, comando, 287
390 repdir, coniando, 232-233
Q t , programación en, 399-41 3 repeat, estructura, 125, 130
aplicaciones, 399-403 reports, comando, 198-1 99
argumentos, 402 retrollai~~ado, fuiicióii de, 403
cuadros de diálog0~411-412 1-eturn,coii~ando,286
descripción, 372 retui-11,eiilinciado, 243,402
herencia en objetos, 406-407 reverse, operación, 2 12,213
librerías, 12,380,399 rindes, fiincióii, 236, 237
seiiales, 381 -382,403-404 Ilitchie, lkiinis, 1 8
slots, 38 1-382, 403-404 riiidii-, coiiiando, 233
ventanas, 405, 407 I\l>M, paquetes, 25,27
widgets, 3C)9-403,4b7-412 llS, variable, 149
QT11111, variable del shell, 380
quit, fiinción, 41 1
QWidget, coiistriictor, 408-400

salida estándar (STDOUT), 194- 196

Scale, widget, 296
scan, coiriando, 280
script, entrada y snlidn dc un, 47-50
radiobutton, widget, 296 scripts
ratón de GAWK, 184-186
bot611 del, 342 de Perl, 1 88, 190-192
eventos del, 304,314-31 5 del sliell TCSH, 94,97-99
puntero del, 342 GNOME, 347
read, coiiinndo Tcl, 251
 --
Índice ( 445

Tk,295 sliells, prograinación de los, 1 - 135

scripts del shell BASH, 33-52 shift, operación, 2 12, 2 13
argumentos de la línea de shoní fiinción, 377,39 1,393,402,
coinandos, 50-32 406
comentarios, 35-40 signal, fiiiicióri, 404
descripción, 35 signo de dinero (S)
ejec~~tar, 36, 39-40 GAWK, 146
exportar variables, 53-57 l'erl, 19 1, 197,202,208
let, coniando, 58-60 sliell UASH, 41,42,43
Ilaniar otros scripts, 53 sliell TCSH, 96, 1O0
operaciones aritméticas, 58-60 Tcl, 255
perinisos, 36-38 signo de interrogación (?)
variables, 4 1-50,53-57 GAWK, 145
Scrollbar, widget, 296 shell UASH, 42
seek, coiiiando, 280 Tcl, 273
seleccionar estructura, 73 signo de riúiilero (#)
selectfile, f~inciim,312 arreglos TCSH, 96- 101
selection, coniaiido, 296 shell UASH, 36,39,95
separadores de campo, 168 signo de porcentaje ('Xi), 157-1 58,203
set, coniando signo i g ~ ~(=)
al
shell UASH, 42 GAWK, 158
shell TCSH, 95-99, 108 I'erl, 203, 204
Tcl, 252,254-257,259 ' shell I-IASH,59,63,64
setBarPos, f~iiición,393 signo menos (-), 36, 203
setenv, coniarido, 108- 1 1 1 signo iriás (+), 36, 145, 203
setMain Widget, fiinción, 377,402 sistenia de archivos, 23
setStatusUar, fiinción, 391 sistenias operativos, 14- 15
señales sitios Web
GNOME, 340-346 Caldera, 26
IClIE, 38 1-382 de GNU, 7,9
Qt, 381-382, 403-4U4 Ikbian Lin~is,26
shell UASH, 88-89 Espect, aplicación, 290
shell wisti, 11, 295, 296 GNOME, 12,24,329
shell, interhz del, 22 GTK API, 337
shell, progranias del, 7,8, 34,35 lnfoniagic, 27
sliell, scripts del. V6me Scripts ICDE, 13,24,372,377,309
shells padre, 108 Linux, recursos, 57-60
446 1 Fundamentos de programación
-. .
en Linux

Liii~ixPlX,27 subscripts, 167, 168

Ma~idrakc,28 subshells
O p m Group, consorcio, 23 shell UASH, 53-56
OpeiiLin~ix,26 shell TCSH, 108-121
I>erl,9, 188 subst, coiiiaiido, 287
Qt, 399 substr, fiincióii, 152,153,235,236,237
I<ed Hat, 25-26, 2.50 siibwidgets, 373
Scriptics Tcl/Tk, 250 SuSE Liiiiix, distribución, 26
Slackwai-e,27 switch, coniaiido, 274
SuSE, 26 switch, estructura
Tcl, 1 0 I'erl, 230-231
Tk, 10 shellTCSH, 112-1 13, 1 15,
Troll Tech, 372 120-1 24
T~irboLinux,27 Tcl, 206, 272-274
slackwart. Liii~ix,distribucióii. 27 switch, palabra clave, 272
slots SysteiiiV UNIX, 19,20
I<l)E, 381-382,403-404 Systerii V/386,20
Qt, 403-404 símbolo (@,), 207-2 1 0
socket, coniando, 280 sínibolo de puilto (.), 35, 42, 144
sort, filtro, 9, 140 síiiibolo iiiayor que (>)
sort, operación, 2 12,213 k r l , 193, 198,2O3,218
source, coimiido, 280 shell UASH, 42,59
s p v i i , coinando, 290 ' Tcl, 267
split, coiiiaiido, 259,262-263,287 síiiibolo iiieiior que (<)
split, f~iiiciGii,151, 1 52, 168, 174 I>erl,193, 203
split, operacióii, 2 12, 214 shell BASH, 42,59
spriiitf, coiiiaiido, 194 Tcl, 267
STIIIN (entrada cstáridar), 193-1 94, síinbolos de modo, 197
263-264
S T D O U T (salida estáildai-), 194- 196
string indes, coniando, 287
string length, coii~andu,287
striiig match, coiiiaiido, 2136 tajadai, 21 0-21 2
string raiige, coiiiando, 280 Taniieiibauiii, Ariclrew, 20
striiig, coiiiaiido, 286-288 TC-hell, 22
sub, coniaiido, 240-242 Tcl (Tool Coinmaiid Language),
sub, fiiiición, 240-246 247-292
subrutii~as,240-246 aplicaciones de, 249-25 1
 Índice 1 447
nrg~~nientos, 270, 283 variables de entorno, 108-1 1 1
arreglos, 256-258 tell, coniando, 280
bucles, 266,27.5-280 test (prueba), condiciones, GAWK,
condiciones, 266 141, 1.58
descripción, 1O, 248-249 test, coniando, 03-65
entrada g salida de, 203-26h test, condiciones, shell TCSH, 1 12
estructuras de control, 266-280 Test, coniando, 3 1 1
Espect, aplicación, 290-29 1 test, widget, 296
expresiones, 252-254 then, palabra clave, 66, 116
extensiones de, 249-254 Thonipson, I h i , 18
GUI, constructores, 294 timeout, coniando, 291
listas, 259-263 tipos de niinie, 333
manejo de archivos, 280-285 Tk. aplicación, 293-323
operaciones de archivo, 288-290 ~idniinistradoresde geonietría,
operadores especiales, 1 16 300-302
procedimientos de, 285-286 descripción, 10,294
scripts, 251 etiquetas, 3 14-3 31 5
T k y, 10,248,294 eventos, 304-309
usos de, 4 extensiones de, 249-250
variables, 255-236,258 GUI, constructores, 294
tclsh, coitiando, 10, 248, 251 niarcos, 3 14-33 5
TCSH, prograniación dcl shell, 93-135 scripts, 295
argumentos, 94-97, 101-7 08 sliell wisli, 1 1 , 295
arreglos, 99- 108 Tcl y, 10,248-249,294
ayuda en línea, 8 uniones, 304-309
bucles, 1 15- 120, 125-1 26 usos de la, 4
coniando read y, 97 ventanas, 31 0-31 4
condiciones, 1 1 5- 124 widgets, 294,295-304
ciescripción, H,94 Tk, ventana en el shell, 295
estructiiras de control, 1 12-1 15,1 16 Tk, widgets de, 295-304
expresiones, 1 11 7- 1 18 Tool Coniiiiand Laiigiiage. Vi.osc Tcl
Ilaniar scripts de lJerl desde, toolbar, widgets, 351 -357
201 -202 toplevel, coniando, 296,3 1 O
opernciones aritiiibticas, 105-1 OS Torvalds, Linus, 20
operador de asignación, 106 trace, coinando, 253
scripts, 94, 97-90 trap, coniando, 89-90
variables, 94-97, 105-1 11 trap, estructuras, 88-90
448 1 Fundamentos de programación en Linux
- --

tree, argumento, 357 variables

true, coiilando, 80-8 1 GAWK, 145- 1 50
TuiboLiniis, clistribucióii, 27 l'erl, 191, 196,202-207,238-240
shell LIASH, 35,41-50,55-56
shell T C S H , 95-97,105-111
Tcl, 255-256,258
variables de campo, 145,146-1 48,173
iindef, operación, 217 variables de entorno
iiniones, 304-309 shell UASH, 55-56
UNIX sliell T C S H , 108-1 1 1
descripción, 16- 17 Tcl, 258
historia de, 17-20 variables locales, 108
Linux y, 15 ventanas
Tcl y, 248 GTK, 338
versiones de, 19-20 I<I>E,376-378,385-389
versión USII de, 19 Q t , 405, 407
versión Systeni V, 10, 20 Tk, 310-31 4
U N I X System Laboratories, 19 virg~llill~ (-), 162
UnixWlare, 20
uiiless, comando, 228, 229, 230
unset, cornando
shell UASH, 42
shell T C S H , 93 wc, filtro, 9, 140
Tcl, 250 while, bucle
~iritii,estriictiin, 73-74, 77 GAWK, 171-175
LIP level, coniando, 296 l'erl, 189,22 1-222,224,238
~iplevel,coiilando, 286 sliell UASH, 62,74-77,86
upvar, conlando, 256 shell T C S H , 112, 125-126
USU, soporte para el, 27 Tcl, 275-276
use, cornando, 192 while, coniando, 275
while, estructura
shell UASH, 62,73-74,86
sliell TCSH, 112- 115,125-127,13 1
Tcl, 266
values, operación, 216,217 while, palabra clave, 74, 222
variable, coniando, 250
 índice 1 449
widgets wni, comando, 296,3 1 O
de Tcl, 249 wrappers, 329
deTk, 249,294,295-304
descripciOn, 11
GNOME, 351-357,365-307
GTK, 337,34 1
KIIE, 372-399,406-413 X Window, sisteina, 1 1,24,295,330
Q t , 399-403,407-412 s,operador, 235,236
widgets de distribiicií,n, 407 X 11, caja de herramientas, 294
window, coninndo, 295 XIINLI, protocolo, 329
Wiiidowq, sisteiiias basados en Xenix, sistema, 20
Tcl y, 248 Xest, librería, 340
versiones U N l X para, 20 Xlib, librerías, 330-331,340
wish, coniando, 11,295 Xterni, ventana, 295