Comandos básicos de Linux — práctica explorando Fedora, montando tu carpeta de IC2 y saliendo de un laberinto de carpetas (y la estructura que creé en el sitio equivocado)

La semana de la primera entrega de IC2 quise ordenar mis prácticas. Abrí la terminal, encadené unos cuantos cd .. para «volver arriba», escribí mkdir -p IC2/Practicas/P1 y me puse a copiar archivos. Una hora después, la profesora me preguntó por qué mi carpeta compartida estaba vacía. Había creado la estructura entera dentro de Documentos/IC2, porque conté mal los niveles al subir. Desde entonces tengo una regla: antes de crear o borrar nada, pwd. Esa regla aparece en los tres programas de hoy.

Esta práctica pone en marcha todo lo que viste en la teoría de comandos básicos de Linux. Son tres programas (sesiones de terminal) de nivel medio: explorar el sistema de archivos de Fedora, montar y llenar tu carpeta de IC2, y un mini reto de rutas con siete pasos. Usan datos parecidos a los de verdad: carpetas con nombres reales de prácticas, archivos que se copian, se renombran y se borran, y errores que te vas a encontrar en el laboratorio.

Antes de empezar

Conviene tener claro:

• Qué hacen pwd, ls y cd, y los atajos .., ~ y -.
• La diferencia entre una ruta absoluta (empieza por /) y una relativa.
• Que cp y mv se comportan distinto según el destino sea una carpeta que existe o un nombre nuevo.
• Que rm no tiene papelera.

Si alguno te suena dudoso, repasa la teoría antes de seguir.

Programa 1: explorar el sistema de archivos de Fedora

Antes de crear nada conviene saber dónde estás y qué hay alrededor. Este programa recorre tu carpeta personal, mira las carpetas importantes del sistema sin tocarlas, descubre dónde viven los comandos y practica los atajos de navegación. Lo que lo complica: hay carpetas que no son lo que parecen (una es un enlace) y un atajo, cd -, que escribe algo aunque no se lo pidas.

La idea

Cuatro pasos, de lo más cercano a lo más lejano: tu casa (pwd, ls -a), las carpetas del sistema vistas desde fuera (ls -ld), los comandos como archivos (which) y, por último, moverte por ellas con los atajos. La clave está en ls -ld: la -d le pide a ls que hable de la carpeta y no de lo que tiene dentro. Así ves seis carpetas del sistema en seis líneas, en lugar de cientos de archivos.

El código

# 1. ¿Dónde empiezo? En mi carpeta personal
pwd
# los archivos ocultos son la configuración de tu usuario
ls -a
# 2. Las carpetas importantes del sistema, sin entrar en ellas (-d: la carpeta, no su contenido)
ls -ld /bin /etc /home /tmp /usr /var
# 3. Los comandos son archivos: which dice dónde vive cada uno
which ls cp mv
# 4. Atajos de navegación: ir, volver de golpe y deshacer el último cd
cd /etc
pwd
cd ~
pwd
cd -
cd ..
pwd

Salida

$ pwd
/home/sergio
$ ls -a
.
..
.bash_history
.bash_logout
.bashrc
.profile
Descargas
Documentos
Escritorio
$ ls -ld /bin /etc /home /tmp /usr /var
lrwxrwxrwx  1 root root    7 Apr 22  2024 /bin -> usr/bin
drwxr-xr-x 88 root root 4096 Oct 25 23:59 /etc
drwxr-xr-x  7 root root 4096 Oct 25 23:58 /home
drwxrwxrwt 10 root root 4096 Oct 25 23:59 /tmp
drwxr-xr-x 12 root root 4096 Sep 30 14:05 /usr
drwxr-xr-x 11 root root 4096 Sep 30 14:12 /var
$ which ls cp mv
/usr/bin/ls
/usr/bin/cp
/usr/bin/mv
$ cd /etc
$ pwd
/etc
$ cd ~
$ pwd
/home/sergio
$ cd -
/etc
$ cd ..
$ pwd
/

Vamos a comprobarla. pwd dice /home/sergio: al abrir la terminal estás en tu carpeta personal. ls -a enseña los archivos de configuración ocultos (.bashrc, .profile…) y las tres carpetas de siempre: Descargas, Documentos y Escritorio.

La línea de /bin empieza por l y acaba en -> usr/bin: no es una carpeta, es un enlace que apunta a /usr/bin. Por eso which dice que ls vive en /usr/bin/ls: es el mismo sitio con dos nombres. En Fedora pasa exactamente igual. Las demás líneas empiezan por d (carpetas) y son de root, el administrador.

En la parte de los atajos, cd - escribe /etc sin que se lo pidas: es su forma de decirte adónde ha vuelto. Y el último cd .. desde /etc te deja en /, la raíz, porque /etc cuelga directamente de ella.

Este dibujo resume qué guarda cada una de las seis carpetas que acabas de listar:

Preguntas que te puedes hacer

¿Por qué ls -ld y no ls -l? Porque ls -l /etc te listaría los cientos de archivos que hay dentro de /etc. Con -d obtienes una sola línea con la información de la carpeta misma, que es lo que queremos comparar.

¿Puedo romper algo explorando? No. ls, cd, pwd y which solo miran. Además, las carpetas del sistema son de root: aunque intentaras borrar algo de /etc, Linux te diría «Permission denied». Lo verás en Permisos.

¿Por qué /tmp tiene una t al final de los permisos (drwxrwxrwt)? Es un permiso especial que deja a todo el mundo crear archivos en /tmp pero solo borrar los suyos. Es un adelanto del tema de permisos.

¿Qué diferencia hay entre cd ~ y cd? Ninguna: los dos te llevan a tu carpeta personal. ~ es útil dentro de rutas, como cd ~/IC2.

¿Para qué sirve .bash_history? Guarda las órdenes que escribes en la terminal, y es lo que recorres con las flechas ↑ y ↓. Por eso, si te equivocas en una orden larga, no hace falta escribirla otra vez: flecha arriba, corriges y pulsas Intro. Y .bashrc es la configuración de bash: ahí se guardan los alias y los colores de tu terminal (no lo toques todavía).

¿Qué pasa si escribo cd - dos veces? Vas y vuelves entre las dos últimas carpetas. Es muy cómodo cuando trabajas con dos carpetas a la vez (por ejemplo, tu práctica y la de entregas).

Pruébalo tú

• Lista con ls -ld las carpetas /root y /boot. ¿De quién son? ¿Puedes entrar en /root con cd?
• Escribe type cd ls. ¿Qué diferencia ves entre las dos? (Pista: cd no puede ser un programa aparte, porque tiene que cambiar la carpeta de la propia bash.)

Programa 2: copiar y organizar los archivos de tus prácticas

Es la situación real de IC2: necesitas una estructura de carpetas ordenada y archivos que se crean, se copian a otra práctica, se renombran, se rellenan y se borran. Lo que lo complica: cinco órdenes distintas (mkdir, touch, cp, mv, rm) en el orden correcto, y el detalle de > frente a >>, que machaca o añade.

La idea

Primero el esqueleto, después el contenido. Una sola orden mkdir -p crea las seis carpetas de golpe. Después trabajamos dentro de P1_introduccion con rutas relativas cortas (../P2_comandos/) en lugar de absolutas largas, porque sabemos exactamente dónde estamos. Y terminamos borrando con rm -i, que pregunta antes.

El código

# 1. La estructura de IC2, de una vez (-p crea lo que falte)
mkdir -p IC2/Practicas/P1_introduccion IC2/Practicas/P2_comandos IC2/Apuntes IC2/Entregas
ls -l IC2
ls -R IC2
# 2. Archivos de prueba en la práctica 1
cd IC2/Practicas/P1_introduccion
touch hola.c ejercicio1.c ejercicio2.c
ls -l
# 3. Copiar a la práctica 2 y renombrar
cp ejercicio1.c ../P2_comandos/
ls ../P2_comandos
mv ejercicio2.c practica_final.c
ls
# 4. Contenido: > crea o machaca, >> añade al final
echo '#include <stdio.h>' > hola.c
echo 'int main(void) { return 0; }' >> hola.c
cat hola.c
ls -l hola.c
# 5. Borrar con red: rm -i pregunta y contesto y
rm -i practica_final.c
ls

Salida

$ mkdir -p IC2/Practicas/P1_introduccion IC2/Practicas/P2_comandos IC2/Apuntes IC2/Entregas
$ ls -l IC2
total 12
drwxr-xr-x 2 sergio sergio 4096 Oct 25 23:59 Apuntes
drwxr-xr-x 2 sergio sergio 4096 Oct 25 23:59 Entregas
drwxr-xr-x 4 sergio sergio 4096 Oct 25 23:59 Practicas
$ ls -R IC2
IC2:
Apuntes
Entregas
Practicas

IC2/Apuntes:

IC2/Entregas:

IC2/Practicas:
P1_introduccion
P2_comandos

IC2/Practicas/P1_introduccion:

IC2/Practicas/P2_comandos:
$ cd IC2/Practicas/P1_introduccion
$ touch hola.c ejercicio1.c ejercicio2.c
$ ls -l
total 0
-rw-r--r-- 1 sergio sergio 0 Oct 25 23:59 ejercicio1.c
-rw-r--r-- 1 sergio sergio 0 Oct 25 23:59 ejercicio2.c
-rw-r--r-- 1 sergio sergio 0 Oct 25 23:59 hola.c
$ cp ejercicio1.c ../P2_comandos/
$ ls ../P2_comandos
ejercicio1.c
$ mv ejercicio2.c practica_final.c
$ ls
ejercicio1.c
hola.c
practica_final.c
$ echo '#include <stdio.h>' > hola.c
$ echo 'int main(void) { return 0; }' >> hola.c
$ cat hola.c
#include <stdio.h>
int main(void) { return 0; }
$ ls -l hola.c
-rw-r--r-- 1 sergio sergio 48 Oct 25 23:59 hola.c
$ rm -i practica_final.c
rm: remove regular empty file 'practica_final.c'? y
$ ls
ejercicio1.c
hola.c

Comprobemos lo que importa:

• ls -l IC2 enseña tres carpetas (d al principio). Practicas tiene 4 enlaces y las otras 2: cada carpeta cuenta su propio nombre, el . de dentro y un .. por cada subcarpeta. Practicas tiene dos subcarpetas, así que 2 + 2 = 4.
• ls -R IC2 recorre el árbol entero: Apuntes y Entregas están vacías y Practicas tiene P1_introduccion y P2_comandos.
• Tras touch, los tres archivos pesan 0 bytes.
• cp deja ejercicio1.c en los dos sitios y mv cambia ejercicio2.c por practica_final.c: ya no existe con el nombre viejo.
• hola.c acaba ocupando 48 bytes. Compruébalo: #include <stdio.h> son 18 caracteres más el salto de línea (19), e int main(void) { return 0; } son 28 más el salto (29). 19 + 29 = 48.
• rm -i pregunta, contesto y y el último ls confirma que solo quedan ejercicio1.c y hola.c.

Así queda tu carpeta al terminar:

Preguntas que te puedes hacer

¿Por qué mkdir -p con cuatro rutas y no cuatro órdenes? Porque mkdir acepta varias rutas en la misma orden y -p crea lo que falte de cada una. Las cuatro órdenes separadas de la teoría hacen lo mismo; esta es la versión rápida.

¿Por qué ../P2_comandos/ lleva barra al final? No es obligatoria, pero deja claro que el destino es una carpeta. Si la carpeta no existiera, cp daría error en vez de crear un archivo llamado P2_comandos sin que te dieras cuenta.

¿Qué pasaría si usara > en la segunda línea de hola.c? Machacaría la primera: el archivo se quedaría solo con int main(void) { return 0; } y ocuparía 29 bytes. > crea o vacía el archivo; >> añade al final.

¿Por qué practica_final.c dice «regular empty file»? Porque rm -i describe lo que va a borrar: es un archivo normal (regular) y está vacío (0 bytes). Si tuviera contenido, diría solo «regular file».

¿Y si ejercicio1.c ya existiera en P2_comandos? cp lo sobrescribiría sin preguntar. En una práctica de verdad, donde la versión de P2 podría tener cambios tuyos, usa cp -i: te pregunta antes de machacar y contestas n si no estás seguro.

¿mv hace una copia y luego borra? Dentro del mismo disco, no: solo cambia el nombre en la «ficha» de la carpeta, por eso es instantáneo aunque el archivo pese mucho.

Pruébalo tú

• Añade una tercera línea a hola.c con echo '// fin' >> hola.c y predice el tamaño nuevo antes de mirarlo con ls -l.
• Copia toda la carpeta P1_introduccion dentro de Entregas (necesitarás -r) y comprueba el resultado con ls -R.

Programa 3: el mini reto de navegación

El reto final: siete operaciones en orden, partiendo de tu carpeta personal. Crear una estructura de tres niveles, colocar un archivo, copiarlo con otro nombre, bajar y subir, listar sin moverte, borrar una carpeta vacía y obtener la ruta absoluta de un archivo sin entrar en su carpeta. Cronométrate: el objetivo es hacerlo en menos de tres minutos.

La idea

Casi todo se hace sin moverse, escribiendo rutas relativas desde ~. Solo hay un viaje: bajar a nivel3 y subir con cd ../.. (dos saltos). Para la ruta absoluta usamos realpath, que convierte cualquier ruta relativa en absoluta.

El código

# 1. reto con tres subcarpetas
mkdir -p reto/nivel1 reto/nivel2 reto/nivel3
# 2. secreto.txt dentro de nivel2
touch reto/nivel2/secreto.txt
# 3. copia a nivel3 con otro nombre
cp reto/nivel2/secreto.txt reto/nivel3/copia_secreto.txt
# 4. entrar en nivel3 y subir dos niveles con una sola orden
cd reto/nivel3
cd ../..
pwd
# 5. listar nivel2 y nivel3 sin moverme
ls reto/nivel2 reto/nivel3
# 6. borrar nivel1, que está vacía
rmdir reto/nivel1
ls reto
# 7. ruta absoluta de la copia sin entrar en su carpeta
realpath reto/nivel3/copia_secreto.txt

Salida

$ mkdir -p reto/nivel1 reto/nivel2 reto/nivel3
$ touch reto/nivel2/secreto.txt
$ cp reto/nivel2/secreto.txt reto/nivel3/copia_secreto.txt
$ cd reto/nivel3
$ cd ../..
$ pwd
/home/sergio
$ ls reto/nivel2 reto/nivel3
reto/nivel2:
secreto.txt

reto/nivel3:
copia_secreto.txt
$ rmdir reto/nivel1
$ ls reto
nivel2
nivel3
$ realpath reto/nivel3/copia_secreto.txt
/home/sergio/reto/nivel3/copia_secreto.txt

Después de cd ../.., pwd dice /home/sergio: el primer .. sube de nivel3 a reto y el segundo de reto a tu carpeta personal. Dos saltos, como en el dibujo.

ls reto/nivel2 reto/nivel3 lista dos carpetas en una sola orden: cuando le das varias, ls pone el nombre de cada una antes de su contenido. rmdir reto/nivel1 funciona a la primera porque nivel1 está vacía, y ls reto confirma que solo quedan nivel2 y nivel3. Por último, realpath traduce reto/nivel3/copia_secreto.txt a su ruta completa sin que tengas que entrar en ninguna carpeta.

Preguntas que te puedes hacer

¿Por qué no cd .. dos veces? También vale, pero cd ../.. lo hace en una sola orden y el reto pide «un solo comando».

¿Por qué rmdir y no rm -r para nivel1? Porque el enunciado dice que está vacía. Si te hubieras equivocado y tuviera algo, rmdir te avisaría; rm -r lo borraría todo en silencio.

¿realpath comprueba que el archivo existe? Sí: si la ruta no existe, da error. Es una buena forma de verificar una ruta antes de usarla en otra orden.

¿Por qué ls reto no enseña secreto.txt? Porque ls solo lista un nivel: dentro de reto hay carpetas, y lo que tienen dentro no se ve hasta que entras o usas ls -R reto. Es la misma razón por la que en el programa 2 usamos ls -R para comprobar toda la estructura de IC2 de una vez.

¿Y si no tengo realpath? En Fedora viene instalado. La alternativa clásica es escribir echo $HOME/reto/nivel3/copia_secreto.txt, pero esa no comprueba nada: escribe la ruta aunque el archivo no exista.

Pruébalo tú

• Repite el reto sin cd en ningún momento: ¿qué orden cambia?
• Añade un paso 8: mueve copia_secreto.txt a nivel2 y comprueba con ls -R reto que nivel3 se ha quedado vacía. Después quítala con rmdir.

Errores típicos en esta práctica

• Crear la estructura en el sitio equivocado. Un cd .. de más y tu carpeta IC2 acaba dentro de Documentos. Solución: pwd antes de cualquier mkdir.
• Copiar una carpeta sin -r. cp avisa con «omitting directory» y no copia nada.
• Usar > en lugar de >>. > vacía el archivo antes de escribir.
• Confundir / con ./. /reto es la raíz del sistema; ./reto es «aquí».
• Escribir ic2 en minúsculas. Linux distingue mayúsculas: IC2 e ic2 son carpetas distintas.
• Borrar con rm -r sin mirar. Primero ls, después rm -i o rmdir.

Pruébalo en tu terminal

Esta sesión corta resume la idea más importante de la práctica: una ruta relativa depende de dónde estés, y realpath te la convierte en absoluta.

mkdir -p IC2/Practicas/P1
cd IC2/Practicas/P1
pwd
cd ../../..
pwd
realpath IC2/Practicas/P1

Lo que deberías ver:

$ mkdir -p IC2/Practicas/P1
$ cd IC2/Practicas/P1
$ pwd
/home/sergio/IC2/Practicas/P1
$ cd ../../..
$ pwd
/home/sergio
$ realpath IC2/Practicas/P1
/home/sergio/IC2/Practicas/P1

Qué observar:

1. mkdir -p crea tres niveles de golpe.
2. Dentro de P1, pwd enseña la ruta absoluta entera.
3. cd ../../.. son tres saltos: P1 → Practicas → IC2 → tu carpeta personal.
4. realpath IC2/Practicas/P1 da la misma ruta que pwd dentro de P1: es la prueba de que la relativa y la absoluta apuntan al mismo sitio.

Resumen

• pwd antes de crear, copiar o borrar: evita trabajar en la carpeta equivocada.
• ls -ld habla de la carpeta; ls -l de lo que tiene dentro.
• mkdir -p monta una estructura entera con una orden.
• cp duplica, mv renombra o mueve, y los dos dependen de si el destino es una carpeta que existe.
• > machaca y >> añade; el tamaño en ls -l te deja comprobarlo.
• cd ../.. sube dos niveles y realpath te da la ruta absoluta de cualquier cosa.

Checklist: ¿lo has practicado?

• ¿Has ejecutado los tres programas y comprobado las salidas?
• ¿Has intentado los «Pruébalo tú» sin mirar la teoría?
• ¿Sabes explicar por qué /bin aparece con una l en ls -ld?
• ¿Puedes predecir el tamaño de un archivo después de un echo ... >>?
• ¿Sabes cuántos .. necesitas para volver a tu carpeta desde cualquier sitio de tu estructura de IC2?
• ¿Usas rm -i o rmdir en lugar de rm -r cuando no estás seguro?

Si has respondido que sí a casi todo, estás listo para los ejercicios de comandos básicos de Linux, donde ya no te doy las órdenes hechas. ¡Nos vemos allí!

Siguiente paso: ejerciciosComandos básicos de Linux — ejercicios con rutas, comodines, una entrega de IC2 y una carpeta en caos (y el espacio que se llevó mis archivos .c)

¿Te ha servido este artículo? Así puedes apoyar SergioLearns →