Dominá cd: . .. ~ - y cd sin argumentos (con ejemplos prácticos y ejecutables)

Introducción

El comando cd (change directory) es la herramienta fundamental para moverse por el sistema de archivos en cualquier shell de estilo Unix. Aunque parezca simple, entender sus variantes (., .., ~, - y la forma sin argumentos) puede ahorrarte mucho tiempo, evitar frustraciones al explorar el árbol de directorios y hacer que tus scripts sean más robustos.

Este artículo está pensado para principiantes que recién comienzan a trabajar en la terminal, para desarrolladores que usan regularmente la línea de comandos, y para cualquier persona que quiera afianzar su dominio de la navegación en shell. A lo largo del texto, vas a aprender:

• Qué hace realmente cd . (y por qué a veces es útil).
• Cómo trepar hacia arriba en el árbol de directorios con cd ...
• El atajo hacia tu hogar con cd ~.
• El truco para volver rápidamente al directorio anterior con cd -.
• Qué ocurre cuando escribes solo cd (sin argumentos).

Todas las explicaciones vienen acompañadas de bloques de comandos ejecutables (con run:bash) para que puedas copiarlos, pegarlos y ver la salida esperada en tiempo real. Así vas a poder practicar, verificar tu entendimiento y tener un punto de referencia rápido cuando necesites repasar.

Conceptos básicos del sistema de archivos

Antes de profundizar en los detalles de cd, es útil tener clara una visión simple del sistema de archivos:

• **/` – el directorio raíz, la punta del árbol.
• /home/<usuario> – el hogar de cada usuario, donde suelen residir los proyectos personales.
• Directorios relatives – . (el directorio actual), .. (el padre) y ~ (el hogar).
• Directorios absolutos – rutas completas que comienzan con /.

Entender estos conceptos facilita el uso de los atajos cd y te ayuda a evitar errores comunes como perderte en profundos senderos sin retorno.

cd . – el directorio actual

¿Qué hace?

cd . cambia al directorio actual, es decir, no hace casi nada. Internamente, el shell resuelve . como el camino del directorio actual, así que cambiar a él es un no-op (una operación sin efecto). El directorio en el que estabas no cambia.

¿Por qué querrías usarlo?

Aunque puede parecer redundante, cd . es útil en ciertos contextos:

• Scripts donde necesitas un cambio de directorio condicional (ejemplo: si una variable indica el directorio actual, podés ejecutar cd "$dir" && cd . para garantizar una operación de cambio de directorio exitosa).
• Argumentos heredados de otros programas que siempre incluyen un . (ejemplo: cd "$parent/$sub/$dot").
• Prácticas didácticas – ayuda a entender que . es un nombre válido para un directorio.

Ejemplo

A continuación tenés un bloque de bash autocontenido que demuestra que cd . no cambia la ubicación. El bloque imprime el directorio actual antes y después de ejecutar cd ., mostrando el mismo resultado.

pwd
# Mover al directorio actual (no debería cambiar nada)
cd .
pwd

Salida esperada:

/tmp/testdir
/tmp/testdir

El comando pwd (present working directory) se ejecuta antes y después de cd ., confirmando que la ruta no ha cambiado.

cd .. – el directorio padre

¿Qué hace?

cd .. cambia al directorio padre, es decir, uno de nivel superior en el árbol de directorios. Si estás en /home/user/projects/webapp, cd .. te llevará a /home/user/projects.

Casos de uso típicos

• Explorar un árbol de proyectos – moverte hacia arriba para revisar niveles superiores.
• Backups o copias – navegar a un directorio padre antes de copiar archivos.
• Scripts de navegación – subir un nivel, listar contenido, luego volver a descender.

Ejemplo

El siguiente fragmento crea un árbol pequeño (/tmp/demo), luego demuestra cómo cd .. sube un nivel.

# Crear una estructura de directorios de prueba
rm -rf /tmp/demo
mkdir -p /tmp/demo/a/b/c
# Empezar en el nivel más profundo
cd /tmp/demo/a/b/c
pwd
# Subir un nivel
cd ..
pwd

Salida esperada:

/tmp/demo/a/b/c
/tmp/demo/a/b

Como podés ver, el pwd después de cd .. muestra el directorio padre.

cd ~ – el hogar del usuario

¿Qué hace?

cd ~ (o simplemente cd $HOME) te transporta al directorio de inicio del usuario actual, generalmente /home/<usuario> en sistemas Linux o C:\Users\<usuario> en Windows (con WSL).

Para qué sirve

• Regreso rápido – después de una larga expedición por el sistema de archivos, un simple cd ~ te devuelve a casa.
• Scripts – muchas secuencias de comandos comienzan con cd ~ para establecer un punto de partida conocido.
• Isolamento de entorno – evitar accidentalmente comandos que operan en el raíz (/) o en otras ubicaciones.

Ejemplo

El bloque demuestra cómo cd ~ te lleva al directorio personal, sea cual sea tu ubicación actual.

# Empezar desde una ubicación aleatoria (ejemplo: /tmp)
cd /tmp
pwd
cd ~
pwd

Salida esperada:

/tmp
/home/yourusername

El segundo pwd muestra el hogar del usuario, confirmando el cambio.

cd - – el directorio anterior

¿Qué hace?

cd - te lleva al directorio que estabas antes de la última operación de cd. Es un atajo práctico para alternar entre dos ubicaciones, algo muy útil cuando estás moviéndote entre un directorio de trabajo y su directorio hermano.

Funciona así:

El shell guarda el directorio previo en una variable (a menudo $OLDPWD). cd - restaura esa variable.

Ejemplo práctico

# Empezar en $HOME
cd ~
pwd
# Ir a /tmp
cd /tmp
pwd
# Volver al hogar usando -
cd -
pwd

Salida esperada:

/home/yourusername
/tmp
/home/yourusername

El último bloque demuestra el toggle entre dos directorios.

cd sin argumentos – la forma corta de cd ~

¿Qué hace?

Si invocas cd sin ningún argumento, el shell interpreta que querés ir a tu directorio personal ($HOME). Es exactamente lo mismo que escribir cd ~ o cd $HOME.

Por qué es conveniente

• Atajo rápido – cd es corto y fácil de escribir.
• Compatibilidad – algunas herramientas históricas (ejemplo: csh) lo tratan como un valor por defecto.

Ejemplo

# Ir a la ubicación actual (ejemplo: /tmp)
cd /tmp
pwd
# Ahora, solo `cd`
cd
pwd

Salida esperada:

/tmp
/home/yourusername

El segundo pwd confirma que cd sin argumentos te llevó al hogar.

Demostración interactiva – Navegando un árbol de directorios

A continuación tenés un script completo y autocontenido que crea un árbol de directorios poco profundo, luego recorre varias operaciones de cd. Copiá y pegá este bloque en una terminal para ver cómo cada comando se comporta.

# === Limpieza ===
rm -rf /tmp/navdemo
mkdir -p /tmp/navdemo/{src,tests,docs}
mkdir -p /tmp/navdemo/src/{components,services}
mkdir -p /tmp/navdemo/tests/unit

# === Navegación ===
echo "Directorio inicial:"
pwd

echo "
1. Entrar al directorio src"
cd /tmp/navdemo/src
echo "Ubicación actual:" $(pwd)

echo "
2. Entrar al subdirectorio components"
cd components
echo "Ubicación actual:" $(pwd)

echo "
3. Subir un nivel con cd .."
cd ..
echo "Ubicación actual:" $(pwd)

echo "
4. Ir al hogar con cd ~"
cd ~
echo "Ubicación actual:" $(pwd)

echo "
5. Ir al directorio anterior con cd -"
cd /tmp/navdemo/tests/unit
echo "Antes de cd -:" $(pwd)
cd -
echo "Después de cd -:" $(pwd)

echo "
6. Usar cd . (no-op)"
cd .
echo "Ubicación actual:" $(pwd)

echo "
7. cd sin argumentos (hogar)"
cd
echo "Ubicación actual:" $(pwd)

# === Limpieza (opcional) ===
# rm -rf /tmp/navdemo

Salida esperada (con tu nombre de usuario en lugar de yourusername):

Directorio inicial:
/tmp

1. Entrar al directorio src
Ubicación actual: /tmp/navdemo/src

2. Entrar al subdirectorio components
Ubicación actual: /tmp/navdemo/src/components

3. Subir un nivel con cd ..
Ubicación actual: /tmp/navdemo/src

4. Ir al hogar con cd ~
Ubicación actual: /home/yourusername

5. Ir al directorio anterior con cd -
Antes de cd -: /tmp/navdemo/tests/unit
Después de cd -: /tmp/navdemo/src

6. Usar cd . (no-op)
Ubicación actual: /tmp/navdemo/src

7. cd sin argumentos (hogar)
Ubicación actual: /home/yourusername

Este script muestra la funcionalidad práctica de cada forma de cd, ayudándote a visualizar los cambios en tiempo real.

Buenas prácticas y errores comunes

• Preferí los directorios absolutos cuando la claridad es importante – cd /home/user/project es más fácil de entender que cd ../../project.
• Usa cd - para alternar entre dos ubicaciones – es un ahorro de tiempo versus escribir una ruta completa.
• Evita anidar cd . innecesariamente – solo incluílo en scripts donde necesites una operación de cambio de directorio que siempre se ejecute.
• Ten en cuenta la variable OLDPWD – puedes consultarla con echo $OLDPWD si necesitas registrar dónde estabas.
• Cuando escribas scripts, tené cuidado con el entorno – si ejecutas set -e y un cd falla (ejemplo: intentar ir a un directorio que no existe), el script se detendrá. Considerá cd "$dir" || { echo "No puedo entrar en $dir"; exit 1; }.
• Usa cd sin argumentos para saltar al hogar rápidamente – es un atajo útil cuando terminás de trabajar en otra parte.
• Evita cd .. repetido para subir mucho – en su lugar, usá cd /ruta/absoluta para ir directo al destino.
• Verifica los directorios de trabajo después de cd en scripts – una forma rápida de hacerlo es [[ "$PWD" == "$TARGET" ]] && echo "Ya estás allí".

Resumen

Revisamos a fondo las variantes de cd que son esenciales para navegar eficientemente en cualquier shell de estilo Unix:

1. cd . – no-op, útil en scripts y para reforzar el concepto de “directorio actual”.
2. cd .. – sube un nivel hacia el directorio padre; ideal para explorar jerarquías.
3. cd ~ – regresa rápidamente al hogar del usuario ($HOME).
4. cd - – alterna hacia el directorio previamente visitado, perfecto para moverse entre dos ubicaciones.
5. cd (sin argumentos) – lo mismo que cd ~, un atajo conveniente.

Dominar estas formas te hará más rápido al moverte por el sistema de archivos, facilitará la escritura de scripts más robustos y reducirá los errores típicos como perderse en directorios profundos o necesitar volver manualmente a casa.

Practicá con el script interactivo provisto; ver la salida en vivo ayudará a afianzar los conceptos. Una vez que domines estos atajos, podrás concentrarte en lo que realmente importa: escribir código, automatizar tareas y resolver problemas, no en cómo navegar por el sistema de archivos.

¡Feliz navegación, y recordá que un cambio de directorio adecuado puede ser la diferencia entre una sesión productiva y una llena de frustraciones!