Crear, copiar, mover y borrar

1. Tres reglas antes de empezar

Los comandos de este tema comparten un comportamiento que los distingue de cualquier administrador de archivos gráfico. Conviene tenerlo presente desde la primera línea:

No es descuido de diseño. Estos comandos se pensaron para ser usados también por otros programas y dentro de scripts, donde una pregunta detendría todo. El sistema supone que quien escribe la orden sabe lo que pide. A cambio, cada comando tiene opciones para pedirle que pregunte o que informe, y las veremos junto con cada uno.

2. Un taller descartable

Para practicar sin riesgo, trabajamos dentro de un directorio nuevo, que al final del tema borraremos entero:

$ cd ~/practica
$ mkdir taller
$ cd taller
$ pwd
/home/ana/practica/taller

Todos los ejemplos, salvo indicación, se ejecutan desde ~/practica/taller, y cada uno parte del estado en que lo dejó el anterior. Conviene seguirlos en orden y ejecutar ls después de cada paso, hasta que predecir el resultado se vuelva fácil.

3. touch: crear un archivo vacío

touch recibe uno o más nombres y crea, por cada uno, un archivo sin contenido:

$ touch lista.txt
$ ls -l
total 0
-rw-rw-r-- 1 ana ana 0 oct 12 12:10 lista.txt

El archivo existe, tiene dueño, permisos y fecha, y mide cero bytes. Parece poco útil, y sin embargo se usa mucho: para preparar un archivo que luego se editará, para hacer pruebas, como hicimos en el tema 9, y porque hay programas que solo necesitan comprobar que cierto archivo existe.

El nombre del comando delata que crear archivos no es su propósito original. touch «toca» un archivo: actualiza su fecha de modificación al momento actual. Si el archivo no existe, lo crea, y ese efecto secundario terminó siendo el uso principal.

La segunda fila es importante: touch nunca borra ni vacía nada, y por eso es seguro usarlo sobre un nombre que ya existe.

Un archivo con contenido se crea de otras maneras. La más directa la usamos en el tema 2: echo "Mi primer archivo" > notas.txt, que envía la salida de echo a un archivo. La estudiamos en el tema 23. La otra es un editor de texto, en el tema 13.

4. mkdir: crear directorios

mkdir crea los directorios cuyos nombres recibe. Lo usamos varias veces; ahora miramos sus dos fallos típicos y la opción que los resuelve:

$ mkdir docs
$ mkdir docs                        # otra vez: ya existe
mkdir: cannot create directory 'docs': File exists
$ mkdir viajes/2026/fotos           # falta el camino: no existe «viajes»
mkdir: cannot create directory 'viajes/2026/fotos': No such file or directory

El segundo error es el que desconcierta. mkdir crea un solo nivel: el último nombre de la ruta. Todos los anteriores deben existir. La opción -p, de parents, crea de una vez los que falten:

$ mkdir -pv viajes/2026/fotos
mkdir: created directory 'viajes'
mkdir: created directory 'viajes/2026'
mkdir: created directory 'viajes/2026/fotos'
$ mkdir -p docs                     # con -p, que ya exista no es un error
$ ls
docs  lista.txt  viajes

La opción -v, de verbose, existe en los seis comandos del tema y hace lo mismo en todos: rompe la regla del silencio y cuenta lo que se hizo. Es buena compañía mientras se aprende.

Con las llaves del tema 9, mkdir -p arma una estructura completa en una línea, como mkdir -p proyecto/{src,docs,tests}.

5. cp: copiar archivos

cp recibe un origen y un destino, en ese orden, y deja en el destino un duplicado. El original no cambia.

$ cp ../notas.txt .                 # traer aquí el archivo del directorio padre
$ cp notas.txt copia.txt            # duplicarlo con otro nombre
$ ls -l
total 16
-rw-rw-r-- 1 ana ana   18 oct 12 12:14 copia.txt
drwxrwxr-x 2 ana ana 4096 oct 12 12:11 docs
-rw-rw-r-- 1 ana ana    0 oct 12 12:10 lista.txt
-rw-rw-r-- 1 ana ana   18 oct 12 12:14 notas.txt
drwxrwxr-x 3 ana ana 4096 oct 12 12:12 viajes

La primera línea usa las rutas del tema 6: el origen es .., el directorio padre, y el destino es ., «aquí». La segunda da un nombre nuevo a la copia. Las copias son archivos independientes: modificar una no afecta a la otra.

El listado muestra un detalle: las copias tienen la fecha de ahora, las 12:14, y no la del original, que era de las 10:32. Una copia es un archivo nuevo, y como tal recibe fecha nueva y pasa a ser de quien la hizo.

cp tiene tres formas de uso:

$ cp /etc/hostname docs
$ cp notas.txt copia.txt docs
$ ls docs
copia.txt  hostname  notas.txt

En la tercera forma, el último argumento es siempre el destino y debe ser un directorio existente; todos los anteriores son orígenes. Es la forma que se usa con comodines: cp *.txt docs copia todos los archivos de texto, porque la shell convierte el patrón en la lista de nombres.

6. El destino decide el resultado

Las dos primeras formas se escriben igual: cp, un origen y otra palabra. Lo que cp hace depende de qué sea esa palabra en el momento de ejecutar, y esta es la idea más importante del tema:

La tercera fila es la primera forma de perder datos con estos comandos. Veámosla ocurrir, sobre un archivo que no importa:

$ cp lista.txt copia.txt            # lista.txt está vacío; copia.txt tenía 18 bytes
$ ls -l copia.txt
-rw-rw-r-- 1 ana ana 0 oct 12 12:18 copia.txt

No hubo mensaje ni pregunta. copia.txt tiene ahora cero bytes, y lo que contenía no existe en ninguna parte. La opción -i, de interactive, hace que cp pregunte antes de reemplazar:

$ cp -i notas.txt copia.txt
cp: overwrite 'copia.txt'? y
$ ls -l copia.txt
-rw-rw-r-- 1 ana ana 18 oct 12 12:19 copia.txt

Se responde y, de yes, para aceptar; cualquier otra cosa cancela. La ambigüedad del destino tiene también una defensa simple. Cuando la intención es copiar dentro de un directorio, se escribe el destino con una barra final:

7. Copiar directorios: -r y -a

Sin opciones, cp se niega a copiar un directorio:

$ cp docs respaldo
cp: -r not specified; omitting directory 'docs'
$ cp -r docs respaldo
$ ls respaldo
copia.txt  hostname  notas.txt

La opción -r, de recursive, copia el directorio con todo su contenido, incluidos los subdirectorios, hasta el fondo. El resultado fue un directorio nuevo, respaldo, igual a docs.

La regla de la sección anterior se aplica aquí también, y produce la sorpresa más frecuente de cp. Ejecutar la misma línea una segunda vez no da el mismo resultado:

$ cp -r docs respaldo               # la misma línea, pero ahora «respaldo» existe
$ ls respaldo
copia.txt  docs  hostname  notas.txt

Por eso, antes de copiar un directorio conviene saber si el destino existe: un ls lo responde.

Para las copias de seguridad hay una opción mejor que -r. Es -a, de archive: copia de manera recursiva y además conserva las fechas, los permisos y los enlaces de cada archivo. La copia resulta idéntica al original, no solo en contenido.

8. Las opciones de cp

Reunidas, las opciones que conviene conocer:

$ cp -v notas.txt lista.txt docs/
'notas.txt' -> 'docs/notas.txt'
'lista.txt' -> 'docs/lista.txt'

-u, de update, sirve para repetir una copia grande trayendo solo lo que cambió. Para sincronizar directorios de verdad hay una herramienta dedicada, rsync, que excede este curso pero conviene tener anotada.

Antes de seguir, deshacemos el efecto de ese último ejemplo, para mantener ordenado el taller. Es también el primer uso de rm:

$ rm docs/lista.txt

9. mv: mover y renombrar

En la terminal no hay un comando para cambiar el nombre de un archivo. No hace falta: renombrar es mover. Cambiar lista.txt por compras.txt es moverlo a otro nombre dentro del mismo directorio. Las dos operaciones las hace mv.

$ mv lista.txt compras.txt          # renombrar
$ mv compras.txt docs/              # mover a un directorio
$ mv docs/hostname equipo.txt       # mover y renombrar a la vez
$ mv respaldo seguridad             # renombrar un directorio
$ ls
copia.txt  docs  equipo.txt  notas.txt  seguridad  viajes
$ ls docs
compras.txt  copia.txt  notas.txt

La sintaxis es la de cp, con las mismas tres formas y la misma regla del destino:

La tercera fila es más grave que en cp. Con cp, tras sobrescribir quedan dos archivos iguales. Con mv, el destino desaparece y el origen ocupa su nombre: de dos archivos distintos queda uno.

10. mv en detalle

Las opciones de protección son las mismas que en cp:

$ mv -i equipo.txt notas.txt
mv: overwrite 'notas.txt'? n
$ mv -v copia.txt duplicado.txt
renamed 'copia.txt' -> 'duplicado.txt'

Hay tres diferencias con cp que conviene saber.

Los directorios no necesitan -r. mv mueve un directorio con todo lo que contiene, sin opciones, como hicimos con respaldo.

Es instantáneo, casi siempre. Mover un archivo dentro del mismo disco no copia nada: el sistema solo cambia la anotación de en qué directorio y con qué nombre figura. Un archivo de varios gigabytes se mueve en el mismo tiempo que uno vacío. Solo cuando el destino está en otro disco, como una memoria USB, mv debe copiar los datos y borrar el original, y entonces tarda lo que una copia.

No sirve para renombrar en masa. Es un intento natural, y falla por lo que aprendimos en el tema 9:

$ mv *.txt *.bak
mv: target '*.bak': No such file or directory

La shell expande los patrones antes de que mv los vea. Como no hay archivos .bak, el segundo queda literal, y mv recibe una lista de archivos seguida de un «directorio» llamado *.bak, que no existe. mv no sabe nada de la intención de cambiar una extensión por otra. Renombrar muchos archivos requiere un bucle, que es materia del próximo curso, o el comando rename.

11. rm: borrar archivos

rm elimina los archivos que recibe como argumentos.

$ rm equipo.txt
$ rm -i duplicado.txt
rm: remove regular file 'duplicado.txt'? y
$ ls
docs  notas.txt  seguridad  viajes

El primer rm no dijo nada, y el archivo ya no está. No fue a una papelera. Su nombre desapareció del directorio y el espacio que ocupaba quedó libre para otros datos.

Una curiosidad que se aclara en el bloque 4: para borrar un archivo no hace falta permiso sobre el archivo, sino sobre el directorio que lo contiene. Borrar es quitar un nombre de la lista de un directorio, y lo que se modifica es esa lista.

12. Borrar directorios: rmdir y rm -r

Sin opciones, rm no borra directorios. Para eso hay dos caminos, uno prudente y otro expeditivo:

$ rm docs
rm: cannot remove 'docs': Is a directory
$ rmdir docs
rmdir: failed to remove 'docs': Directory not empty
$ rmdir viajes/2026/fotos           # este sí: está vacío
$ rmdir -p viajes/2026              # borra «2026» y, al quedar vacío, «viajes»
$ ls
docs  notas.txt  seguridad

rmdir es un comando seguro por construcción: no puede destruir datos, porque se niega a actuar si hay alguno. Cuando crees que un directorio está vacío, es la manera correcta de borrarlo: si te equivocabas, lo sabrás por el mensaje y no por la pérdida. Recuerda del tema 7 que un directorio puede parecer vacío y tener archivos ocultos.

rm -r desciende por el árbol y borra cada archivo y cada directorio que encuentra:

$ rm -r seguridad
$ rm -rv docs
removed 'docs/compras.txt'
removed 'docs/copia.txt'
removed 'docs/notas.txt'
removed directory 'docs'
$ ls
notas.txt

El directorio seguridad, con sus archivos y su subdirectorio, desapareció en un instante y sin una línea de salida.

13. rm -rf y los accidentes clásicos

La combinación rm -rf es la orden más temida de Unix. Une «todo lo que haya debajo» con «sin preguntar nada». No tiene nada de malo en sí: es la forma normal de eliminar un directorio grande. El problema es que hace exactamente lo que se le pide sobre la ruta que recibe, y que una ruta equivocada por un carácter puede ser otro lugar del sistema.

Los accidentes reales se parecen todos. Vale la pena conocerlos, porque se evitan sabiendo que existen:

El sistema tiene dos protecciones. Los permisos impiden a un usuario común borrar lo que no es suyo, de modo que el daño se limita a su directorio personal, que es justamente donde están sus archivos. Y rm se niega expresamente a actuar sobre la raíz:

rm: it is dangerous to operate recursively on '/'
rm: use --no-preserve-root to override this failsafe

Esa protección cubre solo el caso exacto de /. No cubre /*, ni /home, ni tu directorio personal. Y con sudo delante, los permisos dejan de proteger.

14. Cómo no perder datos

Nada de lo anterior es motivo para temerle a la terminal. Quienes la usan a diario borran y mueven archivos todo el tiempo sin incidentes, porque trabajan con unos pocos hábitos fijos:

1. Mirar antes. ls con la misma ruta o el mismo patrón que se va a usar. ver
2. Reutilizar la línea. Flecha arriba y cambiar ls por rm, en vez de escribir el patrón otra vez. historial
3. Completar las rutas con Tab. Un nombre completado existe y está bien escrito. Tab
4. Usar -i cuando haya duda. Sobre todo con comodines. preguntar
5. Preferir rmdir para lo que debería estar vacío. seguro
6. Mover en lugar de borrar. Ante la duda, mv a un directorio «para borrar», y eliminarlo días después. reversible
7. Copiar antes de modificar. Antes de tocar un archivo importante, cp -a archivo archivo.bak. respaldo

El sexto es la versión manual de una papelera. Existe también la automática: en un escritorio como el de Ubuntu, el comando gio trash archivo envía un archivo a la papelera del entorno gráfico, de donde se lo puede restaurar. Es una buena alternativa a rm para el uso personal.

Sobre el cuarto hábito hay una advertencia que hicimos en el tema 5 y que ahora se entiende del todo. Es tentador definir alias rm='rm -i' para que siempre pregunte. El riesgo es acostumbrarse a esa red: el día que trabajes en otra máquina, o que un script use rm, no estará. Es preferible escribir el -i cuando se lo necesita, y que el hábito sea mirar antes.

Y el séptimo apunta a la única protección que funciona contra todos los errores, incluidos los que no dependen de ti, como un disco que falla: una copia de seguridad en otro dispositivo. Ningún cuidado al escribir la reemplaza.

15. Dejar todo como estaba

Queda desarmar el taller. Es un buen ejercicio de lo aprendido, aplicando las comprobaciones:

$ cd ..                             # no se puede borrar cómodamente el directorio en el que se está
$ pwd
/home/ana/practica
$ ls taller                         # qué voy a borrar
notas.txt
$ rm -r taller
$ ls
fotos  informe.txt  notas.txt

El directorio de práctica quedó como al comenzar. El notas.txt que se borró era la copia del taller; el original nunca se tocó.

La referencia rápida del tema:

Sabemos crear archivos, pero todavía no mirar bien lo que tienen dentro: cat muestra todo de golpe, y con un archivo largo no alcanza. En el tema 12 vemos las herramientas para leer contenido: por páginas, solo el principio, solo el final, o a medida que se escribe.

16. Resumen

• Los comandos que modifican archivos no usan papelera, no piden confirmación y no informan cuando tienen éxito.
• touch crea archivos vacíos; si el archivo existe, solo actualiza su fecha.
• mkdir crea directorios; con -p, también los intermedios que falten.
• cp origen destino copia. La copia es un archivo nuevo, con fecha nueva.
• El resultado de cp y de mv depende del destino: si no existe, se crea con ese nombre; si es un directorio, el origen va dentro; si es un archivo, se lo reemplaza.
• cp -r copia directorios; cp -a, además, conserva fechas y permisos.
• mv mueve y renombra, que son la misma operación. Dentro de un mismo disco es instantáneo.
• rm borra archivos de manera definitiva. Con -r borra directorios con todo su contenido.
• rmdir borra solo directorios vacíos, y por eso no puede destruir datos.
• -i hace que cp, mv y rm pregunten; -v, que informen lo que hacen.
• Los accidentes con rm -rf se deben casi siempre a un espacio de más o a estar en otro directorio.
• Los hábitos que evitan pérdidas: mirar con ls antes, reutilizar la línea, completar con Tab, y tener copias de seguridad.

17. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. En ~/practica, crea con una sola línea la estructura curso/{teoria,ejercicios/{resueltos,pendientes}} y verifícala con tree o con find.
2. Crea en curso/teoria los archivos tema1.txt a tema5.txt con touch y las llaves.
3. Copia /etc/hostname y /etc/os-release a curso/ejercicios/pendientes/ con un solo comando y la opción -v.
4. Renombra curso/teoria/tema5.txt como anexo.txt, y luego muévelo a curso.
5. Haz una copia de curso llamada curso-respaldo con cp -a. Compara las fechas de los archivos con ls -l en el original y en la copia. Repite con cp -r hacia curso-copia y observa la diferencia.
6. Intenta copiar hostname sobre os-release con cp -i, y responde que no. Luego prueba la misma copia con -n: ¿qué ocurre?
7. Intenta borrar curso/ejercicios con rmdir y lee el mensaje. Bórralo después de la manera adecuada.
8. Borra todos los archivos .txt de curso/teoria: primero mira la lista con ls, y luego recupera la línea con la flecha arriba y cambia el comando.
9. Crea un archivo llamado -prueba.txt con touch -- -prueba.txt. Intenta borrarlo con rm -prueba.txt, lee el mensaje y bórralo de dos maneras correctas.
10. Elimina curso, curso-respaldo y curso-copia, aplicando las tres comprobaciones. Al terminar, ~/practica debe contener solo fotos, informe.txt y notas.txt.