Curso básico Linux gestión ficheros

EUSKAL HERRIKO UNIBERTSITATEA
UNIVERSIDAD DEL PAÍS VASCO
CURSO BÁSICO
DE LINUX
Bilbao, marzo 2003

Sistema Operativo UNIX - ii -
ÍNDICE
1. INTRODUCCIÓN ............................................................................................................. 1
1.1 Sistemas operativos .................................................................................................... 1
1.2 Breve historia del sistema operativo UNIX ............................................................... 2
1.3 Características generales del S.O. UNIX ................................................................... 2
2. ACCESO AL SISTEMA Y COMANDOS GENERALES ............................................... 4

2.1 Usuarios y acceso al sistema ...................................................................................... 4
2.2 Formato de comandos ................................................................................................ 5
2.3 Comandos informativos ............................................................................................. 6
2.4 Comandos de mensaje ................................................................................................ 8
3. FICHEROS ........................................................................................................................ 9
3.1 Concepto y tipos de ficheros ...................................................................................... 9
3.1.1 Denominación de ficheros ...................................................................................................9
3.2 El sistema de ficheros. Directorios ........................................................................... 10
3.3 Manipulación de directorios ..................................................................................... 11
3.4 Manipulación de ficheros ......................................................................................... 11
3.5 Protecciones de ficheros ........................................................................................... 13
4. PROCESOS Y ENTORNO.............................................................................................. 16
4.1 Concepto de proceso ................................................................................................ 16
4.2 Concepto de entorno................................................................................................. 16
4.3 Visualización de procesos ........................................................................................ 17
4.4 Variables................................................................................................................... 18
5. PROGRAMACIÓN SHELL. CONCEPTOS BÁSICOS ................................................. 20

5.1 Metacaracteres .......................................................................................................... 20
5.2 Redireccionamientos ................................................................................................ 21
5.3 Pipelines ................................................................................................................... 22
5.3.1 Filtros .................................................................................................................................23
5.4 Asignación de salida de comandos a variables ........................................................ 23
6. PROGRAMACIÓN SHELL. COMANDOS ................................................................... 24

6.1 Comando sort ........................................................................................................ 24
Curso básico de Linux

Sistema Operativo UNIX - iii -
6.2 Comando grep ........................................................................................................ 25

6.3 Comando wc............................................................................................................. 25
6.4 Comando tee .......................................................................................................... 26
6.5 Comando cut .......................................................................................................... 26
6.5.1 Corte por caracteres ...........................................................................................................26
6.5.2 Corte por campos ...............................................................................................................26
6.6 Comando pr............................................................................................................. 27
6.7 Comando lp............................................................................................................. 27
6.8 Comando expr ........................................................................................................ 28
7. PROGRAMACIÓN SHELL. CONTROL DE PROCESOS ........................................... 29

7.1 Ejecución de procesos en background ..................................................................... 29
7.2 Prioridad de un proceso ............................................................................................ 30
7.3 Código de retorno ..................................................................................................... 30
7.3.1 Comandos true y false ................................................................................................31
7.4 Comando test ........................................................................................................ 31
7.4.1 El comando test con ficheros como argumentos............................................................31
7.4.2 El comando test con números o caracteres como argumentos .......................................32
8. FICHEROS DE COMANDOS ........................................................................................ 33

8.1 Argumentos en los ficheros de comandos ................................................................ 33
8.2 Introducción de datos a través de variables .............................................................. 34
8.3 Comando exit ........................................................................................................ 35
8.4 Estructuras de programación .................................................................................... 35
8.4.1 La construcción if ............................................................................................................35
8.4.2 La construcción while .....................................................................................................37
8.4.3 La construcción for..........................................................................................................39
8.4.4 La construcción case ..........................................................................................................39

Sistema Operativo UNIX -1-
1. INTRODUCCIÓN
1.1 Sistemas operativos

UNIX es un sistema operativo. Por tanto, su función básica es controlar los recursos de un
computador.
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.
Estos recursos básicos se utilizan para diferentes tipos de operaciones, las cuales pueden
clasificarse de la siguiente manera:
 Ejecución de comandos.
 Creación y mantenimiento de ficheros.
 Control de redes.
 Ejecución de procesos en general.
El Sistema Operativo, por tanto, establece la comunicación entre usuario y hardware a dos
niveles:
 El intérprete de comandos o shell que interpreta las órdenes dadas al computador a

través de los comandos y otros procesos. Los comandos son pequeños programas en
lenguaje C.
 El kernel, que está constituido por el código máquina que coordina el hardware, a fin
de que efectúe las distintas operaciones requeridas.
Las características citadas son comunes a todos los sistemas operativos. De todos ellos,
probablemente los más utilizados en la actualidad sean el UNIX y el DOS. Veamos qué
diferencias fundamentales pueden establecerse entre estos dos sistemas.
 El DOS es un sistema operativo destinado a controlar computadores personales,

mientras que el UNIX está enfocado al control de estaciones de trabajo.
 UNIX es un sistema multitarea, es decir, que es capaz de ejecutar varios procesos

”de forma simultánea”, mientras que DOS es un sistema monotarea.
 En general, UNIX es un sistema mucho más potente que DOS, y por tanto requiere
mayores-prestaciones de los computadores sobre los que trabaja.
 UNIX es un sistema menos tratable, más difícil de utilizar que el DOS.

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 Mcllroy, Joe Ossaha 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
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.
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 “userfriendly 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
manager. El manager 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 manager, 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 computador
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 (con un máximo de 8 caracteres,
normalmente), y es introducido al sistema por el manager.
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. El password es, habitualmente,
una cadena de al menos 6 caracteres, entre los cuales debe existir una cifra al menos. 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.
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. Sus principales
opciones son:
-l: proporciona la lista de terminales conectadas, pero esperando acceder al sistema.

-g: sólo escribe los nombres de los usuarios conectados
-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.
 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.

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.) hasta un máximo de 14. 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, 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).

Sistema Operativo UNIX - 10 -
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:
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 la última modificación
identificador
del fichero
 cat: muestra en pantalla el contenido de un fichero que se utilice como argumento.

No tiene opciones.
 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. Su funcionamiento es exactamente el mismo

que el del comando mv.
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 se traslada a todos.
 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: 1a 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)
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-xr--
rwxr-xr-- g=rw rwxrw-r--
rwxr-xr-x = ---------
Comando chmod: 2a 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.

4. PROCESOS Y ENTORNO
4.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.
4.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.
4.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.

4.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í, tas
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.

5. 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.
5.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:
$: 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. O bien, el comando
$ ls *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.
5.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 standard 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, BORRARÁ 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
5.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 contenidos 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|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).
5.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 segundo pipe. En apartados posteriores se
indicarán ejemplos de filtros.
5.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.

6. PROGRAMACIÓN SHELL. COMANDOS
En este capítulo se va a exponer el funcionamiento de una serie de comandos útiles en UNIX.
6.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 (:)

6.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.
6.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.

6.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 precede en
el pipe. Sin embargo, no altera en absoluto los datos que recoge:
$ proc1|tee file|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 sobrescribirlo.
6.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.
6.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).
6.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 -fINT -dsep -s ficheros
6.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.
6.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, la 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.

6.8 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.

7. PROGRAMACIÓN SHELL. CONTROL DE PROCESOS
7.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 ser 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.
7.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.
7.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 $?
7.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
7.4 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.
7.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: el 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.

7.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 ¡guales.

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.

8. 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.
8.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 fichero de comandos 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 fichero de comandos. Sin embargo, es posible que
un determinando 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).

8.2 Introducción de datos a través de variables

Como se ha visto, los argumentos permiten introducir informaciones a los ficheros de
comandos. 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 fichero de comandos 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 fichero de comandos 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
fichero de comandos 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.
8.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.
8.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.
8.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 lee 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
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.
8.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
CDMA
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.
8.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
do
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.
8.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.
8.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 modelo2,
y se va repitiendo la operación hasta llegar al final.
En los modelos de comparación pueden utilizarse metacaracteres (*,?, etc.)

Curso básico Linux gestión ficheros

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso básico Linux gestión ficheros

Cargado por

Copyright:

Formatos disponibles

EUSKAL HERRIKO UNIBERTSITATEA

UNIVERSIDAD DEL PAÍS VASCO

Bilbao, marzo 2003

2. ACCESO AL SISTEMA Y COMANDOS GENERALES ............................................... 4

5. PROGRAMACIÓN SHELL. CONCEPTOS BÁSICOS ................................................. 20

6. PROGRAMACIÓN SHELL. COMANDOS ................................................................... 24

Curso básico de Linux

6.2 Comando grep ........................................................................................................ 25

7. PROGRAMACIÓN SHELL. CONTROL DE PROCESOS ........................................... 29

8. FICHEROS DE COMANDOS ........................................................................................ 33

Curso básico de Linux

1.1 Sistemas operativos

Estos recursos se pueden clasificar, de forma muy amplia, en:

 La Unidad Central de Proceso (CPU).

 El intérprete de comandos o shell que interpreta las órdenes dadas al computador a

 El DOS es un sistema operativo destinado a controlar computadores personales,

 UNIX es un sistema multitarea, es decir, que es capaz de ejecutar varios procesos

 UNIX es un sistema menos tratable, más difícil de utilizar que el DOS.

Curso básico de Linux

1.2 Breve historia del sistema operativo UNIX

1. Era un sistema utilizable en minicomputadores.

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.

1.3 Características generales del S.O. UNIX

- Existe distinción entre letras mayúsculas y minúsculas.

Curso básico de Linux

- No es un “userfriendly system”. Existen pocos mensajes de advertencia en la

Curso básico de Linux

2. ACCESO AL SISTEMA Y COMANDOS GENERALES

2.1 Usuarios y acceso al sistema

Curso básico de Linux

Al período de tiempo transcurrido entre un acceso y posterior abandono del sistema se le

2.2 Formato de comandos

$ comando opciones argumentos

Una opción es un indicador que modifica de alguna manera el funcionamiento general y

Pero si se ejecuta simultáneamente con las dos opciones, se escribirá

$ cmd -bc ó $ cmd -cb

Curso básico de Linux

2.3 Comandos informativos

%a: escribe únicamente el día de la semana de forma abreviada

Curso básico de Linux

%Y: escribe únicamente el año con el siglo

-l: proporciona la lista de terminales conectadas, pero esperando acceder al sistema.

 man: este comando proporciona información sobre el funcionamiento de un comando

Curso básico de Linux

2.4 Comandos de mensaje

 banner: este comando escribe en pantalla en grandes caracteres el argumento que

 echo: refleja en pantalla el argumento que lleve a continuación. Su auténtica utilidad

Curso básico de Linux

3.1 Concepto y tipos de ficheros

3.1.1 Denominación de ficheros

El nombre relativo de un fichero respecto a un directorio es el formado por todos los

El salto de un directorio a otro situado en un nivel inmediatamente inferior (o que cuelga

Curso básico de Linux

3.2 El sistema de ficheros. Directorios

Un directorio es un fichero cuyo contenido es más ficheros o directorios.

 El directorio raíz /: es el directorio del que cuelga todo el sistema de ficheros. No

 Directorio login o directorio de acceso: es aquel directorio al cual va a parar un

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

 Directorio padre: cada directorio cuelga directamente de otro (salvo el /) que es su

Curso básico de Linux

3.3 Manipulación de directorios

___