90383990 comandos-basicos-unix

eman ta zabal zazu

Universidad

del país vasco

Euskal herriko

Unibertsitatea

COMANDOS BÁSICOS UNIX

(LABORATORIO DE TELEMÁTICA)

INGENIERÍA DE TELECOMUNICACIÓN

SISTEMA OPERATIVO

UNIX

DEPARTAMENTO DE ELECTRÓNICA Y TELECOMUNICACIONES

ÁREA DE INGENIERÍA TELEMÁTICA

Sistema Operativo UNIX pág i

Laboratorio de Telemática

INDICE

1. INTRODUCCIÓN _____________________________________________________ 1

1.1 SISTEMAS OPERATIVOS __________________________________________________ 1

1.2 BREVE HISTORIA DEL SISTEMA OPERATIVO UNIX _________ _______________ 1

1.3 CARACTERÍSTICAS GENERALES DEL S.O. UNIX ___________________________ 1

2. ACCESO AL SISTEMA Y COMANDOS GENERALES_______________________ 3

2.1 USUARIOS Y ACCESO AL SISTEMA ________________________________________ 3

2.2 FORMATO DE COMANDOS _______________________________________________ 4

2.3 COMANDOS INFORMATIVOS _____________________________________________ 5

2.4 COMANDOS DE MENSAJE ________________________________________________ 6

3. FICHEROS __________________________________________________________ 7

3.1 CONCEPTO Y TIPOS DE FICHEROS _______________________________________ 7 3.1.1 DENOMINACIÓN DE FICHEROS ________________________________________________ 7

3.2 EL SISTEMA DE FICHEROS. DIRECTORIOS ________________________________ 8

3.3 MANIPULACIÓN DE DIRECTORIOS _______________________________________ 9

3.4 MANIPULACIÓN DE FICHEROS ___________________________________________ 9

3.5 PROTECCIONES DE FICHEROS __________________________________________ 11

4. COMUNICACIONES ENTRE USUARIOS ________________________________ 14

4.1 MAIL ___________________________________________________________________ 14

4.2 NEWS ____________________________________________ ¡Error! Marcador no definido.

4.3 WRITE __________________________________________________________________ 15

5. EDITORES __________________________________________________________ 16

5.1 EL BUFFER DE MEMORIA _______________________________________________ 16

5.2 DOS MODOS DE FUNCIONAMIENTO DE EDITORES _______________________ 16

5.3 COMPARACION ENTRE LOS EDITORES DE LÍNEAS Y DE PANTA LLA ______ 17

5.4 EL EDITOR vi ___________________________________________________________ 17 5.4.1 PARA EMPEZAR EN vi _______________________________________________________ 18 5.4.2 MOVIMIENTOS DEL CURSOR _________________________________________________ 18 5.4.3 EL MODO TEXTO ____________________________________________________________ 19 5.4.4 CÓMO AÑADIR TEXTOS A UN FICHERO YA EXISTENTE _________________________ 19 5.4.5 BORRADO Y ALTERACIÓN DEL TEXTO _______________________________________ 20 5.4.6 PARA DESHACER CAMBIOS: u y U ____________________________________________ 20 5.4.7 CÓMO ABANDONAR EL EDITOR vi ____________________________________________ 20 5.4.8 OTROS COMANDOS vi _______________________________________________________ 21 5.4.9 COMANDOS DE POSICIÓN DEL CURSOR _______________________________________ 22 5.4.10 "DESPLAZAMIENTO" Y "PAGINADO" DE LA PANTALLA _________________________ 22 5.4.11 BÚSQUEDA DE PATRONES ___________________________________________________ 23 5.4.12 OPERADORES QUE BORRAN, DUPLICAN O CAMBIAN Y REORGANIZAN EL TEXTO. 24 5.4.13 LOS OPERADORES YANK Y DELETE COMBINADOS CON EL COMANDO PUT ______ 25 5.4.14 BORRADO, DUPLICACIÓN Y REORGANIZACIÓN DE TEXTOS EN BUFFERS TEMPORALES ______________________________________________________________________ 26 5.4.15 OTROS COMANDOS Y PARTICULARIDADES DE vi ______________________________ 27

5.5 EL EDITOR DE LÍNEAS ex ________________________________________________ 28

pág ii Sistema Operativo UNIX


5.5.1 INTRODUCCIÓN ____________________________________________________________ 28 5.5.2 LLAMADA AL EDITOR ex_____________________________________________________ 28 5.5.3 FORMATO DE LOS COMANDOS ex ____________________________________________ 28 5.5.4 LOCALIZACIÓN DE LÍNEAS __________________________________________________ 29 5.5.5 BÚSQUEDA DE PATRONES ___________________________________________________ 30 5.5.6 DESPLAZAMIENTOS POR EL TEXTO __________________________________________ 31 5.5.7 INTRODUCCIÓN DE TEXTO EN ex _____________________________________________ 31 5.5.8 EL COMANDO DE SUSTITUCIÓN: s ____________________________________________ 32

6. PROCESOS Y ENTORNO _____________________________________________ 34

6.1 CONCEPTO DE PROCESO ________________________________________________ 34

6.2 CONCEPTO DE ENTORNO _______________________________________________ 34

6.3 VISUALIZACIÓN DE PROCESOS __________________________________________ 35

6.4 VARIABLES _____________________________________________________________ 35

7. PROGRAMACIÓN SHELL. CONCEPTOS BÁSICOS _______________________ 37

7.1 METACARACTERES _____________________________________________________ 37

7.2 REDIRECCIONAMIENTOS _______________________________________________ 38

7.3 PIPELINES ______________________________________________________________ 39 7.3.1 FILTROS____________________________________________________________________ 40

7.4 ASIGNACIÓN DE SALIDA DE COMANDOS A VARIABLES ______ ____________ 40

8. PROGRAMACION SHELL. COMANDOS ________________________________ 40

8.1 COMANDO sort __________________________________________________________ 40

8.2 COMANDO grep _________________________________________________________ 41

8.3 COMANDO wc ___________________________________________________________ 41

8.4 COMANDO tee ___________________________________________________________ 42

8.5 COMANDO cut __________________________________________________________ 42 8.5.1 CORTE POR CARACTERES ___________________________________________________ 42 8.5.2 CORTE POR CAMPOS ________________________________________________________ 42

8.6 COMANDO pr ___________________________________________________________ 43

8.7 COMANDO lp ___________________________________________________________ 43

8.8 EL COMANDO expr ______________________________________________________ 43

9. PROGRAMACIÓN SHELL. CONTROL DE PROCESOS ____________________ 44

9.1 EJECUCIÓN DE PROCESOS EN BACKGROUND ____________________________ 44

9.2 PRIORIDAD DE UN PROCESO ____________________________________________ 45

9.3 CÓDIGO DE RETORNO __________________________________________________ 45 9.3.1 COMANDOS true y false _______________________________________________________ 46

9.4 EL COMANDO test _______________________________________________________ 46 9.4.1 EL COMANDO test CON FICHEROS COMO ARGUMENTOS ________________________ 46 9.4.2 EL COMANDO test CON NÚMEROS O CARACTERES COMO ARGUMENTOS ________ 46

10. FICHEROS DE COMANDOS __________________________________________ 47

10.1 ARGUMENTOS EN LOS FICHEROS DE COMANDOS ______________________ 47

10.2 INTRODUCCIÓN DE DATOS A TRAVÉS DE VARIABLES __________________ 48

10.3 COMANDO exit ________________________________________________________ 49

10.4 ESTRUCTURAS DE PROGRAMACIÓN ___________________________________ 49

Sistema Operativo UNIX pág iii


10.4.1 LA CONSTRUCCIÓN if _______________________________________________________ 49 10.4.2 LA CONSTRUCCIÓN while ____________________________________________________ 51

10.4.2.1 LOS COMANDOS break y continue __________________________________________ 52 10.4.3 LA CONSTRUCCIÓN for ______________________________________________________ 53 10.4.4 LA CONSTRUCCIÓN case _____________________________________________________ 53

Sistema Operativo UNIX pág 1


1. INTRODUCCIÓN

1.1 SISTEMAS OPERATIVOS UNIX es un sistema operativo. Por tanto, su función básica es, por una parte, controlar los recursos de un computador y, por otra parte, ofrecer a los programas una interfaz más independiente del hardware. Estos recursos se pueden clasificar, de forma muy amplia, en:

♦ La Unidad Central de Proceso (CPU). ♦ La memoria RAM de funcionamiento del computador. ♦ La memoria de almacenamiento en disco.

Un sistema operativo modeliza esos recursos por medio de lo que se denomina sistema de archivos y gestión de memoria.

1.2 BREVE HISTORIA DEL SISTEMA OPERATIVO UNIX El sistema operativo UNIX nació en los laboratorios Bell, de la compañía AT&T de Estados Unidos, en 1.969. El 'padre' del sistema fue Ken Thompson, con la colaboración de Rudd Canaday, Doug McIlroy, Joe Ossana y Dennis Richie, los cuales utilizaron un viejo computador abandonado para desarrollar un pequeño "sistema de propósito general” de tiempo compartido, que rápidamente comenzó a llamar la atención. A comienzos de la década de los 70, el sistema UNIX fue cedido a las universidades, alcanzando pronto gran popularidad, debido a varias razones: 1. Era un sistema utilizable en minicomputadores. 2. Era flexible, ya que a las universidades se les cedió el código fuente del sistema con lo

que podían incorporar diversas modificaciones. 3. Era barato, ya que se les cedió a las universidades de forma prácticamente gratuita. Obviamente, frente a estas ventajas debían contraponerse una serie de inconvenientes: 1. El sistema no estaba lo suficientemente probado, por lo que contenía errores. 2. La documentación existente era muy escasa. 3. No existía soporte técnico. La llegada del sistema UNIX a la Universidad de Berkeley supuso un gran impulso, hasta el punto de que lanzó su propia versión. Fue en este momento cuando AT&T lo comenzó a comercializar, al tiempo que Berkeley continuaba desarrollando el sistema, añadiendo más capacidades, a lo largo de varias versiones, hasta llegar a la actualidad.

1.3 CARACTERÍSTICAS GENERALES DEL S.O. UNIX Hay cuatro clases de sistemas UNIX:

♦ UNIX de AT&T ♦ Berkeley ♦ Sistemas con licencia por AT&T ♦ Asimilados

pág 2 Sistema Operativo UNIX


El UNIX AT&T es el UNIX standard; los sistemas con licencia deben estar autorizados por AT&T. Habitualmente los sistemas con licencia incluyen el UNIX AT&T al que añaden ciertas capacidades adicionales. Los asimilados no son UNIX realmente (UNIX sólo es el de AT&T y Berkeley) pero su funcionamiento y estructura es casi la misma.

1.3.1 CARACTERÍSTICAS ESPECÍFICAS DEL SISTEMAS OPERATIVO UNIX Al sistema operativo propiamente dicho se le suele denominar kernel y está constituido por el código máquina que coordina el hardware, a fin de que efectúe las distintas operaciones requeridas. Por otra parte, se suelen incluir junto con el sistema operativo una serie de utilidades básicas como un intérprete de comandos o shell, que interpreta las órdenes dadas al ordenador y ejecuta otros procesos, así como pequeñas utilidades para manipular ficheros.

1.3.2 El intérprete de comandos (shell) de UNIX El intérprete de comandos de UNIX, o shell, es un proceso que muestra un indicador de comandos ($, %, o #) y aguarda que el usuario introduzca un comando. Toda vez que el usuario introduce un comando, el intérprete lo valida, y si es correcto crea un proceso hijo que realiza la acción encomendada. Al terminar el proceso hijo, exhibe nuevamente el indicador de comando e intenta leer una nueva línea de la entrada.

1.3.3 Procesos Un proceso es básicamente un programa en ejecución. Consta del programa ejecutable, datos, pilas, registros y toda la información necesaria para ejecutar. Un intérprete de comandos (shell) es un proceso que lee los comandos de usuario desde una terminal y crea procesos hijo para ejecutar ese comando. Se crea así un árbol de procesos en ejecución. Los procesos se manejan mediante señales que los obligan a suspender, reiniciar o terminar su acción. Las señales se utilizan también para comunicación entre procesos. Cada usuario tiene asignado un identificador de usuario (uid), y grupos de usuarios tienen un identificador de grupo (gid). Un proceso tiene asignado el uid y gid del usuario que lo inició. Ambos identificadores se utilizan para proteger la información manejada por el proceso.

1.3.4 Archivos Existen llamadas al sistema para crear, eliminar, leer y escribir archivos. Los archivos se agrupan en directorios, y existen llamadas al sistema para crear y eliminar directorios, y para colocar y quitar archivos de ellos. Esto crea una jerarquía de directorios y archivos llamada sistema de archivos que se estudiarán en detalle en los apartados siguientes. Por otro lado, todos los sistemas UNIX tienen una serie de características comunes, que deben ser tenidas en cuenta. Básicamente son: - Existe distinción entre letras mayúsculas y minúsculas. - No es un “user friendly system”. Existen pocos mensajes de advertencia en la ejecución de comandos. - No todo el mundo puede utilizar un sistema UNIX. Sólo los usuarios autorizados pueden hacerlo. Debe distinguirse entre el usuario normal y el manager o superusuario.



2. ACCESO AL SISTEMA Y COMANDOS GENERALES

2.1 USUARIOS Y ACCESO AL SISTEMA Como ya se ha indicado, el sistema UNIX sólo puede ser utilizado por los usuarios autorizados. Los usuarios se clasifican en dos clases: usuarios normales y superusuario o root. El superusuario es un usuario especial, con mayor capacidad y privilegios que los demás, que se encarga de controlar y cuidar del buen funcionamiento del sistema. Sus actividades y responsabilidades se estudiarán en los capítulos correspondientes a la administración del sistema. Un usuario normal es una persona que tiene permiso para utilizar el sistema. A su vez, los usuarios están distribuidos por grupos, asignados por el root, y que habitualmente reciben a usuarios con tareas similares. A diferencia de un computador personal al que cualquiera puede acceder una vez puesto en marcha, en UNIX sólo los usuarios pueden acceder. Cuando se enciende un sistema bajo UNIX, el sistema, después de realizar una serie de tests y operaciones previas, lanza este mensaje a pantalla: login: Esa es la señal de que el sistema está preparado para atender la petición de acceso de un usuario. El usuario es reconocido por el sistema mediante el nombre de usuario. Este nombre puede estar formado por cualquier cadena de caracteres (tradicionalmente con un máximo de 8 caracteres, aunque en muchos sistemas Unix actuales el límite sea mayor), y es introducido al sistema por el superusuario. Una vez introducido el nombre, se accede al sistema, de forma que en la pantalla aparecerá el prompt, representado habitualmente por el símbolo $. A partir de este momento, el usuario ejecutará los comandos y procesos que desee. Así pues, un usuario sólo necesita su nombre para acceder al sistema. Sin embargo, cualquier persona que posea este dato puede acceder al sistema en nombre de otro. Para evitar esto, un usuario puede protegerse mediante la utilización de una palabra clave o password. La asignación del password es realizada por el propio usuario, mediante el comando passwd. Este comando solicita al usuario el password, que será introducido por duplicado para evitar confusiones, ya que su tecleado no se refleja en la pantalla. De esta forma, el usuario queda protegido, de modo que al solicitar acceso al sistema, tras el login, aparecerá el mensaje password: indicando que el mismo debe ser introducido. Si éste no es correcto, volverá a lanzarse a pantalla el mensaje login: Si alguien teclea un nombre no autorizado, el sistema le solicita el password, con el fin de que no sepa si ese usuario existe o no. Una vez terminado el trabajo, el usuario debe abandonar el sistema, lo que hará mediante el comando exit o bien con las teclas ctrl-d. Al período de tiempo transcurrido entre un acceso y posterior abandono del sistema se le denomina sesión. También, al hecho de poseer un nombre autorizado en el sistema se le denomina "tener una cuenta". Por tanto, ser usuario autorizado o -tener una cuenta- en un sistema expresa el mismo concepto.



2.2 FORMATO DE COMANDOS Una vez dentro de una sesión, el manejo del sistema se realiza a través de comandos o aplicaciones. Un comando es una orden propia del sistema que realiza una función determinada. Una aplicación es un programa de computador creado por un usuario, que igualmente transmite órdenes al computador. Operativamente, no existe ninguna diferencia entre comando y aplicación. La única distinción reseñable entre ambos es el hecho de que el comando pertenece al sistema operativo, y en todos los UNIX standard el mismo comando ejercerá la misma función. En UNIX los distintos comandos están escritos originalmente en lenguaje C como ya se indicó previamente. Si se desea conocer el programa concreto que se utiliza al ejecutar un comando, se puede visualizar mediante el comando which: $ which echo /bin/echo Cuando se ejecuta un comando, debe tenerse en cuenta el formato del comando. De manera general. este formato responde a la siguiente estructura. $ comando opciones argumentos El comando es, sin más, su nombre, que lo distingue de los demás, y que permite al sistema determinar la orden a ejecutar cuando es tecleado. Los comandos siempre se escriben en letras minúsculas. Una opción es un indicador que modifica de alguna manera el funcionamiento general y habitual del comando. Como tal opción no tiene por qué utilizarse siempre. Habitualmente, las opciones consisten en un solo carácter (si bien pueden ser más) escrito en mayúsculas o minúsculas (aunque a veces pueden intervenir caracteres numéricos). Normalmente, las opciones van precedidas por un guión -. Las opciones son acumulativas, de modo que sobre un comando pueden actuar a la vez distintas opciones, dando como resultado la ejecución del comando con las particularidades correspondientes a todas las opciones. En este caso, únicamente antes de la primera opción se colocará el guión. Así, si el comando cmd se ejecuta con la opción b o la c, el comando se escribirá $ cmd -b ó $ cmd -c Pero si se ejecuta simultáneamente con las dos opciones, se escribirá $ cmd -bc ó $ cmd -cb Entre comando y opción debe existir al menos un espacio en blanco (y no comas, guiones u otros caracteres. El espacio en blanco es el separador universal en UNIX). No deben dejarse espacios en blanco entre las distintas opciones de un comando. Además, debe indicarse que antes de escribir el comando pueden dejarse tantos espacios en blanco como se desee, con una sola excepción: el comando exit que debe ir situado al comienzo de la línea.



Un argumento es “aquello” sobre lo que recae la acción del comando, o bien una información externa suministrada por el usuario, y que resulta necesaria para la ejecución del comando. En muchas ocasiones, los argumentos serán ficheros del sistema. El número de argumentos que puede utilizar un comando puede decirse que es ilimitado, si bien raras veces se usan más de dos. Entre un argumento y las opciones (en caso de haberlas) debe existir al menos un espacio en blanco, al igual que entre los distintos argumentos entre sí. Cuando se ha escrito correctamente un comando, debe presionarse la tecla INTRO, con lo que el comando es ejecutado. Siempre que se pulsa INTRO, el cursor de pantalla se situará en el primer lugar de la línea siguiente de la pantalla. Pueden combinarse varios comandos en una misma línea a través del símbolo ';'. Sin embargo, esta no es una práctica aconsejable.

2.3 COMANDOS INFORMATIVOS Los comandos informativos proporcionan al usuario informaciones generales sobre el sistema. Los principales son los siguientes: • date: escribe en pantalla la fecha y hora del sistema. Este comando no utiliza

argumentos habitualmente, si bien posee numerosas opciones. Excepcionalmente, las opciones van precedidas por el signo + en lugar de -. Además, todas sus opciones comienzan con el símbolo %. Las más importantes son:

% a: escribe únicamente el día de la semana de forma abreviada % A: escribe únicamente el día de la semana de forma completa % b: escribe únicamente el nombre del mes de forma abreviada % B: escribe únicamente el nombre del mes de forma completa % d: escribe únicamente el día del mes en número (01-31) % H: escribe únicamente la hora en número (00-23) % j: escribe únicamente el día del año en número (001-366) % m: escribe únicamente el mes como número (01-12) % M: escribe únicamente el minuto como número (00-59) % S: escribe únicamente el segundo como número (00-59) % x: escribe únicamente la fecha % X: escribe únicamente la hora % y: escribe únicamente el año sin el siglo (0-99) % Y: escribe únicamente el año con el siglo

El comando date también permite modificar la fecha y hora del sistema. Esta función sólo le está permitida al manager; en este caso el comando utiliza un argumento compuesto por 10 cifras, con la siguiente estructura. $ date mm dd hh nn aa mm = mes dd = día hh = hora nn = minuto aa = año



• who: este comando indica qué usuarios están conectados al sistema en un momento determinado.

Habitualmente, este comando no lleva argumentos. Cuando se utiliza, aparecen en pantalla los usuarios que en ese momento se hallan conectados al sistema. Por cada usuario, se escribe el nombre, la terminal a la que está conectado, la fecha y la hora de conexión. Su principales opciones son: -b: indica la fecha y hora en que el sistema fue conectado por última vez -t: indica el último cambio del reloj del sistema realizado por el manager utilizando el comando date. Además de éstas, el comando posee la opción 'am i", escrita sin guión (who am i) y que proporciona el nombre del usuario conectado a mi terminal. No debe confundirse con whoami comando que realiza la misma función. “whoami” es un comando, mientras que “who am i” es un comando con una opción. • id: proporciona la identificación del usuario invocante, dando el nombre de usuario y su

número (UID), nombre de grupo primario y su número (GID), nombres de otros grupos a los cuales pertenece (si los hay) y sus números.

• finger: proporciona nombre del usuario en el sistema, nombre en la vida real y otros

datos del usuario invocante, indicando si está en este momento en el sistema, y si tiene correo por leer.

• hostname: muestra el nombre de la máquina UNIX sobre la que se está trabajando. • man: este comando proporciona información sobre el funcionamiento de un comando del

sistema. Es un manual incorporado al sistema, y resulta muy útil.

El comando man siempre lleva un argumento, que es el nombre del comando del cual queremos la información. Posee una opción, la “k”' con la cual, se obtiene una información más resumida que en el caso anterior y referente a todos los comandos similares al solicitado.

• apropos: muestra el nombre de la máquina UNIX.

2.4 COMANDOS DE MENSAJE Son comandos que únicamente reflejan en pantalla la información suministrada por el usuario. Los principales son: • banner, este comando escribe en pantalla en grandes caracteres el argumento que lleve

a continuación. Este argumento estará constituido por cualquier cadena de caracteres. • Echo: refleja en pantalla el argumento que lleve a continuación. Su auténtica utilidad se

verá posteriormente.



3. FICHEROS

3.1 CONCEPTO Y TIPOS DE FICHEROS Un fichero es un conjunto de información agrupada bajo un nombre que reside almacenada en un disco. Toda la información del sistema se halla contenida en ficheros, incluso aquellas órdenes que cada comando supone para el sistema. Algo importante a tener en cuenta es el hecho de que en UNIX son ficheros tanto lo que habitualmente se conoce como ficheros, como los directorios, e incluso los periféricos (discos, terminales, teclados, impresoras, .... ). Estos últimos son denominados device files y pueden ser de dos tipos: character (o especial) y block. Cada fichero tiene un propietario, que es el usuario que lo ha creado (ya sea mediante un editor o mediante copia de otro).

3.1.1 DENOMINACIÓN DE FICHEROS Los nombres de los ficheros pueden estar constituidos por cualquier cadena de caracteres (salvo algunos caracteres especiales, como *, /, etc.). Debe recordarse que en UNIX se distinguen mayúsculas y minúsculas, y por lo tanto el fichero FILE será distinto del fichero file. Un dato importante es que en UNIX, al contrario que en otros sistemas como el DOS o Windows, no existen extensiones para los nombres. Así pues, un fichero denominado file.abc tiene un nombre de 8 caracteres, no un nombre de 4 con una extensión de 3. Por otra parte, para cada fichero (cualquier tipo de ficheros) deben distinguirse su nombre absoluto y los nombres relativos. El nombre absoluto de un fichero es el formado por todos los directorios por los que se debe pasar para, partiendo del directorio raíz, llegar al fichero. Los nombres absolutos siempre comienzan por /. Un fichero sólo tiene un nombre absoluto. Sin embargo, puede tener diversos nombres relativos, tantos como directorios haya en el sistema. El nombre relativo de un fichero respecto a un directorio es el formado por todos los directorios por los que se debe pasar para, partiendo del directorio en cuestión, llegar al fichero. Los nombres relativos nunca empiezan por /. El salto de un directorio a otro situado en un nivel inmediatamente inferior (o que cuelga directamente de él) se representa mediante el símbolo /. El paso al directorio inmediatamente superior (o directorio padre) se representa mediante el símbolo ../( el símbolo .. representa al directorio padre).



3.2 EL SISTEMA DE FICHEROS. DIRECTORIOS Como ya se ha dicho, toda la información del sistema se almacena en ficheros, los cuales a su vez se agrupan en directorios. Un directorio es un fichero cuyo contenido es más ficheros o directorios. Cuando un sistema UNIX está instalado, tiene definidos una serie de directorios con nombres standard, y cuya estructura es la siguiente: / bin usr lib etc home lost+found dev tmp Por supuesto, los usuarios pueden definir sus propios directorios. Los contenidos básicos de los directorios indicados suelen ser los siguientes: • bin: contiene diferentes comandos del sistema, habitualmente los más utilizados • usr contiene comandos menos utilizados que los anteriores, o bien ficheros referentes a

aplicaciones externas al sistema • lib: librerías de ficheros objeto (gráficas, matemáticas...) • etc: ficheros propios de la administración del sistema • users: directorios login de los usuarios • dev: ficheros asociados a los periféricos del sistema • lost+found: directorio utilizado en ciertas tareas de la administración del sistema.

Habitualmente estará vacío. • tmp: directorio de ficheros temporales. Suele utilizarse cuando se instala alguna

aplicación o revisión del sistema, o cuando se producen errores en ciertas aplicaciones. Hay una serie de directorios particulares para los usuarios que es necesario considerar: ∗ El directorio raíz /: es el directorio del que cuelga todo el sistema de ficheros. No tiene

padre. ∗ Directorio login o directorio de acceso es aquel directorio al cual va a parar un usuario

cuando accede al sistema. Cada usuario tiene su propio directorio login, que es asignado por el manager. El directorio login del manager es el /.

∗ Directorio actual: es el directorio en el que un usuario está situado en un momento

determinado. Su nombre absoluto se representa por el símbolo .. ∗ Directorio padre: cada directorio cuelga directamente de otro (salvo el /) que es su

directorio padre. El nombre absoluto del directorio padre del directorio actual se representa por ...



3.3 MANIPULACIÓN DE DIRECTORIOS Los principales comandos que intervienen en la manipulación de directorios son los siguientes:

∗ mkdir: crea uno o más directorios, con los nombres indicados como argumentos:

$ mkdir dir1 dir2 crea los directorios dir1 y dir2. ∗ rmdir: borra los directorios indicados como argumentos, con la condición de que están

vacíos. ∗ cd: permite situarse en el directorio indicado como argumento. Si se utiliza sin

argumento, el usuario es situado en su directorio login. ∗ pwd: escribe en pantalla el nombre absoluto del directorio actual.

3.4 MANIPULACIÓN DE FICHEROS A continuación se indican los principales comandos que se utilizan en el sistema de ficheros. Las operaciones que realizan y sus principales opciones: ∗ ls: escribe en pantalla los nombres de los ficheros que contiene el directorio(s) indicado

como argumento. Salvo aquellos cuyo nombre empieza por el símbolo .. Si no se da argumento, se toma por defecto el directorio actual. Los ficheros salen ordenados alfabéticamente (primero las mayúsculas, después las minúsculas). Si el argumento es un fichero no directorio, escribirá el nombre sin más.

Sus principales opciones son:

-a: muestra en pantalla todos los ficheros del directorio, incluidos aquellos cuyo nombre comienza por .. -d: si el argumento es un directorio, muestra sólo su nombre, no su contenido. -s: además del nombre, se muestra el tamaño de cada fichero en bloques (1 bloque = 512 bytes) -t: los ficheros salen ordenados cronológicamente y no alfabéticamente. -F: detrás de cada directorio aparece el símbolo /, detrás de cada fichero ejecutable el símbolo * y detrás de cada link simbólico el símbolo @. -R: opción Recursiva. Si alguno de los ficheros del directorio es a su vez un directorio, se muestra en pantalla su contenido, y así sucesivamente hasta completar todos los niveles de ficheros. -l: para cada fichero muestra una línea con una serie de informaciones adicionales. El formato de cada línea es el siguiente.

- rwxr-xr-x 1 root other 1072851 May 6 18:22 hp-ux ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ permisos propietario espacio en bytes nombre carácter nº links grupo propietario fecha y hora de identificador la última modificación del fichero



∗ touch: Si no existe el fichero crea un archivo sin contenido alguno. Si el fichero existe,

cambia la fecha del fichero. ∗ cat: muestra en pantalla el contenido de un fichero que se utilice como argumento. No

tiene opciones. ∗ head: muestra las primeras 10 líneas de un archivo. ∗ tail: muestra las primeras 10 líneas de un archivo ∗ more: su función es muy similar a cat. Muestra en pantalla el contenido de un fichero de

forma paginada. De esta manera, se puede leer el contenido de ficheros cuya longitud rebasa la de la pantalla. Cuando la terminal se llena, se detiene la ejecución del comando hasta que sea pulsada la tecla espaciadora, momento en que se pasa a la página siguiente. No tiene opciones.

∗ cp: permite copiar un fichero en otro. La estructura del comando es la siguiente: $ cp F1 F2

F1 y F2 pueden ser nombres relativos o absolutos. Si F2 no existe, se crea un fichero con ese nombre. Si F2 existe y es un directorio, se crea en F2 un fichero con el nombre de F1. Si F2 existe y no es directorio, su contenido desaparece y es sustituido por el de F1. El comando puede tener más de dos argumentos (nunca menos). En este caso, es necesario que el último de ellos sea un directorio de modo que todos los demás representarían ficheros que serán copiados a ese directorio con el nombre original. El comando cp posee una opción, la -r, que permite copiar directorios de forma recursiva, es decir, copiando íntegramente su contenido (y el de los directorios que contenga) en otro directorio.

∗ mv: permite renombrar o trasladar un fichero a otro. Su esquema de funcionamiento es el mismo que el de cp, salvo que no dispone de la opción recursiva.

• ln: permite crear un link de un fichero. Un link de un fichero es una copia virtual del

mismo. Es como tener un fichero con varios nombres o en distintos directorios, de modo que todos representan el mismo fichero, hasta el punto de que una modificación realizada en uno de ellos puede ser trasladada a todos. Existen dos tipos de links: hard o soft.

Un enlace "hard" (hard link) es una nueva referencia a un mismo archivo; consiste en una nueva entrada de directorio que apunta a un archivo ya existente y apuntado desde otra entrada de directorio. El contenido se encuentra en un solo lado, pero el archivo puede ser accedido desde varios lugares, eventualmente con diferentes nombres. El comando utilizado para crear un enlace hard es ln. $ ln F1 F2 Crea un segundo nombre referido al mismo archivo; no se hace copia, crea un enlace (link).Cuando se borra un archivo con varios enlaces hard, sólo se borra el enlace. El archivo es realmente borrado sólo cuando desaparece el último enlace.



$ ln dir1 dir2 Da error; no se puede crear un enlace hard para un directorio. Un enlace "soft" (symbolic link) es un archivo que apunta a otro archivo o directorio. El archivo de enlace simbólico contiene solamente la ruta del otro archivo o directorio. El comando utilizado para crear un enlace hard es ln –s. $ ln -s F1 F2 crea F2 como enlace simbólico a F1. Cuando se borra un enlace simbólico, sólo se borra un archivo puntero, y no el objeto real. $ ln –s dir1 dir2 Crea dir2ls como enlace simbólico hacia un directorio.

∗ rm: borra los ficheros indicados como argumentos. Este comando presenta dos opciones principalmente:

- i: por cada fichero que va a ser borrado se pide al usuario la confirmación de la operación. -r: opción recursiva. Se utiliza con directorios y permite borrar todo el contenido del directorio, incluidos los ficheros de los directorios que contenga hasta el último nivel. Esta opción debe manejarse con mucha precaución.

3.5 PROTECCIONES DE FICHEROS Todos los ficheros en UNIX están protegidos. Cuando se estudiaba el comando ls con la opción -l (ls –l), veíamos que se obtiene en pantalla el conjunto de ficheros de un directorio, con una serie de informaciones referentes a cada uno de ellos. Entre ellas están los permisos de ese fichero, simbolizados por 9 caracteres. A estos caracteres nos referiremos en lo que sigue. Cada fichero posee tres tipos de permisos: permiso de lectura, permiso de escritura y permiso de ejecución. Los permisos actúan en tres niveles diferentes: permisos para el propietario, permisos para el grupo del propietario y permisos para el resto de los usuarios. De los 9 caracteres que representan los permisos, los 3 primeros representan los permisos del propietario, los tres siguientes son los permisos de los usuarios pertenecientes al grupo del propietario. Los tres últimos corresponden a los permisos del resto de usuarios.

--- --- --- --- --- --- --- --- --- permisos propietario permisos grupo permisos otros Para cada uno de esos niveles definen los permisos de lectura, escritura y ejecución. Todo lo que se explique a continuación para un nivel es aplicable a los otros dos. La primera posición corresponde al permiso de lectura, la segunda al de escritura y la tercera al de ejecución. _____ _____ _____ lectura escritura ejecución



El permiso de lectura se representa por una r, el de escritura por una w y el de ejecución por una x. Si el permiso existe, la letra aparece en la posición correspondiente. De lo contrario, aparecerá un guión. El significado de los permisos de un fichero es diferente según que se trate de un directorio o de un fichero ordinario. A continuación se indica el significado de la no existencia de un permiso. ∗ Permiso de lectura: para un fichero o directorio, quiere decir que no se puede ver su

contenido. Por tanto, no puede ejecutarse el comando cat en caso de fichero, o ls en caso de directorio

∗ Permiso de escritura: para un fichero, significa que no puede modificarse ni borrarse por

tanto, no puede utilizarse con él el comando rm, ni grabar modificaciones con un editor de textos. Para un directorio significa que no puede alterarse su contenido. Por tanto, no pueden borrarse ni añadirse ficheros a él, pero sí a los directorios que cuelgan de él

∗ Permiso de ejecución: para un fichero significa que no puede ser ejecutado (obviamente,

siempre que tenga capacidad de serlo). Para un directorio significa que no se puede acceder a él (por tanto, no puede ejecutarse el comando cd sobre él ni a ninguno de sus directorios. Esta imposibilidad de acceso supone en la práctica también la negación del permiso de escritura.

Los permisos de un fichero sólo pueden ser modificados por su propietario (y por el manager, evidentemente). Para ello, se utiliza el comando chmod, que puede ser utilizado en dos formas distintas: * Comando chmod: 1ª forma: La estructura del comando es: $ chmod nivel modificación permiso fichero El primero de los argumentos, como puede verse, es una combinación de tres datos: el nivel al que va a afectar la modificación (propietario, grupo, otros), el tipo de modificación (adición de un permiso, eliminación o asignación), y por último, el permiso o permisos implicados en la modificación. El nivel de la modificación se indica mediante las letras:

u (propietario) g (grupo) o (otros) a todos (dueño, grupo y otros)

Si no se indica, se entiende que la modificación afecta a los 3 niveles. El tipo de modificación se representa por los símbolos

+ añadir permiso (dejando los demás como están) - eliminar permiso (dejando los demás como están) = asignar sólo los permisos asignados (y eliminando los demás)

Los permisos implicados se representan por sus correspondientes letras:

r lectura w escritura x ejecución



En la siguiente tabla se presentan unos ejemplos del funcionamiento del comando.

inicial Modificación final rw-rw-rw- +x rwxrwxrwx rwxrwxrwx o-w rwxrwxr-x

r-xr-xr-- u+w rwxr-x--- rwxr-xr-- g=rw rwxrw-r-- rwxr-xr-x = ---------

Ejemplos de permisos en notación simbólica: u+r g+w-r ug+r ugo+w-rx u+rwx,g+r-wx,o-rwx chmod u+rwx,g+rw-x,o+r-wx arch1 chmod u=rwx,g=rw,o=r arch1 cambian los permisos de los archivos indicados. * Comando chmod: 2ª forma: La estructura del comando en esa segunda forma es similar a la primera. Sin embargo, el primer argumento en este caso se expresa mediante tres cifras. Cada una de las cuales toma valores ente 0 y 7. La primera de ellas indica los permisos del propietario; la segunda, los del grupo, y la última los de los otros usuarios. Para cada nivel, existen 8 posibles combinaciones de sus permisos de lectura, escritura y ejecución, que se representan por cada uno de los 8 valores comprendidos entre 0 y 7. La forma de obtener el número correspondiente a cada combinación es la siguiente:

r w x

4 2 1 Se asigna el número 1 al permiso de ejecución, el 2 al de escritura y el 4 al de lectura, y se suman los números correspondientes a los permisos deseados. El número obtenido indica la combinación deseada de permisos. Así, el 7 indica todos los permisos, mientras que el 0 significa ningún permiso. Ejemplos de permisos en notación absoluta: 0777 0755 0764 0640 0710 chmod 0764 arch1



4. COMUNICACIONES ENTRE USUARIOS

4.1 MAIL El comando mail sirve para enviar mensajes entre usuarios como si se tratara de un correo. El mensaje puede ser leído días más tarde de haberse emitido, y es independiente de las terminales del computador, es decir, va dirigido a un usuario, no a una terminal concreta. El comando sirve tanto para enviar como para leer los mensajes.

* Funcionamiento del mail enviar mensajes:

En este caso la estructura del comando es: $ mail usuario(s) Los argumentos son nombres de usuarios a los que se enviará el mensaje. Al pulsar el return, no aparece el prompt $, sino que la pantalla queda en espera para recibir el mensaje. Dicho mensaje es escrito por el usuario emisor a través del teclado. Para finalizar el mensaje, se pulsan las teclas Ctrl d, momento en que aparece de nuevo el prompt $. * Funcionamiento del mail para leer mensajes: Cuando un usuario recibe un mail, no tiene, en principio, notificación alguna de ello, si bien la mayor parte de los sistemas UNIX lanzan el aviso You have mail al usuario cuando éste entra en sesión. (Es lo mismo que cuando una persona recibe una carta en el buzón. Si no se mira, no se sabe que ha llegado). Para leer los mensajes recibidos (o para ver si hay alguno), basta con teclear $ mail En ese momento, si existe algún mensaje, éste aparece en pantalla. De lo contrario aparecerá el texto no mail Un usuario puede tener varios mensajes acumulados. En este caso, el mensaje que aparece en pantalla es el último recibido. Cuando el mensaje se ha escrito en su totalidad, el computador queda a la espera de la contestación por parte del usuario. Esta espera se simboliza mediante el símbolo ? en pantalla. La contestación puede ser del siguiente tipo:

Return: aparece en pantalla el siguiente mensaje. Sin embargo, el anterior permanece en el mail. Esto quiere decir que cuando se vuelva a ejecutar mail, volverá a aparecer ese mensaje.

p: vuelve a aparecer en pantalla el mismo mensaje d: se borra el mensaje y aparece el siguiente



s F1: el mensaje queda almacenado en el fichero F1, pasándose al siguiente. Si con la opción s no se especifica un nombre de fichero, el mensaje se almacena en el fichero mbox.

-: se vuelve al mensaje anterior sin alterar el presente.

m user: se reenvía el mensaje al usuario user. El comando mail, cuando se utiliza para leer mensaje tiene una opción, -r, con la cual los mensajes aparecen ordenados en orden cronológico. Siempre que se contesta al último mensaje, se retorna al entorno UNIX.

4.2 WRITE El comando write se utiliza para mantener una conversación entre dos usuarios que están conectados simultáneamente en dos terminales distintas. La estructura del comando es $ write U1 Esto quiere decir que el usuario establece comunicación con el usuario U1. Este usuario recibirá en pantalla el aviso correspondiente, y a partir de ese momento, cada usuario escribirá por teclado los mensajes que quiera enviar. Siempre que se pulse return. el mensaje aparecerá en la otra terminal. Para finalizar la comunicación, basta con pulsar ctrl d, con lo que se obtendrá de nuevo el prompt $. En ocasiones, puede ocurrir que un mismo usuario esté conectado a la vez a varias terminales. En este caso, si se lanza un write a ese usuario, en la pantalla aparecerá la lista de terminales a las que está conectado, con el fin de elegir una concreta. En ocasiones, un usuario puede no querer ser molestado con este tipo de acciones. Por ello, existe un comando, mesg, que permite inhabilitar la terminal para recibir mensajes. El comando puede ser utilizado en solitario, o bien con las opciones y o n. Nunca lleva argumentos. Su funcionamiento es: $ mesg n: se inhabilita la terminal para recibir mensajes $ mesg y: se habilita la terminal para recibir mensajes $ mesg: escribe en pantalla la situación de la terminal (habilitada o no)



5. EDITORES La familia de editores en UNIX está compuesta de tres editores distintos, llamados ex, ed y vi.

ed el editor de líneas estándar original ex un editor “de líneas” que sustituye a ed vi un editor de pantalla

En el sistema operativo UNIX, todo se almacena en ficheros, incluso el propio sistema operativo UNIX Los editores UNIX permiten alterar los ficheros de un modo fácil y eficiente, facilitando el soporte básico que se necesita para la mayoría de tareas UNIX. En estas secciones daremos un repaso al funcionamiento de los editores y sus buffers, y a continuación describiremos las principales características de vi. En el siguiente capítulo estudiaremos el editor ex.

5.1 EL BUFFER DE MEMORIA Nuestros ficheros están clasificados en la memoria del sistema: cuando disponemos que un editor trabaje con un fichero, la copia original de este último permanece inalterada. Para ello, se crea una copia del fichero sobre la que se trabaja: esta copia se mantiene en un área de memoria temporal denominada buffer. Los cambios realizados se ejecutan sobre esta copia, no sobre el fichero original. Si se desea que estos cambios afecten al fichero de forma permanente, se deberá sustituir el fichero original por la nueva copia. Esta última etapa es muy sencilla: simplemente se da a la máquina la orden de escritura y el ordenador se encarga de sustituir el original por la versión actualizada. El trabajo con buffer supone una gran ventaja: por ejemplo, si hacemos una chapuza en el trabajo que estamos editando (borrar una página accidentalmente), no se habrá dañado el fichero original. Para reparar nuestro despiste, basta con abandonar el editor y quedarán perdidas para siempre las pruebas de nuestro error, dejando el original inalterado. Evidentemente, este modo de funcionamiento supone también una desventaja: los cambios no se almacenan automáticamente. Es importante recordar que se deben escribir dichos cambios; si no se hace, todo el trabajo de alteraciones se perderá. Algunas versiones de editores UNIX intentan refrescarle su memoria con una aviso si trata de abandonar el editor antes de escribir su texto, otras, no. Nos ocuparemos de inmediato de estudiar cómo funciona el proceso de edición.

5.2 DOS MODOS DE FUNCIONAMIENTO DE EDITORES Los editores ex y vi tienen dos modos básicos de operación: el modo texto (Text Input Mode) y el modo comando o modo de edición (Command Mode). Cuando “entramos” por primera vez al editor, nos encontramos en comando. Esto significa que cualquier tecla que se pulse se toma como si fuera una orden, semejante a los comandos que ya hemos visto anteriormente. En este modo de funcionamiento se puede borrar una palabra o línea, o cambiar un error ortografía. Accedemos al modo texto utilizando el comando Añadir (Append), es decir, pulsando la tecla <a>. A partir de ese momento, cualquier tecla que se pulse se interpretará como texto para ser almacenado en el buffer, no como comandos tal como sucedía antes. Ahora podemos introducir un texto que eventualmente sea un programa FORTRAN, unos datos de ventas o los capítulos de un



libro. Cada editor tiene una única forma de salir del modo texto: en el caso de( editor vi es la tecla <esc> mientras que el editor ex abandona el modo texto cuando se introduce un punto <.> como primer y único carácter de una línea.

5.3 COMPARACION ENTRE LOS EDITORES DE LÍNEAS Y DE P ANTALLA Todos los sistemas UNIX contienen la familia completa de editores ex. ¿Con qué editor nos quedamos?. Recomendamos que se comience con el editor de pantalla vi. En el capítulo siguiente nos preocuparemos del estudio detallado del editor de líneas ex.

5.4 EL EDITOR vi vi es un editor de texto interactivo, diseñado para utilizarse con un terminal provisto de pantalla. En dicha pantalla se muestra normalmente una “ventana” del fichero que se está editando: esta última permite ver unas cuantas líneas de fichero al tiempo, y además la ventana se puede subir o bajar a lo largo del fichero. También se puede trasladar a cualquier parte de cualquier línea de la pantalla, y realizar cambios allí, las adiciones y cambios que se realizan en el fichero quedan reflejados sobre lo que se ve en pantalla Si se intentase una descripción completa de los aproximadamente 100 comandos de vi, el principiante quedaría totalmente abrumado; por esta razón, se ha decidido dividir la presentación de los comandos vi en tres partes. Estas partes representan tres niveles distintos de experiencia de manejo con el editor. 1. Comandos básicos para comenzar a utilizar vi. A. Comandos de posición del cursor: h, j, k, l y <return> B Comandos para entrar en modo texto: a, i, o, O C Comandos para abandonar el modo texto: <esc> D. Comandos para borrar y sustituir x, dd, r E. Comandos para deshacer cambios: u, U F Comandos para almacenar y abandonar el editor: ZZ, :w, :q!, :wq, q 2. Comandos vi avanzados para aumentar sus posibilidades. A. Comandos de posición del cursor incluyendo “desplazamiento”, “paginado” y “búsqueda”: <control-d>, <control-f>, <control-b>,<control-u>, e,b,G,nG B. Comandos que actúan sobre palabras, frases, líneas o párrafos: c,d,y C. Abreviaturas de palabras, frases, líneas o párrafos: w,b,e,<,>,O,$, {,} D. Comandos para imprimir lo almacenado en los buffers. p, P E. Unión de líneas: J 3. Otros comandos vi A. Existen unos 60 o más comandos adicionales, que permiten hacer otras operaciones

de adición del mismo tipo que los descritos anteriormente.



5.4.1 PARA EMPEZAR EN vi Aunque, como ya se ha comentado. el editor vi es muy complejo y posee un enorme número de comandos, su estructura básica es muy simple. Existen dos modos de operación, el modo comando y el modo texto. En esta sección nos limitaremos al mínimo número posible de comandos que permitan comenzar a utilizar el editor. Aunque el número de comandos comentados será muy reducido, en realidad quedan cubiertas las cuatro principales características de la edición:

• llamada al editor: vi nombre de fichero • posicionado del cursor: h, j, k, l y <return> • inserción de texto: a, i, o, O • borrado y cambio: x, dd, r • almacenamiento permanente de la información: wq

Nuestro primer ejemplo mostrará cómo entrar y salir del editor vi. Debemos estar situados en el sistema UNIX lo que quedará reflejado por el prompt ($) del mismo. El comando que se introduce es

$vi fichero para iniciar el trabajo con el editor

Para salir de vi, utilizaremos la secuencia de comandos

<esc> :wq para abandonar el editor Recuerde que <esc> significa pulse la tecla marcada ESC o ESCAPE, dependiendo de la terminal: a continuación pulse :wq para escribir y abandonar la edición. El fichero puede ser un fichero ya existente en su directorio, en cuyo caso queda copiado en un buffer temporal para su edición. En el caso de que no exista un fichero con ese nombre, se crea un nuevo fichero. Cuando se llama al editor vi, éste responde en pantalla con el contenido del fichero seguido con una serie de símbolos tilde (-). en caso de que la longitud del fichero sea menor que la de la pantalla. Al final de la pantalla, aparece el nombre del fichero. El editor se sitúa en modo comando y el cursor se coloca en la esquina superior izquierda de la pantalla. Cualquier cambio, operación de borrado o adición que se quiera hacer se realizará tomando como punto de referencia la posición del cursor. Por consiguiente, la pregunta inmediata es “¿cómo se mueve el cursor?”

5.4.2 MOVIMIENTOS DEL CURSOR Existen más de 40 comandos en vi para ayudarle a colocar el cursor en cualquier posición del buffer. Habitualmente los terminales tienen teclas con “flechas” para desplazar el cursor. Más adelante, en la sección "comandos de posición del cursor, mostraremos otros muchos comandos para desplazarlo. La tecla <return> también desplaza el cursor una línea hacia abajo. Sin embargo, la tecla <return> coloca el cursor siempre al comienzo de la siguiente línea, mientras que la flecha correspondiente desplaza el cursor en dirección vertical desde la posición en que se encuentre, que bien puede ser el centro de una línea. El cursor no puede moverse sobre un fichero nuevo que no contiene texto; es decir, las teclas se moverán únicamente sobre líneas o caracteres de texto ya existente en el fichero.



5.4.3 EL MODO TEXTO Trabajaremos ahora con cuatro comandos que permitirán utilizar el teclado para introducir texto en el fichero. Estos comandos son: a para añadir texto (append) i para insertar texto (insert) o y O para abrir (open) Todos estos comandos toman como punto de referencia la posición actual del cursor. Si se comienza una edición vi sobre un nuevo fichero, el cursor está restringido a la esquina superior izquierda de la pantalla; el cursor no puede desplazarse por medio de las teclas indicadas; sin embargo, si se utiliza la orden a, para añadir texto, i para insertarlo, o bien open para abrir una línea, se podrá introducir el texto que se desee comenzando precisamente en la mencionada esquina superior izquierda, tal como se hace normalmente en una hoja de papel. Puede ser que esté preguntándose: ¿y cómo meto texto en mitad de la línea, por ejemplo, un título? La respuesta es que debe utilizar la barra espaciadora después de haber entrado en modo texto. Si comienza una sesión de edición vi en un fichero y utiliza el comando de abrir (open, o u O), el cursor se moverá hacia arriba (O) o hacia abajo (o) una Iínea y quedará listo para recibir texto desde teclado. La manera habitual de comenzar un nuevo fichero es teclear vi seguido por un espacio y el nombre del fichero que se desea utilizar. Cuando el editor esté listo, teclee a; a continuación puede empezar a usar el teclado como si se tratase de una máquina de escribir. Pulse la tecla <return> para comenzar una nueva línea: si comete algún error, puede utilizar la tecla de borrado normal para retroceder y corregir. En algunos terminales, las letras borradas no desaparecen de la pantalla hasta que se reescribe texto sobre ellas, pero en todo caso quedan eliminadas del buffer.

5.4.4 CÓMO AÑADIR TEXTOS A UN FICHERO YA EXISTENTE ¿Qué sucede cuando utilizamos los cuatro comandos de introducción de texto? Cada uno de ellos nos pasará a modo texto; a continuación podemos introducir una letra o varias docenas de líneas, si así se desea. La mayor diferencia que existe entre los distintos comandos es el lugar donde se coloca el nuevo texto: a introduce el texto que se teclee detrás del cursor, “empujando” el resto de línea hacia

la derecha. En muchos terminales, no se ven las palabras desplazadas hasta después de pulsar la tecla <esc> para abandonar el modo texto.

i Introduce cualquier cosa que se teclee antes del cursor, empujando el texto de la línea

hacia la derecha igual que en el caso anterior. o abre una línea debajo de la línea en donde se sitúa el cursor, coloca el cursor al

comienzo de la nueva línea e introduce el texto en esa posición O es igual que o, con la diferencia de que la línea se abre sobre la posición actual del

cursor.



En cada uno de los casos, se ha de pulsar la tecla <esc> para abandonar el modo texto; con ello quedaremos situados en modo comando de nuevo.

5.4.5 BORRADO Y ALTERACIÓN DEL TEXTO Existen tres comandos utilizados con profusión para realizar pequeños cambios en el contenido de un fichero. Nos referimos al comando x para borrar un carácter, el comando r para sustituir un carácter, y el comando dd para borrar una línea. Estos tres comandos se ejecutan en modo comando, y los tres vuelven a dejar el mismo modo una vez cumplida su misión. Los tres emplean la posición del cursor en la pantalla como punto de referencia para realizar los cambios. El comando x borra el carácter sobre el que está situado el cursar. Si va precedido de un número n, borra n caracteres, comenzando a contar por aquél en el que está situado el cursor. El comando r sustituye el carácter en el que está situado el cursor por aquél que es tecleado a continuación. Por último, el comando dd borra completamente la línea sobre la que está situado el cursor. Al igual que el comando x, dd puede ir precedido de un número n, con lo que se borrarán n líneas, contadas a partir de la línea en que se halla el cursor.

5.4.6 PARA DESHACER CAMBIOS: u y U En ocasiones se realiza un cambio y de repente se cambia de opinión o se decide que no debería haberse hecho. En este caso, se usan los comandos “deshacer o undo”. Tal como indica su nombre, estas órdenes deshacen lo que se acaba de hacer. El comando u se puede introducir solamente en modo comando, y “niega” la orden anterior. Así, si se borra una línea con dd, se puede pulsar u para regenerada; si se utiliza el comando i para insertar una palabra en una línea, la orden u se encargará de eliminarla (previamente debe volver a modo comando para deshacer el cambio). El comando U es más general. Con él se deshacen todos los cambios que se hayan realizado en la Iínea actual.

5.4.7 CÓMO ABANDONAR EL EDITOR vi Probablemente, una de las experiencias más frustrantes que se pueden tener con un ordenador es perder un fichero con el que se ha estado trabajando durante siete horas. Realmente, no es difícil de conseguir, introduciendo un par de órdenes sin el debido cuidado. Siempre que esté pensando abandonar el editor, debe interrogarse a sí mismo con una cuestión básica: ¿deseo guardar los cambios que he realizado durante esta sesión? Hay tres posibles respuestas: sí, no y quizá. Existen varias formas diferentes de abandonar el editor vi con o sin almacenamiento de información, tal como se resume a continuación: Comando Acción <ESC> ZZ <return> Escribe el contenido del buffer temporal en disco, para su almacenamiento permanente. Utiliza el nombre de fichero que se empleó



para entrar en vi. Lo coloca de nuevo en el shell. <ESC> :wq <return> Tiene el mismo efecto que ZZ, w deriva de write (escribir) y q procede de quit (abandonar). <ESC> :w <return> Escribe el contenido del buffer en <ESC>:q <return> memoria, y a continuación se abandona el editor. Es una versión en dos etapas de wq. <ESC>:q! <return> Abandona el editor y se olvida del contenido del buffer temporal. No se realizan cambios. Todas estas órdenes se han de ejecutar desde modo comando, y lo devolverán al sistema (shell), lo cual quedará reflejado por la aparición del prompt ($). Se ha indicado explícitamente una vez más que se utilice la tecla <return> para ordenar la ejecución de los comandos. Si se desea abandonar el editor guardando los cambios realizados, la mejor salida es usar :wq estando en modo comando. También se pueden abandonar el editor con ZZ, o bien, w <return> :q. Para abandonar el editor sin guardar los cambios, la forma natural de irse es :q! Se puede usar este comando cuando se comienza a editar un fichero y no le gusta el aspecto con el que estaba quedando. La orden :q! deja intacto el fichero original y abandona el buffer temporal del editor. Si no está seguro de la oportunidad de almacenar o no los cambios, lo mejor que puede hacer es guardar ambas versiones del fichero, la original y la alterada. Esta operación se realiza utilizando el comando write con un nuevo nombre de fichero. Por ejemplo, podría ser. :w fich.nuevo Así, si ha editado el fichero fich y realizado en él algunos cambios, este comando creará un nuevo fichero con el nombre indicado. Ahora ya puede abandonar el editor tranquilamente con :q o con :q!. La diferencia existente entre los comandos :q! y :q es que este último abandonará el fichero únicamente si no se han introducido cambios desde el último comando w. Con ello se ofrece una cierta protección contra abandonos accidentales del editor. El comando :q! por su parte, abandona el editor sin más trámites. En realidad, cuando se está metido en una sesión de edición lo suficientemente larga, es aconsejable utilizar el comando write cada 15 ó 20 minutos, para actualizar la copia permanente del fichero.

5.4.8 OTROS COMANDOS vi Ya hemos visto en la sección anterior la enorme importancia de la colocación del cursor; esa importancia es aún mayor, si cabe, en ficheros de tamaño medio y grande; por ello nos ocuparemos de la colocación del cursor en cualquier lugar del fichero, por medio de unas pocas órdenes. A continuación estudiaremos tres comandos conocidos como 'operadores' que pueden realizar cambios que afectan a palabras, líneas, frases o párrafos. Dos de



estos operadores facilitan en realidad otros buffers de almacenamiento temporal que permiten la reorganización de líneas y párrafos del texto.

5.4.9 COMANDOS DE POSICIÓN DEL CURSOR Hasta ahora hemos utilizado las cinco teclas básicas de posición del cursor: las flechas y <return>. Añadiremos a este conjunto nueve teclas más y una función de búsqueda, que ayudan a colocar el cursor con sencillez en ficheros de texto de cualquier tamaño. Nos ocuparemos en principio de cuatro teclas (b,e,$,O) que resultan muy útiles en ficheros de textos cortos. Después añadiremos otras cuatro, <control-d>, <control-u>. <control-f> y <control-b>, que son más aplicables a ficheros medios (2-10 páginas de pantalla). Llegados a ese punto, explicaremos también las operaciones de “desplazamiento” y “paginado”. Completaremos el repertorio de posicionamiento del cursor estudiando dos comandos que se utilizan para colocar el cursor en ficheros de texto grandes 10-100 o incluso más páginas de pantalla). Nos referimos a los comandos nG y /patrón. Las cuatro teclas <b,e,$,O> tienen una cierta simetría en su forma de operar. Su acción concreta es la siguiente: <b> Desplaza el cursor al comienzo de una palabra (beginning). Cada vez que se pulsa

la tecla <b>, el cursor se mueve hacia la izquierda a la primera letra de la palabra anterior.

<e> Desplaza el cursor al final de una palabra (end). Cada vez que se pulsa la tecla <e>, el cursor se desplaza a la derecha hasta la última letra de la siguiente palabra.

De una forma similar, las teclas <O> y <$> desplazan el cursor al comienzo y al final de la línea (no de la palabra): <O> Se refiere a la tecla cero. Desplaza el cursor al comienzo de la línea. <$> Desplaza el cursor al final de la línea. Estas dos teclas pueden utilizarse únicamente en la línea que contiene el cursor, éste no saltará a la línea siguiente tal como ocurre con las teclas <b> y <e>.

5.4.10 "DESPLAZAMIENTO" Y "PAGINADO" DE LA PANTALLA Hay ocasiones en las que el buffer contiene más texto que el que se puede presentar de una sola vez en pantalla. Ya habrá observado que, cuando se da esta circunstancia, las líneas ocultas se pueden traer a pantalla llevando el cursor hacia el final (o el comienzo) de la misma e intentando avanzar aún más. En tal caso, el cursor permanece en pantalla, pero aparece una nueva línea, moviéndose hacia arriba (o hacia abajo) dentro del campo de edición. Esta forma de desplazamiento de texto se llama scrolling, por su semejanza al antiguo sistema de lectura de un pergamino en el que se desplazaba la parte visible del mismo desde un rollo interior a otro superior. Para visualizar este movimiento, imagínese que el texto está distribuido en una página larga y continua (como un pergamino) y que la pantalla es una especie de “ventana” por la que podemos observar un trozo de la página. Esta ventana tiene generalmente 80 caracteres de ancho por 24 líneas de largo; imagínese que la ventana se desplaza mientras el texto permanece fijo.



Se suele aceptar como convenio que la dirección de desplazamiento está referida al desplazamiento de la ventana, no del texto. Por ejemplo, un desplazamiento descendente mueve la ventana hacia abajo, mostrándose el texto que estaba en el fichero por debajo del original (o lo que es lo mismo, el texto asciende). Por el contrario, en desplazamiento ascendente, estamos "empujando' la ventana hacia arriba, mostrando porciones del texto que precedía al texto de la localización de ventana original (el texto desciende). Generalmente, las teclas de posición de cursor <b>, <e>, <return> realizan 'desplazamiento" de pantalla de una línea cada vez. Sin embargo, como las pantallas contienen 24 líneas, los movimientos línea a línea pueden resultar muy lentos cuando se trabaja con un fichero de texto grande, con las consiguientes pérdidas de tiempo, tanto del usuario como del ordenador. El editor vi soluciona el problema con cuatro comandos de 'desplazamiento'. Son los comandos <control-u>, <control-f>, <control-b> y <control-d>. Le recordamos que para conseguir un <control-d>, se pulsa la tecla <control> y a continuación se oprime la tecla <d> manteniendo la otra apretada. La acción de estas cuatro teclas de cursor es la siguiente: <control-d> Desplaza el texto moviendo el cursor hacia abajo (down), generalmente 12 líneas. <control-f> Desplaza el cursor hacia delante (forward) en el texto generalmente 24

líneas. <control-u> Desplaza el cursor hacia arriba (up), generalmente 12 líneas. <control-b> Desplaza el cursor hacia atrás (back), generalmente 24 líneas. El comando, nG siendo 'n' un número entero, colocará el cursar en la línea número 'n'. Así, podemos teclear 1400G para movernos a la línea 1400. Una orden similar es G (G mayúscula) sin ningún número, que coloca el cursor al final del fichero. Así, si se pulsa G estando en modo comando, el cursor se posiciona al final del fichero. Si queremos volver al principio, se puede indicar al editor la siguiente orden 1G Otro comando muy útil relacionado con nG es el comando <control-g>, que informa del número de línea en el que está colocado el cursor en ese momento.

5.4.11 BÚSQUEDA DE PATRONES Otra forma de colocar el cursor en algún punto del fichero es enviar al editor una palabra o cadena de caracteres para que la busque. Cuando se está en el modo comando vi, se puede teclear el carácter /, seguido de una cadena de caracteres terminado por un <return>. El editor colocará el cursor en la primera aparición de la cadena de caracteres dentro del texto, tomando como punto de partida la posición actual del cursor, y desplazándose hacia abajo en el texto. Por ejemplo, si se desean localizar las palabras “buenos días”, se envía la orden



/buenos días Si la primera aparición de “buenos días” no es la que deseábamos, se puede mover a la siguientes pulsando n (next). Estos sistemas de búsqueda “enganchan” el final del buffer con el principio, de manera que si se alcanza el final sin encontrar el patrón de búsqueda requerido, se comienza por el principio del fichero hasta llegar a la posición actual del cursor. Esta operación continúa realizándose mientras se siga pulsando n. Si se prefiere organizar la búsqueda en sentido contrario (ascendente), se utiliza ? a tal efecto. Una vez colocado el cursor en el punto deseado, podemos dedicarnos de nuevo a realizar cambios, desplazar textos o añadir nuevo texto al fichero. Nos ocuparemos ahora de este tipo de actividades. -

5.4.12 OPERADORES QUE BORRAN, DUPLICAN O CAMBIAN Y REORGANIZAN EL TEXTO. Algunas páginas antes, en la sección dedicada a los comandos básicos vi, aprendíamos a borrar una línea utilizando el comando dd. Este comando de borrado está compuesto en realidad de dos partes: el “operador” d, (delete, borrado) y el operador “alcance”, referido a la línea, y simbolizado de nuevo por "d”. El comando dw utiliza el operador d pero su alcance es una sola palabra (word), definida por el cursor y simbolizada por “w”, Podemos representar este tipo de órdenes de la siguiente manera:

Operador + alcance = comando En esta sección nos ocuparemos de tres operadores y nueve alcances. Los operadores son “delete”, “change” y “yank” (borrar, cambiar y extraer). Pueden operar con los alcances siguientes: palabras, líneas, frases y párrafos. Los utilizaremos para borrar, duplicar, cambiar y reorganizar el texto. En ocasiones, este tipo de cambios se llaman y popularmente “cortar y pegar” (cut and paste), refiriéndose al viejo sistema de realizar cambios con tijeras y goma de pegar. Sin embargo, la versión electrónica de “cortar y pegar” es más poderosa, ya que puede “cortar” con más precisión y hacer copias múltiples al “pegar”. En la siguiente tabla se resumen los tres operadores y sus distintos alcances. (Incluimos también una descripción de un comando put (poner, colocar), que funciona en combinación con los comandos yank y delete). Comando Operador d Operador delete. Borra el texto depositando una copia en un

buffer de memoria temporal. La copia puede recuperarse empleando el comando put, p.

y Operador yank. Saca una copia del texto (palabra, frase, línea,

etc.), colocándola en un buffer de memoria temporal para depositarla en otro sitio. El texto original permanece inalterado; la copia se "pega" en el punto marcado por la posición del cursor, utilizando el comando put, p.



p Comando put. Trabaja con los comandos yank y delete; coloca

cualquier fragmento que haya sido borrado o extraído en el lugar correspondiente detrás o debajo del cursor.

c Operador change. Equivale a una operación delete y un

comando insert. Borra una palabra, frase, etc, y pasa a modo texto para permitir que se teclee el texto alternativo correspondiente. Se termina de operar con un <esc>.

Estos operadores actúan sobre un alcance determinado, que se puede describir como: Operación Alcance e El alcance se define entre el cursor y el final de la palabra en que está

colocado (end); por ejemplo, si el cursor se coloca sobre la letra 'u' de "curioso", y se teclea de, se borra el fragmento “urioso”.

w El alcance abarca desde el cursor hasta el comienzo de la siguiente

palabra (word) incluyendo el espacio. b Abarca desde la letra anterior al cursor hasta el comienzo de la

palabra (beginning). $ Tiene un alcance desde el cursor hasta el final de la línea. 0 Comprende desde la letra o posición anterior al cursor hasta el

comienzo de la línea. ) El alcance está definido desde el cursor al comienzo de la frase

siguiente. Se considera que una frase acaba con un “.”, “!”, o “?”, seguido de un “fin de línea” (procedente de la tecla <return> ) o dos espacios.

( El alcance se determina desde la posición anterior al cursor al

comienzo de la frase que contiene a dicho cursor. } El alcance abarca desde el cursor hasta el final del párrafo. Se

considera que un párrafo comienza después de una línea vacía. { El alcance está comprendido desde la posición anterior al cursor y el

comienzo de su párrafo. Habrá observado que no existe ningún símbolo para línea completa. Los creadores del vi decidieron que es una operación tan común, que la manera más fácil de obtenerlas sería pulsar el operador correspondiente dos veces. Los comandos que afectan a la línea completa, por consiguiente serán, dd, cc o yy.

5.4.13 LOS OPERADORES YANK Y DELETE COMBINADOS CON EL COMANDO PUT Se puede utilizar la combinación de comando de borrado y colocación (delete y put) , para trasladar un fragmento de texto en un fichero. Por otra parte, los comandos de extracción y



colocación (yank y put) combinados resultan adecuados para copiar un fragmento de texto y colocarlo en otra parte. Los nueve "alcances" descritos permitirán definir con precisión las distintas partes de palabras, líneas, frases y párrafos sobre los que se desea aplicar la operación. Los comandos yank y delete almacenan estos fragmentos de texto en un buffer temporal, que se utiliza para ser copiado en pantalla con un comando put. Como siempre, las órdenes se ejecutan tomando como punto de referencia la posición del cursor. Por lo que respecta al comando put, yank y delete funcionan de manera idéntica: producen un buffer temporal con un fragmento de texto. La diferencia respecto al usuario es que deja el texto original inalterado, mientras que delete lo borra.

5.4.14 BORRADO, DUPLICACIÓN Y REORGANIZACIÓN DE TEXTOS EN BUFFERS TEMPORALES Tal como se comentó anteriormente en este capítulo, cuando se desea comenzar una sesión de edición con un fichero ya existente, se deposita una copia de dicho fichero en la memoria del buffer del editor. Se ha comprobado que el empleo de estos buffers es de enorme utilidad, por eso, el editor vi tiene en realidad más de 30 áreas de memoria temporal que se pueden utilizar para duplicar, reordenar y almacenar texto temporalmente. Además, si accidentalmente destruye una serie de líneas de texto, se puede recuperar no sólo el último fragmento destruido, sino también los 8 anteriores. Estos fragmentos se almacenan en un conjunto de buffers temporales numerados del 1 al 9; para conseguir la recuperación del texto borrado que se almacena en el buffer n, se puede usar el comando “np (las comillas sirven para indicar al editor que va detrás un nombre de buffer). Este comando colocará el texto detrás del cursor. Si usamos otro comando put, P, el contenido se coloca delante del cursor. Así el comando: “1p recupera el contenido de la última porción borrada y la coloca detrás del cursor, mientras que el comando “1P colocará este mismo texto delante del cursor. Los comandos undo resultan especialmente útiles cuando se desea localizar entre los buffers 1 a 9 un determinado párrafo que se borró. Por ejemplo, para averiguar el contenido del buffer número 4 se ordena. "4p y si no es el que buscaba, se pulsa u Se puede repetir esta operación cuantas veces se desee en los distintos buffers. Hay otro método mejor de guardar, duplicar y reordenar texto que no utiliza los buffers 1 a 9 descritos aquí. El problema con estos buffers es que el buffer número 1 contiene siempre la última operación de borrado. Así, cuando se desplaza por el texto borrando aquí y allá, el contenido de los buffers está cambiando constantemente. Si tiene pensado copiar o desplazar un texto, es mejor emplear otro conjunto de buffers que permanecen inalterados en las operaciones de borrado normales. Este conjunto está formado por la serie de buffers con nombres de letra, ordenados de la “a” a la “z”. Para usarlos, se debe anteponer el nombre del buffer en el que se desea almacenar el texto a la operación de borrado. Se



utilizan de nuevo las comillas (“) para indicar al editor que estamos empleando un nombre de buffer. Por ejemplo, la orden “c5dd borrará 5 líneas y las guardará en el buffer c. Estas líneas pueden recuperarse en el mismo sitio o en sitios diferentes, utilizando los comandos put, p y P: “cp Así se depositará el contenido del buffer detrás del cursor. Se puede mover el cursor y repetir el comando para colocar copias adicionales del buffer c en cualquier otro lugar del fichero. Estos buffers alfabéticos también almacenan los contenidos de las operaciones yank, que se utilizan cuando se desea simplemente copiar una determinada parte del texto; la forma de utilizar los comandos es idéntica.

5.4.15 OTROS COMANDOS Y PARTICULARIDADES DE vi Además de los comandos anteriores, el editor vi tiene una serie de potencialidades que probablemente le interesará conocer. Entre ellas se pueden destacar. • especificar el tipo de terminal • ajustar el tamaño de pantalla • ajustar la identificación, tabulado y margen derecho • usar macros y abreviaturas para simplificar una operación compleja o una entrada desde

teclado demasiado larga • editar dos o más ficheros al mismo tiempo • utilizar comandos ex. Esta última particularidad merece un comentario más extenso, sobre todo porque la hemos utilizado varias veces en este capítulo sin avisarlo. Para emplear un comando ex, se pasa a modo comando y se pulsa la tecla [:]. Aparecerá un símbolo dos puntos en la parte inferior de a la pantalla. A continuación se puede introducir cualquiera de los comandos que se presentan en el capítulo dedicado a ex; una vez ejecutada la orden, el editor le devuelve automáticamente al modo comando estándar de vi. Si se desea permanecer más tiempo en el editor de línea ex, se puede introducir el comando Q desde modo comando vi. Con ello conseguiremos también un símbolo dos puntos en la parte inferior de la pantalla, pero permaneceremos en modo ex hasta que se teclee vi para volver. En este capítulo ya hemos usado algunos comandos 'prestados' de ex, como write y los comandos quit (:q, wq, y :q!). De los demás comandos ex disponibles, los más útiles son aquellos que permiten manejar trozos de texto grandes; como ejemplo, mencionaremos los dos más importantes: el comando co para copiar texto, y el comando m para desplazarlo. Realizan el mismo tipo de función que los comandos vi delete-put y yank-put, respectivamente, pero restringiéndose a líneas completas. Así, el comando: :20,300m500 realiza una copia de las líneas 20 a 300 inmediatamente después de la línea 500, dejando inalterado el texto original en su posición. Otro comando ex extremadamente útil es la orden de búsqueda y sustitución global. Por ejemplo, el comando



:g/e/s//#/g sustituye todas las "e” del fichero por símbolos “#”.

5.5 EL EDITOR DE LÍNEAS ex

5.5.1 INTRODUCCIÓN El editor de líneas ex es, con toda propiedad, el editor estándar del UNIY- Incluso si tiene pensado trabajar preferentemente con vi, como hacen la mayoría de usuarios, resulta aconsejable aprender el funcionamiento básico de ex. Una gran parte de la potencia del vi se deriva precisamente de este editor. Se dice que ex es un editor de líneas porque la mayoría de operaciones se realizan empleando como referencia una línea. (Recordemos que vi utiliza el cursor como punto de referencia). El sistema de referencias por líneas hace que ex resulte útil para desplazar o copiar grandes bloques de texto, y también para hacer operaciones de búsqueda y sustitución global.

5.5.2 LLAMADA AL EDITOR ex La operación de arranque de un editor recibe diversos nombres en el argot informática. Si el nombre está ya en el directorio, el contenido del fichero se vuelca en el buffer temporal de ex para permitir su edición. Si no existe fichero alguno con tal nombre, se crea uno nuevo. Cuando se llama a ex con un fichero ya existente, el editor responde en pantalla con el número de caracteres almacenados en el mismo: si el fichero es nuevo, ex responde con el comentario (new file) y el nombre del fichero. Con este convenio se advierte al usuario que pretendía reformar un fichero ya creado, pero inadvertidamente ha tecleado su nombre de forma incorrecta. Las respuestas devueltas por el editor pueden variar ligeramente de una versión a otra. ex indica el número de líneas y caracteres del fichero, pero no imprime éste en la pantalla a menos que se le dé la orden de impresión adecuada. El editor está ahora en modo comando, listo para aceptar órdenes tales como añadir, mover, borrar, escribir, salirse, imprimir. Estos comandos deben seguir un formato concreto que se describe a continuación.

5.5.3 FORMATO DE LOS COMANDOS ex Un comando ex completo, en general, tiene tres partes: dirección, comando y parámetros. La dirección indica al editor la línea o líneas sobre las que ha de actuar. El comando informa al editor sobre la actuación concreta que debe realizar ejemplos de comandos son p (print, para imprimir una línea en la pantalla), d (delete, para borrar una línea) y s (para sustituir un fragmento de texto por otro). Los parámetros añaden la necesaria información adicional; por ejemplo, cuando se ha de hacer una sustitución. Sin embargo, con frecuencia un comando completo posee una o dos de estas partes tan sólo.



5.5.4 LOCALIZACIÓN DE LÍNEAS Uno de los principales problemas al utilizar editores es indicar al programa en qué parte del texto se desea insertar o introducir cambios. El editor de líneas ex soluciona esta dificultad utilizando números de línea; el texto se distribuye en el buffer temporal de ex según una serie de líneas numeradas; a tal efecto, se considera una línea cualquier cosa que se haya tecleado seguida de un <return>. Las líneas de buffer están numeradas consecutivamente, y se renumeran cada vez que se inserta, borra o traslada una línea nueva. Además de esta lista de líneas de texto, el editor mantiene siempre el concepto de línea actual; se puede imaginar la línea actual como una línea apuntada por un "cursor invisible”. Pero, ¿qué línea del buffer es la línea actual?. La primera vez que se llama al editor para actuar sobre un fichero ya existente, la línea actual es la última del buffer del editor. Cuando se pulsa un comando de impresión, apéndice o inserción, el comando se ejecuta con respecto a la línea actual. Por ejemplo, podemos utilizar el comando de impresión tecleando p Con esta orden se imprimirá en pantalla la línea actual. Por otra parte, si se teclea 3p se imprimirá la línea 3. En este último caso, hemos dado al editor una línea específica sobre la que trabajar; a continuación, la línea 3 se transforma en la línea actual. En general, cuando se ejecuta un comando, se tomará como nueva línea actual la última línea afectada por el mismo. Se puede emplear el símbolo punto (.) como abreviatura para indicar la línea actual, por ello, esta línea se llama también “línea punto”. Así, hablaremos de la línea 3, o de la línea 4, o de la línea punto. Por cierto, no permita que el múltiple uso del punto en el editor ex le confunda. Recuérdese que cuando se pretende abandonar el modo texto se introduce un punto solitario en la línea; sin embargo, si está en modo comando, el punto se interpreta como una forma abreviada de expresar la dirección de la línea actual. Así, si tecleamos

.P

se imprimirá la línea actual. mientras que si ordenamos

.d

se destruirá dicha línea. Otra abreviatura útil del editor es el símbolo $, indicando la última línea del fichero. Por ejemplo $p imprime la última línea del fichero. También se pueden indicar direcciones relativas, utilizando los signos + y - seguidos por un número. Su funcionamiento sería: .+3 3 líneas después de la línea actual $-2 2 líneas antes de la última línea del fichero Se puede especificar un rango de líneas, indicando dos números de líneas separados por una coma. Por ejemplo,



3,8d borra todas las líneas entre 3 y 8. en tanto que 1,$p imprime todas las líneas del fichero en la pantalla. Por su parte, .-9,.+9p imprimirá 19 líneas, tornando la línea actual como centro. Se puede ver, por tanto, que hay varias formas de indicar direcciones de líneas. Así, se puede enviar al editor un número de línea, o un rango; o emplear los símbolos especiales “.” y “$” para referirse a las líneas actual y final, respectivamente; además, utilizando signos más y menos se puede localizar líneas con respecto a la línea actual o a la última línea. Bien, pero ¿cómo podemos saber los números de línea de cada una de ellas?. Si el fichero es corto, se puede usar 1,$nu para presentar el fichero completo en pantalla. Otra posibilidad es averiguar el número de línea de la línea actual (línea punto); esto último se consigue tecleando un punto seguido de un signo igual: .= El editor responderá indicando el número de línea correspondiente a la línea actual. (Recuerde además, que todos los comandos ex a semejanza de los comandos UNIX, deben terminarse con un <return>.) Este comando es particularmente útil cuando se ha estado moviendo con desplazamientos relativos usando los signos + y -, descritos anteriormente, y también cuando se utiliza el sistema de búsqueda de textos que se describe a continuación.

5.5.5 BÚSQUEDA DE PATRONES El editor ex presenta una alternativa interesante y útil para encontrar líneas; en lugar de especificar el número de línea, se le puede entregar un patrón (combinación de letras, números y signos de puntuación) para que busque él mismo en el fichero. Para ello se encierra el patrón entre barras. Si se envía el comando /coliflor/ el editor buscará a lo largo del fichero la palabra “coliflor” y, a continuación, imprimirá la línea que contiene el primer ejemplo de ésta: en ese momento, detiene la búsqueda. El proceso de búsqueda comienza a partir de la línea actual y en dirección hacia el final del fichero. Si ex no encuentra el patrón indicado cuando llega al fin de fichero, vuelve al comienzo del mismo y rastrea hasta la línea original. Si aun así no lo encuentra, se lo indicará imprimiendo un signo de interrogación. Los patrones son interpretados por ex como "cadenas de caracteres”, no como palabras. Así, si indicamos a ex que localice la cadena /eso/ buscará una coincidencia con dicha cadena, sin importarle si es una palabra separada (eso, en este caso) o un fragmento de una palabra mayor (esotérico o resoplar, por ejemplo): simplemente buscará la primera aparición de las tres letras consecutivas e-s-o. Podemos introducir un espacio como parte del patrón de búsqueda, para evitarnos este tipo de problemas. Así, el comando



/eso / encontrará “eso” y "beso” pero no “resoplar”, ya que no existe espacio detrás de la “o” en esta última palabra.

5.5.6 DESPLAZAMIENTOS POR EL TEXTO Existe aún otra técnica para localizar líneas de texto. Si se pulsa <return> sin ningún otro comando, el editor ex interpreta esta orden como .+1p Es decir, ex avanzará una línea y la imprimirá en pantalla. De este modo, si se desea avanzar lentamente en el buffer para localizar determinados cambios, se puede emplear la siguiente secuencia: 1p <return> <return> <return> y así sucesivamente. Cuando se encuentre una línea que se desea cambiar, se tienen dos alternativas. Se puede trabajar sobre la línea actual con el número de línea, o bien utilizar la dirección por defecto, que es la línea punto. Es decir, si se teclea. p únicamente, la dirección considerada es la línea actual por defecto. Existe también en ex una forma muy conveniente de llenar la pantalla de texto de un sola vez; es el comando z, que llena la pantalla con texto a partir de la línea actual hacia abajo; además, este comando acepta un número de línea a efectos de posicionamiento. Así, un buen sistema de observar un fichero sería la siguiente secuencia de comandos: prompt del modo comando 1z imprime texto en pantalla comenzando por la línea 1 z imprime texto adicional según se requiera Una vez que sabemos localizar líneas, dedicaremos nuestra atención a la creación y alteración de ficheros.

5.5.7 INTRODUCCIÓN DE TEXTO EN ex El editor ex posee tres comandos que transforman el teclado en una máquina de escribir para la introducción de texto (o datos o programas) en su buffer. Estos comandos son a para añadir texto, i para insertarlo, y c para efectuar cambios. Cuando no se incluye ninguna dirección, los comandos afectan a la línea actual. En caso contrario, los comandos añadir e insertar deberán contener una única dirección de línea, mientras que cambiar podrá tener las direcciones de una o más líneas. El comando añadir situará el texto a continuación de la línea indicada, mientras que insertar lo colocará antes de esa línea. Las líneas anotadas en un comando cambiar quedan borradas para dejar sitio al nuevo texto que se introduzca.



5.5.8 EL COMANDO DE SUSTITUCIÓN: s Si se desea cambiar la ortografía de una palabra, o añadir palabras nuevas dentro de una línea, se debe usar el comando s, o comando de sustitución. Recordamos que ex es un editor de líneas, por lo que nuestro cursor imaginario puede únicamente distinguir entre una línea y otra; no puede moverse dentro de una línea. Este defecto es quizá la mayor desventaja de un editor de líneas. Así, para indicar al editor la palabra que deseamos cambiar, tenemos que teclearla por completo. Recuérdese que el número es una dirección. Si no se específica, la sustitución se aplicará a la línea actual. Se puede añadir también un parámetro p (un parámetro es semejante a un comando) con el fin de imprimir el resultado. El parámetro se introduce al final de la línea de comando, y el editor imprimirá la línea después de efectuar la sustitución. El aspecto de la línea completa sería: 3s/texto antiguo/texto nuevo/p Los patrones de sustitución son cadenas de caracteres, exactamente iguales a los patrones de búsqueda ya mencionados; por ello, se deben manejar con cierta precaución. Por ejemplo, supongamos que la línea 3 contiene Sobre usted pesa la responsabilidad de esa muerte. Como queda un poco cacofónico, intentamos la sustitución 3s/esa/aquella/p Sin embargo, el resultado es muy distinto al que se podía esperar. El editor rastrea la línea hasta encontrar la primera aparición de las letras 'esa', localizándolas dentro de la palabra “pesa”. Sin preocuparse más del asunto, realiza la sustitución obteniendo esta curiosa frase

Sobre usted paquella la responsabilidad de esa muerte.

En un caso como éste, se lograría la sustitución correcta con el comando

3s/esa m/aquella m/p

que define sin ambigüedades la sustitución que se desea realizar.

RESUMEN: EX - EDITOR DE LINEAS -----� ----� ↓ ↑

Los modos de funcionamiento del editor ex

Modo texto

Shell UNIX

Modo Comando

Shell UNIX

Modo Texto



a añade líneas tras la línea punto, a menos que se especifique el número de línea, por ejemplo, 3a introducirá el nuevo texto a partir de la línea 3.

i Inserta líneas antes de la línea punto, a menos que se especifique el número de línea; por ejemplo 3i introduce texto antes de la línea 3.

c cambia la línea punto o las líneas especificadas por sus direcciones; por ejemplo, 2,4c borra las líneas 2 a 4 y añade el nuevo texto que se teclee.

Modo comando p Imprime en pantalla las líneas especificadas. Si no se especifica el

número de línea, se imprime la línea actual. Así, 2,4p imprime las líneas 2, 3, y 4.

d Borra las líneas especificadas. Si no se especifica, se borra la línea punto; por ejemplo, 5,8d destruye las líneas 5 a 8

m Desplaza las líneas especificadas hasta la línea indicada tras la letra m; por ejemplo, 1,2m5 mueve la línea 1 y 2 colocándolas detrás de la línea 5.

Co Copia las líneas especificadas en la línea citada tras el comando co; por ejemplo, 2,4,co$ copia las líneas 2 al 4. Colocándolas al final del buffer

r fichero Lee el contenido de fichero y lo introduce en la línea actual o en la línea actual o línea especificada.

s/uno/dos Sustituye la palabra “uno” por la palabra “dos” la primera vez que aparece la palabra “uno" en las líneas especificadas.

/bonito/ Busca la siguiente línea que contenga la(s) palabra(s) situada(s) entre las barras; en este caso, la cadena de caracteres “bonito".

g Búsqueda o sustitución global, utilizada generalmente con s o s/pat1/pat2/g, sustituyendo el patrón "pat1” por “pat2” en todas las apariciones de “pat1” en las líneas especificadas.

un Numera las líneas y las imprime en pantalla; por ejemplo, 1,$nu numera e imprime todas las líneas del fichero.

u Comando undo. Deshace el último cambio realizado en el buffer z Imprime líneas en la pantalla; por ejemplo, 3z imprime el fichero en la

pantalla, comenzando por la línea 3. Para abandonar el editor

w Comando write, que escribe las líneas especfficadas en un fichero cuyo nombre se indica a continuación; por ejemplo, 2,5w limonero escribe las líneas 2 a 5 del buffer en el fichero limonero.

q Comando quit; abandona el editor Q! Abandona el editor sin escribir los cambios realizados Direccionamiento de líneas . Este carácter se refiere a la línea actual, también llamada, por este

motivo, “línea punto”. La línea actual es la última línea afectada por un comando. Por ejemplo, .p imprime la línea actual.

.= Imprimen el número de línea correspondiente a la línea actual; por ejemplo, el editor responde con un número como "5”.

$ Este carácter indica la última línea del buffer, por ejemplo, $d borra la última línea.

n Un número decimal n indica la línea n; por ejemplo, 3p imprime la línea número 3.

+ - Los símbolos + y - se utilizan conjuntamente con una línea de referencia que puede especificarse con n, $ o por defecto la línea punto; por ejemplo $-5,$p imprime las seis últimas líneas del buffer

<return> Cuando se utiliza sin ningún otro comando, equivale a punto más uno, es decir, la siguiente línea. Es muy útil para avanzar lentamente por el buffer

Nota: Si accidentalmente pulsa las teclas o o vi mientras está en el editor ex, la manera de volver a éste es pulsar la tecla <esc> seguida por Q.



6. PROCESOS Y ENTORNO

6.1 CONCEPTO DE PROCESO Proceso es toda acción que se lleva a cabo dentro de un sistema UNIX, ya sea por la ejecución de un comando propio del sistema o por la ejecución de un programa elaborado por el usuario. Un proceso supone la existencia de un fichero, en el cual reside la información necesaria para que aquél se lleve a cabo. Siempre que un sistema UNIX está conectado existe algún proceso en ejecución. Así cuando un usuario tiene ante sí el prompt, se está ejecutando un proceso llamado shell (o sh), cuya misión es interpretar los comandos que el usuario introduce. Un proceso siempre es lanzado desde otro proceso. Así, si yo ejecuto un programa o aplicación, ese proceso es lanzado desde el shell. A su vez, las aplicaciones pueden lanzar sus propios procesos. Se llama proceso padre de otro (parent process) al proceso desde el cual es lanzado. Por analogía, los procesos lanzados del padre se llaman procesos hijo (child process). Los procesos se reconocen en UNIX por un número identificador (PID). Este número, es asignado directamente por el sistema, y es distinto para todos los procesos que se ejecutan simultáneamente en el sistema.

6.2 CONCEPTO DE ENTORNO Además de un fichero, en el cual residen las instrucciones para su ejecución, un proceso necesita de la existencia de un entorno. El entorno de un proceso es un conjunto de informaciones básicas necesarias para la ejecución del proceso. Muchas de las informaciones del entorno están más bien relacionadas con el usuario que lanza un proceso que con el propio proceso. Así, algunas de estas informaciones son el nombre de usuario, el nombre de su directorio login o el directorio actual. Cada proceso debe disponer de su propio entorno para poder ser lanzado. Ahora bien, la mayoría de las informaciones del entorno de distintos procesos serán comunes. Por ello, la forma más sencilla de obtener el entorno de un proceso es copiárselo al padre. Esta copia se hace a través de una llamada interna del sistema denominada fork. El fork produce un proceso (que incluye al entorno) exactamente igual al proceso padre. Sin embargo, cuando el fork ha sido llamado, es cuando se produce la diferenciación entre proceso padre e hijo. En este momento, al hijo se le asigna el PID correspondiente. Una vez ejecutado el fork, se dispone de dos procesos prácticamente idénticos. Sin embargo, lo que se desea es que el proceso hijo realice su propia misión. Por ello, una vez creado, el proceso hijo se desprende de las instrucciones que debe ejecutar el padre, y adopta sus propias instrucciones, que tomará del fichero correspondiente. Esto se realiza mediante otra llamada interna denominada exec. Así pues, cuando se ejecute un proceso, internamente se ejecutará una secuencia fork-exec.



6.3 VISUALIZACIÓN DE PROCESOS Se pueden ver los procesos que en un momento dado se están ejecutando en el sistema a través del comando ps. Ejecutado sin opciones, el comando proporciona una lista de los procesos que tienen lugar en la terminal. La opción más importante es la ef (ps -ef), que proporciona una lista de todos los procesos que están ejecutándose en el computador, independientemente de la terminal. Por cada proceso se obtienen una serie de informaciones, según el esquema siguiente. root 118 1 0 Aug 20 ? 0:00 LmSpool root 123 1 0 Aug 20 ? 0:01 LnMailslot root 137 1 0 Aug 20 ? 0:00 /etc/cron root 129 3 0 Aug 20 ? 4:31 Gcsp root 139 1 0 Aug 20 ? 0:00 /etc/ptydaemon root 142 1 0 Aug 20 ? 0:00 /etc/vtdaemon root 158 1 0 Aug 20 ? 0:00 Sleep 999999999 root 1224 3 0 Aug 21 ? 3:02 Gcsp bcus 4550 2665 10 10:37 55 console 0:00 ps –ef Como se observa, por cada proceso aparecen ocho campos, cuyas significados son los siguientes: 1: Usuario que ordena la ejecución del proceso (UID) 2: Número de identificación del proceso (PID) 3: Número de identificación del proceso padre (PPID) 4: Tiempo de utilización del procesador para reparto de gastos 5: Fecha u hora de comienzo del proceso 6: Terminal desde la que se ejecuta el proceso 7: Tiempo de ejecución del proceso 8: Nombre del proceso

6.4 VARIABLES Una variable es una información a la que se asigna un nombre. A primera vista, puede parecer que una variable es lo mismo que un fichero. Sin embargo, existen dos diferencias importantes: la primera es que las variables no residen físicamente en ningún disco. La segunda es que la información de las variables es información propia de un proceso. Así, las informaciones del entorno de un proceso residen en variables. Las variables existentes en un momento y en un entorno dados pueden ser de dos tipos: * Variables de entorno: son aquéllas que transmiten el valor (con el mismo nombre) a los procesos hijo. Contienen informaciones que forman parte del entorno de un proceso. * Variables locales: son aquéllas que no se transmiten a los procesos hijo. Debe quedar claro que las variables de entorno transmiten la información a los procesos hijo, pero no al revés. Es decir, si una variable de entorno en un proceso hijo es alterada, el entorno del proceso padre no será modificado. Las variables pueden ser clasificadas también según otro criterio en: * Variables de sistema: son variables con un nombre y un contenido específico, que



normalmente es común a todos los sistemas UNIX. Las más habituales son:

HOME: su contenido es el nombre absoluto del directorio login del usuario PS1: su contenido es el símbolo del prompt (habitualmente el $) PATH: su contenido es el conjunto de directorios donde el sistema buscará los comandos a ejecutar. TERM: su contenido es el tipo de terminal que se utiliza.

* Variables de usuario: todas las variables asignadas por el usuario, y que no tienen un contenido fijo. Como puede deducirse de esto último, un usuario puede definir las variables que quiera. Para crear una variable, basta con asignarle un valor de la forma siguiente: $ VAR=valor En la expresión anterior, VAR es el nombre de la variable, y valor pasa a ser su contenido. No debe existir espacio en blanco ni antes ni después del signo =. Habitualmente, las variables se escriben con letras mayúsculas si bien esto no es obligatorio. Cuando se define una variable, ésta no es de “entorno”. Para que lo sea, se ejecuta el comando export, de la siguiente manera: $ export VAR VAR1..... De esta forma, las variables situadas como argumentos del comando pasan a ser variables de entorno y como tales, cederán su nombre y contenido a los procesos hijo. Si el comando export se ejecuta sin argumentos, se obtiene la lista de las variables de entorno, pero sin indicar su contenido. Si se desea saber el conjunto de variables de entorno junto con su contenido, puede ejecutarse el comando env. Existe otro comando, el set que permite ver el valor de todas las variables existentes, ya sean de entorno o locales. Por último, el comando unset seguido del nombre de una variable, elimina esa variable. El contenido de una variable puede ser ampliado concatenando varias variables o expresiones. Así, la expresión $ A=$A$B asigna a la variable A el contenido que tenía junto con la variable B o bien la expresión

A=$A:b

modifica el contenido de la variable A añadiéndole los caracteres :b.



7. PROGRAMACIÓN SHELL. CONCEPTOS BÁSICOS Como ya se ha indicado, siempre que se está en una sesión UNIX existe un proceso en ejecución que es el shell, o sh. Su función es interpretar los comandos ejecutados por los usuarios. El proceso tiene su soporte en un comando también llamando sh, el cual puede ser ejecutado por un usuario. Si se ejecuta $ sh simplemente aparecerá el prompt ($). Sin embargo, hemos ejecutado un proceso que está en activo, y que no desaparecerá hasta que finalice, lo que conseguiremos mediante el comando exit, o Ctrl-d. Este comando, sh, dentro del cual se efectúan todas nuestras operaciones en el sistema, posee gran cantidad de particularidades y capacidades que se van a estudiar en este capítulo y en los posteriores.

7.1 METACARACTERES Un metacarácter es un carácter que tiene un significado especial, independiente de su propio símbolo. Así, el / es un metacarácter, pues aparte del “slash” representa el directorio raíz (más adelante se verá que también representa el símbolo de la división). Los principales metacaracteres son los siguientes: $: el $, puesto delante de una variable, representa el contenido de esa variable. Así, si la variable A tiene el valor 1, el comando $ echo A mostrará en pantalla A, pero el comando $ echo $A mostrará en pantalla 1. * este símbolo, al lado de algún otro carácter, sustituye a cualquier posible conjunto de caracteres (salvo el ·) que pudiera ir colocado en esa posición (en DOS tiene un significado similar). Así, el comando $ ls a* mostraría en pantalla los nombres de todos los ficheros del directorio actual cuyo nombre empieza por a. 0 bien, el comando

$ Is *a

mostraría los nombres de todos los ficheros del directorio actual cuyo nombre termina en a.

Si el símbolo * se emplea solo, representa a todos los ficheros del directorio actual. Además de este significado, más adelante se verá cómo también representa el símbolo de la multiplicación.



?: su significado es análogo a *, pero referido a un sólo carácter, en lugar de a un conjunto (en DOS tiene un significado similar) [ ] : delimita un conjunto de caracteres (tomados de uno en uno) - : indica un intervalo de caracteres ! : indica lo contrario del carácter siguiente No es conveniente utilizar los metacaracteres en los nombres de los ficheros, con el fin de evitar problemas. Sin embargo, en alguna ocasión puede ser preciso su utilización como tal símbolo, evitando el carácter especial. Para ello se utiliza el metacarácter, “\” (back-slash) que antepuesto a otro metacarácter anula el significado especial del mismo. Así, el resultado de los siguientes comandos será: $ A=1 $ echo $A -> 1 $ echo \$A -> $A El significado de un metacarácter también puede ser anulado encerrándolo entre comillas simples (‘) o dobles (“). Sin embargo, y dependiendo de los sistemas UNIX, no todos los metacaracteres son anulados de esta forma.

7.2 REDIRECCIONAMIENTOS Cuando se ejecuta un proceso, éste habitualmente conlleva una entrada y una salida. En algunos comandos puede no existir alguna de las dos. Normalmente, los datos necesarios para la ejecución de un proceso se introducen en el momento de su ejecución a través del teclado, que constituye la entrada standard, o standard input. De la misma forma. la salida del proceso (el resultado de su ejecución) se refleja habitualmente en la pantalla, que constituye la salida standard, o standar output. Igualmente, si se produce algún error durante la ejecución del proceso, la correspondiente salida se reflejará también en pantalla, que construye así la salida standard de errores, o error output. Sin embargo, puede resultar interesante en ocasiones desviar la salida de un proceso a un fichero, en lugar de a la pantalla. Así, por ejemplo, si en mi directorio existen una gran cantidad de ficheros y ejecuto el comando $ ls no podré ver todos en la pantalla. Por ello, será más conveniente desviar la salida a un fichero, que podré posteriormente editar o visualizar tranquilamente a través de un comando more. A ese desvío de la salida de un proceso a un fichero se le llama redireccionamiento de salida. El redireccionamiento provoca que la salida de un programa vaya a parar a un fichero en lugar de a la pantalla. Para ejecutado, se puede de la siguiente forma utilizando el símbolo >: $ PROC>fich El proceso anterior direcciona la salida del proceso PROC al fichero fich, de modo que en pantalla sólo aparecerá el prompt ($) a la finalización del mismo. Si el fichero no existe lo crea, pero si existe, BORRARA SU CONTENIDO, y lo sustituirá por la salida del proceso. En ocasiones, interesará que la salida de un proceso se añada a un fichero ya existente, sin borrar su contenido. En estos casos se utiliza el símbolo >>:



$ PROC >> fich El redireccionamiento de salida no incluye la salida de errores, sino sólo la salida habitual del proceso. Si se desea redireccionar los errores, puede hacerse mediante el símbolo 2>: $ PROC 2> F1 Normalmente, la salida de errores se redirecciona al mismo fichero que la salida standard. Esto se hace de la siguiente forma: $ PROC >F1 2>&1 De la misma forma que se puede redireccionar la salida de un proceso, puede redireccionarse la entrada, si bien esto es menos habitual. Por ejemplo, cuando se envía un mensaje a través de mail, se ejecuta el comando (sin argumentos) y a continuación se escribe el mensaje a través del teclado (standard input). Si se desea, puede redireccionarse la entrada, de modo que el mensaje sea el contenido de un fichero. Para ello, el signo a utilizar es <, y el comando quedaría de la siguiente forma: $ mail <F1

7.3 PIPELINES Un pipeline, o simplemente pipe, es un procedimiento por el que se conectan dos procesos, de forma que la salida del primero pasa a ser la entrada del segundo. El pipe se representa por el símbolo |: $ P1 | P2 Así se ha visto que el conjunto de procesos $ ls > F1 $ more F1 permite ver de forma pausada los ficheros contendos en el directorio actual. Para ello, se ha redireccionado la salida de ls al fichero F1, y luego se ha leído el contenido del fichero mediante el comando more. Esta operación puede hacerse de un sólo golpe a través de un pipe: $ ls l more El resultado es que cada vez que la pantalla se llene, se detendrá, para que pueda ser leída. En este caso, more toma sus datos de entrada a partir de la salida de ls (que no se refleja en la pantalla). Como puede verse, existe una cierta similitud entre el pipe y el redireccionamiento. Sin embargo, hay dos diferencias fundamentales: • Un redireccionamiento conecta un proceso con un fichero, mientras que un pipe conecta

dos procesos. • Un pipe es más rápido que un redireccionamiento, al no existir fichero, con lo que se

evita el acceso a disco (que siempre es lento).



7.3.1 FILTROS Algunos comandos pueden actuar como filtros. Un filtro es un proceso situado entre dos pipe, de modo que su actuación sobre los datos de entrada (salida del primer proceso) no se refleja en pantalla, sino que pasa a ser la entrada del 2º pipe. En apartados posteriores se indicarán ejemplos de filtros.

7.4 ASIGNACIÓN DE SALIDA DE COMANDOS A VARIABLES Se ha visto anteriormente cómo la salida de un proceso puede desviarse a un fichero, mediante el redireccionamiento, o a otro proceso, mediante el pipeline. De forma similar, puede desviarse a una variable, asignando a la variable el nombre del proceso encerrado entre comillas simples invertidas: $ VAR=`PROC` En la estructura anterior la variable VAR pasa a tomar el valor de la salida del proceso PROC.

8. PROGRAMACION SHELL. COMANDOS En este capítulo se va a exponer el funcionamiento de una serie de comandos útiles en UNIX.

8.1 COMANDO sort El comando sort sirve para ordenar las líneas de un fichero, ya sea alfabéticamente o numéricamente (en caso de que el contenido sean números). La estructura del comando es la siguiente: $ sort [opc] [campo] ficheros Habitualmente, el comando sort siempre va acompañado de al menos un argumento, que es el nombre de un fichero cuyas líneas deben ser ordenadas. Es importante tener en cuenta que la ordenación afecta sólo a la salida del comando, es decir, el fichero a ordenar queda inalterado. En caso de que no se proporcione ningún argumento, se ordenará todo lo que desde ese momento se introduzca a través del teclado, hasta que se pulsa Ctrl-d. Si no se introduce ninguna opción, la ordenación se realizará lexicográficamente (similar a alfabéticamente), con las siguientes reglas: en primer lugar, los números (sin considerar su valor numérico, únicamente el símbolo, donde el primero es el 0 y el último el 9), a continuación las letras mayúsculas en orden alfabético, y por fin las letras minúsculas, también en orden alfabético. Las principales opciones del comando son las siguientes: -c: solo proporciona salida si el fichero está desordenado -o file: redirecciona la salida al fichero file - r: invierte el sentido de las comparaciones



- n: ordena numéricamente, es decir, atendiendo al valor numérico y no simbólico de los números

En ocasiones, las líneas de un fichero pueden estar compuestas por diferentes campos. En este caso, la ordenación puede realizarse según los símbolos de un campo determinado. Para ello, se utiliza una opción, de la forma +N, donde N indica el número de campos que deben saltarse para realizar la ordenación. En estos casos, debe indicarse al comando cuál es el separador de campo, lo cual se realiza mediante la opción t, seguida del separador (por defecto, el separador es el espacio en blanco). Así, el comando $ sort -nt: +2 file realiza la ordenación del fichero file numéricamente, utilizando el campo 3 (se salta dos campos) siendo el separador de campo el símbolo (:)

8.2 COMANDO grep Este comando sirve para localizar una cadena de caracteres dentro de un fichero o ficheros dados. La estructura del comando es: $ grep [opc] cadena ficheros El primer argumento marca la cadena de caracteres que debe ser localizada. Los restantes indican los ficheros donde debe ser localizada la cadena. En caso de que la cadena exista, en pantalla aparecerá la línea completa en que se halla. Si se han dado varios ficheros para la localización, además de la línea aparecerá el nombre del fichero. Las principales opciones del comando son las siguientes: -v: Funcionamiento inverso: se escriben todas las líneas salvo aquellas en las que se ha

hallado la cadena -c: sólo se obtiene la cantidad de líneas en las que se ha hallado la cadena -i: se ignora la distinción entre letras mayúsculas y minúsculas -l: sólo se indican los nombres de los ficheros en los que aparece la cadena (el nombre

aparece sólo una vez, independientemente del número de líneas que tenga la cadena).

-n: las líneas van precedidas por su número de orden dentro del fichero -e: se utiliza cuando la cadena a buscar comienza por el signo - -s: se suprimen los mensajes de error correspondientes a ficheros no existentes o sin

permiso de lectura

8.3 COMANDO wc Este comando sirve para contar líneas, palabras y caracteres de un fichero. Su estructura es: $ wc [opc] ficheros si no se indican argumentos, se toma como entrada el teclado.



La salida por pantalla es el número de líneas, palabras y caracteres del fichero seguido del nombre del fichero. Este comando posee tres opciones: -l: cuenta sólo líneas -w: cuenta sólo palabras -c: cuenta sólo caracteres Estas opciones pueden combinarse para obtener dos de las cuentas. Por palabra se entiende cualquier conjunto de caracteres separado por espacios en blanco.

8.4 COMANDO tee El comando tee siempre es utilizado como filtro. Su función es recoger los datos de su entrada, y pasarlos a su salida, a la vez que a la salida standard y al fichero que se indique como argumento. Es decir provoca todas las salidas posibles para el proceso que le procede en el pipe. Sin embargo, no altera en absoluto los datos que recoge: $ proc1 l tee file l proc2 El comando puede llevar la opción - a, con la cual añade su entrada al fichero indicado (en lugar de crear el fichero con esa entrada), en lugar de sobreescribirlo.

8.5 COMANDO cut El comando cut se utiliza para seleccionar porciones de líneas de un fichero (o de varios). Estas porciones son enviadas a la pantalla. Sin embargo, el fichero permanece inalterado. La estructura del comando es: $ cut [opc] ficheros Existen dos posibles funcionamientos de cut: corte por caracteres, o corte por campos, indicado cada uno de ellos por la correspondiente opción.

8.5.1 CORTE POR CARACTERES La opción correspondiente es la c, seguida del intervalo a cortar en cada línea. La estructura del comando quedaría de la siguiente manera: $ cut -cINT ficheros En la estructura anterior, INT indica el intervalo de caracteres a seleccionar en cada línea. Un intervalo cerrado entre los caracteres N1 y N2 se indica N1-N2. N1, N2 indicaría los caracteres N1 y N2 de cada línea. Si utilizando el guión no se indica alguno de los extremos, se asume el primero (N1) o el último (N2).

8.5.2 CORTE POR CAMPOS La opción correspondiente es la -f. Su funcionamiento es igual que en el caso anterior, sólo que contando campos en lugar de caracteres. Para ello, debe definirse el separador de campo, para lo que se usa la opción d. La estructura quedaría de la siguiente manera:



$ cut -fINT -dsep ficheros Con la opción f puede utilizarse además la opción s, indicando que las líneas que no tienen ningún separador de campo son suprimidas: $ cut -flNT -dsep -s ficheros

8.6 COMANDO pr Este comando es similar al cat, si bien su función es mostrar en pantalla el contenido de un fichero preparado para ser impreso, es decir, con cabecera, separación de páginas, definición de márgenes, etc. Su estructura es la siguiente: $ pr [opc] ficheros Las principales opciones son las siguientes: +K: comienza la 'impresión' por la página K -K: 'imprime' en K columnas por hoja -d: 'impresión' a doble espacio -n: numera las líneas del fichero -ok: comienza la 'impresión' en la posición k+l -lk: establece la longitud de la página en k líneas -p : establece una pausa en cada página -t: elimina la cabecera Este comando se utiliza habitualmente en un pipe junto con el comando lp, que se verá a continuación.

8.7 COMANDO lp Este comando imprime en la impresora el fichero indicado como argumento. Su estructura es $ lp ficheros Al ejecutarse, el comando devuelve a la pantalla un número de trabajo, el correspondiente a ese fichero. No dispone de opciones interesantes. En muchas ocasiones se utiliza conjuntamente con el comando pr, visto en el apartado anterior. El comando lp envía los trabajos a la cola de impresión. Por tanto, Ia terminal queda disponible para seguir trabajando. El control de la cola de impresión se hace a través del comando lpstat. Este comando no utiliza argumentos. Muestra en pantalla la lista de trabajos en espera de impresión.

8.8 EL COMANDO expr Entre otras posibilidades el comando expr permite realizar operaciones aritméticas con números enteros. La estructura es la siguiente: $ expr num1 signo num2



La respuesta es obtenida en pantalla. Es importante tener en cuenta que debe existir un espacio en blanco entre el signo, y los argumentos num1 y num2, que deben ser valores enteros. El signo será uno de los siguientes: +: suma -: resta *: multiplicación. Debe ir precedido de \ para eliminar el metacarácter. /: división. Debe ir precedido de \ para eliminar el metacarácter. %: resto de la división

9. PROGRAMACIÓN SHELL. CONTROL DE PROCESOS

9.1 EJECUCIÓN DE PROCESOS EN BACKGROUND Hasta ahora se ha venido diciendo que una de las principales ventajas del sistema UNIX es que se trata de un sistema multitarea. Este puede apreciarse considerando que desde varias terminales diferentes pueden ejecutarse distintos procesos al mismo tiempo. Sin embargo, en una sola terminal, vemos que hasta que no finaliza un proceso no puede lanzarse el siguiente, ya que no se recupera el control de la terminal. Por ello, si se desea la ejecución de varios procesos simultáneamente, en una única terminal, estos procesos deben ejecutarse en background. Ejecutar un proceso en background consiste en lanzarlo de modo que se recupere inmediatamente el control de la terminal (aparece el prompt), sin esperar a la finalización del mismo. De esta forma, mientras se está ejecutando un proceso, pueden ser lanzados otros. Para lanzar un proceso en background, lo único que hay que hacer es añadir al final del proceso un &: - $ proc & En ese momento, el sistema devolverá en la pantalla el PID (identificador de proceso) correspondiente, y aparecerá el prompt. La razón de que aparezca el PID es que sólo a través de él podremos abortar el proceso en caso necesario (como se verá posteriormente). Si un proceso tiene salida por pantalla, el hecho de lanzado en background no la elimina. Esto daría lugar a una pérdida de eficacia, ya que si la pantalla está ocupada por esa salida, no seremos capaces de controlar adecuadamente la terminal. Por ello, siempre que se lance un proceso en background deben redireccionarse tanto la salida como la salida de errores. Un comando lanzado en background interrumpe su ejecución si el usuario sale de la sesión. En ocasiones, esto puede suponer un problema, por lo que existe la forma de evitarlo, utilizando el comando nohup. Este comando permite lanzar un proceso en background, sin que se interrumpa cuando el usuario abandone la sesión. La estructura del mismo es: $ nohup proceso & Cuando se utiliza nohup, es obligado redireccionar tanto la salida como la salida de errores. Si no se hace, el sistema los redirecciona al fichero nohup.out.



Un comando lanzado de manera habitual puede ser abortado mediante la tecla break o interrupt. Sin embargo, este no puede realizarse con un comando lanzado en background. Para interrumpir éstos, debe utilizarse el comando kill. El comando kill se utiliza para abortar la ejecución de un proceso (de cualquier tipo de proceso, si bien para los background es la única forma). La estructura es: $ kill PID donde PID es el identificador del proceso que desea abortarse. La necesidad de utilizar el PID explica el que este número aparezca en pantalla cuando se lanza un proceso en background. Es posible realizar comandos o procesos inmunes al comando anterior. En estos casos, se utiliza una opción que es: $ kill -9 PID la cual garantiza la interrupción del proceso. Obviamente, un usuario sólo puede abortar sus propios procesos, no los de los demás.

9.2 PRIORIDAD DE UN PROCESO La prioridad de un proceso indica la velocidad con que va a ser ejecutado por parte del sistema. Esta prioridad se mide en un rango de 1 a 29, donde 1 es la máxima y 29 es la mínima prioridad. Habitualmente, los procesos tienen prioridad 10 (todos la misma salvo, los lanzados en background, que tienen menor prioridad). Sin embargo, un usuario puede disminuir (nunca aumentar) la prioridad de un proceso. Sólo el manager puede aumentar una prioridad. Para modificar la prioridad de un proceso se utiliza el comando nice, de la siguiente forma: $ nice -increment proceso increment es un número de 1 a 19 que representa cuántos niveles sobre diez va a disminuir la prioridad. Así,

$ nice -6 PROC

indicará que PROC se va a ejecutar con prioridad 16.

Si el manager quiere aumentar la prioridad de un proceso, utilizará un incremento negativo.

9.3 CÓDIGO DE RETORNO Todos los procesos UNIX generan un código de retorno cada vez que son ejecutados. El código de retorno es una señal que nos indica de qué manera se ha ejecutado el proceso. Esta señal es un número entero, cuyo significado es: 0: el proceso se ha ejecutado correctamente distinto de 0: el proceso ha finalizado con algún tipo de error El valor del código de retorno no se muestra directamente en pantalla, sino que se halla en la variable ?. Por ello, para conocer el código de retorno de un proceso, haremos: $ echo $?



9.3.1 COMANDOS true y false Estos dos comandos únicamente tienen como función dar un valor al código de retorno. Su verdadera utilidad podrá verse en capítulos posteriores. El comando true da un valor 0 al código de retorno. El comando false da el valor de 255 al código de retorno.

9.4 EL COMANDO test El comando test se utiliza para evaluar expresiones y generar un código de retorno. Es importante destacar que test no produce respuesta en la pantalla. Su resultado debe ser examinado a través del código de retorno. Si la expresión evaluada es correcta, el código de retorno será 0. De lo contrario será un valor distinto de 0 (habitualmente 1). Los argumentos sobre los que trabaja el comando test son ficheros, números enteros y cadenas de caracteres. Las distintas evaluaciones que pueden llevarse a cabo actúan a modo de opción.

9.4.1 EL COMANDO test CON FICHEROS COMO ARGUMENTOS Cuando los argumentos utilizados son ficheros, el comando test se utiliza para evaluar la situación de los mismos. Las principales evaluaciones que pueden efectuarse son: -f: argumento es un fichero ordinario (no directorio ni device) -c: el argumento es un fichero device character -b: el argumento es un fichero device bloque -d: el argumento es un directorio ? -s: el argumento es un fichero y no está vacío, o es un directorio -r: el argumento tiene permiso de lectura (para el usuario que lo evalúa) -w: el argumento tiene permiso de escritura (para el usuario que lo evalúa) -x: el argumento tiene permiso de ejecución (para el usuario que lo evalúa) Así, $ test -r file provocaría un código de retorno 0 si el fichero file tiene permiso de lectura para el usuario.

9.4.2 EL COMANDO test CON NÚMEROS O CARACTERES COMO ARGUMENTOS En este caso, el comando se utiliza para determinar la veracidad de una expresión lógica. Las evaluaciones que pueden efectuarse son: Para evaluaciones no numéricas: a = b : compara si las cadenas a y b son iguales a != b : compara si las cadenas a y b son distintas a : compara si la cadena a no es el carácter nulo -z a : compara si la longitud de a es cero -n a : compara si la longitud de a es distinta de cero



Para comparaciones numéricas n1 -eq n2 : compara si n1 es igual que n2 n1 -ne n2 : compara si n1 es distinto de n2 n1 -lt n2 : compara si n1 es menor que n2 n1 -gt n2 : compara si n1 es mayor que n2 n1 -le n2 : compara si n1 es menor o igual que n2 n1 -ge n2 : compara si n1 es mayor o igual que n2 Todas las evaluaciones vistas (tanto para ficheros, números o caracteres) pueden combinarse a través de uniones and (-a) y or (-o). Es decir, $ test -r file -a -w file producirá un código de retorno 0 si file tiene permiso de lectura y de escritura. Asimismo, $ test -r file -o -w file producirá un código de retorno 0 si file tiene permiso de lectura o de escritura.

10. FICHEROS DE COMANDOS Un fichero de comandos es un fichero ejecutable creado con un editor, que contiene comandos o estructuras ejecutables en UNIX, que actúa a modo de proceso, de forma que cuando se lanza, ejecuta secuencialmente todos los procesos que contiene en su interior.

10.1 ARGUMENTOS EN LOS FICHEROS DE COMANDOS Como se ha indicado, un fichero de comandos actúa como si fuera un comando más, que a su vez ejecuta otros comandos. Ahora bien, normalmente los comandos necesitan argumentos sobre los que actuar. Así, por ejemplo, podemos idear un fichero de comandos que asigna permisos a ficheros sin necesidad de conocer el funcionamiento de chmod. Sin embargo, ese fichero sería prácticamente inútil si no somos capaces de indicar en cada ocasión a qué fichero queremos cambiar los permisos. Para salvar este tipo de problemas, los ficheros de comandos admiten argumentos (como si se tratara de un comando normal). Los argumentos de los ficheros de comandos son informaciones que el usuario aporte, y que serán manejadas convenientemente en el interior del fichero de comandos. Ahora bien ¿cómo se hace referencia internamente a los argumentos?. Se hace, teniendo en cuenta su posición. Así, si en un f.c. quiero manejar el primer argumento, utilizaré el símbolo $1. $2 será el segundo argumento, y así sucesivamente, hasta un máximo de 9. No se admiten más argumentos en un f.c. Sin embargo, es posible que un determinado proceso necesite un mayor número de ellos. En este caso, puede utilizarse DENTRO DEL FICHERO, el comando shift, cuya función es desplazar una posición los argumentos. De esta forma, $3 pasa a ser $2, $2 pasa a ser $1, $10 pasa a ser $9, etc. $1 desaparecerá.



shift puede utilizarse con un argumento numérico, que indica cuántas posiciones deben desplazarse los argumentos. Así, $ shift 2 indica que los argumentos se desplazan dos posiciones, Por lo que $3 pasaría a ser $1, $4 pasaría a ser $2, y los argumentos $1 y $2 desaparecen. Además de los símbolos que indican los argumentos, existen otros que tienen un significado especial dentro de un fichero de comandos: $0: nombre del fichero de comandos $#: número de argumentos $*: todos los argumentos $$: PID del proceso actual (el correspondiente al fichero de comandos)

10.2 INTRODUCCIÓN DE DATOS A TRAVÉS DE VARIABLES Como se ha visto, los argumentos permiten introducir informaciones a los f.c. Sin embargo, este funcionamiento puede ser un tanto incómodo, sobre todo para usuarios no habituados a utilizarlo. Sin embargo, es posible también introducir información a un f.c. a medida que se va ejecutando. Estas informaciones se recogen en forma de variables. La forma de hacerlo es a través del comando read, el cual detiene la ejecución del f.c. y espera a que se introduzca el valor correspondiente por parte del usuario. La estructura correspondiente es: read VAR1 donde VAR1 es el nombre de la variable donde quedará almacenada la información. Read puede asignar varias variables al mismo tiempo, si bien lo más recomendable es hacerlo de una en una.

A modo de ejemplo, supongamos el siguiente read:

read V1 V2

y sea la respuesta del usuario A1 A2 A3 En este caso, la variable V1 tomaría el valor Al. mientras que la variable V2, tomaría el valor A2 A3. Si la respuesta es A1 la variable V1 tomaría el valor A1 y la variable V2 el carácter nulo. Debe tenerse en cuenta que el comando read no lanza ningún mensaje a pantalla, por lo que es habitual utilizar delante de un read un comando echo, que indique al usuario qué información se le está pidiendo. Por último, hay que indicar que un fichero de comandos en ejecución define un nuevo shell, es como si previamente se ejecutara sh. Por ello, las variables que se definan en el interior



del f.c. no afectarán a las ya existentes en el shell (aunque sean de entorno), y al finalizar la ejecución, no quedará constancia de ellas. Si se desea detectar un error en la elaboración de un fichero de comandos, una ayuda consiste en ejecutar el fichero de la siguiente manera: $ sh -x fich De esta forma, el fichero se ejecutará de forma que antes de ejecutarse cada comando, se escribirá en pantalla el nombre del comando a ejecutar. Con ello, es más fácil controlar el funcionamiento del programa.

10.3 COMANDO exit Cuando un fichero de comandos finaliza su ejecución, el código de retorno será el correspondiente al último proceso ejecutado por él. Sin embargo, se puede finalizar la ejecución en cualquier momento, sin esperar a que se complete todo el fichero (en el apartado siguiente, en el que se explicarán las estructuras de programación, se entenderá mejor esto). Esto se hace mediante el comando exit. Anteriormente, se ha visto cómo exit se utiliza para abandonar la sesión, o para abandonar un shell cuando se ha ejecutado un comando sh. En realidad, ahora el funcionamiento es el mismo, ya que en un fichero de comandos su función es abandonar la shell correspondiente al mismo. Se puede dar un argumento a exit, un número comprendido entre 0 y 255. En este caso, el código de retorno adopta ese valor.

10.4 ESTRUCTURAS DE PROGRAMACIÓN Las estructuras de programación son construcciones que permiten controlar el funcionamiento de un fichero de comandos. Cada una de ellas puede ejecutarse independientemente en el shell, si bien su utilidad se manifiesta dentro de un fichero de comandos. Se verán cuatro construcciones: if, while, for, case.

10.4.1 LA CONSTRUCCIÓN if La construcción if se utiliza para tomar decisiones basadas en los códigos de retorno. La estructura básica de esta construcción es: if CMD1 then CMDA

CMDB . . fi y se le de la siguiente manera: si el código de retorno de CMD1 es 0 entonces ejecutar CMDA, CMDB



Si el código de retorno no es 0, la ejecución del fichero continúa en el proceso situado después de fi. fi indica el fin de la construcción if (fi es if al revés). Se puede incluir una construcción if dentro de otra. En este caso, las distintas construcciones deben cerrarse en orden inverso a como han sido abiertas. Si entre if y then existen varios procesos, se ejecutarán todos ellos, pero sólo el código de retorno del último marcará la decisión. Una variante de la estructura básica es la siguiente: if

CMD1 then

CMDA CMDB

else

CMDC CMDD

fi que se lee de la siguiente manera: si el código de retorno de CMD1 es 0 entonces, se ejecutan CMDA, CMDB... si no, se ejecutan CMDC, CMDD... Una última variante poco recomendable, es la siguiente: if CMD1 then CMDA CMDB . . elif CMD2 then

CMDC CMDD

. . fi Y su lectura es: si el código de CMD1 es cero entonces se ejecutan CMDA, CMDB,...



si no es cero, y además es cero el código de retorno de CMD2 entonces se ejecutan CMDC. CMDD... .. La construcción elif siempre puede obtenerse a base de varios if. Como se ha indicado, la construcción if (y cualquiera de las que se verán posteriormente) puede utilizarse directamente sobre el shell. En este caso, cuando tecleamos if, aparecerá en pantalla lo siguiente. $ if > El símbolo > indica que la construcción no está completa. Por tanto, el terminal seguirá esperando la introducción de órdenes hasta que se llegue al fi, momento en el que volverá a aparecer el prompt ($), pues se ha completado la construcción. En ese instante se ejecuta toda la construcción. Al símbolo > se le denomina segundo prompt y su valor reside en la variable PS2, por lo que puede ser modificado a voluntad del usuario.

10.4.2 LA CONSTRUCCIÓN while La construcción while se utiliza para generar un ciclo condicionado. La estructura es la siguiente: while

CMD1 do

CMDA CMDB

. done Y se lee de la siguiente forma: Mientras el código de retorno de CMD1 sea 0 se ejecutan los comandos CMDA, CMDB, .... comprendidos entre do y done. Al llegar a done, se vuelve a ejecutar CMD1, y vuelve a repetirse el proceso. Si el código de retorno de CMD1 no es cero la ejecución continúa en el proceso siguiente a done. Así pues, se ha creado un ciclo condicionado a la correcta ejecución de CMD1. Al igual que ocurre en la construcción if, entre while y do, pueden existir varios procesos, pero sólo el último determinará la ejecución del ciclo. Obviamente, si CMD1 es true, puede establecerse un ciclo sin fin. Al igual que en la construcción if (y como sucederá en las posteriores construcciones) puede incluirse una construcción while dentro de otra, debiendo cerrarse de forma inversa a como han sido abiertas.



10.4.2.1 LOS COMANDOS break y continue El comando break se utiliza para finalizar un ciclo de forma prematura, sin que éste llegue a su fin. Así supongamos la siguiente estructura: while CMD1 done

CMDA CMDB while

CMDC do

CMDE break

done CMDJ CMDK

done CMDX Al alcanzarse el break, el ciclo do-done correspondiente queda interrumpido, y la ejecución del fichero de comandos continúa en el proceso siguiente al done. En este caso, continuaría con CMDJ. break puede llevar un argumento numérico, que indica cuántos ciclos do-done (incluidos uno dentro de otro) deben saltarse para continuar la ejecución. Así, si en lugar de break en el ejemplo anterior apareciera break 2 la ejecución continuaría con CMDX El comando continue funciona de forma similar. Cuando se halla dentro de un ciclo do-done, interrumpe la ejecución del ciclo pero vuelve a ejecutar el proceso que condiciona la ejecución del mismo. Así, si en el ejemplo anterior apareciera continue en lugar de break el fichero de comandos volvería a ejecutar CMDC, y podría volver a ejecutar el mismo ciclo, en caso de que el código de retorno fuera 0. Al igual que break, continue puede llevar un argumento numérico, indicando qué ciclo do-done (incluido uno dentro de otro) debe ser evaluado. Así, si en lugar de break apareciera continue 2 en el ejemplo anterior, el fichero continuaría ejecutando CMD1 y entrando en el ciclo correspondiente si su código de retorno es 0.



10.4.3 LA CONSTRUCCIÓN for Esta construcción es bastante similar a la while. Sirve también para generar un ciclo, pero un número determinado de veces. La estructura es la siguiente: for V in char1 char2.... do

CMD1 CMD2

. . done Y su funcionamiento es el siguiente: La variable V (una variable cualquiera) toma el valor char1 (puede ser un número, un carácter o conjunto de caracteres o un fichero) y a continuación ejecuta todos los procesos comprendidos entre do-done. A continuación, V torna el siguiente valor de la lista (char2) y vuelve a repetirse el proceso, y así continúa hasta que V toma el último valor. De esta forma se crea un ciclo que se ejecutará un determinado número de veces. Todo lo dicho para la construcción while es aplicable a for, incluido el funcionamiento de break y continue.

10.4.4 LA CONSTRUCCIÓN case Esta construcción es equivalente a un if múltiple. Todo lo que puede hacerse con case, puede obtenerse mediante varios if. La estructura es: case CHAR in modelo 1) (delimitador de modelo) CMD1 …… . ;; (fin de modelo) modelo 2)

CMD2 …… . ;; . . modelo n)

CMDN .…….. ;;

esac (fin de case, esac es case al revés)

El funcionamiento es el siguiente: Se compara la cadena CHAR (normalmente será el contenido de una variable) con modelos. Si coincide, se ejecutan los procesos siguientes hasta el símbolo ;;. Se compara con modeIo2, y se va repitiendo la operación hasta llegar al final. En los modelos de comparación pueden utilizarse metacaracteres (*,?,etc)

90383990 comandos-basicos-unix

Documents