# Comandos útiles de Linux para el día a día **Categoría:** Linux y sistemas · **Nivel:** Inicial · **Lectura:** 11 min **Publicada:** 2026-07-28 · **Actualizada:** 2026-07-28 · **Autoría:** Underc0de **Versión HTML (canónica):** https://underc0de.org/guias/linux/comandos-utiles-de-linux/ ## Respuesta rápida Los comandos de Linux se agrupan por lo que querés hacer. Para **moverte**: `pwd` (dónde estás), `ls` (qué hay), `cd` (ir a otro lado). Para **archivos**: `cat` y `less` (ver), `cp`, `mv`, `rm` (copiar, mover, borrar), `mkdir` (crear carpetas). Para **procesos y recursos**: `ps`, `top`, `df`, `free`, `kill`. Para **permisos**: `chmod` y `chown`, y `sudo` para tareas de administración. Y lo que multiplica todo lo anterior: la **tubería** `|`, que conecta la salida de un comando con la entrada del siguiente, y `grep`, que filtra texto. No hace falta memorizarlos: con `man` y `--help` el sistema documenta cada uno. Lo que sí hay que entender son los **patrones** que los combinan. ## Por qué la terminal Se puede usar Linux sin tocar la terminal, pero es donde el sistema rinde de verdad, y por tres motivos concretos: es **precisa** (decís exactamente qué querés), es **repetible** (un comando que funcionó hoy funciona mañana igual) y es **combinable** (la salida de uno alimenta a otro). Esas tres propiedades son las que hacen posible automatizar. > **La idea que quita el miedo** > > No hay cientos de comandos para memorizar. Hay **media docena de patrones** —moverse, mirar, filtrar, encadenar, gestionar, pedir ayuda— y cada comando concreto es una instancia de uno de ellos. Entendido el patrón, el comando exacto lo dice el propio sistema con `man`. Aprender la terminal es aprender a preguntarle, no a recordarla. ## Moverse por el sistema El sistema de archivos de Linux es un árbol que empieza en la raíz, `/`. Para moverse por él, tres comandos: ```bash # ¿Dónde estoy? Imprime la ruta actual. pwd # ¿Qué hay acá? Listar. -l da detalle, -a incluye lo oculto, -h tamaños legibles. ls ls -lah # Ir a otra carpeta. Rutas útiles: cd /etc # ruta absoluta, desde la raíz cd Documentos # ruta relativa, desde donde estás cd ~ # tu carpeta personal cd .. # subir un nivel cd - # volver a la carpeta anterior ``` Dos atajos que ahorran horas: la tecla de **tabulación** autocompleta nombres de archivo y de comando (empezá a escribir y pulsala), y las **flechas arriba y abajo** recorren los comandos que ya usaste. Casi nadie escribe una ruta larga entera: la autocompleta. ## Ver y editar archivos ```bash # Ver el contenido. cat lo vuelca entero; less lo pagina (q para salir). cat archivo.txt less archivo-largo.log # Ver solo el principio o el final. -n define cuántas líneas. head -n 20 archivo.txt tail -n 20 archivo.txt tail -f registro.log # -f sigue el archivo en vivo: ideal para registros # Crear, copiar, mover, borrar. mkdir proyecto # crear carpeta touch notas.txt # crear archivo vacío cp origen.txt destino.txt # copiar mv viejo.txt nuevo.txt # mover o renombrar rm archivo.txt # borrar ``` > **Atención** > > `rm` borra de inmediato y sin confirmación, y `rm -r` borra carpetas enteras con todo lo que contienen. No hay «deshacer». Antes de un `rm` con comodines —como `rm *.txt`— conviene ejecutar el mismo patrón con `ls` para ver *exactamente* qué va a desaparecer. Es la costumbre que más disgustos evita. Para editar en la terminal, el editor más accesible para empezar es **nano**: se abre con `nano archivo`, se escribe normal, y las combinaciones útiles aparecen al pie (guardar y salir es Ctrl+O y Ctrl+X). ## Procesos y recursos Cuando algo va lento o un programa se colgó, estos comandos dicen qué pasa: ```bash # Qué procesos corren. top se actualiza en vivo (q para salir). top ps aux # foto de todos los procesos # Cuánto disco y cuánta memoria hay. -h da tamaños legibles. df -h # espacio por sistema de archivos free -h # memoria usada y libre du -sh carpeta/ # cuánto ocupa una carpeta # Terminar un proceso que no responde, por su número (PID). kill 4521 # pedirle que termine kill -9 4521 # forzar, solo si lo anterior no alcanzó ``` El patrón habitual: `top` muestra qué consume recursos y su número de proceso; si algo está colgado, `kill` con ese número lo termina. La opción `-9` es el último recurso, porque no le da al programa la oportunidad de cerrar bien. ## Permisos y sudo Cada archivo tiene permisos para tres grupos —su **propietario**, su **grupo** y el **resto**— y tres acciones: **leer** (r), **escribir** (w) y **ejecutar** (x). El listado detallado los muestra como una cadena de letras: ```bash # En "ls -l", la primera columna son los permisos: # -rwxr-xr-- → propietario: rwx · grupo: r-x · resto: r-- chmod +x script.sh # dar permiso de ejecución chmod 644 archivo.txt # lectura/escritura al dueño, lectura al resto chown ana:equipo archivo # cambiar propietario y grupo (requiere sudo) ``` Y **`sudo`**: la mayoría de las tareas se hacen con tu usuario normal, pero las que tocan el sistema entero —instalar programas, editar configuración del sistema, crear usuarios— requieren privilegios de administración. `sudo` los concede por el tiempo de ese único comando, pidiendo tu contraseña. > **Atención** > > La separación entre usuario común y administración es una de las razones por las que Linux es difícil de romper por accidente: un error con tu usuario afecta a tus archivos, no al sistema. Poner `sudo` delante de cada comando tira abajo esa protección. La regla es usarlo solo cuando un comando lo pida, y desconfiar de instrucciones de internet que lo usan sin explicar por qué. ## Tuberías: el patrón que lo cambia todo Acá está lo que hace poderosa a la terminal. Cada comando de Linux hace *una* cosa, y la **tubería** `|` conecta la salida de uno con la entrada del siguiente. Combinando piezas pequeñas se resuelven tareas que ningún comando resuelve solo. ```bash # grep filtra líneas que contienen un texto. # Buscar "error" en un registro: cat registro.log | grep error # Encadenar más: errores, y de esos contar cuántos hay. cat registro.log | grep error | wc -l # Qué procesos de un programa están corriendo. ps aux | grep nginx # Los diez archivos más grandes de una carpeta. du -ah . | sort -rh | head -n 10 ``` El patrón mental es de fábrica: cada `|` es una estación que transforma lo que llega y lo pasa a la siguiente. `grep` filtra, `sort` ordena, `wc -l` cuenta líneas, `head` se queda con las primeras. Aprender estas cuatro y la tubería resuelve una cantidad enorme de tareas cotidianas. ## Pedir ayuda desde la propia terminal No hay que memorizar las opciones de cada comando: el sistema las documenta. Dos formas de preguntar: ```bash # La página de manual completa (q para salir, / para buscar dentro). man ls # El resumen rápido de opciones, más corto. ls --help # ¿Qué hace este comando, en una línea? whatis grep ``` La costumbre de abrir `man` ante la duda, en vez de buscar en internet, tiene una ventaja: la página de manual describe *tu* versión exacta del comando, no una cualquiera. Es la fuente más confiable que existe, y viene instalada. > Estos comandos son la base de todo lo que sigue en la categoría. En [administración de servidores](../administracion-de-servidores-linux-desde-cero/index.md) se usan sin entorno gráfico, y en [diagnóstico con systemd y journalctl](../diagnostico-con-systemd-journalctl-y-strace/index.md) se combinan con herramientas para averiguar por qué algo falla. ## Errores frecuentes - **Usar `rm` con comodines sin mirar antes.** No hay papelera. Ejecutá el patrón con `ls` primero para ver qué se va a borrar. - **Poner `sudo` delante de todo.** Anula la protección que separa tu usuario del sistema. Solo cuando el comando lo pida. - **Escribir rutas largas a mano.** La tecla de tabulación las autocompleta y evita errores de tipeo. - **Copiar comandos de internet sin entenderlos.** Sobre todo si llevan `sudo`: leé qué hacen antes de ejecutarlos. - **Confundir `-9` con la forma normal de `kill`.** Forzar no da al programa la chance de cerrar bien; es el último recurso. - **Buscar en internet lo que responde `man`.** La página de manual describe tu versión exacta y viene instalada. - **Frustrarse por no memorizar.** Nadie memoriza: se entienden los patrones y se consulta el resto. ## Preguntas frecuentes **¿Hay que aprender la terminal para usar Linux?** Para usar el escritorio en tareas cotidianas, no: navegar, ver videos, escribir documentos o gestionar archivos se hace con el entorno gráfico como en cualquier otro sistema. La terminal se vuelve necesaria cuando querés aprovechar de verdad lo que Linux ofrece: instalar y actualizar software de forma precisa, automatizar tareas repetitivas, administrar un servidor que no tiene entorno gráfico, o diagnosticar un problema. No es un requisito para empezar, pero sí es la habilidad que más multiplica lo que podés hacer, y por eso conviene ir perdiéndole el miedo desde temprano, aunque sea de a poco. **¿Qué diferencia hay entre una ruta absoluta y una relativa?** Una ruta absoluta empieza en la raíz del sistema, con una barra, y describe la ubicación completa sin ambigüedad: siempre apunta al mismo lugar, sin importar desde dónde la escribas. Una ruta relativa parte de la carpeta en la que estás en ese momento, así que su significado depende de dónde te encuentres. Por ejemplo, escribir el nombre de una subcarpeta a secas es relativo a tu ubicación actual, mientras que la misma carpeta escrita desde la raíz es absoluta. Los atajos habituales son útiles acá: la virgulilla apunta a tu carpeta personal, dos puntos suben un nivel y un guion vuelve a la carpeta anterior. **¿Qué hago si borré algo con rm por error?** La respuesta incómoda es que `rm` no manda a una papelera: borra de inmediato, y recuperar un archivo eliminado así es difícil y no siempre posible. Por eso la prevención es todo. La costumbre más útil es, antes de un borrado con comodines, ejecutar el mismo patrón con `ls` para ver exactamente qué archivos coinciden, y recién entonces cambiar `ls` por `rm`. Para tareas delicadas, algunas personas configuran `rm` para que pida confirmación, o usan una herramienta que sí mueve a la papelera. Y la defensa de fondo sigue siendo tener respaldos de lo que no querés perder. **¿Para qué sirve la tubería?** La tubería, el símbolo de barra vertical, conecta la salida de un comando con la entrada del siguiente, y es lo que da a la terminal su verdadero poder. La filosofía de Linux es que cada comando haga una sola cosa y la haga bien; la tubería permite combinar esas piezas pequeñas para resolver tareas complejas que ningún comando resuelve solo. Por ejemplo, un comando lista procesos, la tubería pasa esa lista a otro que filtra por un nombre, y una tubería más la pasa a uno que cuenta las líneas. Aprender un puñado de comandos que filtran, ordenan y cuentan, y encadenarlos con tuberías, resuelve una cantidad enorme de tareas cotidianas. **¿Cuándo tengo que usar sudo?** Solo cuando una tarea afecta al sistema entero y no únicamente a tus archivos: instalar o quitar programas, editar la configuración del sistema, crear o modificar usuarios, o iniciar y detener servicios. En esos casos el propio comando falla con un mensaje de permiso denegado, y ahí es cuando se antepone `sudo`, que concede privilegios de administración por el tiempo de ese único comando tras pedir tu contraseña. Lo que conviene evitar es usarlo por costumbre delante de todo, porque anula la separación entre tu usuario y el sistema, que es justamente una de las cosas que hacen a Linux difícil de dañar por accidente. **¿Cómo sé qué hace un comando que no conozco?** El sistema trae su propia documentación, así que no hace falta salir a buscar. El comando `man` seguido del nombre abre la página de manual completa, con todas las opciones y ejemplos; dentro se busca con la barra y se sale con la tecla q. Para algo más breve, la mayoría de los comandos aceptan la opción de ayuda, que imprime un resumen de sus opciones. Y hay una utilidad que describe en una línea qué hace un comando. La ventaja de consultar el manual local en lugar de internet es que describe exactamente tu versión instalada, que es la fuente más confiable posible y siempre está a mano. ## Fuentes Documentación oficial y material de la comunidad consultados para esta guía. Fecha de consulta: 28 de julio de 2026. ### Aportes de la comunidad Underc0de 1. **Underc0de, foro.** [Sección GNU/Linux](https://underc0de.org/foro/gnu-linux/). Consultas de la comunidad sobre uso de la terminal y resolución de tareas cotidianas. 2. **Underc0de, foro.** [Sección Scripting](https://underc0de.org/foro/scripting/). Automatización con Bash y encadenado de comandos. ### Documentación oficial 1. **GNU.** [Coreutils Manual](https://www.gnu.org/software/coreutils/manual/coreutils.html). La documentación oficial de las utilidades básicas del sistema, como `ls`, `cp` o `cat`. 2. **GNU.** [Bash Manual](https://www.gnu.org/software/bash/manual/bash.html). El manual del intérprete de comandos más usado, con las tuberías y la redirección. 3. **The Linux man-pages project.** [man-pages](https://www.kernel.org/doc/man-pages/). Las páginas de manual que documentan cada comando en el propio sistema. 4. **GNU.** [grep Manual](https://www.gnu.org/software/grep/manual/grep.html). La herramienta de búsqueda de texto que aparece en casi toda tubería. ## Guías relacionadas - [Instalar Ubuntu paso a paso](../instalar-ubuntu-paso-a-paso/index.md) - [Administrar servidores Linux](../administracion-de-servidores-linux-desde-cero/index.md) - [Diagnóstico con systemd y journalctl](../diagnostico-con-systemd-journalctl-y-strace/index.md) - [Actualizar el sistema](../actualizar-el-sistema-operativo-linux/index.md) - [Índice de Linux y sistemas](../index.md)