ÍNDICE

1. USO DEL SISTEMA UNIX. ................................................................................................................. 4

1.1. CARACTERÍSTICAS DE UNIX. ........................................................................................................... 4

1.2. SISTEMAS DE CONTROL Y UTILIZACIÓN DE RECURSOS.................................................................... 4
1.3. COMPONENTES PRINCIPALES DEL SISTEMA. .................................................................................... 5
1.4. ENTRADA Y SALIDA DEL SISTEMA..................................................................................................... 5
1.5. CONTRASEÑA. ................................................................................................................................... 6
1.6. ÁRBOL DE DIRECTORIOS................................................................................................................... 6
1.6.1. Principales Directorios del sistema............................................................................................ 6
1.7. FORMATO DE COMANDOS. ................................................................................................................ 7
1.8. FORMATO DE LOS COMANDOS SHELL. ............................................................................................. 7
1.9. COMANDOS DEL SISTEMA. ................................................................................................................ 7
1.9.1. Comando passwd. ....................................................................................................................... 7
1.9.2. Comando pwd. ............................................................................................................................ 8
1.9.3. Comando ls. ................................................................................................................................ 8
1.9.4. Trabajo con directorios. ............................................................................................................. 9
1.9.4.1. Comando “cd”. .................................................................................................................... 9
1.9.4.2. Comando “mkdir”................................................................................................................ 9
1.9.4.3. Comando “rmdir”. ............................................................................................................... 9
1.9.4.4. Comando “rm”. .................................................................................................................... 9
1.9.5. Gestión básica de ficheros. ....................................................................................................... 10
1.9.5.1. Comando “cat”. ................................................................................................................. 10
1.9.5.2. Comando “cp”. .................................................................................................................. 10
1.9.5.3. Comando “mv”. ................................................................................................................. 10
1.9.5.4. Comando “ln”. ................................................................................................................... 11
1.9.6. Mensajes en el terminal. ........................................................................................................... 11
1.9.6.1. Comando “who”. ............................................................................................................... 11
1.9.6.2. Comando “finger”.............................................................................................................. 11
1.9.6.3. Comando “tty”. .................................................................................................................. 11
1.9.7. Permisos de acceso. .................................................................................................................. 12
1.9.7.1. Comando “chmod”. ........................................................................................................... 12
1.9.7.2. Comando “umask”. ............................................................................................................ 13
1.9.7.3. Comando “chown”. ........................................................................................................... 13
1.9.7.4. Comando “chgrp”. ............................................................................................................. 13
1.9.8. Recepción y envío de correo. Comando mail. .......................................................................... 14
1.10. COMANDOS DE USO GENERAL....................................................................................................... 15
1.10.1. Editores. ................................................................................................................................. 15
1.10.1.1. El editor joe. .................................................................................................................... 15
1.10.1.2. El editor vi. ...................................................................................................................... 15

2
 1.10.2. Comandos relacionados con la fecha del sistema. ................................................................. 16
1.10.2.1. Comando date. ................................................................................................................. 16
1.10.2.2. Comando cal. ................................................................................................................... 17
1.10.2.3. Comando calendar. .......................................................................................................... 17
1.10.3. Comandos para la visualización de ficheros. ......................................................................... 17
1.10.3.1. Comando pg. .................................................................................................................... 17
1.10.3.2. Comando more. ............................................................................................................... 18
1.10.3.3. Comando hexdump. ......................................................................................................... 18
1.10.3.4. Comando bpe. .................................................................................................................. 18
1.10.4. Comandos de comparación de ficheros. ................................................................................. 18
1.10.4.1. Comando cmp. ................................................................................................................. 18
1.10.4.2. Comando comm. .............................................................................................................. 18
1.10.4.3. Comando diff. .................................................................................................................. 18
1.10.4.4. Comando uniq.................................................................................................................. 18
1.10.5. Operaciones sobre ficheros de texto. ...................................................................................... 19
1.10.5.1. Comando sort. .................................................................................................................. 19
1.10.5.2. Comando cut. ................................................................................................................... 19
1.10.5.3. Comando paste. ............................................................................................................... 19
1.10.5.4. Comando join. ................................................................................................................. 19
1.10.5.5. Otros comandos. .............................................................................................................. 20
1.10.6. Localización de ficheros. ........................................................................................................ 20
1.10.6.1. Comando find. ................................................................................................................. 20
1.10.6.2. Comando grep.................................................................................................................. 21
1.10.6.3. Comando sed. .................................................................................................................. 22
1.11. EL SHELL ...................................................................................................................................... 24
1.11.1. Redireccionamientos y pipes. ................................................................................................. 24
1.11.2. Variables del Shell. ................................................................................................................. 25
1.11.3. Variables de entorno. ............................................................................................................. 26
1.11.4. Fichero .profile. ...................................................................................................................... 26
1.11.5. Órdenes internas del shell. ..................................................................................................... 27
1.11.6. La orden eval y el operador grave. ........................................................................................ 27
1.12. IMPLEMENTACIÓN DE SHELL-SCRIPTS. ........................................................................................ 28
1.12.1. Construcción if-then-else. ....................................................................................................... 28
1.12.2. La orden test. .......................................................................................................................... 28
1.12.3. Construcciones de control iterativas ...................................................................................... 29
1.12.3.2. Construcción while o until. .............................................................................................. 29
1.12.3.3. Comando expr.................................................................................................................. 30
1.12.4. Sentencias read, exit y break. ................................................................................................ 30
1.12.5. Sentencia case ........................................................................................................................ 31
1.12.6. Declaración de funciones. ...................................................................................................... 31

3
1. USO DEL SISTEMA UNIX.

1.1. Características de UNIX.

- Portabilidad: Es posible adaptar fácilmente este Sistema Operativo a diferentes ordenadores de

diferentes fabricantes.
- Portabilidad del software: Las aplicaciones software escritas para el UNIX son fácilmente
adaptables a los diferentes ordenadores.
- Propósito General: El UNIX es un Sistema Operativo de propósito tal general por lo que es
aplicable a muchos y diferentes entornos de usuarios.
- Multitarea: Es posible utilizar diferentes lenguajes en diferentes funciones y que un usuario
pueda estar realizando simultáneamente varias tareas. Permite la ejecución simultánea de varias
tareas (llamadas procesos).
- Tiempo Compartido:A cada proceso se le asigna un mínimo de ejecución de programa por
unidad de tiempo (SCHEDULER).
- Multiusuario: Más de un usuario puede acceder al sistema al mismo tiempo (limitado por el
número de terminales).
- Interactivo: Cualquier usuario puede comunicarse directamente con el sistema y recibir respuesta
inmediata a su solicitud de ejecución.
- Fácil Modificación y mantenimiento: El uso del lenguaje Ç"permite al Sistema Operativo ser
fácilmente mantenido y modificado. Esto le da una buena portabilidad.
- Su estructura de archivos basada en nodos-i: El uso de una estructura jerárquica permite un fácil
organización de archivos, tanto del sistema como de los usuarios.
- Silencioso: Únicamente visualiza información en el caso de producirse un error.
- Usa Procesos Fore/Background: Permite a un usuario tener más de un proceso ejecutándose al
mismo tiempo.
- Proceso de textos y documentos: El sistema aporta una serie de herramientas que facilitan esta
labor.
- Utilidades de edición: Creación, Edición, Manejo de documentos
- Utilidades de Formateado: proporciona herramientas para modificar formatos e imprimir con
calidad.
- Comunicaciones: Se pueden establecer redes de comunicaciones UNIX a UNIX por medio de las
utilidades aportadas por el Sistema Operativo. Ningún otro sistema operativo incluye unas
posibilidades de conexión en red tan ajustadamente acopladas y ningún otro sistema operativo
posee la flexibilidad incorporada de estas mismas características. Tanto si se necesita hablar con
otro usuario a través de una utilidad de correo como si se necesita transferir archivos extensos de
otro sistema que se encuentra en el otro extremo del país.
- Accounting: Se pueden instalar, para cada usuario, sistemas de conteo, por el cual perderán
acceso al sistema cuando el sistema lo determine.
- Proporciona Shell programables El shell programable es una característica que hace que UNIX y
por tanto Linux sea lo que es: el sistema operativo más flexible de los existentes. Dentro del
marco del shell hay un nuevo mundo accesible a todos aquellos que sean lo suficientemente
aventureros para dominar los entresijos de la sintaxis de los comandos de Linux.
- Independencia de dispositivos UNIX. Evita los problemas que supone agregar nuevos
dispositivos contemplando cada periférico como un archivo aparte. A medida que se necesitan
nuevos dispositivos, el administrador del sistema añade al kernel el enlace necesario. Este
enlace, también denominado controlador de dispositivo, garantiza que el kernel y el dispositivo
se fusionan del mismo modo cada vez que se solicita el servicio del dispositivo. A medida que se
van desarrollando y facilitando periféricos mejores para el usuario, el sistema operativo UNIX
permite un acceso inmediato y sin limitaciones a sus servicios, una vez se han enlazado los
dispositivos con el kernel. La clave de la independencia de los dispositivos estriba en la
adaptabilidad del kernel

1.2. Sistemas de control y utilización de recursos.

UNIX proporciona sistemas para ayudar al mantenimiento de programas. Proporciona

herramientas con gran cantidad de facilidades en el tema de oficina: Correo, Agenda, Mensajes, Envío de
Documentación, y otras utilidades. UNIX provee de varios lenguajes de programación como pueden ser:
COBOL, FORTRAN, Basic, RPG, Pascal, y por supuesto C. UNIX usa generalmente dos tipos de
editores: Editores de línea y Editores de pantalla (JOE, VI).

4
1.3. Componentes principales del sistema.

1. KERNEL
2. Shell
3. Utilidades.- conjunto de aplicaciones que normalmente suele suministrar UNIX para facilitar
todo tipo de tareas.

KERNEL

Es el corazón del Sistema UNIX. Es la porción del Sistema Operativo que trabaja más cerrada e
independientemente del usuario. Es el manejador del Sistema UNIX. Se encarga de realizar las funciones
de más bajo nivel con respecto al hardware del sistema, permitiendo por lo tanto, la no dependencia del
hardware del resto de las partes del Sistema Operativo. La utilidades de UNIX, así como las aplicaciones
de los usuarios, lo utilizan para que realice por ellas los servicios de interfaces necesarios con el hardware
(status, etc). Reside permanentemente en la memoria. El kernel maneja los procesos y los recursos del
siguiente modo:

- Maneja los procesos: asignando recursos, planificando Procesos (Multiusuario) y manejando

solicitudes de servicios del Kernel.
- Maneja Unidades: supervisando la transmisión de datos entre las unidades y las aplicaciones.
El Kernel contiene un manejador para las unidades físicas de cada ordenador. Estos manejadores
son propios para cada ordenador y dispositivo periférico.

Esencialmente, el KERNEL es el conjunto de programas que controlan el acceso al ordenador,

maneja su memoria y asigna los recursos del sistema a los usuarios, cuando así lo demanden.

Shell

El Shell es realmente la única parte del Sistema UNIX que el usuario ve. Actúa como un
intérprete, permitiéndole comunicarse con el Sistema Operativo UNIX. Cuando los usuarios introducen
un comando, el Shell, que es un programa que está en constante ejecución, lo analiza y llama a ejecución
al programa que realiza la función especificada por el comando. Cada usuario que trabaja en el Sistema
UNIX tiene su propio programa Shell o "entorno". Hay más de un tipo de prompt, dependiendo del
SHELL: Bourne, Berkeley, Creados por los usuarios, Super User.
Un usuario puede utilizar diferentes SHELLS al mismo tiempo. También actúa como un
lenguaje de programación: ya que se combina mediante estructuras de control grupos de comandos
almacenados en archivos llamados SHELLSCRIPTS pudiendo así crear aplicaciones que pueden realizar
tareas complicadas.

1.4. Entrada y salida del sistema.

Dada la característica multiusuario del sistema UNIX y por motivo de seguridad, el acceso al
mismo está restringido.
Sólo tendrán acceso al sistema aquellos usuarios a los que el administrador haya asignado
previamente un identificativo (ID). El identificativo de usuario, asignado por el administrador, puede
tener longitud variable, pero tan sólo serán significativos los primeros ocho caracteres. No están
permitidos los espacios.
Para incrementar la seguridad, cada usuario puede añadir opcionalmente una contraseña de
acceso al sistema. La existencia de contraseña puede ser impuesta por el administrador.
Cuando se va a trabajar desde un terminal conectado directamente al ordenador, nada más
encenderlo aparecerá un mensaje solicitando la identificación del usuario. Este mensaje puede ser
modificado por el administrador.

login:

En este momento el usuario puede introducir el identificativo que se le haya asignado y pulsar
Intro. Es importante que el identificativo sea introducido en minúsculas, pues en caso contrario el sistema
asume que el terminal sólo dispone de mayúsculas y mantendrá la comunicación de esta forma durante
toda la sesión de trabajo. Esto puede traer complicaciones, pues el sistema UNIX diferencia mayúsculas
de minúsculas.

5
 En el caso de que el usuario tuviera contraseña de acceso al sistema, le será solicitada a
continuación por medio de la palabra “passwd”. Para mayor seguridad, la contraseña tecleada por el
usuario no aparece jamás en la pantalla. Cualquier equivocación al teclear el identificativo hará que el
sistema solicite una contraseña y una vez tecleada ésta, contestará con “login incorrect” y volverá a pedir
el identificativo. Tan sólo cuando el identificativo de usuario y la contraseña de acceso se han introducido
correctamente, aparecerán en pantalla una serie de mensajes y el sistema quedará preparado para recibir
las órdenes del usuario.
Siempre que el sistema esté en espera para recibir órdenes, aparecerá en la pantalla un mensaje
indicativo o prompt.
Para finalizar la sesión de trabajo basta mantener pulsada la tecla control-d, o teclear exit +
Intro. Una vez finalizada la sesión, el sistema vuelve a mostrar los mensajes con los que solicita el
identificativo de usuario. En este momento se podrá apagar el terminal.

1.5. Contraseña.

La contraseña puede ser modificada siempre que se desee. Tiene las siguientes características:
- Cada contraseña deberá tener al menos seis caracteres, pero es configurable.
- Son significativos los ocho primeros caracteres.
- Deberá tener al menos dos caracteres alfabéticos y al menos un carácter numérico o carácter
especial. Cada contraseña deberá diferir del login del usuario en tres caracteres.
- Las nuevas contraseñas deberán diferir de las anteriores al menos en tres caracteres.
- Puede tener limitado su tiempo de efectividad.

1.6. Árbol de directorios.

- La estructura de directorios del S.O. UNIX es arborescente.

- El directorio raíz se representa con la barra inclinada a la derecha ( / ), que también se utiliza
como separador en los nombres de ruta (pathnames).
- El nombre de los ficheros en UNIX puede tener hasta 255 caracteres de longitud, y en ellos
el punto (.) es uno más.
- Directorio HOME de un usuario.- es aquél directorio donde se le deja al usuario cuando
entra al sistema. Es un directorio definido por el superusuario al crear la cuenta de cada
usuario, donde normalmente el usuario tiene plena libertad para crear y gestionar sus
ficheros.

1.6.1. Principales Directorios del sistema.

- Directorio raíz: en muchos sistemas Unix es el directorio HOME del superusuario. Contiene
un fichero muy importante para el arranque del sistema, el unix (depende del sistema el
nombre del fichero: dgux, xenix, vmlinux, etc), que es el núcleo del sistema operativo. Por
lo demás, habitualmente no habrá más que entradas de directorios en la raíz.
- Directorio “usr”: es el directorio de los usuarios. De él cuelgan normalmente los
subdirectorios de los diferentes usuarios del sistema. Además contiene otros subdirectorios
(bin, sbin, doc, include, lib, man, tmp, spool) , que esencialmente tienen por objeto
proporcionar herramientas para la programación.
- Directorio “bin”: Contiene algunas órdenes de uso habitual por los usuarios del sistema.
- Directorio “sbin”: Contiene algunos programas relacionados con la administración del
sistema, y que por tanto, están reservados al superusuario.
- Directorio “dev”: Contiene un conjunto de ficheros especiales destinados a la gestión de
periféricos (console, hda, fd0, lp0, tty,...).
- Directorio “etc”: Contiene ficheros y herramientas empleados para la administración del
sistema. Contiene un subdirectorio default en el que se almacenan los valores por defecto de
algunas variables del sistema, así como un subdirectorio “rc.d”, en el que se encuentran los
ficheros de comando (shell-scripts) que serán ejecutados según el nivel de inicialización
elegido.
- Directorio “tmp”: Al igual que /usr/tmp es otro directorio de uso temporal.
- Directorio “var”: Complementa al directorio usr. De hecho, muchos subdirectorios de usr en
realidad son ligaduras a directorios de var, e.d., están físicamente ubicados como
subdirectorios de var, aunque también pueden accederse a través de usr.

6
 - Directorio “mnt”: Habitualmente todos los sistemas Unix disponen de este directorio, que se
emplea para montar sobre él otros sistemas de ficheros. Por ello este directorio estará
generalmente vacío.

1.7. Formato de comandos.

El formato de los comandos shell es una secuencia de palabras, cada palabra se separa de la
siguiente por uno o más espacios. En este contexto, una palabra es una serie de caracteres contiguos no
blancos. El comando es terminado con el carácter Nueva Línea (\n), el cual se introduce cuando se pulsa
Intro.
La primera palabra es el comando, las restantes palabras son argumentos del comando. Los
espacios son usados como separadores entre argumentos. Si por alguna razón fuera necesario incluir un
espacio en algún argumento, entonces todo el argumento deberá ser encerrado entre doble comillas (“), o
bien entre comillas simples (‘).
Comando Opciones Argumentos
cp –R ./etc /mnt

Opciones.- es un literal, que usualmente va precedido por el signo menos. Las opciones
modifican la acción de un comando, o indican cómo operar el comando. El efecto de las opciones varía
con cada comando.
Argumentos.- En ciertos comandos del primer argumento suele ser una serie de caracteres que
son utilizados como entrada a un comando, en otros muchos comandos suelen ser nombres de archivos o
directorios que van a ser utilizados.
man comando, es el equivalente a help comando en msdos.
1.8. Formato de los comandos Shell.

Los comandos shell constan de una sola palabra que se introduce a continuación del prompt
shell, seguida de un <CR> o una lista de opciones o argumentos. Los argumentos están separados por
espacios.

La notación estandarizada es:

- arg: Opciones o argumentos que pueden no estar presentes.
- ....: Indica repetición de argumentos.
- |: Indica una condición OR.
- los corchetes [] indican que son opcionales.
Ejemplo:
- comando [argA | argB] .- argA o argB son opcionales.
- comando argA.... .- argA deberá estar presente, al menos una vez.
- comando argA [argB...] argA deberá estar presente y argB podrá estar una o más veces.

1.9. Comandos del sistema.

1.9.1. Comando passwd.

Este comando permite al usuario cambiar o asignar una contraseña.

Observaciones:
- Es obligatorio su uso.
- Para cambiar una contraseña se necesita conocer la antigua.
- El administrador puede asignar una contraseña nueva.
- Nadie puede visualizar ninguna contraseña.
- La contraseña queda registrada en el archivo /etc/passd y /etc/shadow.
- La contraseña puede tener un mínimo de tiempo efectivo.

7
 Descripción:
Este comando cambia la contraseña para usuarios y grupos. Un usuario normal, sólo puede
cambiar su propia contraseña, aunque el superusuario puede cambiar todas las contraseñas del
sistema. El administrador de un grupo puede cambiar cualquier contraseña del grupo. También
se cambia la información sobre la cuenta, como el nombre completo, el login de entrada o la
caducidad de la cuenta y los intervalos de caducidad de la contraseña.

Sintaxis

passwd

Si el administrador quiere cambiar alguna contraseña passwd nombre_usuario

passwd [-f|-s] [name]

-s se usa para el cambio del shell
-f se usa para el cambio de la información del usuario
passwd [-g] [-r|R] group
-g para cambiar la contraseña de un grupo.
-r para eliminar la contraseña de un grupo.
-R para restringir el grupo a todos los usuarios
passwd [-x max] [-n min] [-w warn] [-i inact] name
-x indica el nº de días que la contraseña es válida.
-n indica el mínimo nº de días durante los cuales la contraseña no puede ser cambiada
-w indica el nº de días en los que el usuario recibirá un aviso de contraseña a caducar.
-i se utiliza para desactivar una cuenta que no se utiliza durante un periodo de días.
passwd –l|-u|-d|-S|-e name
-l desactiva la cuenta cambiando la clave a un valor que no valida una entrada nunca.
-u reactiva la cuenta y deja la clave a su valor anterior.
-d para borrar la clave de un usuario.
-S para consultar el estado de una cuenta.
-e para que la clave caduque de forma inmediata.

1.9.2. Comando pwd.

Permite conocer en cada momento el directorio en el estamos situados.

1.9.3. Comando ls.

Se utiliza para visualizar los ficheros del directorio actual. La orden ls presenta los ficheros por
orden alfabético. También puede indicarse como argumentos los nombres de ficheros o directorios, y
además se pueden utilizar las máscaras * e ? igual que en DOS. Si se indican varios ficheros como
argumentos, estos deben ir separados por espacios en blanco.
ls –l, o simplemente l, es similar a la salida del comando DIR en el DOS. Con esta orden, además
de indicar los nombres de los ficheros, se presenta la siguiente información (atributos):
- Tipo de fichero: ocupa un carácter (-: normal, d:directorio, p:pipe, c:fichero especial de
caracteres, b: fichero especial de bloques, l:ligadura simbólica).
- Permisos de lectura/escritura/ejecución: ocupan los siguientes 9 caracteres, y se dividen en
permisos de usuario (los 3 primeros), permisos del grupo (los 3 siguientes) y permisos para
otros usuarios.
- Nº de ligaduras no simbólicas al fichero: nº de entradas de directorio que se refieren al
fichero.
- Usuario propietario del fichero.
- Grupo propietario.
- Tamaño del fichero en bytes.
- Fecha y hora de la última modificación del fichero.
- Nombre del fichero.

8
-a Con esta opción se visualizan también los ficheros ocultos. Un fichero es oculto si su primer
carácter es un punto.
-R Si el argumento es un directorio, la opción R visualiza el subárbol de directorios que cuelga de él,
así como los ficheros contenidos en cada uno de esos subdirectorios.
-F Indica para cada fichero su tipo (/si es un subdirectorio, * si es un ejecutable y @ si es una ligadura
simbólica).
-C Realiza el listado de una forma más compacta, por columnas.
-r Realiza la salida en orden alfabético inverso.
-d Si el argumento pasado a la orden es el nombre de un directorio, no nos muestra su contenido, sino
que muestra los atributos correspondientes a dicho directorio.
-1 La salida se presenta en una sola columna
-m La salida se presenta separada por comas.

Otras opciones de interés de la orden ls.

Ejemplo1: Observar la diferencia existente entre los resultados de las dos órdenes siguientes:
- ls –dl /etc
- ls –l /etc

Ejemplo2: Indica el comando y las opciones correspondientes a usar para mostrar el nombre de
cualquier fichero (incluidos los ocultos) introducido/s como argumento/s desde el directorio actual y en
una sola línea.
- ls –am arg1, arg2, .arg3, ....
- ls –a –m arg1, arg2, .arg3, …

1.9.4. Trabajo con directorios.

Para movernos por el árbol de directorios se usan unas órdenes idénticas a las del DOS.

1.9.4.1. Comando “cd”.

Con esta orden se cambia el directorio actual, siendo éste ahora el indicado en la orden.
- El punto simple “.” indica el directorio actual.
- Los dos puntos consecutivos “..” el directorio padre del actual.
- La barra hacia la derecha ( / ), el directorio raíz.

La orden “cd” sin argumentos lleva al usuario que la invoca a su directorio “HOME”.

Sintaxis: cd [camino_subdirectorio]

1.9.4.2. Comando “mkdir”.

Permite crear un subdirectorio, donde camino_subdirectorio puede ser un nombre de ruta

relativo o absoluto.

Sintaxis: mkdir camino_subdirectorio

1.9.4.3. Comando “rmdir”.

Permite borrar el subdirectorio, siempre y cuándo el subdirectorio esté vacío.

Sintaxis: rmdir camino_subdirectorio

1.9.4.4. Comando “rm”.

Permite borrar ficheros del sistema, aunque para ello necesitamos disponer de ciertos derechos
sobre el fichero y sobre el directorio donde éste se encuentre. La opción r de esta orden nos permite borrar
incluso directorios, aunque estos no estén vacíos. Por tanto, la orden “rm – r” debe manejarse con
cuidado.

9
1.9.5. Gestión básica de ficheros.

Un fichero es una secuencia de bytes que reside en disco o cinta. En Unix no se realiza una
interpretación de la estructura lógica de los ficheros, de forma que todos son tratados por igual,
independientemente de su contenido. Así, todos los ficheros (ya sean ficheros de texto, ficheros de datos
con una cierta estructura lógica o ficheros ejecutables) se consideran como una secuencia finita de bytes.
El sistema operativo reconoce el fin de fichero mediante un carácter especial situado al final de todos los
ficheros (Control-d).

1.9.5.1. Comando “cat”.

Permite visualizar el contenido de ficheros de texto. Su formato es el siguiente:

cat [camino_fichero]

La salida se envía al dispositivo de salida por defecto, que habitualmente será la pantalla.
Podremos redireccionar la salida a un fichero, mediante el símbolo “>”, de la forma siguiente:

cat nombre_fichero > nuevo_fichero

Esta orden además, nos permitirá crear pequeños ficheros de texto, mediante la siguiente
sintaxis:
cat > nuevo_fichero o bien cat-> nuevo_fichero

Una vez pulsado Intro, se podrán escribir líneas de texto, que se irán añadiendo al fichero. Se
finaliza la entrada de líneas de texto tecleando Control-d.

Además, el comando cat se puede usar también para concatenar ficheros, con el siguiente
formato:
cat fichero1 fichero2 ... ficheron > fichero_union

1.9.5.2. Comando “cp”.

Realiza la copia de ficheros. Con esta orden se pueden realizar dos tipos de operaciones:
- Si fuente y destino son ambos nombres de ficheros, entonces se realiza la copia de fuente a
destino.
- Si destino es el nombre de un directorio, entonces fuente pueden ser varios ficheros
(separados por blancos, o definidos por medio de * e ?), y la orden copiará entonces los
ficheros indicados sobre el directorio destino.

En todos los casos, se requieren ciertos derechos para poder realizar esas acciones.
La opción r de la orden permite hacer operaciones de copia de subárboles de directorios
completos.
Su sintaxis es:
cp [-r] fuente destino

Ejemplo: Indicad cómo podríamos copiar todo el contenido de un directorio1 (/etc), incluidos
todos sus subdirectorios, en otro directorio2 (/tmp).

cp –r /etc/* /tmp

1.9.5.3. Comando “mv”.

Realiza el movimiento de ficheros. Cuando ambos argumentos son nombres de ficheros esta
orden tiene el significado de cambiar el nombre del fichero fuente, mientras que si destino es un
directorio se trasladan los ficheros indicados en fuente a destino.

mv fuente destino

10
1.9.5.4. Comando “ln”.

Establece ligaduras. Crea una nueva entrada de directorio que corresponde a un fichero ya
existente (el nombre de la ligadura no puede coincidir con el nombre de otra entrada de directorio ya
existente en el directorio en que va a ser creada). El usuario percibe la sensación de que otro dichero ha
sido creado (el especificado como destino), con el mismo contenido del fichero fuente. Sin embargo, la
copia es ficticia, ya que el fichero destino es el mismo que el fuente, y cualquier modificación posterior
de uno afectará al otro, ya que se trata de dos nombres para un mismo fichero ( en disco existe un único
fichero físicamente almacenado).
Sintaxis: ln [-s] fuente destino.

Cuando se borra una ligadura a un fichero, sólo se borra el nombre especificado en la orden rm.
El fichero sólo se borra (su contenido) cuando se borra la última referencia al mismo. Hay que indicar que
un fichero puede estar, por medio de ligaduras, en varios directorios al mismo tiempo. Sin embargo, esto
no será posible si los directorios están en distintos dispositivos.

También es posible establecer ligaduras entre directorios, con la opción s del comando ln (se
crea lo que se llama una ligadura simbólica, que es una entrada de directorio cuyo contenido es
únicamente un nombre de ruta). Las ligaduras simbólicas no se contabilizan en el número de ligaduras al
directorio que aparece en el listado obtenido con la orden ls –l.

Las ligaduras (simbólicas o no) se borran siempre con la orden rm, incluso aunque apunten a un
directorio.

Ejemplo1.- Cread una ligadura de un fichero a otro y obtener los atributos asociados a ambas
ligaduras (derechos, tamaño, etc...). Comprobad que coinciden, y que ambos se ven afectados por
cualquier modificación sobre uno de ellos.
Ejemplo2.- Cread una ligadura simbólica a un directorio. Obtener los atributos de las dos
entradas y compararlas. Observad que si en este caso se borra el directorio, la ligadura permanecerá como
entrada de un directorio, pero no apuntará a ningún sitio.

1.9.6. Mensajes en el terminal.

Los usuarios pueden enviarse mensajes (cortos) que aparecerán sobre el terminal del destinatario
(si éste no ha desactivado tal posibilidad) con la orden “write”. Con esta orden se envía el mensaje que se
teclee a continuación al usuario especificado, que debe estar conectado al terminal indicado. El mensaje
se termina de escribir tecleando “Control-d”. Es posible evitar que otros usuarios interfieran nuestro
trabajo con mensajes en pantalla mediante la orden “mesg n”. Para permitir de nuevo la recepción de
mensajes se teclea “mesg y”. Su sintaxis es:

write usuario [terminal]

1.9.6.1. Comando “who”.

Permite conocer qué usuarios están conectados al sistema en un momento dado. Dicha orden
nos indica en la segunda columna el terminal sobre el que están trabajando los usuarios conectados al
sistema.

1.9.6.2. Comando “finger”.

Permite conocer qué usuarios están conectados al sistema en un momento dado y también nos
indica el tiempo que los usuarios llevan sin acceder al terminal, y desde dónde están conectados al
sistema.

1.9.6.3. Comando “tty”.

Permite conocer el terminal sobre el que se está trabajando en un momento dado, puesto que esta
orden devuelve el nombre del fichero especial de caracteres asociado al terminal.
Es posible enviar el contenido de ficheros a los terminales, mediante una operación de escritura
sobre el fichero especial que tengan asociado.

11
Ejemplo1: ¿Qué órdenes podríamos usar para enviar el contenido de un fichero determinado llamado
pepe a un terminal determinado (tty2)?
- cat pepe > /dev/tty02
- cp pepe /dev/tty02
Ejemplo2: ¿Qué ocurrirá si un usuario cualquiera ejecuta ls -lR / > /dev/tty02

1.9.7. Permisos de acceso.

Son atributos que definen la forma en que puede acceder al fichero o directorio un usuario
cualquiera del sistema.
Cuando un usuario crea un fichero o directorio en el sistema, automáticamente se convierte en su
propietario (owner), y en principio puede leer y escribir sobre él. El resto de usuarios (salvo naturalmente
el superusuario) sólo podrá leerlo. Esta situación puede cambiarse.
Los usuarios, al ser creados por el superusuarios, se asignan a un grupo de usuarios.
Los permisos de acceso a un fichero se dividen en tres niveles:
- Accesos para el propietario.
- Accesos para un grupo de usuarios.
- Accesos para el resto.
Además, existen tres clases de permisos:
- De lectura
- De escritura.
- De ejecución.

En el caso de un directorio, el permiso de lectura indica que se puede examinar el contenido del
directorio (leer sus entradas de directorio), el de escritura que se pueden crear, modificar o borrar entradas
de directorio, y el de ejecución que se puede acceder al directorio (se puede pasas a través del directorio
en busca de otros subdirectorios).
Los derechos no se suman, es decir, se aplican exclusivamente aquellos que corresponden a la
categoría en la que se enmarca el usuario (usuario, grupo u otros).

Ejemplo: Se han obtenido los atributos de un fichero a.out mediante la orden “ls –l a.out” y el resultado
ha sido el siguiente:
-rwx—xr-x 1 al123 alumnos 12798 Dec 31 18:11 a.out

1.9.7.1. Comando “chmod”.

Para un determinado fichero o directorio, el propietario o el superusuario pueden cambiar los

permisos de acceso por medio de la orden “chmod”, que tiene la siguiente sintaxis:

chmod [-R][quien] +-=permisos{,quien +-=permisos} ficheros

Donde “quien” puede ser una combinación de: a(all) para todos, u (user) para el propietario del
fichero (valor por defecto), g (group) para el grupo, y o (others) para el resto de usuarios.
Los permisos pueden ser una combinación de: r para lectura, w para escritura y x para ejecución.
La opción R se emplea para que la orden se aplique no sólo a los ficheros que respondan al
patrón indicado, sino también en todo el subárbol de directorios que cuelgue del directorio afectado.

OBSERVACIONES:

Para borrar un fichero se necesitan derechos de acceso y escritura sobre el directorio en donde se
encuentre el fichero, así como el derecho de escritura sobre el fichero. Sin embargo, para modificar el
fichero (sin borrarlo) sólo se necesita el derecho de acceso al directorio, y el derecho de escritura sobre el
fichero (aunque sin derecho de lectura no se podrá leer su contenido).

Ejemplo1: Indicad la orden a ejecutar para añadir derechos de lectura y escritura a los ficheros (o
directorios) del directorio /usr/alumnos/al123 que empiecen por “a”, para los usuarios del grupo al que
pertenece el usuario.
chmod g+rw /usr/alumnos/al123/a*

12
Ejemplo2: Para los mismos ficheros anteriores, quitar derechos de ejecución al usuario propietario, y
poner el derecho de lectura para los usuarios que no pertenecen al grupo.
chmod u-x, o+r /usr/alumnos/al123/a*
Ejemplo3: Para establecer que el usuario propietario tenga únicamente derechos de lectura, y que los
demás usuarios no tengan ningún derecho:
chmod u=r, go-rwx /usr/alumnos/al123/a*

1.9.7.2. Comando “umask”.

Un usuario puede modificar la máscara de derechos por defecto que se aplica sobre los ficheros o
directorios recién creados mediante la orden “umask”:

Sintaxis: umask mascara

donde mascara se obtiene de acuerdo a los siguientes valores octales

0400 Lectura para el propietario

0200 Escritura para el propietario
0100 Ejecución para el propietario
0040 Lectura para el grupo
0020 Escritura para el grupo
0010 Ejecución para el grupo
0004 Lectura para otros
0002 Escritura para otros
0001 Ejecución para otros

El sistema utiliza este valor “umask” para definir los derechos de los ficheros y directorios recién
creados, sustrayendo este valor al indicado en la llamada al sistema realizada para la creación del fichero
o directorio (open o creat). De esta forma, como el sistema crea normalmente los ficheros y directorios
con la máscara 0666, si el valor de umask es 0022, la diferencia es 0644, que son los derechos que
finalmente se asignan al fichero o directorio.

Ejemplo: Para conseguir que los ficheros o directorios recién creados adquieran como máscara
de derechos por defecto “rw-rw—w-“ tendríamos que considerar el valor octal 0004. ¿Por qué?.

1.9.7.3. Comando “chown”.

Permite transferir la propiedad del fichero o directorio a otro usuario. Su sintaxis es:

chown [-R] usuario ficheros

siendo usuario el nombre del nuevo usuario propietario de los ficheros indicados. Por supuesto,
sólo el propietario (NO EN LINUX) de los ficheros indicados o el superusuario pueden ceder la
propiedad de los mismos. La opción R se emplea de nuevo para que la orden se aplique no sólo a los
ficheros que respondan al patrón indicado, sino también en todo el subárbol de directorios que cuelgue del
directorio afectado.

1.9.7.4. Comando “chgrp”.

Permite transferir la propiedad del dichero a todo el grupo. La sintaxis es similar al comando
chown y funciona del mismo modo. En Linux, sólo la puede ejecutar el superusuario al igual que chown.

chgrp [-R] grupo ficheros

13
1.9.8. Recepción y envío de correo. Comando mail.

Tecleando mail + Intro se visualiza el primer mensaje. Si se teclea “?” se muestra un menú de
ayuda con las distintas opciones del mail:

- Visualiza el mensaje anterior

+ Visualiza el mensaje siguiente
! comando Ejecuta el comando del sistema operativo indicado
d Borra el mensaje actual
q Sale al sistema operativo
h Visualiza las cabeceras de los mensajes
r Enviar respuesta al emisor del mensaje actual
s fichero Salva el mensaje actual en el fichero indicado
w fichero Salva el mensaje actual en el fichero indicado, pero sin la cabecera
p Visualiza de nuevo el mensaje actual
+n Ver mensaje n-ésimo siguiente
-n Ver mensaje n-ésimo anterior

Para enviar un mensaje a otro usuario se ejecuta la orden

mail direccion_usuario

A continuación se escribe el texto del mensaje, finalizando con <Control-d>. La dirección del
usuario puede especificarse de diversas formas, dependiendo del sistema de que se trate. En todo caso, si
se desea enviar un mensaje a un usuario en nuestro sistema local basta con poner su nombre de login en el
sistema.
Es posible también escribir primero el texto del mensaje en un fichero, y después ejecutar la
orden:
mail usuario < fichero

14
1.10. Comandos de uso general.

1.10.1. Editores.

Los sistemas Unix actuales vienen dotados de editores manejables para usar sobre entornos X-
Windows. Aún así, los siguientes editores han sido y son los más usados, sobre todo el joe.

1.10.1.1. El editor joe.

Se trata de un editor de pantalla completa de libre disposición. Se invoca al editor poniendo

como argumento el nombre del fichero que se desea editar, es decir:

joe fichero.txt

Las acciones de edición más complicadas se realizan a través de combinaciones de pulsaciones

de teclas con la tecla de Control. Para conocerlas todas pulsar Control-K-H y nos proporcionará un menú
de ayuda.
Control-K-H Proporciona un menú de ayuda
Control-F Cursor a la derecha
Control-N Cursor abajo
Control-L Buscar el siguiente
Control-V Pantalla siguiente
Control-E Ir al final de la línea actual
Control-K-V Ir al final del fichero
Control-K-B Marcar inicio de bloque
Control-K-M Mover bloque
Control-K-W Escribir bloque en fichero
Control-D Borra carácter actual
Control-R Actualiza pantalla
Control-K-Z Crea un shell
Control-K-R Inserta fichero
Control-T-T Inserción/Sobreescribe
Control-T-I Autoindentación
Control-B Cursor a la izquierda
Control-P Cursor arriba
Control-K-F Búsqueda, búsqueda y sustitución
Control-U Pantalla anterior
Control-A Ir a comienzo de línea actual
Control-K-U Ir al comienzo del fichero
Control-K-L Ir a línea n
Control-K-K Marcar fin de bloque
Control-K-C Copiar bloque
Control-K-Y Borrar bloque
Control-Y Borra línea actual
Control-K-X Salva fichero y abandona
Control-K-D Salva fichero
Control-C Abandona sin salvar fichero
Control-T-D Ancho de tabulación
Control-K-n Ejecuta macro número n

Opciones del editor joe

1.10.1.2. El editor vi.

La principal característica del editor vi es su funcionamiento en dos modos de operación: modo

texto y modo comando. Es precisamente esta dualidad la que nos crea dificultades a la hora de trabajar
con este editor. Cuando entramos al editor, éste se encuentra en modo comando.

vi fichero.txt

15
 Los comandos aceptados por vi son combinaciones de unas pocas letras, y algunos de ellos
provocan la entrada del editor en modo texto. En el modo texto el editor acepta caracteres desde teclado
para introducirlos en el fichero, así como la tecla de borrado (Del). Para volver al modo comando se pulsa
la tecla de escape.

hlkj Desplazamiento del cursor a izda, dcha, arriba, abajo

retorno de carro Desplaza el cursor al comienzo de línea siguiente
b Desplaza el cursor al comienzo de la palabra
e Desplaza el cursor al final de la palabra
0 Desplaza el cursor al comienzo de línea
$ Desplaza el cursor al final de línea
a Añade texto detrás del cursor
i Inserta texto antes del curso
O Crea una nueva línea por encima del cursor
o Crea una nueva línea por debajo del cursor
x Borra carácter bajo el cursor
dd Borra línea actual
r Reemplaza carácter bajo el cursor
u Deshace la última operación
U Deshace las últimas operaciones sobre la línea actual
J Une la línea actual con la inmediata inferior
Q Abandona el editor vi y entra al ex
ZZ Almacenar fichero y abandonar
:wq Almacenar fichero y abandonar
:w Salvar fichero a disco
:q Abandonar (si no hay cambios)
:q! Abandonar en todos los casos
Control-d Desplaza la pantalla 12 líneas abajo
Control-b Desplaza la pantalla 24 líneas abajo
Control-f Desplaza la pantalla 24 líneas arriba
Control-u Desplaza la pantalla 12 líneas arriba
nG Posiciona el cursor en línea n
G Posiciona el cursor en el final del fichero
Control-g Visualiza nº de línea actual
Control-L Actualiza pantalla

Comandos del editor vi

1.10.2. Comandos relacionados con la fecha del sistema.

1.10.2.1. Comando date.

Cuando no se especifica ningún argumento, el comando date devuelve la fecha y hora actual del
sistema. El superusuario también puede utilizar este comando para establecer la fecha y hora del sistema,
con la sintaxis:
date mmddhhmm[yy]

También es posible indicar al comando “date” un formato de presentación de la fecha y hora, con
la sintaxis:
date “+formato”

El formato se especifica mediante los llamados descriptores de campo, que van precedidos por el
símbolo “%”, y son reemplazados en la salida en pantalla por sus valores asociados.

16
 n Inserta un carácter de retorno de carro
t Inserta un carácter de tabulación
m Nº del mes del año
d Nº del día del mes
y Últimos dos dígitos del año
D Fecha en el formato clásico: mm/dd/yy
H Hora (de 00 a 23)
M Minutos (de 00 a 59)
S Segundos (de 00 a 59)
T Hora en el formato clásico: HH:MM:SS
w Día de la semana (de 0 a 6, siendo el Domingo el 0)
a Día de la semana de forma abreviada (Sun, …, Sat)
h Mes abreviado (Jan, ... , Dec)
r Hora en formato AM/PM

Descriptores de campo del comando date.

Ejemplo1: Indicar la orden correspondiente a usar por el usuario para establecer como fecha y
hora del sistema el 27 de Abril del 2005, a las 16:30 horas.

date 0427163005
Ejemplo2: Indicar la orden correspondiente para obtener la fecha con el siguiente formato:

FECHA DEL SISTEMA: 04/27/05

HORA: 16:40:23

date “+FECHA DEL SISTEMA: %m/%d/%y%Nhora:%H:%M:%S”

1.10.2.2. Comando cal.

El comando “cal” presenta un calendario en pantalla, correspondiente al año indicado como

argumento. Su sintaxis es:
cal [mes] año

1.10.2.3. Comando calendar.

Proporciona un sencillo servicio de agenda. Su objeto es inspeccionar un fichero llamado

“calendar”, en el directorio HOME del usuario. Cada línea de este fichero contiene un aviso o
recordatorio, que debería ser mostrado (ejecutando el comando “calendar” en la fecha indicada). Para
ello, cada uno de estos avisos debe ir acompañado de la fecha en que debe mostrarse. El formato en que
puede ir indicada la fecha es (mes-día), y no se impone una ubicación concreta dentro de la línea,
pudiendo ir en cualquier parte de ésta.

Ejemplo1: Contenido de un fichero calendar:

8/5 CUMPLEAÑOS DE PEPE

16/7 BODA DE ANTONIO
9/24 RECARGAR TARJETA MÓVIL

1.10.3. Comandos para la visualización de ficheros.

1.10.3.1. Comando pg.

Con esto comando podemos visualizar ficheros de texto de cierto tamaño, que no quepan en una
sola pantalla, pues muestra sus contenidos pantalla a pantalla.
Cuando se ejecuta la orden “pg fichero”, aparece el comienzo del fichero en pantalla y una línea
de ordenes en la parte inferior de la misma.

17
1.10.3.2. Comando more.

Permite también visualizar un fichero pantalla a pantalla. En este caso, con la tecla de espacio se
va pasando de una pantalla a otra, mientras que si se pulsa q se termina la visualización del fichero, y se
abandona la ejecución.
El comando “more” se utiliza con mucha frecuencia en pipes para ir mostrando pantalla a
pantalla los resultados de algún programa:
ls –lR / |more

1.10.3.3. Comando hexdump.

Es posible visualizar el contenido de ficheros en ascii (-c), octal (-b), decimal (-d) y
hexadecimal(-x).

1.10.3.4. Comando bpe.

El comando “bpe” nos permite ver y editar ficheros binarios. Se invoca poniendo como
argumento el nombre del fichero a editar.

1.10.4. Comandos de comparación de ficheros.

1.10.4.1. Comando cmp.

Permite comparar dos ficheros, para ver si son idénticos. Si los ficheros resultan diferentes, se
muestra el nº de línea y el nº de carácter dentro de la línea donde se ha encontrado la primera diferencia.
Si ambos ficheros son idénticos no se muestra ningún resultado en pantalla. En este caso puede
comprobarse que realmente son idénticos consultando el valor de errorlevel (echo $?), que debería ser 0.
El programa cmp admite la opción s, que suprime los mensajes en pantalla, y retorna:
- 0 si los ficheros son idénticos.
- 1 si los ficheros son diferentes.
- 2 si algún fichero es inaccesible.

1.10.4.2. Comando comm.

Este comando nos permite comparar dos ficheros ordenados alfabéticamente por líneas. Como
resultado nos indica en una primera columna las líneas que únicamente se encuentran en el primer
fichero, en una segunda columna las líneas que únicamente se encuentran en el segundo fichero, y en una
tercera columna las líneas que pertenecen a ambos ficheros.

1.10.4.3. Comando diff.

Localiza las diferencias entre dos ficheros de texto, indicando las acciones que habría que
realizar para hacerlos coincidir. Además, el errorlevel devuelto es como el del comando cmp.

1.10.4.4. Comando uniq.

El comando “uniq” elimina las líneas duplicadas de un fichero ordenado alfabéticamente.

Ejemplo1: Consideremos los ficheros siguientes y probar las órdenes comm y diff con ambos:

fichero1: fichero2:
linea 1 de fichero1 linea 1 de fichero2
linea 2 de fichero1 y fichero2 linea 2 de fichero1 y fichero2
linea 3 de fichero1 y fichero2 linea 3 de fichero1 y fichero2
linea 4 de fichero1 linea 4 de fichero2

18
1.10.5. Operaciones sobre ficheros de texto.

1.10.5.1. Comando sort.

Ordena ficheros de texto alfabéticamente, presentando el resultado en la salida estándar. Si se

indican varios ficheros argumento, el programa realiza la ordenación sobre la unión de todos ellos.

sort fichero fichero ...

Otra posibilidad de este programa es organizar el fichero o ficheros de entrada por campos,
utilizando un cierto carácter como delimitador de campos. Mientras no se especifique otra cosa, el
separador es una blanco.

c Comprueba si todos los ficheros indicados están ya ordenados. Si lo están, devuelve como
errorlevel un 0, mientras que si no lo están, muestra un mensaje indicativo en pantalla, y el
errorlevel es 1
m Mezcla los ficheros argumentos, que deben estar ya ordenados, para presentar en la salida
estándar el resultado de ordenar el conjunto (se utiliza cuando los ficheros son grandes por
razones de eficiencia).
d Ordena considerando únicamente los caracteres alfabéticos, numéricos y blancos, ignorando
los demás.
f Ignora la distinción entre las mayúsculas y minúsculas
o fichero Envía la salida del programa al fichero indicado.
r Realiza la ordenación en sentido inverso
t separador El carácter indicado como separador se utiliza para delimitar campos dentro de cada línea
del fichero o ficheros indicados como argumento (por defecto es un blanco)
n Realiza una ordenación aritmética cuando aparece al comienzo de la línea una cadena de
caracteres numérica, precedida opcionalmente por un cierto nº de blancos, y un signo
aritmético (+,-)
M Se consideran los tres primeros caracteres de cada línea como un nombre abreviado de mes
(Jan, Feb, etc), de modo que se ordena siguiendo su enumeración.
u Para aquellas líneas que tengan igual clave, sólo considera una de ellas.
+n Se salta n campos antes de empezar a ordenar

1.10.5.2. Comando cut.

Se emplea para eliminar una parte en cada línea de un fichero de texto, ya sea atendiendo a una
división en campos, o bien según una delimitación de columnas.

cut [opciones] –b lista_columnas –f lista_campos

Con la opción b, se especifica la lista de columnas (separadas por comas) o un rango de

columnas (utilizando un guión para indicarlo) que deben ser visualizadas. Se entiende que cada carácter
de una línea ocupa una columna, numeradas desde 0 en adelante.
Con la opción f se especifica una lista de campos (o un rango) que deben ser visualizados. Por
defecto se emplea como delimitador un tabulador. Para establecer un delimitador distinto se emplea la
opción d:

1.10.5.3. Comando paste.

Este comando toma dos ficheros como argumento, y va procesándolos simultáneamente, leyendo
en cada etapa una línea de cada fichero, uniéndolas separándolas por un tabulador. Con la opción d puede
especificarse un separador diferente.

1.10.5.4. Comando join.

Se emplea para unir las líneas de dos ficheros de texto de acuerdo a una clave común. Se
considera que cada fichero argumento constituye una tabla relacional, siendo cada línea de texto en
ambos ficheros un registro de la tabla, dividida en campos según el separador empleado (un blanco por

19
defecto). Por defecto, se emplea como clave el primer campo de cada línea en ambos ficheros, los cuales
deben estar ordenados de acuerdo a dicha clave.
En la salida por defecto se muestra una línea por cada par de líneas de los ficheros argumento
que tengan la misma clave, que corresponde a la unión de ambas líneas, pero sin duplicar la clave común.
Se emplea la opción t para indicar un separador diferente. Asimismo, si se desea utilizar un
campo distinto como clave se emplea la opción “-jn m”, siendo n el nº del fichero (1 ó 2), y m el nº de
campo en el fichero argumento n.

1.10.5.5. Otros comandos.

head fichero Visualiza las 10 primeras líneas del fichero indicado

tail fichero Visualiza las 10 últimas líneas del fichero indicado
nl fichero Visualiza el fichero con sus líneas numeradas
split [-num] fichero prefijo Rompe el fichero de texto indicado en trozos, cada uno de num líneas de
texto (1000 por defecto), creando para ello nuevos ficheros, cuyo nombre
está prefijado por prefijo.
wc fichero Contabiliza líneas, palabras y caracteres del fichero indicado
look cad fichero Visualiza las líneas del fichero indicado que empiezan con la cadena “cad”.
Para ello el fichero debe estar ordenado alfabéticamente

1.10.6. Localización de ficheros.

1.10.6.1. Comando find.

Permite localizar ficheros que satisfacen un determinado criterio, para realizar a continuación
alguna acción sobre los mismos. La búsqueda comienza en el directorio que se especifica como primer
argumento, y desciende a todo el subárbol de directorios que dependen de éste.
La sintaxis de esta orden es la siguiente:

find nombre_de_directorio criterio_de_búsqueda acción

Las acciones posibles son:

- print: Muestra en pantalla los nombres de los ficheros localizados.
- exec programa: ejecuta el programa indicado. Los ficheros localizados pueden ser pasados
como argumento del programa empleando para ello un juego de llaves (que representan a
cada fichero localizado). Si se emplea la opción exec, debe finalizarse la línea de órdenes
con ‘\;’.

Es posible localizar ficheros siguiendo criterios de búsqueda más complejos, basados en

expresiones condicionales más generales. Para ello se emplean las conectivas lógicas (! Para la negación,
-a para el AND y –o para el OR), pero en tal caso, cada subexpresión de búsqueda debe estar encerrada
entre paréntesis.
Cuando las subexpresiones van conectadas por conectiva “-a” pueden omitirse los paréntesis..

Para seguir escribiendo la orden en una siguiente orden, se teclea una barra hacia atrás. Véase
ejemplo5

20
 Los criterios de búsqueda del comando find son:

-name nombre_fichero Busca el fichero cuyo nombre se indica. También puede especificarse una
máscara de búsqueda, encerrando todo el nombre entre comillas dobles,
mediante la sintaxis siguiente:
* Cualquier tira de caracteres
? Un carácter cualquiera
[...] Cualquier carácter encerrado entre los corchetes
[^...] Cualquier carácter, excepto los encerrados entre corchetes
-type x Busca ficheros de dispositivo de bloques (x=b), de caracteres (x=c),
directorios (x=d), pipes (x=p), ligaduras simbólicas (x=l), o ficheros
regulares (x=f)
-links n Busca aquellos ficheros que tienen n ligaduras (hard links) establecidas
-user nombre_usuario Busca aquellos ficheros que pertenecen al usuario indicado
-group nombre_usuario Busca los ficheros que pertenecen al grupo de usuarios indicado
-size n Busca aquellos ficheros que ocupan en disco n bloques (512 bytes por
bloque). Si el nº n va seguido de una c, se buscan los ficheros que tengan
ese tamaño n en bytes
-atime n Localiza los ficheros que fueron accedidos hace exactamente n dias. La
orden find por sí misma modifica la fecha de acceso. Si se pone +n se
interpreta como localizar los ficheros accedidos hace más de n días, y si se
pone –n se interpreta como localizar los ficheros accedidos en los últimos
n días.
-mtime n Localiza los ficheros que fueron modificados hace exactamene n días.
También son válidos +n y -n
-ctime n Localiza los ficheros que fueron cambiados (modificados sus atributos)
hace exactamente n días. Son válidos +n y –n.
-perm [-] m Localiza ficheros cuya máscara de derechos sea exactamente m. Si se pone
un signo menos delante de la máscara, entonces busca ficheros que tengan
como mínimo los derechos indicados en la máscara.

Ejemplo1: Indicar la orden que permita eliminar todos los ficheros del directorio actual (y de sus
subdirectorios) que no han sido utilizados en los últimos cien días.
$ find . –atime +100 –exec rm \{\} \;
Ejemplo2: Indica la orden que permita localizar y presentar en pantalla los ficheros cuyo nombre
comience con “pe”, que se encuentren en el subárbol de directorios “/usr/alumnos”.
$ find /usr/alumnos –name “pe*” -print
Ejemplo3: Indicar la orden que permita localizar y presentar en pantalla los ficheros regulares cuyo
nombre empieza por “f” o “g” y que ocupan en disco 3 o más bloques, dentro del subárbol de directorios
“/usr”.
$ find /usr -type f –name “[fg]*” –size +2 –print
$ find /usr \( -type f –a –name “[fg]*” –a –size +2 \) -print
Ejemplo4: Indicar la orden que permita localizar y presentar en pantalla los ficheros del usuario al123
cuyo nombre empieza por “pe” (en todo el árbol di directorios).
$ find / -name “pe*” –a –user al123 -print
Ejemplo5: Indicar la orden que localiza y presenta en pantalla el nombre y atributos de los ficheros y
directorios que o bien pertenecen al usuario al123 y su nombre empieza por “f” o “p”, o bien no
pertenecen al grupo escuela (en todo el árbol de directorios).
$ find / \(\(\( -user al123 \) –a \( -name “[fp]*” \) \) –o \
\( ! – group escuela \) \) –exec ls –l \{\} \;

1.10.6.2. Comando grep.

Permite localizar una palabra clave o una frase en varios ficheros, indicando las líneas y ficheros
en los que aparece.
grep [opciones] patrón ficheros

El patrón utilizado puede contener espacios en blanco, pero en tal caso tenemos que encerrarlo
entre apóstrofos o comillas dobles. Asimismo, para expresar el nombre de los ficheros podemos utilizar
las máscaras (* y ?).

21
 Los patrones de búsqueda no tienen por qué limitarse a palabras o frases determinadas. Pueden
construirse patrones más generales utilizando los formatos de sustitución siguientes:

. Representa un carácter cualquiera

[...] Puede ser reemplazado por cualquier carácter de los encerrados entre corchetes
[^...] Puede ser reemplazado por cualquier carácter no incluido en la lista
^... Considera únicamente aquellas líneas que comiencen por la expresión que precede al $.
...$ Considera únicamente aquellas líneas que acaben en la expresión que sigue al ^.
\c Se reemplaza por el carácter c, al margen del significado especial que grep asocia a dicho
carácter para constituir expresiones regulares.
Por ejemplo “grep ‘\.f’ fichero” buscará “.f” tal cual, sin emplear el punto como formato de
sustitución

Formatos de sustitución del comando grep.

n Cada línea visualizada se acompaña del nº de línea correspondiente en el fichero.

v Indica que se muestren las líneas que no encajen en el patrón.
c Indica que se muestre únicamente el nº de líneas que encajan en el patrón
i Ignora la distinción entre mayúsculas y minúsculas
x Selecciona sólo aquellas líneas que encajen enteras en el patrón.

Opciones del comando grep

Ejemplo1.- Indicar la orden que busca la palabra pepito en los tres ficheros indicados: pepe1, pepe2,
pepe3.
$ grep pepito pepe1 pepe2 pepe3

Ejemplo2.- Indicar la orden que localiza las líneas que contienen la palabra “con” en los ficheros del
directorio actual cuyo nombre empiece por “fic”. Diferenciar entre éstas dos órdenes:

$ grep con fic*

$ grep “ con “ fic*

Ejemplo3.- Indicar que hace la siguiente orden:

$ grep “^La.*[ns]$” *.txt

Esta orden va a mostrar las líneas (y los nºs de línea) de los ficheros del directorio actual
cuyo nombre acabe en “.txt” que contengan líneas que empiecen por la palabra “La”, y
acaben en “n” ó “s”.
Ejemplos posibles:
Fic.txt:2: La pinto de colores
Fic.txt:5: La canción

1.10.6.3. Comando sed.

Permite procesar el contenido de un fichero de texto línea a línea, sometiendo a las mismas a
determinadas acciones, enviándose el resultado de este procesamiento a la salida estándar. La sintaxis
básica de este comando es:
sed [opciones] ‘comandos-sed’ fichero

El formato de las instrucciones aceptadas por sed es el siguiente:

[Dirección, [Dirección]] función [argumentos]

donde las direcciones pueden ser nº decimales especificando líneas concretas del fichero, o
rangos de líneas (en la forma l1, l2 para indicar el rango de líneas desde la l1 hasta la l2), un ‘$’
representando la última línea del fichero e incluso expresiones regulares encerradas entre ‘/’. La forma de

22
construir expresiones regulares es la misma que la descrita para el comando grep. Además, se puede
utilizar “\(“ y “\)” para delimitar campos sobre la línea que encaja en la expresión regular considerada.
Si se desea utilizar más de un comando de edición hay que introducir un comando por línea y
encerrar la lista completa entre apóstrofos.
Si no se introduce ninguna dirección, la acción indicada afectará a todas las líneas del fichero.
El programa sed acepta las dos opciones siguientes:

-n Suprime las salidas al dispositivo de salida estándar, salvo que se indique de forma
explícita la visualización en la acción de procesamiento.

-f fichero Las acciones a realizar se obtienen desde el fichero indicado.

Ejemplo: Si se considera la expresión regular siguiente:

“^E[ls].* [ml]e regalo un \(.*\)” tenemos que líneas como:

- Ella me regalo un disco

- Ese le regalo un libro
- El le regalo un ordenador personal

encajarían en dicha expresión regular. Además, se ha delimitado un campo sobre dicha expresión regular
(el objeto regalado en este caso). Este campo se puede referenciar posteriormente mediante “\1”. Si se
definen más campos, estos se referencian de la misma forma: “\1”,”\2”,etc...
Si se desea utilizar más de un comando de edición hay que introducir un comando por línea y
encerrar la lista completa entre apóstrofos.

a\ linea_texto Añade la línea de texto que sigue al comando a la salida estándar después de
procesar las líneas del fichero de entrada afectadas por el rango indicado
c\ linea_texto Visualiza sobre la salida estándar la línea de texto que sigue al comando,
descartando las líneas de texto del fichero de entrada afectadas por el rango
indicado.
d Borra la líneas indicadas
i\ línea texto Visualiza la línea de texto que sigue al comando, y a continuación procesa las
líneas afectadas, incluso bajo la opción n
p Visualiza el resultado de procesar las líneas afectadas, incluso bajo la opción n
q Abandona
r fichero Lee un fichero, añadiendo el contenido del mismo a la salida estándar, antes de leer
y procesar la siguiente línea desde el fichero de entrada
s/e_reg/n_exp./flags Sustituye “n_exp” por toda ocurrencia de la expresión regular “e_reg”. Algunos
flags admisibles son: g (sustitución global, para que afecte a todas las ocurrencias
de la expresión regular, y no sólo a la primera), p (visualiza el resultado del
procesamiento si el reemplazamiento fue llevado a cabo), w fichero (añade las
líneas procesadas al fichero indicado si se realizó el reemplazamiento). Si en
“e_reg” se han delimitado campos por medio ‘\(‘, ‘\)’, es posible referenciarlos en
“n_exp” por medio de ‘\1’, ‘\2’, etc
s/e_reg/&n_exp/ Inserta “n_exp” detrás de la expresión regular “e_reg”, para toda línea que contenga
una cadena que encaje en la citada expresión regular.
w fichero Añade las líneas afectadas al fichero indicado
= Visualiza el número de línea actual sobre la salida estándar

Principales acciones aceptadas por sed.

Ejemplo1: Indicar la orden que borre la línea 3 de un fichero.

sed ‘3d’ fichero

Ejemplo2: Indicar la orden para borrar las líneas 2,3, y 4 de un fichero.

sed ‘2,4d’ fichero

23
Ejemplo3: Indicar la orden que permita borrar las líneas de un fichero que contengan la palabra “clave”.
sed ‘/clave/d’ fichero
Ejemplo4: Indicar la orden para insertar una línea en blanco detrás de cada línea de un fichero.
sed ‘i\>’ fichero
Ejemplo5: Indicar la orden para borrar todas las líneas vacías de un fichero:
sed ‘/^$/d’ fichero
Ejemplo6: Indicar la orden para mostrar el campo “comentario” del fichero /etc/passwd, que contiene la
información de los usuarios del sistema (en dicho fichero cada línea corresponde a la información de un
usuario, y esta información está dividida en campos separados por ‘:’)
sed –n “s/^al123:.*:.*:.*:\(.*\):.*:.*$/ \1 /p” /etc/passwd
Ejemplo7: Indicar la orden para obtener el valor asignado a la variable PATH en el fichero .profile de
vuestro usuario.
sed –n “s/^PATH=//p” /usr/alumnos/al123/.profile
Ejemplo8: Probar finalmente el siguiente ejemplo, y descubrir su efecto:
sed “/^c[aeh].*.*.*[^n]$/d” fichero > fichero2

1.11. El Shell

El shell es el intérprete de comandos en Unís. Actúa como interface del usuario con el sistema
operativo, traduciendo sus órdenes y ejecutando sus programas. Los sistemas Unix suelen ir dotados de
varios shells, de forma que el usuario puede elegir aquél que le resulte más cómodo para trabajar. Entre
ellos, los más utilizados son el shell Bourne y el shell-C. Siendo el primero el que vamos a ver.
El proceso asociado al intérprete de comandos se identifica por el nombre sh (si se trata del shell
Bourne), y un usuario puede en cualquier momento crearse un shell integrado dentro del actual
ejecutando este programa:
$ sh

Al ejecutar esta orden aparece de nuevo el inductor o prompt del sistema ($), pero ahora este
prompt corresponde al nuevo shell creado. Para abandonar estos shells anidados se debe teclear la orden
exit o bien Control-d, y en tal caso se retorna al shell anterior.
También podemos lanzar un shell anidado y ejecutar bajo él un fichero de comandos, que en Unix
se llama shell-script, de forma que cuando éste termine se regrese al shell progenitor. Para ello se requiere
el derecho de lectura sobre el fichero de comandos. La sintaxis es:

$ sh shell-script

También es posible ejecutar un shell-script de forma directa, tecleando su nombre sobre el prompt
del shell. También se crearía en este caso un nuevo shell integrado en el actual para la ejecución de dicho
shell-script, pero se necesitan derechos de lectura y ejecución sobre el fichero de comandos:

$ shell-script

Podemos construir líneas de órdenes más complejas de la forma siguiente:

- & Todos los programas separados por ‘&’ se ejecutan de forma simultánea.
- ; Los programas separados por ‘;’ se ejecutan secuencialmente, es decir, conforme termina
uno se ejecuta el siguiente en la línea de órdenes.
- && Se ejecuta el programa que aparece a la izquierda de ‘&&’, y si éste retorna al terminar
un valor de errorlevel 0, entonces se ejecuta el programa que aparece a la derecha de ‘&&’.
- || Es similar al anterior, pero sólo ejecuta el siguiente proceso si el anterior devolvió un valor
de errorlevel destinto de 0.

1.11.1. Redireccionamientos y pipes.

- Para el redireccionamiento de salida se usa >

- Para el redireccionamiento de entrada se usa <
- Para añadir información sobre un fichero ya creado, se usa >>
- También es posible redireccionar el dispositivo al que los procesos envían sus mensajes de
error. Dicho dispositivo es por defecto la pantalla. Para ello se redirecciona la salida con el
símbolo “2>”, que significa que los mensajes de error se dirijan hacia el fichero que se
indique a continuación.

24
 - Otra de las posibilidades del shell es la creación de pipes, cuyo objetivo es ejecutar en
paralelo dos procesos, haciendo que la salida de uno de ellos sea la entrada del otro. La
creación de pipes se realiza mediante el símbolo “|!, que separa los dos procesos
considerados.

Ejemplo: Mediante la orden siguiente obtenemos un listado alfabético de los ficheros del
directorio actual.
ls –r | sort

- Los sistemas Unix disponen de diversas herramientas, llamadas filtros, que se emplean
habitualmente en pipes para modificar en cierta forma la salida de algún proceso.

o Uno de estos programas es “tr”, cuyo objeto es transformar algún carácter o grupo
de caracteres. Puede indicarse en una sola orden “tr” un cambio múltiple.
$ ls –l | tr e t
$ ls –l | tr ap bc

o Otro de estos programas es “tee”, que envía la salida del proceso precedente en la
pipe hacia la salida estándar y hacia un fichero (indicado como argumento).
$ ls –l | tee salida

1.11.2. Variables del Shell.

Una de las posibilidades del shell es la definición de variables, para lo cual se emplea la sintaxis:
$ nombre_variable=valor

Posteriormente, para leer el contenido de las variables definidas se emplea la sintaxis:

“$nombre_variable”.
Si se quiere asignar un literal constituido por varias palabras, éste debe aparecer entrecomillado.
La diferencia entre el uso de comillas dobles y comillas simples es que con las dobles podemos incluir
dentro de la cadena nombres de variables, y su valor actual será reemplazado por el nombre de la
variable, situación que no ocurre con las comillas simples.

Ejemplo:

$ pepe=10
$ echo “el me debe $pepe pesetas” -> el me debe 10 pesetas
$ echo ‘el me debe $pepe pesetas” -> el me debe $pepe pesetas

$? Valor de errorlevel devuelto por el programa anterior (entre 0 y 255)

$$ Número de identificación de proceso (PID) del shell
$! Número de identificación del último proceso lanzado en background
$- Opciones actuales del shell
$# Número de argumentos posicionales (en un shell-script)
$@ Argumentos posicionales (en un shell-script)
$0 Nombre del comando en ejecución (shell-script)
$i (para i>1) Argumento posicional i (en un shell-script)
$* Son todos los argumentos o parámetros introducidos al shell script.
La referencia a variables admite algunos formatos de sustitución, según la variable esté definida o
tenga un valor no vacío:

${variable}: Se referencia el valor de la variable (las llaves se ponen sólo cuando en la línea en
que aparece referenciada, aparece detrás alguna información, de forma que éstas actúan como
separadores.
${variables:-palabra}: Si la variable es no vacía, se referencia su contenido, pero si tiene
asignado un valor nulo (o no ha sido declarada) se referencia el valor literal palabra, pero no se asigna
nada a la variable.
${variable:=palabra}: Si la variable tiene asignado un valor no vacío, se referencia su contenido.
En caso contrario se le asigna el valor literal palabra y se referencia dicho valor (esta orden no sirve para
los parámetros $0, $1, ...).

25
 ${variable:?palabra}: Si existe la variable indicada y tiene asignado un valor no nulo se le asigna
el valor palabra. En otro caso, visualiza el literal “variable:palabra” y abandona la ejecución del shell
actual.
${variable:+palabra}: Si la variable indicada existe y tiene un valor no nulo, se referencia el
valor literal palabra. En caso contrario, se referencia una cadana vacía.
Los dos puntos (:) pueden omitirse, y en tal caso sólo se realizan las comprobaciones de existencia
de la variable, no las relativas a si tiene asignado un valor vacío.

1.11.3. Variables de entorno.

Las variables tienen visibilidad en principio sobre el shell donde han sido declaradas. Para
extender su visibilidad a nuevos shells anidados se emplea la orden “export”, con la sintaxis:
$ export variable variable variable ...

Esta orden hace que los valores de las variables indicadas como argumentos sean visibles en los
nuevos shells anidados. Sin embargo, hay que observar que en realidad en cada uno de estos nuevos shells
se crearía una nueva copia de cada variable, asignándole inicialmente el valor que tenía en el shell
anterior; evidentemente, al retornar al shell anterior la variable tendría el último valor asignado en este
shell, sin tener en cuenta las modificaciones realizadas en los shells anidados. A las variables del shell
exportadas con esta orden se las llama variables de entorno.

Tecleando esta orden sin argumentos se muestran las variables exportadas actualmente.
Podemos ver las variables de entorno asignadas en un momento dado con la orden “env”.

A continuación se indican algunas de las variables de entorno predefinidos en el shell:

HOME. Indica el directorio home del usuario actual. Cada vez que se ejecuta el proceso sh para invocar
un nuevo shell, el sistema asigna el valor de esta variable según la información introducida por el
administrador durante la creación del usuario.
PATH. Indica los directorios en los que el shell buscará las órdenes que se le ofrecen para ejecutarlas.
Los directorios que constituyen el PATH se separan por ‘:’.
MAIL. Se asigna mediante esta variable el fichero que actúa como buzón de nuestro correo.
PS1. Es el literal que constituye el inductor principal (habitualmente $ para usuarios normales y # para el
superusuario).
PS2. Es el literal que constituye el inductor secundario (habitualmente >).
IFS. Es el carácter separador por defecto de los campos de un fichero (generalmente será un blanco o un
retorno de carro).
SHELL. Indica el tipo de shell asignado al usuario. El tipo de shell de cada usuario lo fija el superusuario
en el momento de crear el usuario.
TERM. Indica el tipo de terminal que se está empleando. Es importante que esté definido correctamente
este valor, porque en caso contrario no funcionarán correctamente algunos programas.
MAILCHECK. Especifica cada cuanto tiempo (en segundos) se revisa el buzón para ver si hay correo
(su valor por defecto es 0, por lo que antes de visualizar cada vez el inductor, el sistema mira en el
buzón). Lo mejor es cambiar dicho valor a un número mayor (por ejemplo: 600 segundos). Si se
encuentra correo en el buzón, el sistema informa al usuario de ello con el mensaje: “You have mail”.

1.11.4. Fichero .profile.

Este fichero oculto contiene un conjunto de órdenes que se ejecutan cada vez que un usuario entra
al sistema, antes de mostrarle el inductor. Además de ejecutarse las órdenes contenidas en el fichero
.profile se ejecutan (previamente) las órdenes contenidas en el fichero /etc/profile, cuyo propietario es el
administrador, que es el único que puede modificar su contenido.

El fichero .profile puede ser ejecutado directamente (sin abandonar el shell) con la orden
$ . .profile

26
1.11.5. Órdenes internas del shell.

: Solo tiene por objeto devolver 0 como retorno de errorlevel

. fichero. Ejecuta las órdenes contenidas en el fichero de comandos indicado. Esta orden no crea
un nuevo shell que se encargue de la ejecución de las órdenes del fichero, sino que usa para ello
el shell actual. Sin embargo, no podemos pasar parámetros al fichero de comandos.

exec [args...].- Se ejecuta el proceso especificado como argumento en lugar del shell (no crea un
nuevo proceso, sino que sobrescribe el espacio de memoria ocupado por el shell, por lo que
cuando concluye su ejecución retorna al proceso padre del shell).

exit.- Abandona el shell

login.- su objeto es introducirnos en una nueva secuencia de logina, para acceder a un nuevo
usuario, abandonando el anterior. Su ejecución sólo se permite mediante la orden:
exec login [args]
newgrp. su objeto es cambiar el grupo del usuario que la ejecuta. El usuario debe estar
autorizado para realizar dicho cambio. Habitualmente su ejecución es posible en la forma:
exec newgrp [args]
read variable. Lee desde la entrada estándar el valor de la variable indicada.
readonly [nombre nombre ... ].- Marca las variables de la lista como de solo lectura, de forma
que no pueda alterarse su valor. Esta orden debe darse una vez asignado o leído un valor para las
variables.
shift.- Su objetivo es rotar los valores de los parámetros posicionales: $i pasa a ser $i-1, para i>1.
times.- Visualiza los tiempos acumulados de gasto de CPU por el sistema y por el usuario para
ejecutar los comandos que éste lanzó (el gasto del sistema corresponde al tiempo consumido por
las llamadas al sistema realizadas durante la ejecución del programa del usuario, así como por las
interrupciones atendidas entre tanto.

1.11.6. La orden eval y el operador grave.

La orden “eval” tiene la sintaxis siguiente:

eval [argumento argumento ... ]

Cuando se ejecuta sin argumentos devuelve siempre 0 como retorno de errorlevel. En caso
contrario, se concatenan los argumentos para conformar una línea de órdenes, la cual es a continuación
ejecutada. El valor de errorlevel obtenido como resultado de la ejecución de dicha línea de órdenes es el
valor de errorlevel devuelto por eval.

La orden eval suele emplearse junto al operador grave ‘, que se emplea habitualmente para
ejecutar una línea de órdenes (encerrada entre dos apóstrosfos hacia la izquierda), y asignar su salida de
resultados estándar como valor de una cierta variable del shell.

Ejemplo1: Para asignar a la variable “x” el tipo de terminal que se está empleando:

$ x=’echo $TERM’
$ echo $x

Ejemplo2: Ejecutad la orden siguiente y observar su resultado:

$ echo “ ’ls –l’ “

27
1.12. Implementación de shell-scripts.

En esta sección se describen las construcciones de control del lenguaje de órdenes aceptado por el
shell Bourne, utilizadas habitualmente en shell-scripts.

1.12.1. Construcción if-then-else.

La sintaxis es
$ if comando; then comando; [else comando;] fi

Para introducir varios comandos en la parte then o else, estos deben aparecer en líneas distintas,
tecleando \ al final de cada línea. También pueden dividirse las distintas partes de esta orden en varias
líneas, omitiendo en este caso los puntos y coma.
Se puede utilizar como comandos true (devuelve como errorlevel 0) o false (devuelve errorlevel
distinto de 0).

Ejemplo1:
$ if true
 then
 echo va bien
 fi

Ejemplo2: Crear un shell-script para asignar ciertos derechos (especificados como primer
argumento) a un fichero pasado como segundo argumento.

$ cat derechos
if chmod $1 $2
then
echo “Asignados derechos $1 sobre fichero $2”
else
echo “No pueden establecerse esos derechos”

1.12.2. La orden test.

Mediante esta orden podemos evaluar expresiones condicionales. Su función es evaluar una
expresión condicional, de forma que si ésta resulta cierta devuelve un errorlevel igual a 0, y si ésta es
falsa devuelve un errorlevel distinto de 0. La sintaxis es:

test expresión o bien [ expresión ]

Pueden emplearse los siguientes operadores para construir expresiones condicionales

compuestas:

! Operador “not” -a Operador “and” -o Operador “or”

( ) Construcción de subexpresiones.

28
 Las expresiones básicas admitidas por la orden test son:

-r fichero Evalúa a cierto si el fichero existe y tiene permiso de lectura para el usuario que accede
-w fichero Evalúa a cierto si el fichero existe y tiene permiso de escritura para el usuario que accede
-x fichero Evalúa a cierto si el fichero existe y tiene permiso de ejecución para el usuario que accede
-f fichero Evalúa a cierto si el fichero existe y es un fichero regular
-d fichero Evalúa a cierto si es un directorio.
-c fichero Evalúa a cierto si el fichero existe y es un fichero especial de caracteres.
-b fichero Evalúa a cierto si el fichero existe y es un fichero especial de bloques
-h fichero Evalúa a cierto si fichero existe y es una ligadura simbólica
-p fichero Evalúa a cierto si fichero existe y es una pipe
-u fichero Evalúa a cierto si fichero existe y tiene activo su bit SETUID
-g fichero Evalúa a cierto si fichero existe y tiene activo su bit SETGID
-s fichero Evalúa a cierto si fichero existe y tiene tamaño mayor que 0
-t [fildes] Evalúa a cierto si fichero abierto cuyo descriptor es el nº fildes (1 por defecto) está
asociado a un terminal
-z s1 Evalúa a cierto si la longitud de la cadena s1 es 0
-n s1 Evalúa a cierto si la longitud de la cadena s1 es distinta de 0
s1=s2 Evalúa a cierto si ambas cadenas son idénticas
s1!=s2 Evalúa a cierto si ambas cadenas no son idénticas
s1 Evalúa a cierto si s1 no es la cadena vacía
n1 –eq n2 Evalúa a cierto si los dos enteros (n1,n2) son exactamente iguales
n1 –lt n2 Evalúa a cierto si el entero n1 es extrictamente menor que n2
n1 –gt n2 Evalúa a cierto si el entero n1 es extrictamente mayor que n2
n1 –le n2 Evalúa a cierto si el entero n1 es menor o igual que n2
n1 –ge n2 Evalúa a cierto si el entero n1 es mayor o igual que n2
n1 –ne n2 Evalúa a cierto si el entero n1 es distinto que n2

1.12.3. Construcciones de control iterativas

1.12.3.1. Construcción for.

for nombre [in palabra palabra ... ]

do
comandos
done

Ejemplo1:
$ for VAL in 1 2 3 4
 do
 echo $VAL
 done

Ejemplo2:
$ for FICHERO in *
 do
 echo $FICHERO
 done

1.12.3.2. Construcción while o until.

while comando
do until condición do
do
comando/s comando/s
done done

29
1.12.3.3. Comando expr.

El objeto de este comando es evaluar una expresión aritmética.

Ejemplo:

$ VAL=1
$ while [ $VAL –lt 11 ]
 do
 echo $VAL
 VAL=’expr $VAL + 1’
 done

1.12.4. Sentencias read, exit y break.

El comando read permite solicitar un valor por teclado y asignárselo a una variable. Su sintaxis es:

read variable

El efecto del comando exit es abandonar el shell con un valor de errorlevel igual a n. Si no se pone
el argumento, entonces se abandona el shell arrojando como errorlevel el valor devuelto por la última
orden ejecutada. Su sintaxis es:
exit [n]

La orden break se emplea para abandonar un bucle (for o while) en tantos niveles de anidamiento
como se especifique (si no se pone el argumento, se supone que éste es 1, que es lo habitual). Su sintaxis
es:
break [n]

Ejemplo1: Escribid un shell-script que al ejecutarlo pida un valor para la variable vari. Si el valor
introducido es exactamente igual a la cadena “pepe”, abandona la ejecución. En caso contrario vuelve a
solicitar otro valor para dicha variable.

Fichero: salta

while true
do
echo INTRODUZCA EL VALOR DE LA VARIABLE
read vari
if [ $vari=’pepe’ ]
then
echo ABANDONO EJECUCION
break
fi
done

Ejemplo2: Ejecutar el siguiente fichero de comandos y estudiad su funcionamiento

Fichero: saltadoble

while true
do
echo INTRODUZCA EL VALOR DE LA PRIMERA VARIABLE
read var1
while true
do
echo INTRODUZCA EL VALOR DE LA SEGUNDA VARIABLE
read var2
if [ $var1=’pepe’ –a $var2 =’juan’]

30
 then
echo ABANDONO EJECUCION
break 2
else
if [ $var2=’juan’ ]
then
break
fi
fi
done
done

1.12.5. Sentencia case

Su sintaxis es la siguiente:
case palabra in
[patrón[ |patrón]..) comandos;;]..... ..... esac

Ejemplo: Escribid un shell-script que listen los ficheros del raiz o del home según la palabra
introducida por el teclado sea “todos” o “local”. Si la palabra introducida no es ninguna de ellas,
se ejecuta echo “no has introducido una opción válida”

Fichero: procesos

echo INTRODUZCA PALABRA

read vpal
case $vpal in
todos) ls –l / ;;
local) ls –l /home/usuario;;
*) echo “NO HAS INTRODUCIDO NINGUNA OPCIÓN VÁLIDA”
esac

1.12.6. Declaración de funciones.

Es posible la creación de funciones dentro de un shell-script (los argumentos de la misma se

acceden como argumentos posicionales: $!, $2, etc). La sintaxis para ello es la siguiente:

nombre_funcion ( ) { comandos }

Entre los posibles comandos está return número, que finaliza la ejecución de la función
devolviendo el valor indicado como retorno de errorlevel (es el valor devuelto por las funciones del shell).

suma()
{
var=`expr $1 + $2
return $var
}
echo Introduce el primer valor
read var1
echo Introduce el segundo valor
read var2
suma $var1 $var2
echo "La suma de $var1 y $var2 es: $?"

31