La terminal desde cero: Bash para principiantes

Pensado para quien nunca abrió una terminal: desde tu primer comando hasta manejar archivos, encadenar comandos, buscar en miles de líneas y escribir tus propios scripts. Los mismos comandos en Linux, macOS y Windows (Git Bash o WSL), paso a paso, con diagramas y ejercicios en cada capítulo.

24 capítulos Linux · macOS · Windows Modo claro / oscuro Optimizado para móvil Bash 5.3
24
Capítulos
48
Ejercicios con solución
6
Partes del curso
0
Requisitos previos
Cómo usar este tutorial: sigue los capítulos en orden (el índice está en el menú si lees desde el móvil). Cada capítulo tiene teoría en lenguaje sencillo, sesiones de terminal reales (todas las salidas que verás las produjo Bash 5.3 de verdad), diagramas, ejercicios con solución y puntos clave. Escribe cada comando en TU terminal: la terminal se aprende con los dedos, no solo leyendo.

1 · Qué es la terminal y por qué aprenderla

Básico ~12 min

Hasta hoy usaste tu computadora con el ratón: abres carpetas, arrastras archivos, haces clic en botones. La terminal es la otra forma de usarla: en lugar de hacer clic, escribes órdenes. Parece cosa del pasado, pero es la herramienta diaria de quienes programan, administran servidores o analizan datos. Este curso te lleva desde cero hasta escribir tus propios programas de terminal.

En este capítulo aprenderás a:

  • entender qué son la terminal, el shell y el prompt;
  • saber por qué la terminal sigue siendo imprescindible para programar;
  • ejecutar tus primeros comandos;
  • conocer el proyecto con el que practicarás todo el curso.

Terminal, shell y prompt

Tres palabras que se confunden mucho:

PalabraQué esEjemplos
TerminalLa ventana donde escribes y lees texto.Terminal de Ubuntu o de macOS, Windows Terminal
ShellEl programa que interpreta lo que escribes y lo ejecuta.Bash, zsh, PowerShell
PromptEl texto que el shell muestra cuando espera una orden; suele terminar en $.ana@laptop:~$
Quién hace qué cuando escribes un comando Tú escribes teclado Terminal la ventana texto Shell Bash interpreta órdenes Sistema Linux, macOS…
Fig. 1.1 · La terminal es la ventana; el shell (en este curso, Bash) es el programa que entiende lo que escribes y se lo pide al sistema operativo.

En este curso usarás Bash (Bourne-Again SHell), el shell del proyecto GNU. Es el que viene en casi todas las distribuciones de Linux, el que trae Git Bash en Windows y el que usan los servidores de internet. En macOS el shell por defecto es zsh, casi idéntico para lo que verás aquí (el capítulo 2 te explica las diferencias).

Tus primeros comandos

Un comando es una orden escrita. Escribes, presionas Enter y el shell responde. Así se ve en este manual: el bloque oscuro es lo que escribes y el bloque que le sigue, lo que responde la terminal:

echo "Hola, terminal"
Hola, terminal
date
Wed Jul 15 09:00:00 -05 2026
whoami
ana

echo repite lo que le das, date muestra la fecha y la hora, y whoami («¿quién soy?») tu nombre de usuario. En el manual el usuario se llama ana; en tu pantalla verás el tuyo, y la fecha será la de hoy.

Todas las respuestas son reales. Cada salida de este manual se obtuvo ejecutando el comando en Bash 5.3. Los textos de la terminal están en inglés porque así responden los programas; si tu sistema está en español, algunos mensajes te saldrán traducidos.

¿Por qué aprender la terminal?

Ana atiende la web de su cafetería, Aroma y Punto. El fotógrafo le pide una carpeta con un archivo vacío por cada plato para ir reemplazándolos. Con el ratón serían varios clics por archivo. En la terminal:

mkdir fotos
touch fotos/plato{1..5}.jpg
ls fotos
plato1.jpg plato2.jpg plato3.jpg plato4.jpg plato5.jpg

No te preocupes si aún no entiendes cada símbolo: al final de la parte II sabrás hacer exactamente esto, y con 500 archivos tardarías lo mismo. Esa es la idea: lo que repites a mano, la terminal lo hace por ti.

Con el ratónCon la terminal
Fácil de empezarRequiere aprender unos comandos
Repetir 100 veces es repetir 100 vecesRepetir 100 veces es un solo comando
Cada programa tiene sus menúsTodos los programas se combinan entre sí
No sirve en un servidor sin pantallaFunciona igual en tu laptop y en un servidor al otro lado del mundo
Difícil de documentar («clic aquí, luego allá»)Los pasos son texto: se copian, se guardan y se automatizan

Además, muchas herramientas de programación solo existen en la terminal: Git, los gestores de paquetes de Python y JavaScript, los servidores de desarrollo, las bases de datos… Todo lo que aprendas aquí lo usarás en los demás cursos.

No vas a romper tu computadora. Casi todos los comandos que verás solo leen o crean cosas. Los dos que pueden hacer daño (rm, que borra, y sudo, que da permisos de administrador) tienen su propio capítulo y llegan cuando ya sepas lo necesario para usarlos con seguridad.

Cómo está organizado el curso

ParteAprenderás a…
I · Primeros pasosabrir la terminal, entender un comando y moverte entre carpetas.
II · Archivos y carpetascrear, copiar, mover, borrar y leer archivos; trabajar con muchos a la vez.
III · Texto y tuberíasguardar resultados, encadenar comandos, buscar y resumir información.
IV · Tu sistema por dentropermisos, instalación de programas, procesos y configuración de tu terminal.
V · Scripts de Bashescribir tus propios programas que automatizan tareas.
VI · Graduaciónusar la terminal en red y dar el salto a Git y GitHub.
Regla de oro: lee siempre lo que responde la terminal. Si no dice nada, todo salió bien; si dice algo, casi siempre te está explicando exactamente qué pasó y qué hacer.

Practica

BásicoEjecuta tus tres primeros comandos: muestra una frase de saludo, la fecha y hora actuales y tu nombre de usuario.

Ver solución 1
echo "Hola, estoy aprendiendo la terminal"
date
whoami
Hola, estoy aprendiendo la terminal Wed Jul 15 09:00:00 -05 2026 ana

En tu pantalla, la fecha será la de hoy y el usuario, el tuyo.

RetoRepite la demostración del capítulo con postres: crea la carpeta postres con tres archivos vacíos (torta1.jpg a torta3.jpg) en un solo comando y lista la carpeta.

Ver solución 2
mkdir postres
touch postres/torta{1..3}.jpg
ls postres
torta1.jpg torta2.jpg torta3.jpg

{1..3} se convierte en 1, 2 y 3. Lo entenderás a fondo en el capítulo 9.

Puntos clave

  • La terminal es la ventana; el shell (Bash) interpreta los comandos; el prompt indica que espera una orden.
  • Un comando se escribe y se ejecuta con Enter.
  • La terminal permite repetir, combinar y automatizar tareas que con el ratón serían lentas.
  • Git, los servidores y casi todas las herramientas de programación se manejan desde la terminal.

2 · Abrir tu terminal en Windows, Linux y macOS

Básico ~15 min

Toda computadora trae una terminal, aunque esté escondida. En este capítulo la encontrarás en tu sistema, la prepararás para usar Bash y comprobarás que todo funciona. Ve directo a la sección de tu sistema operativo.

En este capítulo aprenderás a:

  • abrir la terminal en Linux, macOS o Windows;
  • elegir entre Git Bash y WSL si usas Windows;
  • comprobar qué shell y qué versión de Bash tienes;
  • reconocer las partes del prompt.

Linux (Ubuntu y similares)

Es el caso más sencillo: Bash ya es el shell por defecto. Abre la terminal con Ctrl + Alt + T, o busca «Terminal» en el menú de aplicaciones.

macOS

Abre Terminal desde Aplicaciones → Utilidades, o con Cmd + Espacio escribiendo «Terminal». Desde macOS 10.15 (Catalina) el shell por defecto es zsh, no Bash. Para este curso tienes dos opciones:

  • Quedarte en zsh (recomendado): los comandos de las partes I a IV funcionan igual. Cuando algo cambie, el manual te lo avisará.
  • Abrir Bash cuando lo necesites: escribe bash y presiona Enter; para volver a zsh, exit. macOS trae una versión antigua de Bash; si quieres la actual, instálala con Homebrew (brew install bash).

Windows: dos caminos

Windows trae sus propios shells (PowerShell y el Símbolo del sistema), que usan comandos distintos (dir en lugar de ls, por ejemplo). Para aprender Bash tienes dos opciones:

Git BashWSL (Subsistema de Windows para Linux)
Qué esBash y las herramientas básicas de Linux, empaquetados con GitUn Linux completo (Ubuntu) dentro de Windows
InstalaciónViene con Git for Windowswsl --install y reiniciar
Tus archivos de WindowsEn /c/Users/tu-usuarioEn /mnt/c/Users/tu-usuario
Ideal paraEmpezar ya y trabajar con GitProgramar como en un servidor Linux

Git Bash: si seguiste el curso de Git ya lo tienes. Si no, descarga Git desde git-scm.com, instálalo con las opciones por defecto y busca «Git Bash» en el menú Inicio.

WSL: necesitas Windows 10 versión 2004 (compilación 19041) o superior, o Windows 11. Abre PowerShell como administrador (clic derecho → «Ejecutar como administrador») y escribe:

wsl --install

Reinicia la computadora. Al volver, se abrirá Ubuntu (la distribución que instala por defecto) y te pedirá crear un usuario y una contraseña de Linux: anótalos, la contraseña la necesitarás en el capítulo 16. Desde entonces, busca «Ubuntu» en el menú Inicio. Si quieres otra distribución, wsl --list --online muestra las disponibles.

Mejor aún: Windows Terminal. Es la aplicación de terminal moderna de Windows (viene en Windows 11). Abre en pestañas PowerShell, Ubuntu de WSL y, si lo configuras, Git Bash.

Comprueba tu Bash

Abre tu terminal y escribe:

bash --version
GNU bash, version 5.3.20(1)-release (x86_64-pc-linux-gnu) Copyright (C) 2025 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> This is free software; you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.

La primera línea es la importante: 5.3 es la versión vigente de Bash. Si te sale 5.2, 5.1 o incluso 4.4, no pasa nada: todo lo del curso funciona igual. ¿Y si no estás seguro de qué shell estás usando?

echo $0
bash
echo $BASH_VERSION
5.3.20(1)-release

Si echo $0 responde bash (o -bash), estás en Bash. En macOS verás -zsh: es zsh.

Lee tu prompt

El prompt de la mayoría de los sistemas tiene esta forma:

ana@laptop:~/proyectos$
ParteSignifica
anaTu usuario
laptopEl nombre de la computadora (en un servidor, el del servidor)
~/proyectosLa carpeta donde estás (~ es tu carpeta personal; capítulo 4)
$Eres un usuario normal. Si ves #, eres administrador: ten cuidado

En este manual no se muestra el prompt dentro de los bloques: así puedes copiar los comandos con el botón de la esquina y pegarlos directamente.

Copiar y pegar en la terminal. En Linux y Git Bash, Ctrl + C NO copia: cancela el comando en curso. Para copiar usa Ctrl + Shift + C y para pegar Ctrl + Shift + V (en Git Bash también Shift + Insert). En macOS, Cmd + C y Cmd + V.
Regla de oro: nunca pegues en tu terminal un comando que no entiendes, aunque venga de internet. Lee cada parte: al terminar la parte I sabrás cómo hacerlo.

Practica

BásicoComprueba qué shell estás usando y qué versión de Bash tienes.

Ver solución 1
echo $0
echo $BASH_VERSION
bash 5.3.20(1)-release

Si ves bash, estás en Bash. En macOS con zsh, echo $0 muestra -zsh y la versión sale vacía.

RetoMuestra en una sola línea el shell y su versión, con el formato Shell: bash · versión ….

Ver solución 2
echo "Shell: $0 · versión $BASH_VERSION"
Shell: bash · versión 5.3.20(1)-release

Dentro de comillas dobles, Bash reemplaza $0 y $BASH_VERSION por sus valores. Son variables: las estudiarás en el capítulo 18.

Puntos clave

  • Linux: Ctrl + Alt + T. macOS: app Terminal (zsh por defecto). Windows: Git Bash o WSL.
  • WSL se instala con wsl --install en PowerShell como administrador e instala Ubuntu.
  • bash --version muestra tu versión y echo $0 qué shell usas.
  • El prompt muestra usuario, computadora y carpeta actual; $ = usuario normal, # = administrador.

3 · Anatomía de un comando: opciones, argumentos y ayuda

Básico ~16 min

Todos los comandos, desde el más simple hasta el más avanzado, siguen la misma estructura. Si la entiendes, podrás leer cualquier comando que encuentres en un tutorial y saber qué hace antes de ejecutarlo. Y cuando no lo sepas, la propia terminal te lo explica.

En este capítulo aprenderás a:

  • distinguir comando, opciones y argumentos;
  • combinar opciones cortas y usar opciones largas;
  • escribir nombres con espacios usando comillas;
  • pedir ayuda a la terminal y entender sus mensajes de error.
Las piezas de un comando $ ls comando -l opción -a opción proyectos argumento
Fig. 3.1 · Primero el comando (qué hacer), luego las opciones (cómo hacerlo, empiezan con guion) y al final los argumentos (sobre qué). Todo separado por espacios.

Comandos y argumentos

La primera palabra es siempre el comando. Lo que va después, separado por espacios, son sus argumentos: aquello sobre lo que trabaja.

echo hola
hola
echo hola mundo
hola mundo

En el segundo caso, echo recibió dos argumentos (hola y mundo) y los mostró separados por un espacio.

Opciones: cambiar el comportamiento

Las opciones modifican lo que hace el comando. Empiezan con guion. Mira cómo cambia ls (que lista una carpeta) dentro del proyecto de Ana:

ls
css img index.html menu.html
ls -F
css/ img/ index.html menu.html
ls -l
total 16 drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 css drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 img -rw-r--r-- 1 ana ana 215 Jul 15 08:59 index.html -rw-r--r-- 1 ana ana 104 Jul 15 08:59 menu.html

-F (classify) agrega una / a las carpetas para distinguirlas de los archivos; -l (long) muestra una línea con detalles por cada elemento (los descifrarás en el capítulo 15).

Las opciones cortas se pueden escribir por separado o juntas, y muchas tienen además una versión larga, con dos guiones, que se lee mejor:

ls -l -F
total 16 drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 css/ drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 img/ -rw-r--r-- 1 ana ana 215 Jul 15 08:59 index.html -rw-r--r-- 1 ana ana 104 Jul 15 08:59 menu.html
ls -lF
total 16 drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 css/ drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 img/ -rw-r--r-- 1 ana ana 215 Jul 15 08:59 index.html -rw-r--r-- 1 ana ana 104 Jul 15 08:59 menu.html
ls --classify
css/ img/ index.html menu.html

Opciones que necesitan un valor

Algunas opciones van acompañadas de un dato. head muestra el comienzo de un archivo, y -n 3 le dice cuántas líneas:

head -n 3 menu.html
<h1>Menú</h1> <ul> <li>Espresso S/ 7</li>

Los espacios importan

Como el espacio separa argumentos, un nombre con espacios se convierte en varios argumentos. Ana quiere una carpeta llamada «mis fotos»:

mkdir mis fotos
ls
fotos mis
mkdir "mis fotos"
ls
fotos mis 'mis fotos'

El primer mkdir recibió dos argumentos y creó dos carpetas: mis y fotos. Con comillas, el nombre completo es un solo argumento. Fíjate que ls también muestra entre comillas los nombres con espacios, para que no te confundas. Las comillas sirven también para conservar los espacios tal cual:

echo Aroma     y     Punto
Aroma y Punto
echo "Aroma     y     Punto"
Aroma y Punto
Consejo de quien programa: evita los espacios, tildes y eñes en los nombres de archivos y carpetas de tus proyectos. Usa guiones o guiones bajos: mis-fotos, carta_postres.html. Te ahorrarás comillas y errores en servidores y en la web.

Cuando algo sale mal

La terminal distingue mayúsculas de minúsculas y te avisa cuando no entiende algo. Aprende a leer estos tres mensajes, los verás a menudo:

LS
bash: LS: command not found
ls -z
ls: invalid option -- 'z' Try 'ls --help' for more information.
ls carpeta-que-no-existe
ls: cannot access 'carpeta-que-no-existe': No such file or directory
MensajeSignificaQué hacer
command not foundNo existe un comando con ese nombreRevisa la ortografía y las mayúsculas, o instala el programa
invalid optionEl comando no tiene esa opciónConsulta la ayuda, como sugiere el propio mensaje
No such file or directoryEl archivo o la carpeta no existe ahíRevisa el nombre y en qué carpeta estás

Pedir ayuda

Tienes tres formas de consultar cómo se usa un comando:

FormaPara quéEjemplo
comando --helpResumen de opciones de casi cualquier programals --help
man comandoEl manual completo (no está en Git Bash)man ls
help comandoAyuda de las órdenes propias de Bashhelp cd
help pwd
pwd: pwd [-LP] Print the name of the current working directory. Options: -L print the value of $PWD if it names the current working directory -P print the physical directory, without any symbolic links By default, `pwd' behaves as if `-L' were specified. Exit Status: Returns 0 unless an invalid option is given or the current directory cannot be read.

man abre el manual en un visor de pantalla completa: muévete con las flechas, busca con / seguido de una palabra y sal con q.

man ls

¿Cómo saber si un comando es una orden propia de Bash o un programa aparte? Con type:

type cd
cd is a shell builtin
type ls
ls is /usr/bin/ls
type type
type is a shell builtin

cd está dentro de Bash (builtin); ls es un programa guardado en /usr/bin/ls. En tu Ubuntu quizá veas «ls is aliased to `ls --color=auto'»: un alias que le da colores (capítulo 19).

Regla de oro: antes de ejecutar un comando que encontraste en internet, identifica sus piezas: comando, opciones y argumentos. Si alguna no la conoces, búscala con --help o man.

Practica

BásicoDentro del proyecto de Ana, crea una sola carpeta llamada carta de postres y lista el contenido distinguiendo carpetas de archivos.

Ver solución 1
mkdir "carta de postres"
ls -F
'carta de postres'/ css/ img/ index.html menu.html

Sin comillas habrías creado tres carpetas: carta, de y postres.

RetoAverigua cuáles de estos comandos son órdenes propias de Bash y cuáles programas aparte: pwd, echo y head. Luego muestra las dos primeras líneas de index.html.

Ver solución 2
type pwd echo head
head -n 2 index.html
pwd is a shell builtin echo is a shell builtin head is /usr/bin/head <!DOCTYPE html> <html lang="es">

type acepta varios argumentos. head es un programa en /usr/bin.

Puntos clave

  • Estructura: comando -opciones argumentos, separados por espacios.
  • Las opciones cortas se combinan (-lF) y muchas tienen versión larga (--classify).
  • Un nombre con espacios va entre comillas: "mis fotos".
  • La terminal distingue mayúsculas: LS no es ls.
  • Ayuda: --help, man (salir con q) y help para las órdenes de Bash.

4 · Moverte por el sistema de archivos: pwd, ls y cd

Básico ~18 min

En la interfaz gráfica abres carpetas con doble clic. En la terminal haces lo mismo con tres comandos: pwd para saber dónde estás, ls para ver qué hay y cd para moverte. Con ellos y la idea de ruta, llegarás a cualquier rincón de tu computadora.

En este capítulo aprenderás a:

  • entender el árbol de carpetas y la raíz /;
  • saber en qué carpeta estás y qué contiene;
  • moverte con rutas absolutas y relativas;
  • usar los atajos ~, .., - y la tecla Tab.

Un árbol de carpetas

Las carpetas (en la terminal también se llaman directorios) se organizan como un árbol invertido. En Linux, macOS y Git Bash todo empieza en una única carpeta raíz, que se escribe /. No hay «disco C:» al principio de cada ruta, como en Windows.

El árbol de carpetas 📁 / 📁 etc 📁 home 📁 ana 📁 proyectos 📁 aroma 📁 css 📁 img 📄 index.html 📄 menu.html 📁 tmp 📁 usr
Fig. 4.1 · Todo cuelga de la raíz /. La carpeta personal de Ana es /home/ana (~) y su proyecto está en /home/ana/proyectos/aroma.
CarpetaQué contiene
/La raíz: todo lo demás cuelga de aquí
/home/anaLa carpeta personal de Ana. En macOS es /Users/ana
/etcArchivos de configuración del sistema
/usr/binLos programas, como ls (capítulo 3)
/tmpArchivos temporales que se borran al reiniciar
/c/Users/anaEn Git Bash: la carpeta de Windows C:\Users\ana
/mnt/c/Users/anaEn WSL: la misma carpeta de Windows

¿Dónde estoy y qué hay aquí? pwd y ls

Al abrir la terminal empiezas en tu carpeta personal. pwd (print working directory) muestra la carpeta actual y ls (list) su contenido. Con un argumento, ls muestra otra carpeta sin que te muevas:

pwd
/home/ana
ls
proyectos
ls proyectos
aroma
ls proyectos/aroma
css img index.html menu.html

Rutas absolutas y relativas

Una ruta es la dirección de un archivo o carpeta. proyectos/aroma es una ruta relativa: se busca a partir de donde estás. Una ruta absoluta empieza con / (desde la raíz) y funciona estés donde estés. ~ es un atajo para tu carpeta personal:

ls /home/ana/proyectos/aroma/css
estilos.css
ls ~/proyectos/aroma/img
local.jpg logo.png

Moverse: cd

cd (change directory) te lleva a otra carpeta. .. significa «la carpeta de arriba» (la que contiene a la actual):

cd proyectos
pwd
/home/ana/proyectos
cd aroma/css
pwd
/home/ana/proyectos/aroma/css
cd ..
pwd
/home/ana/proyectos/aroma
cd ../..
pwd
/home/ana

Como siempre, cd no dice nada cuando funciona: por eso usamos pwd para comprobar.

Tres atajos que usarás a diario: cd solo te devuelve a tu carpeta personal, cd - regresa a la carpeta anterior (y te la muestra) y ~ sirve dentro de cualquier ruta:

cd proyectos/aroma/img
cd
pwd
/home/ana
cd -
/home/ana/proyectos/aroma/img
cd ~/proyectos
pwd
/home/ana/proyectos

. y ..: las carpetas especiales

Toda carpeta contiene dos entradas especiales que ls -a (all) deja ver: . es la propia carpeta y .., la de arriba. -a también muestra los archivos ocultos, los que empiezan con punto (como la carpeta .git de los repositorios).

ls -a
. .. css img index.html menu.html
ls ..
aroma

Más detalles: ls -lh y ls -R

-h (human) muestra los tamaños en K, M o G, y -R (recursive) recorre también todas las subcarpetas:

ls -lh
total 16K drwxr-xr-x 2 ana ana 4.0K Jul 15 08:59 css drwxr-xr-x 2 ana ana 4.0K Jul 15 08:59 img -rw-r--r-- 1 ana ana 215 Jul 15 08:59 index.html -rw-r--r-- 1 ana ana 104 Jul 15 08:59 menu.html
ls -R
.: css img index.html menu.html ./css: estilos.css ./img: local.jpg logo.png

Errores típicos

cd menu.html
bash: cd: menu.html: Not a directory
cd Css
bash: cd: Css: No such file or directory

«Not a directory»: menu.html es un archivo, no se puede entrar en él. «No such file or directory»: la carpeta se llama css, en minúsculas.

Tab: deja que la terminal escriba por ti

Escribe cd pro y presiona Tab: la terminal completa proyectos/. Si hay varias opciones, presiona Tab dos veces y te las muestra. Además de ahorrar tiempo, evita errores: si Tab no completa, es que ese nombre no existe donde estás.

AtajoQué hace
TabCompleta nombres de carpetas, archivos y comandos
Tab TabMuestra todas las opciones posibles
↑ / ↓Recorre los comandos que ya escribiste
Ctrl + L o clearLimpia la pantalla
Ctrl + CCancela el comando o la línea actual
En Windows: en Git Bash, cd /c/Users te lleva a la carpeta de usuarios de Windows; en WSL es cd /mnt/c/Users. Para tus proyectos en WSL, es más rápido trabajar dentro de ~ (el disco de Linux).
Regla de oro: antes de crear, mover o borrar algo, mira dónde estás con pwd. La mayoría de los sustos en la terminal vienen de estar en la carpeta equivocada.

Practica

BásicoDesde tu carpeta personal, entra con un solo cd a la carpeta css del proyecto, comprueba dónde estás y regresa a la carpeta anterior.

Ver solución 1
cd proyectos/aroma/css
pwd
cd -
/home/ana/proyectos/aroma/css /home/ana

cd - muestra la carpeta a la que regresas.

RetoEstando en css, lista la carpeta img primero con una ruta relativa y después con una absoluta. Termina volviendo a tu carpeta personal con .. y comprueba.

Ver solución 2
cd proyectos/aroma/css
ls ../img
ls /home/ana/proyectos/aroma/img
cd ../../..
pwd
local.jpg logo.png local.jpg logo.png /home/ana

Desde css, .. es aroma; tres niveles arriba está /home/ana. En tu equipo, cambia /home/ana por tu propia carpeta personal.

Puntos clave

  • Todo cuelga de la raíz /; tu carpeta personal es ~.
  • pwd dice dónde estás, ls qué hay y cd te mueve.
  • Ruta absoluta: empieza con /. Relativa: desde donde estás. .. sube un nivel.
  • cd solo vuelve a casa; cd - regresa a la carpeta anterior.
  • ls -a muestra ocultos, -l detalles, -h tamaños legibles y -R subcarpetas.

5 · Crear carpetas y archivos (y editarlos con nano)

Básico ~16 min

Ya sabes moverte. Ahora vas a construir: carpetas para ordenar un proyecto, archivos vacíos, archivos con contenido y, para editarlos sin salir de la terminal, un editor de texto que funciona en cualquier sistema.

En este capítulo aprenderás a:

  • crear carpetas, incluso varias y anidadas, con mkdir;
  • crear archivos vacíos con touch;
  • escribir y agregar texto a un archivo con echo, > y >>;
  • editar archivos con nano.

Crear carpetas: mkdir

mkdir (make directory) crea una carpeta. Ana necesita una para los programas de JavaScript de su web:

mkdir js
ls -F
css/ img/ index.html js/ menu.html

¿Y una carpeta dentro de otra que todavía no existe? mkdir se niega, salvo que le pidas que cree todo el camino con -p (parents):

mkdir carta/postres/tortas
mkdir: cannot create directory ‘carta/postres/tortas’: No such file or directory
mkdir -p carta/postres/tortas
ls -R carta
carta: postres carta/postres: tortas carta/postres/tortas:

mkdir acepta varios nombres a la vez, y con -v (verbose) te cuenta lo que hace:

mkdir -v fuentes videos
mkdir: created directory 'fuentes' mkdir: created directory 'videos'

Crear archivos vacíos: touch

touch crea un archivo vacío (tamaño 0). Si el archivo ya existe, no lo toca: solo actualiza su fecha de modificación.

touch notas.txt
ls -l notas.txt
-rw-r--r-- 1 ana ana 0 Jul 15 08:59 notas.txt

Escribir en un archivo: echo y >

echo muestra texto en pantalla, pero con > lo envía a un archivo (si no existe, lo crea). Con >> agrega una línea al final sin borrar lo anterior:

echo "Horario: lunes a sábado de 8:00 a 20:00" > horario.txt
cat horario.txt
Horario: lunes a sábado de 8:00 a 20:00
echo "Domingos: cerrado" >> horario.txt
cat horario.txt
Horario: lunes a sábado de 8:00 a 20:00 Domingos: cerrado
El símbolo > reemplaza todo. Si el archivo ya tenía contenido, > lo borra por completo y escribe lo nuevo, sin preguntar:
echo "Cerrado por vacaciones" > horario.txt
cat horario.txt
Cerrado por vacaciones

Las dos líneas del horario desaparecieron. En el capítulo 10 estudiarás a fondo > y >>.

La extensión no decide qué es un archivo

Para la terminal, .html o .png son solo parte del nombre. El comando file mira el contenido y te dice qué es en realidad:

file index.html menu.html img/logo.png
index.html: HTML document, Unicode text, UTF-8 text menu.html: Unicode text, UTF-8 text img/logo.png: empty

logo.png está vacío: lo creamos con touch, así que de imagen solo tiene el nombre.

Editar con nano

Para escribir más de una línea, lo cómodo es un editor. nano funciona dentro de la terminal y viene en Ubuntu y en Git Bash. Ábrelo con el nombre del archivo (si no existe, lo crea al guardar):

nano horario.txt

Escribe normalmente y muévete con las flechas. En la parte inferior verás los atajos; ^ significa Ctrl:

AtajoAcción
Ctrl + O, luego EnterGuardar (write Out)
Ctrl + XSalir (si hay cambios sin guardar, pregunta: Y sí, N no)
Ctrl + KCortar la línea actual
Ctrl + UPegar lo cortado
Ctrl + WBuscar texto
Ctrl + GAyuda completa
En macOS desde la versión 12.3, el comando nano abre un editor muy parecido llamado pico, con los mismos atajos para guardar y salir. Si quieres el nano original: brew install nano.
Regla de oro: antes de usar > sobre un archivo, pregúntate si ya tiene algo que quieras conservar. Si tienes dudas, usa >> o ábrelo con nano.

Practica

BásicoCrea la carpeta js/modulos en un solo paso, dentro crea carrito.js y en js crea app.js. Muestra el resultado con todas las subcarpetas.

Ver solución 1
mkdir -p js/modulos
touch js/app.js js/modulos/carrito.js
ls -R js
js: app.js modulos js/modulos: carrito.js

Sin -p, mkdir js/modulos fallaría porque js todavía no existe.

RetoCrea contacto.txt con dos líneas (teléfono y correo) usando solo echo, muéstralo y comprueba qué tipo de archivo es.

Ver solución 2
echo "Teléfono: 01 555 1234" > contacto.txt
echo "Correo: hola@aromaypunto.pe" >> contacto.txt
cat contacto.txt
file contacto.txt
Teléfono: 01 555 1234 Correo: hola@aromaypunto.pe contacto.txt: Unicode text, UTF-8 text

La primera línea usa > (crea) y la segunda >> (agrega). Con > en ambas, solo quedaría el correo.

Puntos clave

  • mkdir crea carpetas; -p crea todo el camino y -v informa.
  • touch crea archivos vacíos (o actualiza la fecha de uno existente).
  • echo "texto" > archivo reemplaza; >> agrega al final.
  • file dice qué es un archivo según su contenido, no su extensión.
  • nano: Ctrl+O guarda y Ctrl+X sale.

6 · Copiar, mover y renombrar

Básico ~16 min

Hacer una copia de respaldo antes de un cambio, ordenar archivos en carpetas, corregir un nombre mal escrito: son tareas de todos los días. En la terminal se resuelven con dos comandos, cp y mv, y una precaución importante que aprenderás al final.

En este capítulo aprenderás a:

  • copiar archivos y carpetas con cp;
  • mover y renombrar con mv;
  • entender por qué cp y mv pueden reemplazar archivos sin avisar;
  • pedir confirmación con -i.

Copiar un archivo: cp

cp origen destino (copy). Antes de tocar el menú, Ana guarda una copia:

cp menu.html menu-copia.html
ls
css img index.html menu-copia.html menu.html

Si el destino es una carpeta (termínala con / para que quede claro), la copia conserva el nombre. Puedes copiar varios archivos a la vez: el último argumento es siempre el destino.

mkdir respaldo
cp -v index.html menu.html respaldo/
'index.html' -> 'respaldo/index.html' 'menu.html' -> 'respaldo/menu.html'
ls respaldo
index.html menu.html

Copiar carpetas: cp -r

Para copiar una carpeta con todo su contenido necesitas -r (recursive); sin ella, cp la omite:

cp css css-v2
cp: -r not specified; omitting directory 'css'
cp -r css css-v2
ls -F
css/ css-v2/ img/ index.html menu.html

Renombrar y mover: mv

mv (move) hace dos cosas con la misma sintaxis. Si el destino es un nombre nuevo en la misma carpeta, renombra:

mv menu-copia.html carta.html
ls
carta.html css img index.html menu.html

Si el destino es otra carpeta, mueve:

mkdir archivo
mv -v carta.html archivo/
renamed 'carta.html' -> 'archivo/carta.html'
ls
archivo css img index.html menu.html
ls archivo
carta.html

Con carpetas funciona igual y no necesita -r:

mv img imagenes
ls
css imagenes index.html menu.html
Cuidado al renombrar carpetas de un proyecto. Si index.html usaba img/logo.png, al renombrar img a imagenes la web ya no encuentra el logo. Renombrar es fácil; actualizar las referencias es tarea tuya.

El peligro: reemplazar sin avisar

Si el destino ya existe, cp y mv lo reemplazan sin preguntar. Luis tenía su lista de precios y Ana copió la suya encima:

cat precios.txt
Precios de Luis
cp precios-ana.txt precios.txt
cat precios.txt
Precios de Ana

La versión de Luis se perdió. Con -i (interactive), el comando pregunta antes de reemplazar; respondes y (sí) o n (no) y Enter:

cp -i precios-ana.txt precios.txt
cp: overwrite 'precios.txt'? n
cat precios.txt
Precios de Luis
ComandoQué hace
cp a.txt b.txtCopia a.txt con el nombre b.txt
cp a.txt b.txt carpeta/Copia varios archivos a una carpeta
cp -r carpeta copiaCopia una carpeta completa
mv viejo.txt nuevo.txtRenombra
mv a.txt carpeta/Mueve a otra carpeta
-i / -vPreguntar antes de reemplazar / informar cada paso
Regla de oro: cuando copies o muevas hacia un lugar donde podría haber un archivo con el mismo nombre, usa -i. Es un segundo de más contra un trabajo perdido.

Practica

BásicoGuarda una copia del menú en una carpeta respaldo, con el nombre menu-2026-07-15.html.

Ver solución 1
mkdir respaldo
cp menu.html respaldo/menu-2026-07-15.html
ls respaldo
menu-2026-07-15.html

Poner la fecha en el nombre de un respaldo es un hábito muy útil: sabes de cuándo es sin abrirlo.

RetoCopia la carpeta img completa como img-original y renombra index.html a inicio.html viendo qué hace cada comando.

Ver solución 2
cp -rv img img-original
mv -v index.html inicio.html
ls -F
'img' -> 'img-original' 'img/logo.png' -> 'img-original/logo.png' 'img/local.jpg' -> 'img-original/local.jpg' renamed 'index.html' -> 'inicio.html' css/ img/ img-original/ inicio.html menu.html

-v funciona en cp y en mv. Con -r, cp informa la carpeta y cada archivo.

Puntos clave

  • cp origen destino copia; con -r copia carpetas.
  • mv renombra (mismo lugar) o mueve (otra carpeta); con carpetas no necesita -r.
  • Varios orígenes: el último argumento es la carpeta de destino.
  • cp y mv reemplazan archivos existentes sin avisar; -i pide confirmación.

7 · Borrar con cuidado: rm no tiene papelera

Intermedio ~16 min

Borrar es lo más fácil del mundo en la terminal, y justamente por eso merece un capítulo propio. Cuando borras un archivo con el ratón, va a la papelera. Cuando lo borras en la terminal, desaparece: no hay papelera ni «deshacer». Aprenderás a borrar con la misma tranquilidad con la que copias, porque sabrás qué hacer antes.

En este capítulo aprenderás a:

  • borrar archivos con rm y carpetas con rmdir y rm -r;
  • pedir confirmación con -i;
  • entender por qué rm -rf tiene tan mala fama;
  • adoptar el hábito que evita los desastres.

Borrar archivos: rm

rm (remove) borra los archivos que le indiques. Como siempre, en silencio; con -v te informa:

rm borrador.txt
rm -v viejo.txt
removed 'viejo.txt'
ls
css img index.html menu.html

Si el archivo no existe, rm se queja. Con -f (force) no se queja de nada y nunca pregunta:

rm promo.txt
rm: cannot remove 'promo.txt': No such file or directory
rm -f promo.txt

Borrar carpetas: rmdir y rm -r

rm solo no borra carpetas. rmdir borra una carpeta, pero únicamente si está vacía. Para borrar una carpeta con todo lo que contiene se usa rm -r (recursive):

rm img
rm: cannot remove 'img': Is a directory
rmdir img
rmdir: failed to remove 'img': Directory not empty
rmdir vacia
rm -r img
ls
css index.html menu.html

rm -r img borró la carpeta y las dos imágenes de su interior sin preguntar nada. Así de rápido.

Pedir confirmación: -i

Con -i, rm pregunta por cada archivo. Ana borra el borrador, pero decide conservar el otro:

rm -i borrador.txt viejo.txt
rm: remove regular empty file 'borrador.txt'? y rm: remove regular empty file 'viejo.txt'? n
ls
css img index.html menu.html viejo.txt

Con una carpeta, rm -ri pregunta si entrar en ella, por cada archivo y por la carpeta misma:

rm -ri pruebas
rm: descend into directory 'pruebas'? y rm: remove regular empty file 'pruebas/a.txt'? y rm: remove directory 'pruebas'? y

rm -rf: el comando con peor fama

Verás rm -rf en muchos tutoriales: -r borra carpetas completas y -f no pregunta ni se queja. Es útil, pero combina las dos cosas que lo hacen peligroso: borra todo lo que encuentre y no te da ninguna oportunidad de arrepentirte. Un solo espacio de más basta para el desastre. Ana quería borrar los respaldos .bak:

ls
css img index.bak index.html menu.bak menu.html
rm * .bak
rm: cannot remove 'css': Is a directory rm: cannot remove 'img': Is a directory rm: cannot remove '.bak': No such file or directory
ls
css img

Por el espacio entre * y .bak, rm recibió dos argumentos: *, que significa «todo lo que hay aquí» (capítulo 9), y .bak, que no existe. Se borraron index.html y menu.html junto con los respaldos. Solo se salvaron las carpetas, porque faltó -r; con rm -rf no habría quedado nada. (Esto se ejecutó en el laboratorio del manual, no en una computadora real.)

Nunca ejecutes rm -rf con / ni con ~. Borraría todo el sistema o todos tus archivos personales. GNU rm se niega a borrar la raíz / por defecto, pero no protege tu carpeta personal. Tampoco pegues comandos con rm -rf que no entiendas por completo.

El hábito que te salva: mira antes de borrar

Antes de un rm con comodines, ejecuta ls con el mismo patrón. Si la lista es la que esperas, cambia ls por rm (con ↑ recuperas el comando y solo editas la primera palabra):

ls *.bak
index.bak menu.bak
rm -v *.bak
removed 'index.bak' removed 'menu.bak'
ls
css img index.html menu.html
ComandoQué borraPregunta
rm archivoArchivosNo
rm -i archivoArchivosSí, uno por uno
rmdir carpetaUna carpeta vacíaNo (falla si no está vacía)
rm -r carpetaUna carpeta y todo su contenidoNo
rm -rf carpetaTodo, sin quejarse de nadaNunca

¿Y si quieres una papelera de verdad? En Ubuntu con escritorio puedes enviar archivos a la papelera desde la terminal:

gio trash borrador.txt

Y lo más importante: los proyectos con Git (curso de Git) guardan cada versión; un archivo borrado se recupera con un comando. Es otra razón para usar Git en todo lo que hagas.

Regla de oro: antes de borrar con comodines, mira con ls exactamente qué se va a borrar. Y nunca uses rm -rf por costumbre: úsalo solo cuando sepas qué hay dentro de la carpeta.

Practica

BásicoCrea dos archivos temporales, bórralos viendo qué se borra y comprueba que el proyecto quedó como estaba.

Ver solución 1
touch temp1.txt temp2.txt
rm -v temp1.txt temp2.txt
ls
removed 'temp1.txt' removed 'temp2.txt' css img index.html menu.html

Con -v, rm confirma cada archivo borrado.

RetoAntes de borrar la carpeta pruebas, revisa todo lo que contiene. Luego bórrala con su contenido, mostrando cada elemento borrado.

Ver solución 2
ls -R pruebas
rm -rv pruebas
pruebas: a.txt viejas pruebas/viejas: b.txt removed 'pruebas/a.txt' removed 'pruebas/viejas/b.txt' removed directory 'pruebas/viejas' removed directory 'pruebas'

Primero mirar, después borrar. rm -rv informa cada archivo y cada carpeta que elimina.

Puntos clave

  • rm borra para siempre: no hay papelera.
  • rmdir borra carpetas vacías; rm -r, carpetas con contenido.
  • -i pregunta antes de borrar; -f nunca pregunta.
  • Un espacio de más en un patrón (rm * .bak) puede borrarlo todo.
  • Hábito: ls patrón primero, rm patrón después.

8 · Leer archivos: cat, less, head y tail

Básico ~15 min

Los programadores leen archivos todo el tiempo: código, configuraciones y, sobre todo, registros (logs), donde los programas anotan lo que hacen. Algunos tienen miles de líneas. La terminal tiene una herramienta para cada necesidad: ver todo, recorrer con calma, ver el principio o ver el final.

En este capítulo aprenderás a:

  • mostrar archivos completos con cat;
  • recorrer archivos largos con less;
  • ver solo el principio o el final con head y tail;
  • seguir un registro en vivo con tail -f.

cat: mostrar todo

cat muestra el contenido completo. Con -n numera las líneas, algo muy útil cuando un error dice «en la línea 4»:

cat css/estilos.css
body { font-family: sans-serif; } h1 { color: brown; }
cat -n menu.html
1 <h1>Menú</h1> 2 <ul> 3 <li>Espresso S/ 7</li> 4 <li>Americano S/ 8</li> 5 <li>Capuchino S/ 10</li> 6 </ul>

Su nombre viene de concatenate (unir): si le das varios archivos, los muestra uno tras otro, como si fueran uno solo.

cat css/estilos.css menu.html
body { font-family: sans-serif; } h1 { color: brown; } <h1>Menú</h1> <ul> <li>Espresso S/ 7</li> <li>Americano S/ 8</li> <li>Capuchino S/ 10</li> </ul>

cat es perfecto para archivos cortos. Con uno de 5000 líneas, verías pasar el texto a toda velocidad y solo te quedarías con el final.

less: leer con calma

less abre el archivo en pantalla completa y te deja recorrerlo:

less pedidos.log
TeclaAcción
↓ / ↑Una línea abajo / arriba
Espacio / bUna página abajo / arriba
g / GIr al inicio / al final
/texto EnterBuscar «texto»; n salta a la siguiente coincidencia
qSalir

Es el mismo visor que usa man (capítulo 3) y Git para mostrar el historial. En Git Bash también está disponible.

head y tail: el principio y el final

Ana guarda en pedidos.log un registro de los 30 pedidos de la mañana. head muestra las primeras 10 líneas; con -n eliges cuántas:

head pedidos.log
2026-07-15 08:10 pedido #001 Americano 2026-07-15 08:20 pedido #002 Capuchino 2026-07-15 08:30 pedido #003 Latte 2026-07-15 08:40 pedido #004 Mocaccino 2026-07-15 08:50 pedido #005 Espresso 2026-07-15 09:00 pedido #006 Americano 2026-07-15 09:10 pedido #007 Capuchino 2026-07-15 09:20 pedido #008 Latte 2026-07-15 09:30 pedido #009 Mocaccino 2026-07-15 09:40 pedido #010 Espresso
head -n 3 pedidos.log
2026-07-15 08:10 pedido #001 Americano 2026-07-15 08:20 pedido #002 Capuchino 2026-07-15 08:30 pedido #003 Latte

tail hace lo mismo con el final, que en un registro son los eventos más recientes:

tail -n 3 pedidos.log
2026-07-15 12:40 pedido #028 Latte 2026-07-15 12:50 pedido #029 Mocaccino 2026-07-15 13:00 pedido #030 Espresso

Con -n +N, tail muestra desde la línea N hasta el final:

tail -n +28 pedidos.log
2026-07-15 12:40 pedido #028 Latte 2026-07-15 12:50 pedido #029 Mocaccino 2026-07-15 13:00 pedido #030 Espresso

tail -f: seguir un archivo en vivo

Los servidores escriben en sus registros mientras funcionan. Con -f (follow), tail no termina: se queda esperando y muestra cada línea nueva en cuanto aparece. Es la forma de ver «en directo» qué pasa en un servidor web. Se detiene con Ctrl + C:

tail -f /var/log/syslog
Pruébalo con dos terminales. En una ejecuta tail -f pedidos.log; en la otra, echo "nuevo pedido" >> pedidos.log. Verás aparecer la línea en la primera al instante.
Necesito…Comando
Ver un archivo cortocat archivo
Ver con números de líneacat -n archivo
Leer uno largo con calmaless archivo
Las primeras / últimas N líneashead -n N / tail -n N
Seguir un registro en vivotail -f archivo
Regla de oro: si no sabes cuánto mide un archivo, no uses cat: empieza con head o less. Y si la terminal se llena de símbolos raros, abriste un archivo binario: Ctrl + C y luego reset.

Practica

BásicoMuestra los 2 primeros y los 2 últimos pedidos del día.

Ver solución 1
head -n 2 pedidos.log
tail -n 2 pedidos.log
2026-07-15 08:10 pedido #001 Americano 2026-07-15 08:20 pedido #002 Capuchino 2026-07-15 12:50 pedido #029 Mocaccino 2026-07-15 13:00 pedido #030 Espresso

En un registro, tail muestra lo más reciente.

RetoUne la hoja de estilos y el menú en un archivo nuevo llamado todo.txt, muestra sus 3 últimas líneas y después el archivo completo con números de línea.

Ver solución 2
cat css/estilos.css menu.html > todo.txt
tail -n 3 todo.txt
cat -n todo.txt
<li>Americano S/ 8</li> <li>Capuchino S/ 10</li> </ul> 1 body { font-family: sans-serif; } 2 h1 { color: brown; } 3 <h1>Menú</h1> 4 <ul> 5 <li>Espresso S/ 7</li> 6 <li>Americano S/ 8</li> 7 <li>Capuchino S/ 10</li> 8 </ul>

cat une archivos y > guarda el resultado en uno nuevo.

Puntos clave

  • cat muestra todo (y une varios archivos); -n numera.
  • less recorre archivos largos: / busca, q sale.
  • head y tail muestran el principio y el final (10 líneas por defecto, -n para cambiar).
  • tail -f sigue un archivo en vivo hasta Ctrl + C.

9 · Comodines: muchos archivos a la vez

Intermedio ~18 min

En el capítulo 1 viste a Ana crear varios archivos con un solo comando. Era gracias a los comodines: símbolos que Bash reemplaza por una lista de nombres antes de ejecutar el comando. Con ellos, copiar, mover o borrar 100 archivos cuesta lo mismo que hacerlo con uno.

En este capítulo aprenderás a:

  • seleccionar archivos por patrón con *, ? y [ ];
  • previsualizar un patrón con echo antes de usarlo;
  • generar listas de nombres con las llaves { };
  • evitar las trampas: archivos ocultos, patrones sin coincidencias y comillas.

El asterisco: cualquier cosa

La carpeta img de Ana tiene el logo, una foto del local, 12 fotos de platos y 3 de postres. * significa «cualquier texto, de cualquier largo (incluso vacío)»:

ls
local.jpg plato03.jpg plato07.jpg plato11.jpg postre-c.png logo.png plato04.jpg plato08.jpg plato12.jpg plato01.jpg plato05.jpg plato09.jpg postre-a.png plato02.jpg plato06.jpg plato10.jpg postre-b.png
ls *.png
logo.png postre-a.png postre-b.png postre-c.png
ls plato*
plato01.jpg plato04.jpg plato07.jpg plato10.jpg plato02.jpg plato05.jpg plato08.jpg plato11.jpg plato03.jpg plato06.jpg plato09.jpg plato12.jpg

Quién reemplaza el patrón: Bash

Un detalle clave: ls nunca ve el asterisco. Bash lo reemplaza por la lista de nombres que coinciden y recién entonces ejecuta el comando. Por eso puedes ver la lista con echo, que solo repite lo que recibe:

echo *.png
logo.png postre-a.png postre-b.png postre-c.png
Bash expande el patrón antes de ejecutar Tú escribes ls *.png Bash reemplaza *.png por los nombres ls recibe logo.png postre-a.png …
Fig. 9.1 · El comando nunca ve el comodín: recibe la lista de nombres que ya preparó Bash. Por eso echo sirve para previsualizar cualquier patrón.

Esto explica el desastre del capítulo 7: en rm * .bak, Bash convirtió el * en todos los nombres de la carpeta antes de que rm hiciera nada.

? y [ ]: más precisión

? equivale a exactamente un carácter cualquiera:

ls plato0?.jpg
plato01.jpg plato03.jpg plato05.jpg plato07.jpg plato09.jpg plato02.jpg plato04.jpg plato06.jpg plato08.jpg
ls plato1?.jpg
plato10.jpg plato11.jpg plato12.jpg

[ ] equivale a un carácter de la lista o del rango que pongas dentro:

ls plato0[1-4].jpg
plato01.jpg plato02.jpg plato03.jpg plato04.jpg
ls postre-[ab].png
postre-a.png postre-b.png

Tres trampas

1. Los ocultos no entran. * no incluye los archivos que empiezan con punto:

ls -a
. logo.png plato04.jpg plato08.jpg plato12.jpg .. plato01.jpg plato05.jpg plato09.jpg postre-a.png .borrador.jpg plato02.jpg plato06.jpg plato10.jpg postre-b.png local.jpg plato03.jpg plato07.jpg plato11.jpg postre-c.png
echo *.jpg
local.jpg plato01.jpg plato02.jpg plato03.jpg plato04.jpg plato05.jpg plato06.jpg plato07.jpg plato08.jpg plato09.jpg plato10.jpg plato11.jpg plato12.jpg

2. Sin coincidencias, el patrón llega tal cual. Si no hay ningún .gif, Bash no reemplaza nada y el comando recibe literalmente *.gif:

ls *.gif
ls: cannot access '*.gif': No such file or directory
echo *.gif
*.gif

3. Entre comillas no es comodín. Las comillas (dobles o simples) desactivan el reemplazo:

echo "*.png"
*.png
echo '*.png'
*.png

Las llaves: generar nombres

Las llaves no buscan archivos existentes: generan texto. {a,b,c} produce cada opción y {1..5}, una secuencia. Si escribes ceros a la izquierda, los respeta:

echo plato{1..5}.jpg
plato1.jpg plato2.jpg plato3.jpg plato4.jpg plato5.jpg
echo plato{01..12}.jpg
plato01.jpg plato02.jpg plato03.jpg plato04.jpg plato05.jpg plato06.jpg plato07.jpg plato08.jpg plato09.jpg plato10.jpg plato11.jpg plato12.jpg
echo {a..e}
a b c d e
echo postre-{torta,flan,helado}.png
postre-torta.png postre-flan.png postre-helado.png

Combinadas con mkdir o touch, crean estructuras completas en un paso:

mkdir -p semana/{lunes,martes,miercoles}
ls semana
lunes martes miercoles

Todo junto

Ana guarda un respaldo solo de los postres:

mkdir -p respaldo/postres
cp -v img/postre-*.png respaldo/postres/
'img/postre-a.png' -> 'respaldo/postres/postre-a.png' 'img/postre-b.png' -> 'respaldo/postres/postre-b.png' 'img/postre-c.png' -> 'respaldo/postres/postre-c.png'
PatrónSignificaEjemploCoincide con
*Cualquier texto*.pngpostre-a.png, postre-b.png…
?Un carácterplato0?.jpgplato01.jpg … plato09.jpg
[ ]Un carácter de la listaplato0[1-4].jpgplato01.jpg … plato04.jpg
{ , }Genera cada opción{lunes,martes}lunes martes (existan o no)
{ .. }Genera una secuencia{01..03}01 02 03
En zsh (macOS) los comodines funcionan igual, con una diferencia: si un patrón no coincide con nada, zsh muestra «no matches found» y no ejecuta el comando.
Regla de oro: antes de usar un comodín con rm, mv o cp, previsualízalo con echo o ls. Si la lista es la que esperas, recién entonces ejecuta el comando de verdad.

Practica

BásicoLista solo las fotos de los platos 05 al 09 y previsualiza con echo qué archivos .png hay.

Ver solución 1
ls img/plato0[5-9].jpg
echo img/*.png
img/plato05.jpg img/plato07.jpg img/plato09.jpg img/plato06.jpg img/plato08.jpg img/logo.png img/postre-a.png img/postre-b.png img/postre-c.png

[5-9] representa un solo carácter entre 5 y 9.

RetoCrea con un solo mkdir las carpetas carta/platos y carta/postres, copia en cada una sus fotos y muestra el contenido de ambas.

Ver solución 2
mkdir -p carta/{platos,postres}
cp img/plato*.jpg carta/platos/
cp img/postre-*.png carta/postres/
ls carta/*
carta/platos: plato01.jpg plato04.jpg plato07.jpg plato10.jpg plato02.jpg plato05.jpg plato08.jpg plato11.jpg plato03.jpg plato06.jpg plato09.jpg plato12.jpg carta/postres: postre-a.png postre-b.png postre-c.png

ls carta/* recibe las dos carpetas y muestra el contenido de cada una con su nombre como título.

Puntos clave

  • * = cualquier texto, ? = un carácter, [ ] = un carácter de una lista.
  • Bash reemplaza los patrones antes de ejecutar el comando: echo te muestra el resultado.
  • Los archivos ocultos no entran en *; sin coincidencias, el patrón llega literal; entre comillas no se reemplaza.
  • Las llaves generan nombres: {a,b} y {1..5}.

10 · Redirecciones: guardar la salida en archivos

Intermedio ~16 min

Hasta ahora, lo que responden los comandos aparece en pantalla y se pierde al cerrar la terminal. Con las redirecciones puedes guardar esa salida en un archivo, separar los errores de los resultados o dar a un comando un archivo como entrada. Ya conoces >; aquí verás el cuadro completo.

En este capítulo aprenderás a:

  • entender los tres canales: entrada, salida y errores;
  • guardar la salida con > y >>;
  • separar o descartar los errores con 2>, &> y /dev/null;
  • leer la entrada desde un archivo con < y protegerte de sobrescrituras.
Los tres canales de todo comando comando stdin (0) teclado o < stdout (1) pantalla, > o | stderr (2) pantalla o 2>
Fig. 10.1 · Todo comando lee de la entrada estándar (stdin) y escribe en dos salidas: la estándar (stdout) para los resultados y la de errores (stderr). Por defecto, ambas van a tu pantalla; las redirecciones las desvían.

>: la salida a un archivo

Ana quiere guardar la lista de imágenes del proyecto. En pantalla, ls muestra columnas; al enviarla a un archivo, escribe un nombre por línea (así es más fácil de procesar después):

ls img
local.jpg logo.png
ls img > lista.txt
cat lista.txt
local.jpg logo.png

Recuerda (capítulo 5): > crea el archivo o lo reemplaza, y >> agrega al final:

ls css >> lista.txt
cat lista.txt
local.jpg logo.png estilos.css

Los errores van por otro canal

Fíjate qué pasa cuando un comando produce resultados y errores a la vez:

ls img noexiste > salida.txt
ls: cannot access 'noexiste': No such file or directory
cat salida.txt
img: local.jpg logo.png

El error apareció en pantalla y no se guardó en el archivo: > solo desvía la salida estándar (canal 1). Los errores viajan por el canal 2, y se redirigen con 2>:

ls img noexiste 2> errores.txt
img: local.jpg logo.png
cat errores.txt
ls: cannot access 'noexiste': No such file or directory

Para guardar las dos cosas en el mismo archivo, usa &>:

ls img noexiste &> todo.txt
cat todo.txt
ls: cannot access 'noexiste': No such file or directory img: local.jpg logo.png

/dev/null: el agujero negro

/dev/null es un archivo especial que descarta todo lo que recibe. Sirve para silenciar lo que no te interesa, por ejemplo los errores esperados:

ls img noexiste 2> /dev/null
img: local.jpg logo.png

<: un archivo como entrada

< hace lo inverso: entrega el contenido de un archivo a la entrada estándar de un comando. wc -l cuenta líneas; mira la diferencia:

wc -l pedidos.log
30 pedidos.log
wc -l < pedidos.log
30

Con <, wc no sabe de qué archivo vienen los datos, solo los recibe; por eso no muestra el nombre. Esta idea, «un comando que lee datos sin saber de dónde vienen», es la base del capítulo 11.

Protégete de un > accidental

Bash tiene una opción que impide que > reemplace archivos existentes:

set -o noclobber
echo "otra cosa" > lista.txt
bash: lista.txt: cannot overwrite existing file
cat lista.txt
local.jpg logo.png

Para activarla siempre, se agrega set -o noclobber al archivo de configuración de Bash (capítulo 19). Si de verdad quieres reemplazar, usa >|.

SímboloQué haceEjemplo
>Salida a un archivo (lo reemplaza)ls > lista.txt
>>Salida al final de un archivoecho hola >> notas.txt
2>Errores a un archivocmd 2> errores.txt
&>Salida y errores al mismo archivocmd &> todo.txt
2> /dev/nullDescartar los errorescmd 2> /dev/null
<Un archivo como entradawc -l < pedidos.log
¿2>&1? En muchos tutoriales verás cmd > todo.txt 2>&1: significa «la salida al archivo y los errores al mismo lugar que la salida». Hace lo mismo que &>, que es la forma corta de Bash.
Regla de oro: separa siempre resultados y errores: los resultados a un archivo con >, los errores a otro con 2>. Así podrás revisar qué falló sin mezclarlo con lo que salió bien.

Practica

BásicoGuarda en inventario.txt el contenido de css y, a continuación, el de img. Luego cuenta cuántas líneas tiene el inventario sin que se muestre el nombre del archivo.

Ver solución 1
ls css > inventario.txt
ls img >> inventario.txt
wc -l < inventario.txt
3

Con <, wc recibe solo los datos y no sabe de qué archivo vienen.

RetoLista las carpetas css, img y fuentes (que no existe) guardando los resultados en ok.txt y los errores en errores.txt, sin que nada aparezca en pantalla. Después muestra ambos.

Ver solución 2
ls css img fuentes > ok.txt 2> errores.txt
cat ok.txt
cat errores.txt
css: estilos.css img: local.jpg logo.png ls: cannot access 'fuentes': No such file or directory

Cada canal va a su archivo: la salida estándar con > y los errores con 2>.

Puntos clave

  • Todo comando tiene tres canales: stdin (0), stdout (1) y stderr (2).
  • > reemplaza, >> agrega; ambos desvían solo la salida estándar.
  • 2> desvía los errores; &>, ambos; /dev/null los descarta.
  • < entrega un archivo como entrada estándar.
  • set -o noclobber evita reemplazar archivos con >.

11 · Tuberías: encadenar comandos

Intermedio ~18 min

Este es el capítulo que cambia tu forma de ver la terminal. Hasta ahora cada comando trabajaba solo. Con el símbolo | (tubería o pipe), la salida de un comando se convierte en la entrada del siguiente. Combinando piezas pequeñas resuelves problemas que ningún comando resuelve por sí solo.

En este capítulo aprenderás a:

  • conectar comandos con |;
  • construir cadenas de varios comandos paso a paso;
  • guardar el resultado de una tubería y verlo a la vez con tee;
  • entender por qué los errores no pasan por la tubería.

La primera tubería

¿Cuántas imágenes tiene la carpeta img? ls las lista y wc -l cuenta líneas. Con | los unes:

ls img | wc -l
17

ls no escribió en pantalla: su salida fue directo a wc, que contó 17 líneas. El mismo truco sirve para ver solo una parte de una lista larga:

ls img | head -n 3
local.jpg logo.png plato01.jpg

Cada comando hace una cosa

Ana quiere ver los pedidos 11 a 13. No existe un comando «mostrar de la línea 11 a la 13», pero sí dos piezas: tail -n +11 (desde la 11 hasta el final) y head -n 3 (las tres primeras):

tail -n +11 pedidos.log | head -n 3
2026-07-15 09:50 pedido #011 Americano 2026-07-15 10:00 pedido #012 Capuchino 2026-07-15 10:10 pedido #013 Latte
Una tubería de dos comandos tail -n +11 desde la línea 11 | head -n 3 solo 3 líneas | pantalla pedidos 11 a 13
Fig. 11.1 · La salida de tail no va a la pantalla: entra por la tubería como entrada de head, que se queda con las tres primeras líneas.

Esta es la filosofía Unix: programas pequeños que hacen una sola cosa bien y que se combinan con tuberías. Un ejemplo más, tr (translate), que cambia unos caracteres por otros:

echo "aroma y punto" | tr a-z A-Z
AROMA Y PUNTO

Las tuberías pueden tener todos los tramos que necesites:

tail -n +11 pedidos.log | head -n 3 | tr a-z A-Z
2026-07-15 09:50 PEDIDO #011 AMERICANO 2026-07-15 10:00 PEDIDO #012 CAPUCHINO 2026-07-15 10:10 PEDIDO #013 LATTE
Cómo construir una tubería larga: de a un tramo. Ejecuta el primer comando y mira la salida; agrega | siguiente y vuelve a mirar. Con ↑ recuperas el comando anterior y solo agregas el tramo nuevo.

Guardar el resultado

Las tuberías se combinan con las redirecciones del capítulo 10: el > va al final.

ls img | head -n 5 > primeros.txt
cat primeros.txt
local.jpg logo.png plato01.jpg plato02.jpg plato03.jpg

¿Y si quieres guardar y además seguir procesando? tee funciona como una «T» de cañería: escribe lo que recibe en un archivo y también lo deja pasar al siguiente comando:

ls img | tee lista.txt | wc -l
17
head -n 3 lista.txt
local.jpg logo.png plato01.jpg

Los errores no entran en la tubería

| solo conecta la salida estándar. Los errores siguen yendo a la pantalla:

ls noexiste | wc -l
ls: cannot access 'noexiste': No such file or directory 0
ls noexiste 2>&1 | wc -l
1

En el primer caso, el error se mostró y wc recibió cero líneas. Con 2>&1 (los errores al mismo lugar que la salida) el mensaje entra en la tubería y wc lo cuenta.

Tuberías y less

Cuando un comando produce una salida enorme, envíala a less para recorrerla con calma (capítulo 8):

ls -l /usr/bin | less
TuberíaQué hace
ls | wc -lCuenta los elementos de una carpeta
ls | head -n 5Muestra solo los primeros
tail -n +11 archivo | head -n 3Muestra las líneas 11 a 13
comando | tee copia.txt | …Guarda una copia y sigue procesando
comando | lessRecorre una salida larga
comando 2>&1 | …Incluye también los errores
Regla de oro: construye las tuberías de a un tramo, comprobando la salida en cada paso. Una tubería larga escrita de una sola vez es difícil de corregir; una construida por partes casi nunca falla.

Practica

BásicoCuenta cuántas imágenes .jpg hay en img y muestra los pedidos 20 al 22.

Ver solución 1
ls img/*.jpg | wc -l
tail -n +20 pedidos.log | head -n 3
13 2026-07-15 11:20 pedido #020 Espresso 2026-07-15 11:30 pedido #021 Americano 2026-07-15 11:40 pedido #022 Capuchino

El comodín elige los archivos, ls los lista y wc -l cuenta las líneas.

RetoMuestra los 5 últimos pedidos en mayúsculas y, a la vez, guárdalos en ultimos.txt. Comprueba cuántas líneas quedaron guardadas.

Ver solución 2
tail -n 5 pedidos.log | tr a-z A-Z | tee ultimos.txt
wc -l ultimos.txt
2026-07-15 12:20 PEDIDO #026 AMERICANO 2026-07-15 12:30 PEDIDO #027 CAPUCHINO 2026-07-15 12:40 PEDIDO #028 LATTE 2026-07-15 12:50 PEDIDO #029 MOCACCINO 2026-07-15 13:00 PEDIDO #030 ESPRESSO 5 ultimos.txt

tee al final de la tubería escribe en el archivo y también en la pantalla.

Puntos clave

  • a | b envía la salida de a como entrada de b.
  • Comandos pequeños + tuberías = soluciones a medida (filosofía Unix).
  • Las redirecciones van al final: a | b > archivo.
  • tee guarda una copia sin interrumpir la tubería.
  • Los errores no pasan por | salvo que agregues 2>&1.

12 · Buscar texto con grep

Intermedio ~18 min

¿En qué archivo del proyecto aparece el precio del espresso? ¿Cuántas ventas se pagaron con Yape? ¿Qué líneas del registro mencionan un error? Para todas esas preguntas hay una respuesta: grep, el buscador de texto de la terminal. Busca en un archivo, en miles o en la salida de otro comando, en una fracción de segundo.

En este capítulo aprenderás a:

  • buscar líneas que contienen un texto con grep;
  • usar sus opciones más útiles: contar, numerar, ignorar mayúsculas, invertir;
  • buscar en carpetas completas;
  • precisar la búsqueda con expresiones regulares básicas.

grep texto archivo

grep muestra las líneas que contienen el texto buscado. ¿Qué pedidos fueron Latte?

grep Latte pedidos.log
2026-07-15 08:30 pedido #003 Latte 2026-07-15 09:20 pedido #008 Latte 2026-07-15 10:10 pedido #013 Latte 2026-07-15 11:00 pedido #018 Latte 2026-07-15 11:50 pedido #023 Latte 2026-07-15 12:40 pedido #028 Latte

Además del registro de pedidos, Ana tiene un ventas.csv con las ventas de tres días: una venta por línea y las columnas separadas por comas (fecha, producto, cantidad, precio y forma de pago).

Las opciones que más usarás

-c cuenta las líneas en lugar de mostrarlas y -n agrega el número de línea:

grep -c Latte pedidos.log
6
grep -n Latte pedidos.log
3:2026-07-15 08:30 pedido #003 Latte 8:2026-07-15 09:20 pedido #008 Latte 13:2026-07-15 10:10 pedido #013 Latte 18:2026-07-15 11:00 pedido #018 Latte 23:2026-07-15 11:50 pedido #023 Latte 28:2026-07-15 12:40 pedido #028 Latte

grep distingue mayúsculas: latte no encuentra nada (y no muestra nada). Con -i ignora la diferencia:

grep latte pedidos.log
grep -i latte pedidos.log | head -n 2
2026-07-15 08:30 pedido #003 Latte 2026-07-15 09:20 pedido #008 Latte

-v invierte la búsqueda: muestra las líneas que no contienen el texto. Las ventas que no se pagaron con Yape:

grep -v yape ventas.csv
fecha,producto,cantidad,precio,pago 2026-07-13,Espresso,2,7,efectivo 2026-07-13,Latte,3,11,tarjeta 2026-07-13,Torta de chocolate,2,12,tarjeta 2026-07-14,Americano,2,8,efectivo 2026-07-14,Latte,1,11,efectivo 2026-07-14,Cheesecake,1,13,tarjeta 2026-07-14,Capuchino,1,10,tarjeta 2026-07-15,Espresso,2,7,efectivo 2026-07-15,Americano,1,8,tarjeta 2026-07-15,Espresso,1,7,tarjeta

Buscar en una carpeta

Con -r (recursive), grep busca en todos los archivos de una carpeta y sus subcarpetas; el punto . es la carpeta actual. Con -l solo lista los archivos que contienen el texto:

grep -r "S/" .
./menu.html: <li>Espresso S/ 7</li> ./menu.html: <li>Americano S/ 8</li> ./menu.html: <li>Capuchino S/ 10</li>
grep -rl Espresso .
./pedidos.log ./menu.html ./ventas.csv

Expresiones regulares: patrones de búsqueda

El texto que buscas puede ser un patrón con símbolos especiales. Los más útiles: ^ significa «al inicio de la línea» y $, «al final». Las ventas del 15 de julio, y cuántas terminan en yape:

grep "^2026-07-15" ventas.csv
2026-07-15,Espresso,2,7,efectivo 2026-07-15,Mocaccino,2,12,yape 2026-07-15,Capuchino,3,10,yape 2026-07-15,Americano,1,8,tarjeta 2026-07-15,Torta de chocolate,1,12,yape 2026-07-15,Espresso,1,7,tarjeta 2026-07-15,Latte,2,11,yape
grep "yape$" ventas.csv | wc -l
8

Los corchetes funcionan como en los comodines del capítulo 9: un carácter de la lista.

grep "#00[1-3]" pedidos.log
2026-07-15 08:10 pedido #001 Americano 2026-07-15 08:20 pedido #002 Capuchino 2026-07-15 08:30 pedido #003 Latte

Con -E (extended) puedes buscar una cosa o la otra con |. Pon el patrón entre comillas para que Bash no lo interprete como una tubería:

grep -E "Cheesecake|Torta" ventas.csv
2026-07-13,Torta de chocolate,2,12,tarjeta 2026-07-14,Cheesecake,1,13,tarjeta 2026-07-15,Torta de chocolate,1,12,yape
SímboloSignificaEjemplo
^Inicio de líneagrep "^2026" ventas.csv
$Fin de líneagrep "yape$" ventas.csv
.Un carácter cualquieragrep "L.tte"
[ ]Un carácter de la listagrep "#00[1-3]"
a|b (con -E)Una cosa u otragrep -E "Latte|Mocaccino"
Comodines y expresiones regulares no son lo mismo. En el capítulo 9, * era «cualquier texto». En una expresión regular, * significa «el carácter anterior, repetido cero o más veces». Por eso los patrones de grep van siempre entre comillas: así Bash no los toma por comodines.

grep en una tubería

Si no le das un archivo, grep busca en lo que recibe por la tubería. Es la forma de filtrar la salida de cualquier comando:

ls img | grep postre
postre-a.png postre-b.png postre-c.png
En tu Ubuntu verás colores. Ubuntu define grep como un alias de grep --color=auto, que resalta en color el texto encontrado (lo verás en el capítulo 19).
OpciónQué hace
-iIgnora mayúsculas y minúsculas
-nMuestra el número de línea
-cCuenta las líneas que coinciden
-vMuestra las líneas que NO coinciden
-wSolo palabras completas (Latte no coincide con Lattes)
-r / -lBusca en carpetas / solo nombres de archivo
Regla de oro: escribe siempre el patrón de grep entre comillas. Evitas que Bash convierta *, | o los espacios en otra cosa antes de que grep los vea.

Practica

BásicoCuenta los pedidos de Capuchino y muestra, con su número de línea, los de Mocaccino.

Ver solución 1
grep -c Capuchino pedidos.log
grep -n Mocaccino pedidos.log
6 4:2026-07-15 08:40 pedido #004 Mocaccino 9:2026-07-15 09:30 pedido #009 Mocaccino 14:2026-07-15 10:20 pedido #014 Mocaccino 19:2026-07-15 11:10 pedido #019 Mocaccino 24:2026-07-15 12:00 pedido #024 Mocaccino 29:2026-07-15 12:50 pedido #029 Mocaccino

-c cuenta; -n numera.

RetoMuestra las ventas del 14 de julio que se pagaron con tarjeta, encadenando dos grep.

Ver solución 2
grep "^2026-07-14" ventas.csv | grep "tarjeta$"
2026-07-14,Cheesecake,1,13,tarjeta 2026-07-14,Capuchino,1,10,tarjeta

El primer grep filtra por fecha (al inicio de la línea) y el segundo, por forma de pago (al final).

Puntos clave

  • grep "texto" archivo muestra las líneas que contienen el texto.
  • -i, -n, -c, -v y -w cubren casi todas las búsquedas diarias.
  • grep -r busca en carpetas; -l lista solo los archivos.
  • ^ inicio, $ fin, [ ] lista; -E permite a|b.
  • En una tubería, grep filtra la salida de cualquier comando.

13 · Buscar archivos con find

Intermedio ~18 min

grep busca dentro de los archivos. Pero a veces lo que buscas es el archivo mismo: ¿dónde guardé la foto del postre?, ¿qué archivos están vacíos?, ¿qué respaldos viejos puedo borrar? Para eso está find, que recorre carpetas y subcarpetas buscando archivos que cumplan las condiciones que le pidas.

En este capítulo aprenderás a:

  • buscar archivos por nombre con find;
  • filtrar por tipo, tamaño y profundidad;
  • ejecutar un comando sobre cada archivo encontrado;
  • distinguir cuándo usar find y cuándo grep.

find carpeta -name patrón

La estructura es: desde qué carpeta empezar y qué condiciones cumplir. El punto . es la carpeta actual:

find . -name "*.png"
./img/postre-a.png ./img/postre-c.png ./img/postre-b.png ./img/logo.png

Pon siempre el patrón entre comillas: si no, Bash lo expandiría (capítulo 9) antes de que find lo vea. Observa también que find no muestra los resultados en orden alfabético, sino en el orden en que los encuentra. Con una tubería los ordenas o los cuentas:

find . -name "plato0*" | sort
./img/plato01.jpg ./img/plato02.jpg ./img/plato03.jpg ./img/plato04.jpg ./img/plato05.jpg ./img/plato06.jpg ./img/plato07.jpg ./img/plato08.jpg ./img/plato09.jpg
find . -name "*.jpg" | wc -l
14

-iname hace lo mismo sin distinguir mayúsculas:

find . -iname "MENU*"
./menu.html

Filtrar por tipo y tamaño

-type d busca carpetas (directories) y -type f, archivos (files). Las condiciones se suman: todas deben cumplirse.

find . -type d
. ./img ./css
find . -type f -name "*.html"
./menu.html ./index.html

-empty encuentra archivos (o carpetas) vacíos, y -size filtra por tamaño: +500c significa «más de 500 bytes» (k son kilobytes y M, megabytes):

find img -empty | sort | head -n 4
img/.borrador.jpg img/local.jpg img/logo.png img/plato01.jpg
find . -type f -size +500c
./pedidos.log ./ventas.csv

A diferencia de ls y de los comodines, find sí encuentra los archivos ocultos:

find . -name ".*" -type f
./img/.borrador.jpg

Limitar la profundidad

Por defecto, find baja por todas las subcarpetas. Con -maxdepth 1 se queda en la carpeta indicada (ponlo antes de las demás condiciones):

find . -name "menu.html"
./menu.html ./respaldo/2026/julio/menu.html
find . -maxdepth 1 -name "menu.html"
./menu.html

Actuar sobre lo encontrado

-exec ejecuta un comando por cada archivo encontrado. {} se reemplaza por el nombre del archivo y \; marca el final del comando:

find . -name "postre-*" -exec ls -l {} \;
-rw-r--r-- 1 ana ana 0 Jul 15 08:59 ./img/postre-a.png -rw-r--r-- 1 ana ana 0 Jul 15 08:59 ./img/postre-c.png -rw-r--r-- 1 ana ana 0 Jul 15 08:59 ./img/postre-b.png

Para borrar, find tiene su propia acción, -delete. Aplica la regla del capítulo 7: primero ejecuta la búsqueda sin -delete para ver qué se borrará.

find . -name "*.bak"
./index.bak ./menu.bak ./css/estilos.bak
find . -name "*.bak" -delete
find . -name "*.bak" | wc -l
0
Cuidado con -delete. Borra para siempre y en todas las subcarpetas. Escribe -delete siempre al final y solo después de comprobar la lista sin él.

find o grep

Quiero…Uso
Archivos cuyo NOMBRE cumple algofind . -name "*.png"
Archivos cuyo CONTENIDO incluye algogrep -rl "texto" .
Líneas que contienen algogrep "texto" archivo
grep -rl "Capuchino" .
./pedidos.log ./menu.html ./ventas.csv
En macOS find exige indicar la carpeta: escribe siempre find . -name …, nunca find -name …. Así tus comandos funcionan en cualquier sistema.
CondiciónSignifica
-name "*.jpg" / -inameNombre que cumple el patrón (sin distinguir mayúsculas)
-type f / -type dSolo archivos / solo carpetas
-emptyVacío
-size +1MMás de 1 megabyte
-maxdepth 1Sin bajar a subcarpetas
-exec cmd {} \;Ejecuta un comando por archivo
-deleteBorra lo encontrado
Regla de oro: antes de agregar -delete o -exec rm, ejecuta el mismo find sin la acción y revisa la lista. Si está bien, recupera el comando con ↑ y agrega la acción al final.

Practica

BásicoEncuentra todos los archivos .html del proyecto (incluidos los del respaldo), ordenados, y cuéntalos.

Ver solución 1
find . -name "*.html" | sort
find . -name "*.html" | wc -l
./index.html ./menu.html ./respaldo/index.html ./respaldo/menu.html 4

find baja a todas las subcarpetas; sort pone orden en la lista.

RetoLas imágenes .png de img están vacías. Previsualiza cuáles son, bórralas con find y comprueba que no quedó ninguna.

Ver solución 2
find img -name "*.png" -empty | sort
find img -name "*.png" -empty -delete
find img -name "*.png" | wc -l
img/logo.png img/postre-a.png img/postre-b.png img/postre-c.png 0

Primero la lista, después -delete al final del mismo comando.

Puntos clave

  • find carpeta condiciones busca archivos por nombre, tipo, tamaño…
  • Patrón siempre entre comillas; -iname ignora mayúsculas.
  • find no ordena: agrega | sort si lo necesitas.
  • -exec cmd {} \; actúa sobre cada archivo; -delete los borra.
  • find busca nombres; grep -r busca contenidos.

14 · Ordenar, contar y recortar: sort, uniq, cut y wc

Intermedio ~20 min

Ana quiere saber qué producto se vende más y cómo le pagan sus clientes. No necesita una hoja de cálculo: con cuatro comandos y las tuberías del capítulo 11 puede sacar un informe de su archivo de ventas en una sola línea. Es el cierre de la parte III y el momento en que todo lo aprendido se junta.

En este capítulo aprenderás a:

  • contar líneas, palabras y caracteres con wc;
  • extraer columnas con cut;
  • ordenar con sort, también por números y por columnas;
  • eliminar repetidos y contarlos con uniq.

wc: contar

wc (word count) muestra líneas, palabras y bytes. Con -l, solo las líneas:

wc ventas.csv
19 23 623 ventas.csv
wc -l ventas.csv
19 ventas.csv

19 líneas: el encabezado y 18 ventas. Así se ve el comienzo del archivo:

head -n 4 ventas.csv
fecha,producto,cantidad,precio,pago 2026-07-13,Espresso,2,7,efectivo 2026-07-13,Capuchino,1,10,yape 2026-07-13,Latte,3,11,tarjeta

cut: quedarse con una columna

cut recorta columnas. -d, indica que el separador es la coma y -f (fields) qué columnas quieres:

cut -d, -f2 ventas.csv | head -n 5
producto Espresso Capuchino Latte Espresso
cut -d, -f1,5 ventas.csv | head -n 3
fecha,pago 2026-07-13,efectivo 2026-07-13,yape

sort: ordenar

sort ordena líneas alfabéticamente. Primero quitamos el encabezado con tail -n +2 (capítulo 8):

cut -d, -f2 ventas.csv | tail -n +2 | sort
Americano Americano Capuchino Capuchino Capuchino Capuchino Cheesecake Espresso Espresso Espresso Espresso Espresso Latte Latte Latte Mocaccino Torta de chocolate Torta de chocolate

uniq: quitar repetidos (solo si están juntos)

uniq elimina las líneas repetidas, pero solo cuando están una al lado de la otra. Sin ordenar antes, no sirve:

cut -d, -f2 ventas.csv | tail -n +2 | uniq | head -n 4
Espresso Capuchino Latte Espresso

«Espresso» sale dos veces porque no estaban juntos. Por eso uniq casi siempre va después de sort:

cut -d, -f2 ventas.csv | tail -n +2 | sort | uniq
Americano Capuchino Cheesecake Espresso Latte Mocaccino Torta de chocolate

Con -c, además cuenta cuántas veces apareció cada uno:

cut -d, -f2 ventas.csv | tail -n +2 | sort | uniq -c
2 Americano 4 Capuchino 1 Cheesecake 5 Espresso 3 Latte 1 Mocaccino 2 Torta de chocolate

El informe completo

Falta ordenar por esa cuenta, de mayor a menor. sort -n ordena como números (no como texto) y -r invierte el orden:

cut -d, -f2 ventas.csv | tail -n +2 | sort | uniq -c | sort -rn
5 Espresso 4 Capuchino 3 Latte 2 Torta de chocolate 2 Americano 1 Mocaccino 1 Cheesecake
El ranking de productos, tramo a tramo cut -d, -f2 la columna producto | tail -n +2 sin el encabezado | sort agrupa iguales | uniq -c cuenta cada uno | sort -rn mayor primero
Fig. 14.1 · Cinco comandos pequeños forman un informe. Cada uno recibe lo que produce el anterior.

Cambiando solo la columna, Ana sabe cómo le pagan (la quinta columna):

cut -d, -f5 ventas.csv | tail -n +2 | sort | uniq -c | sort -rn
8 yape 6 tarjeta 4 efectivo
Cuenta ventas, no unidades. El ranking cuenta en cuántas ventas aparece cada producto, no cuántas tazas se vendieron (eso está en la columna cantidad). Sumar columnas requiere una herramienta más, awk, o un pequeño script: lo harás en la parte V.

Ordenar por una columna numérica

Con -t, le dices a sort que las columnas se separan por comas y con -k4 que ordene por la cuarta (el precio). Los tres productos más baratos y los tres más caros:

tail -n +2 ventas.csv | sort -t, -k4 -n | head -n 3
2026-07-13,Espresso,1,7,yape 2026-07-13,Espresso,2,7,efectivo 2026-07-14,Espresso,3,7,yape
tail -n +2 ventas.csv | sort -t, -k4 -nr | head -n 3
2026-07-14,Cheesecake,1,13,tarjeta 2026-07-15,Torta de chocolate,1,12,yape 2026-07-15,Mocaccino,2,12,yape

Y combinando con grep, cuántas ventas hubo el 15 de julio:

grep "^2026-07-15" ventas.csv | wc -l
7
ComandoQué hace
wc -lCuenta líneas (-w palabras, -c bytes)
cut -d, -f2Columna 2, separadas por comas (-f1,5 varias)
sort / sort -rOrdena / al revés
sort -nOrdena como números
sort -t, -k4 -nOrdena por la columna 4, numérica
uniq / uniq -cQuita repetidos juntos / y los cuenta
Regla de oro: antes de uniq, siempre sort. Y antes de procesar un CSV, mira su primera línea con head: si es un encabezado, quítalo con tail -n +2.

Practica

Básico¿Cuántas ventas hubo cada día? Usa la columna de la fecha.

Ver solución 1
cut -d, -f1 ventas.csv | tail -n +2 | sort | uniq -c
5 2026-07-13 6 2026-07-14 7 2026-07-15

Mismo patrón que el ranking, con la columna 1.

Reto¿Qué productos se pagaron con Yape y cuántas veces cada uno? Ordénalos del más frecuente al menos frecuente.

Ver solución 2
grep "yape$" ventas.csv | cut -d, -f2 | sort | uniq -c | sort -rn
3 Capuchino 2 Espresso 1 Torta de chocolate 1 Mocaccino 1 Latte

grep filtra las filas, cut se queda con el producto y el resto es el ranking del capítulo.

Puntos clave

  • wc -l cuenta líneas; cut -d, -fN extrae columnas.
  • sort ordena; -n numérico, -r inverso, -t y -k por columna.
  • uniq solo detecta repetidos adyacentes: va después de sort.
  • El patrón clásico de ranking: sort | uniq -c | sort -rn.

15 · Usuarios y permisos: ls -l y chmod

Intermedio ~20 min

Linux y macOS son sistemas multiusuario: cada archivo tiene un dueño, y el sistema decide quién puede leerlo, modificarlo o ejecutarlo. Esa información aparece en ls -l como una cadena misteriosa, -rw-r--r--. Hoy la descifrarás, y aprenderás a cambiarla con chmod, lo que necesitarás para ejecutar tus propios scripts en la parte V.

En este capítulo aprenderás a:

  • leer cada columna de ls -l;
  • entender los permisos de lectura, escritura y ejecución;
  • cambiarlos con chmod en forma simbólica y numérica;
  • saber qué significan los permisos en una carpeta.

Las columnas de ls -l

ls -l
total 16 drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 css drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 img -rw-r--r-- 1 ana ana 215 Jul 15 08:59 index.html -rw-r--r-- 1 ana ana 104 Jul 15 08:59 menu.html
ColumnaEjemploSignifica
Tipo y permisos-rw-r--r--Qué es y quién puede hacer qué (ver abajo)
Enlaces1Cuántos nombres apuntan a este archivo (no lo necesitarás por ahora)
DueñoanaEl usuario propietario
GrupoanaEl grupo propietario (en Ubuntu, cada usuario tiene un grupo con su nombre)
Tamaño215En bytes (con -h, en K, M, G)
FechaJul 15 08:59Última modificación
Nombreindex.htmlEl archivo o la carpeta
Cómo se leen los permisos $ - tipo rwx dueño (u) r-x grupo (g) r-x otros (o)
Fig. 15.1 · El primer carácter es el tipo (- archivo, d carpeta). Luego tres grupos de tres: lo que pueden hacer el dueño, su grupo y todos los demás. Una letra es un permiso; un guion, su ausencia.
LetraEn un archivoEn una carpeta
r (read)Leer el contenidoListar lo que contiene
w (write)ModificarloCrear, renombrar o borrar dentro
x (execute)Ejecutarlo como programaEntrar en ella (cd)

Así, -rw-r--r-- se lee: archivo; el dueño puede leer y escribir; el grupo y los demás, solo leer.

chmod: cambiar permisos

Ana escribió su primer script (lo harás tú en el capítulo 20). Al intentar ejecutarlo, el sistema se niega: el archivo no tiene permiso x. chmod u+x («al usuario dueño, agrega ejecución») lo resuelve:

ls -l saludo.sh
-rw-r--r-- 1 ana ana 40 Jul 15 08:59 saludo.sh
./saludo.sh
bash: ./saludo.sh: Permission denied
chmod u+x saludo.sh
ls -l saludo.sh
-rwxr--r-- 1 ana ana 40 Jul 15 08:59 saludo.sh
./saludo.sh
Hola desde un script

El ./ delante del nombre significa «el archivo de esta carpeta» (capítulo 18 explica por qué hace falta).

La forma simbólica combina quién (u dueño, g grupo, o otros, a todos), qué hacer (+ agregar, - quitar) y qué permiso. Quitar la escritura protege un archivo de cambios accidentales, incluso los tuyos:

chmod a-w menu.html
ls -l menu.html
-r--r--r-- 1 ana ana 104 Jul 15 08:59 menu.html
echo "<p>Nuevo</p>" >> menu.html
bash: menu.html: Permission denied
chmod u+w menu.html
echo "<p>Nuevo</p>" >> menu.html

Permisos en números

Verás a menudo los permisos escritos como tres números. Cada permiso vale un número y se suman: r = 4, w = 2 y x = 1. Cada cifra corresponde a dueño, grupo y otros:

NúmeroPermisosUso típico
644rw-r--r--Archivos normales: tú editas, los demás leen
755rwxr-xr-xScripts y carpetas: todos pueden ejecutar o entrar
600rw-------Archivos privados: solo tú (claves, configuraciones)
700rwx------Carpetas privadas

stat muestra los permisos en las dos formas:

chmod 600 claves.txt
chmod 755 saludo.sh
stat -c "%A %a %n" claves.txt saludo.sh index.html
-rw------- 600 claves.txt -rwxr-xr-x 755 saludo.sh -rw-r--r-- 644 index.html
Las llaves SSH del curso de Git son el caso típico de 600: si tu llave privada tuviera permisos más abiertos, SSH se negaría a usarla por seguridad.

La x en las carpetas

En una carpeta, r permite ver los nombres de lo que contiene y x, entrar. Sin x, ni siquiera el dueño puede abrirla, aunque todavía vea la lista:

ls -ld img
drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 img
chmod u-x img
ls img
local.jpg logo.png
cd img
bash: cd: img: Permission denied
chmod u+x img

Tu propia carpeta personal es un buen ejemplo: en Ubuntu tiene permisos 750, así que otros usuarios del sistema no pueden entrar.

whoami
ana
ls -ld ~
drwxr-x--- 3 ana ana 4096 Jul 15 08:59 /home/ana
En Git Bash los permisos son distintos. Windows maneja los permisos a su manera y chmod casi no tiene efecto en Git Bash. Para practicar este capítulo, usa WSL, Linux o macOS.
Regla de oro: da solo los permisos necesarios. Nunca uses chmod 777 («todos pueden todo») para «arreglar» un error de permisos: abre la puerta a cualquiera. Averigua qué permiso falta y agrega solo ese.

Practica

BásicoCrea con printf un script listo.sh que muestre «Listo», dale permiso de ejecución solo a ti y ejecútalo. Comprueba sus permisos.

Ver solución 1
printf '#!/bin/bash\necho "Listo"\n' > listo.sh
chmod u+x listo.sh
./listo.sh
ls -l listo.sh
Listo -rwxr--r-- 1 ana ana 25 Jul 15 08:59 listo.sh

Sin chmod u+x, ./listo.sh respondería «Permission denied».

RetoCrea un archivo claves.txt que solo tú puedas leer y escribir, y una carpeta publico en la que todos puedan entrar pero solo tú puedas crear archivos. Comprueba ambos en forma simbólica y numérica.

Ver solución 2
touch claves.txt
mkdir publico
chmod 600 claves.txt
chmod 755 publico
stat -c "%A %a %n" claves.txt publico
-rw------- 600 claves.txt drwxr-xr-x 755 publico

600 = rw para el dueño y nada para el resto; 755 = rwx para el dueño y r-x (ver y entrar) para los demás.

Puntos clave

  • ls -l muestra tipo, permisos, dueño, grupo, tamaño, fecha y nombre.
  • Permisos rwx para dueño, grupo y otros; en carpetas, x permite entrar.
  • chmod u+x archivo agrega ejecución; a-w quita escritura a todos.
  • En números: r=4, w=2, x=1. Típicos: 644, 755, 600.
  • Nunca chmod 777.

16 · sudo e instalar programas

Intermedio ~16 min

Instalar programas desde la terminal es más rápido y más seguro que descargar instaladores de páginas web: un gestor de paquetes los baja de repositorios oficiales, verifica que no estén alterados y los mantiene actualizados. Para instalar en el sistema necesitas permisos de administrador, y ahí entra sudo, el comando que exige más responsabilidad.

En este capítulo aprenderás a:

  • entender qué es el usuario root y para qué sirve sudo;
  • instalar, actualizar y desinstalar programas con apt (Ubuntu y WSL);
  • conocer los equivalentes de macOS (Homebrew) y Windows (winget);
  • usar sudo sin poner en riesgo tu sistema.

root y sudo

En Linux existe un usuario especial, root, que puede hacer cualquier cosa en el sistema: modificar /etc, instalar programas, borrar lo que sea. Por seguridad, no trabajas como root. Cuando una tarea lo requiere, antepones sudo (superuser do) a ese comando concreto:

sudo apt update

La primera vez, sudo te pide tu contraseña (la de tu usuario, no una de root):

[sudo] password for ana:

Al escribirla no verás nada, ni asteriscos: es normal. Escríbela y presiona Enter. En Ubuntu, sudo la recuerda durante 15 minutos. Solo los usuarios autorizados (los administradores) pueden usarlo.

apt: el gestor de paquetes de Ubuntu

En Ubuntu (y en WSL), los programas se instalan con apt. Primero se actualiza la lista de programas disponibles; después se instala:

sudo apt update            # descarga la lista actualizada de paquetes
sudo apt install tree      # instala el programa tree
ComandoQué hace¿Necesita sudo?
apt search palabraBusca paquetesNo
apt show paqueteDescribe un paqueteNo
sudo apt updateActualiza la lista de paquetes disponiblesSí
sudo apt install paqueteInstalaSí
sudo apt upgradeActualiza todos los programas instaladosSí
sudo apt remove paqueteDesinstalaSí

apt te mostrará qué va a instalar y te preguntará «Do you want to continue? [Y/n]»: responde Y o simplemente Enter.

Probar lo instalado

tree muestra una carpeta como árbol, ideal para ver la estructura de un proyecto:

tree proyectos
proyectos └── aroma ├── css │   └── estilos.css ├── img │   ├── local.jpg │   └── logo.png ├── index.html └── menu.html 4 directories, 5 files

¿Cómo saber si un programa ya está instalado? command -v muestra dónde está, o nada si no existe:

command -v tree
/usr/bin/tree
command -v programa-que-no-existe || echo "no está instalado"
no está instalado

macOS: Homebrew

macOS no trae gestor de paquetes. El más usado es Homebrew, que se instala con el comando publicado en su sitio oficial, brew.sh:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Después, los programas se instalan sin sudo:

brew install tree
brew upgrade               # actualiza todo lo instalado con Homebrew

Windows: winget

Git Bash no tiene gestor de paquetes: los programas de Windows se instalan con winget, desde PowerShell (por ejemplo, winget install --id GitHub.cli, como en el curso de Git). En WSL usas apt, porque es un Ubuntu completo.

sudo con responsabilidad

Con sudo, el sistema deja de protegerte: un error ya no se limita a tus archivos. Por eso:

  • Usa sudo solo para el comando que lo necesita, no «por si acaso».
  • Si un comando falla con «Permission denied» en tus archivos, el problema son los permisos (capítulo 15), no la falta de sudo.
  • Nunca combines sudo con rm -rf sin leer dos veces.
  • Instala solo desde fuentes oficiales: el comando de Homebrew de arriba descarga y ejecuta un script de internet; es seguro porque viene del sitio oficial, pero el mismo patrón con un sitio desconocido es peligroso.
Un atajo útil: si olvidaste sudo, escribe sudo !!: Bash reemplaza !! por el comando anterior completo.
Regla de oro: sudo es para administrar el sistema, no para trabajar. Si te encuentras usándolo con tus propios archivos, detente y revisa qué está pasando.

Practica

BásicoComprueba si tree y git están instalados y muestra el árbol de la carpeta css del proyecto.

Ver solución 1
command -v tree git
tree proyectos/aroma/css
/usr/bin/tree /usr/local/bin/git proyectos/aroma/css └── estilos.css 1 directory, 1 file

Si alguno faltara, command -v no mostraría nada para él. En Ubuntu se instala con sudo apt install tree.

RetoMuestra con tree solo las carpetas de proyectos y, después, el proyecto de Ana sin bajar más de un nivel. Consulta tree --help para encontrar las opciones.

Ver solución 2
tree -d proyectos
tree -L 1 proyectos/aroma
proyectos └── aroma ├── css └── img 4 directories proyectos/aroma ├── css ├── img ├── index.html └── menu.html 3 directories, 2 files

-d muestra solo carpetas (directories) y -L 1 limita la profundidad (level).

Puntos clave

  • root puede todo; sudo te da ese poder para un solo comando y pide TU contraseña (no se ve al escribirla).
  • Ubuntu/WSL: sudo apt update y sudo apt install programa.
  • macOS: Homebrew (brew install, sin sudo). Windows: winget desde PowerShell.
  • command -v programa dice si está instalado.
  • Nunca uses sudo «por si acaso» ni con comandos que no entiendes.

17 · Procesos: ver, pausar y detener programas

Intermedio ~18 min

Cada programa que se ejecuta en tu computadora es un proceso: tu navegador, el editor, incluso cada comando que escribes. A veces un programa se cuelga, tarda demasiado o quieres que trabaje sin bloquear tu terminal. En este capítulo aprenderás a ver qué se está ejecutando, a enviar tareas al fondo y a detener lo que haga falta.

En este capítulo aprenderás a:

  • ver los procesos con ps, top y htop;
  • ejecutar comandos en segundo plano con & y manejarlos con jobs, fg y bg;
  • pausar y cancelar con Ctrl + Z y Ctrl + C;
  • detener procesos con kill.

ps: los procesos de tu terminal

Cada proceso tiene un número único, el PID (process identifier). ps muestra los de tu terminal:

ps
PID TTY TIME CMD 2401 pts/0 00:00:00 bash 2402 pts/0 00:00:00 ps

Hay dos: Bash (tu shell) y el propio ps, que estaba en marcha mientras se mostraba la lista. TTY es el nombre de tu terminal.

Tus números serán otros. El sistema asigna los PID al vuelo. En este capítulo los renumeramos para que el manual sea siempre igual; en tu terminal verás valores distintos.

Primer plano y segundo plano

Normalmente, un comando ocupa la terminal hasta que termina: está en primer plano. sleep 300 espera 300 segundos y mientras tanto no podrías escribir nada. Con & al final, el comando se va al segundo plano y la terminal queda libre al instante. Bash te informa el número de trabajo y el PID:

sleep 300 &
[1] 2402
sleep 500 &
[2] 2403
jobs
[1]- Running sleep 300 & [2]+ Running sleep 500 &
ps
PID TTY TIME CMD 2401 pts/0 00:00:00 bash 2402 pts/0 00:00:00 sleep 2403 pts/0 00:00:00 sleep 2404 pts/0 00:00:00 ps

jobs lista los trabajos en segundo plano de esta terminal. El + marca el más reciente (el que usarán fg y bg si no indicas otro).

Ctrl + C, Ctrl + Z, fg y bg

AcciónQué hace
Ctrl + CCancela el comando en primer plano
Ctrl + ZLo pausa (queda «Stopped») y te devuelve la terminal
fg / fg %2Trae un trabajo al primer plano
bg / bg %2Reanuda un trabajo pausado en segundo plano
jobsLista los trabajos de esta terminal

Ctrl + Z envía al proceso la señal STOP. Aquí la enviamos con kill -STOP para que veas el efecto en la lista de trabajos, y luego lo reanudamos en segundo plano:

kill -STOP %1
jobs
[1]+ Stopped sleep 300
bg %1
[1]+ sleep 300 &
jobs
[1]+ Running sleep 300 &
kill %1
[1]+ Terminated sleep 300

kill: detener procesos

kill envía una señal a un proceso. Sin indicar cuál, envía TERM: «termina, por favor». Puedes referirte al proceso por su número de trabajo (%1) o por su PID:

jobs -l
[1]- 2401 Running sleep 300 & [2]+ 2402 Running sleep 500 &
kill %1
[1]- Terminated sleep 300
jobs
[2]+ Running sleep 500 &

Si un programa no responde a TERM, la señal 9 (KILL) lo detiene sin darle opción. Es el último recurso: el programa no alcanza a guardar nada.

jobs -l
[1]+ 2401 Running sleep 300 &
kill -9 %1
[1]+ Killed sleep 300

top y htop: el monitor en vivo

Para ver todos los procesos del sistema ordenados por consumo de procesador o memoria, usa top (viene en Linux y macOS) o htop, más amigable (en Ubuntu: sudo apt install htop). Se actualizan cada segundo; salen con q.

top
htop

Para una foto fija de todos los procesos, ps aux; combinado con grep (capítulo 12) encuentras el que buscas, por ejemplo el PID de un servidor que quedó colgado:

ps aux | grep python
kill 12345            # el PID que encontraste
Columna de ps auxSignifica
USERDueño del proceso
PIDNúmero de proceso
%CPU / %MEMUso de procesador y de memoria
STATEstado: R ejecutándose, S esperando, T detenido
COMMANDEl comando que lo inició
Cierra la terminal y los trabajos mueren. Los trabajos en segundo plano pertenecen a tu terminal: si la cierras, normalmente terminan con ella. Para tareas que deben seguir (un servidor, una descarga enorme) existen herramientas como nohup, tmux o los servicios del sistema, que verás en cursos posteriores.
Regla de oro: para detener un programa, intenta primero lo amable: Ctrl + C o kill (TERM). Usa kill -9 solo si no responde: corta en seco y puede dejar archivos a medio escribir.

Practica

BásicoLanza dos esperas en segundo plano (200 y 400 segundos), lista los trabajos con su PID y detén solo la segunda.

Ver solución 1
sleep 200 &
sleep 400 &
jobs -l
kill %2
[1] 2401 [2] 2402 [1]- 2401 Running sleep 200 & [2]+ 2402 Running sleep 400 & [2]+ Terminated sleep 400

Bash avisa «Terminated» cuando el trabajo termina. En tu terminal, los PID serán otros.

RetoLanza una espera de 300 segundos en segundo plano, comprueba con ps que existe y detenla con la señal que no se puede ignorar.

Ver solución 2
sleep 300 &
ps
kill -9 %1
[1] 2402 PID TTY TIME CMD 2401 pts/0 00:00:00 bash 2402 pts/0 00:00:00 sleep 2403 pts/0 00:00:00 ps [1]+ Killed sleep 300

kill -9 (KILL) termina el proceso sin darle opción: Bash informa «Killed».

Puntos clave

  • Cada proceso tiene un PID; ps lista los de tu terminal y ps aux, todos.
  • comando & lo ejecuta en segundo plano; jobs lista los trabajos.
  • Ctrl+C cancela, Ctrl+Z pausa; fg y bg los reanudan.
  • kill %1 o kill PID pide terminar; kill -9 obliga.
  • top y htop muestran el sistema en vivo (salir con q).

18 · Variables de entorno y el PATH

Intermedio ~18 min

Ya usaste $BASH_VERSION en el capítulo 2: era una variable, un nombre que guarda un valor. Bash tiene muchas, y tú puedes crear las tuyas. Son la base de los scripts de la parte V y la clave de un misterio que quedó pendiente: ¿cómo sabe la terminal dónde está el programa ls cuando escribes ls?

En este capítulo aprenderás a:

  • leer las variables del sistema como HOME y USER;
  • crear tus variables y usarlas dentro de textos;
  • guardar la salida de un comando en una variable con $( );
  • entender el PATH y agregarle tus propias carpetas.

Leer una variable: $

Para usar el valor de una variable se antepone $ a su nombre. Algunas las define el sistema al abrir la terminal:

echo $HOME
/home/ana
echo $USER
ana
echo $PWD
/home/ana
VariableContiene
HOMETu carpeta personal (lo mismo que ~)
USERTu nombre de usuario
PWDLa carpeta actual (lo que muestra pwd)
PATHDónde buscar los programas (más abajo)
SHELLTu shell

Crear tus variables

Se escribe nombre=valor. Fíjate en la diferencia entre comillas: las dobles reemplazan las variables que contienen; las simples dejan el texto tal cual:

cafe="Aroma y Punto"
echo $cafe
Aroma y Punto
echo "Bienvenido a $cafe"
Bienvenido a Aroma y Punto
echo 'Bienvenido a $cafe'
Bienvenido a $cafe

La regla más importante: sin espacios alrededor del =. Con espacios, Bash cree que cafe es un comando:

cafe = "Aroma y Punto"
bash: cafe: command not found

Si justo después del nombre viene más texto, usa llaves para marcar dónde termina:

plato=torta
echo "Hoy hay $platos"
Hoy hay
echo "Hoy hay ${plato}s"
Hoy hay tortas

$platos es otra variable, que no existe (vale vacío); ${plato}s es «el valor de plato, seguido de s».

La salida de un comando en una variable: $( )

$(comando) se reemplaza por lo que ese comando escribe. Así guardas la fecha de hoy (date +%F la da en formato año-mes-día) o metes un cálculo dentro de un texto:

hoy=$(date +%F)
echo "Respaldo del $hoy"
Respaldo del 2026-07-15
echo "Hay $(ls | wc -l) elementos aquí"
Hay 4 elementos aquí

export: variables para los programas que lanzas

Una variable recién creada solo existe en tu shell. Los programas que ejecutas desde él (incluso otro Bash) no la ven, a menos que la exportes. Las exportadas se llaman variables de entorno:

sabor=vainilla
bash -c 'echo "Sabor: $sabor"'
Sabor:
export sabor
bash -c 'echo "Sabor: $sabor"'
Sabor: vainilla

El PATH: dónde viven los comandos

Cuando escribes ls, Bash busca un programa con ese nombre en las carpetas listadas en PATH, separadas por :, en ese orden. El primero que encuentra, gana:

echo $PATH
/usr/local/bin:/usr/bin:/bin
command -v ls cp date
/usr/bin/ls /usr/bin/cp /usr/bin/date
Cómo encuentra Bash un comando Escribes: ls Bash recorre el PATH en orden 1.ª carpeta /usr/local/bin/ls no existe: sigue 2.ª carpeta /usr/bin/ls existe: lo ejecuta
Fig. 18.1 · Bash prueba cada carpeta del PATH, de izquierda a derecha, y ejecuta el primer programa con ese nombre. Si no lo encuentra en ninguna: «command not found».

(El PATH de tu equipo será más largo; este es el del laboratorio del manual.) Ahora se entiende el ./ del capítulo 15: la carpeta actual no está en el PATH, así que para ejecutar un script que está aquí hay que decir explícitamente «el de esta carpeta».

Tus propios comandos

Ana guardó un pequeño script llamado buendia en ~/bin. Mientras esa carpeta no esté en el PATH, Bash no lo encuentra. Al agregarla al principio, funciona desde cualquier carpeta como un comando más:

ls ~/bin
buendia
buendia
bash: buendia: command not found
export PATH="$HOME/bin:$PATH"
buendia
¡Buen día, ana!
command -v buendia
/home/ana/bin/buendia

Este cambio dura hasta que cierres la terminal. Para hacerlo permanente se agrega la línea export PATH=… al archivo ~/.bashrc: lo verás en el capítulo 19.

Nunca reemplaces el PATH: agrégale. Escribe siempre PATH="nueva:$PATH". Si escribes PATH="nueva" a secas, borras todas las demás carpetas y comandos como ls dejan de existir hasta que abras otra terminal.
Regla de oro: al usar una variable dentro de un comando, ponla entre comillas dobles: "$archivo". Si el valor tiene espacios, sin comillas se partiría en varios argumentos (capítulo 3).

Practica

BásicoCrea las variables nombre y cafe y úsalas en una frase. Comprueba qué pasa con comillas simples.

Ver solución 1
nombre="Ana"
cafe="Aroma y Punto"
echo "Hola, soy $nombre de $cafe"
echo 'Esto no se reemplaza: $nombre'
Hola, soy Ana de Aroma y Punto Esto no se reemplaza: $nombre

Comillas dobles: Bash reemplaza las variables. Simples: el texto queda literal.

RetoGuarda en una variable cuántas páginas .html tiene el proyecto y muéstralo en una frase junto con la fecha de hoy.

Ver solución 2
cantidad=$(ls *.html | wc -l)
echo "El $(date +%F) el proyecto tiene $cantidad páginas"
El 2026-07-15 el proyecto tiene 2 páginas

$( ) guarda la salida de un comando; puede ir también directamente dentro de un texto.

Puntos clave

  • nombre=valor sin espacios; se lee con $nombre o ${nombre}.
  • Comillas dobles reemplazan variables; simples, no.
  • $(comando) inserta la salida de un comando.
  • export hace que los programas lanzados vean la variable.
  • PATH lista dónde se buscan los comandos; se amplía con PATH="carpeta:$PATH".

19 · Personaliza tu terminal: alias, historial y .bashrc

Básico ~16 min

Llevas 18 capítulos escribiendo comandos. Es hora de que la terminal trabaje para ti: atajos para los comandos que más usas, un historial que recuerda todo lo que escribiste y un archivo de configuración donde guardar tus preferencias para siempre. Con esto termina la parte IV.

En este capítulo aprenderás a:

  • crear atajos con alias;
  • aprovechar el historial: history, !! y Ctrl + R;
  • guardar tu configuración en ~/.bashrc;
  • cambiar el aspecto del prompt.

alias: tus propios atajos

Un alias es un nombre corto que Bash reemplaza por un comando más largo antes de ejecutarlo:

alias ll="ls -alF"
ll proyectos/aroma
total 24 drwxr-xr-x 4 ana ana 4096 Jul 15 08:59 ./ drwxr-xr-x 3 ana ana 4096 Jul 15 08:59 ../ drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 css/ drwxr-xr-x 2 ana ana 4096 Jul 15 08:59 img/ -rw-r--r-- 1 ana ana 215 Jul 15 08:59 index.html -rw-r--r-- 1 ana ana 104 Jul 15 08:59 menu.html
alias
alias ll='ls -alF'
unalias ll
ll
bash: ll: command not found

alias sin argumentos lista los que tienes y unalias borra uno. Los alias creados así duran hasta cerrar la terminal.

Ubuntu ya trae algunos. Su configuración inicial define ll (ls -alF), la y l, y hace que ls y grep usen colores. Escribe alias en tu terminal para verlos.

El historial

Bash guarda los comandos que escribes. Además de las flechas ↑ y ↓, tienes:

AtajoQué hace
historyLista los últimos comandos, numerados
history | grep cpBusca en el historial (capítulo 12)
!!Repite el último comando (útil: sudo !!)
!125Repite el comando número 125 del historial
Ctrl + RBúsqueda interactiva: escribe parte del comando; Ctrl+R otra vez, el anterior; Enter lo ejecuta

Ctrl + R es el que más tiempo ahorra. Al presionarlo, el prompt cambia a (reverse-i-search)`':; empieza a escribir y aparece el comando más reciente que contiene ese texto.

history | tail -n 5

~/.bashrc: tu configuración permanente

Cada vez que abres una terminal, Bash lee el archivo oculto ~/.bashrc y ejecuta lo que contiene. Es el lugar para tus alias, tus variables (como el PATH del capítulo 18) y opciones como noclobber (capítulo 10). Puedes editarlo con nano ~/.bashrc o agregar líneas con >> (¡nunca con >!):

echo 'alias ll="ls -alF"' >> ~/.bashrc
echo 'alias aroma="cd ~/proyectos/aroma"' >> ~/.bashrc
echo 'set -o noclobber' >> ~/.bashrc
cat ~/.bashrc
alias ll="ls -alF" alias aroma="cd ~/proyectos/aroma" set -o noclobber
source ~/.bashrc
aroma
pwd
/home/ana/proyectos/aroma

Los cambios se aplican en las terminales que abras desde ahora. Para aplicarlos en la actual, sin cerrarla, se usa source ~/.bashrc.

Antes de editar .bashrc, haz una copia. cp ~/.bashrc ~/.bashrc.respaldo. Si un error deja la terminal en mal estado, restauras la copia. En macOS con zsh, el archivo equivalente es ~/.zshrc.

Cambiar el prompt

El prompt se define en la variable PS1, con códigos especiales que Bash reemplaza:

CódigoMuestra
\uTu usuario
\hEl nombre de la computadora
\wLa carpeta actual (con ~)
\WSolo el nombre de la carpeta actual
\$$ (o # si eres root)

Pruébalo en tu terminal; si te gusta, agrégalo a ~/.bashrc:

PS1='\u en \W \$ '
# el prompt se verá así:  ana en aroma $
ArchivoCuándo se lee
~/.bashrcAl abrir una terminal con Bash (Linux, WSL, Git Bash)
~/.bash_profile / ~/.profileAl iniciar sesión (en muchos sistemas, cargan ~/.bashrc)
~/.zshrcAl abrir una terminal con zsh (macOS)
Regla de oro: agrega a ~/.bashrc solo lo que entiendes y de a una línea a la vez, probando con source ~/.bashrc. Así, si algo falla, sabes exactamente qué fue.

Practica

BásicoCrea un alias cuenta que muestre cuántos elementos hay en la carpeta actual y pruébalo en img.

Ver solución 1
alias cuenta="ls | wc -l"
cd proyectos/aroma/img
cuenta
8

Un alias puede contener una tubería completa.

RetoAgrega a tu ~/.bashrc un alias menu que muestre el menú de Ana numerado, aplícalo sin cerrar la terminal y úsalo.

Ver solución 2
echo 'alias menu="cat -n ~/proyectos/aroma/menu.html"' >> ~/.bashrc
source ~/.bashrc
menu
1 <h1>Menú</h1> 2 <ul> 3 <li>Espresso S/ 7</li> 4 <li>Americano S/ 8</li> 5 <li>Capuchino S/ 10</li> 6 </ul>

Comillas simples por fuera para que el texto llegue literal al archivo; source aplica el cambio de inmediato.

Puntos clave

  • alias nombre="comando" crea un atajo; alias los lista y unalias los borra.
  • Historial: history, !!, !n y sobre todo Ctrl + R.
  • ~/.bashrc se ejecuta al abrir cada terminal: ahí van alias, PATH y opciones.
  • source ~/.bashrc aplica los cambios sin cerrar la terminal.
  • El prompt se personaliza con PS1 (\u, \w, \$…).

20 · Tu primer script

Intermedio ~18 min

Todo lo que escribiste en la terminal puede guardarse en un archivo y ejecutarse cuando quieras, las veces que quieras. Eso es un script: un programa hecho con los mismos comandos que ya conoces. En esta parte aprenderás a escribirlos, y al final tendrás un script de respaldo que funciona de verdad.

En este capítulo aprenderás a:

  • crear y ejecutar un script de Bash;
  • entender la línea #! (shebang) y los comentarios;
  • recibir datos con argumentos ($1, $#…) y con read;
  • saber si un comando funcionó con el código de salida $?.

Un archivo con comandos

Crea el archivo con nano saludo.sh (capítulo 5) y escribe:

#!/usr/bin/env bash
# saludo.sh — mi primer script: saluda y muestra dónde estoy
echo "Hola, $USER"
echo "Hoy es $(date +%F)"
echo "Estás en: $(pwd)"
LíneaPara qué
#!/usr/bin/env bashEl shebang: indica que este archivo lo ejecuta Bash. Siempre va en la primera línea
# …Un comentario: Bash lo ignora; sirve para explicar el script a quien lo lea
El restoComandos normales, uno por línea, como si los escribieras en la terminal

Ejecutarlo

Hay dos formas. Con bash saludo.sh funciona de inmediato. Para ejecutarlo como cualquier programa (./saludo.sh) necesita permiso de ejecución, como viste en el capítulo 15:

bash saludo.sh
Hola, ana Hoy es 2026-07-15 Estás en: /home/ana/proyectos/aroma
./saludo.sh
bash: ./saludo.sh: Permission denied
chmod u+x saludo.sh
./saludo.sh
Hola, ana Hoy es 2026-07-15 Estás en: /home/ana/proyectos/aroma
¿Por qué /usr/bin/env bash? Busca Bash en tu PATH (capítulo 18) en lugar de una ruta fija. Así el script usa el Bash moderno aunque esté instalado en otro lugar, como pasa en macOS con Homebrew.

Argumentos: datos al ejecutar

Lo que escribes después del nombre del script llega en variables especiales: $1 es el primer argumento, $2 el segundo, y así. Este script crea una página con el título y el nombre de archivo que le indiques:

#!/usr/bin/env bash
# pagina.sh — crea una página HTML: ./pagina.sh "Título" archivo.html
titulo="$1"
archivo="$2"
echo "<h1>$titulo</h1>" > "$archivo"
echo "Creé $archivo con el título «$titulo»"
echo "(el script $0 recibió $# argumentos)"
./pagina.sh "Carta de postres" postres.html
Creé postres.html con el título «Carta de postres» (el script ./pagina.sh recibió 2 argumentos)
cat postres.html
<h1>Carta de postres</h1>
VariableContiene
$0El nombre del script
$1, $2…Primer, segundo… argumento
$#Cuántos argumentos recibió
"$@"Todos los argumentos, cada uno por separado
$?El código de salida del último comando (más abajo)

Fíjate en las comillas: "Carta de postres" es un solo argumento gracias a ellas (capítulo 3), y dentro del script "$titulo" y "$archivo" van entre comillas para que los espacios no los partan.

Preguntar: read

read espera a que la persona escriba algo y presione Enter, y lo guarda en una variable. Con -p muestra una pregunta antes:

#!/usr/bin/env bash
# pregunta.sh — conversa con quien lo ejecuta
read -p "¿Cómo te llamas? " nombre
echo "Bienvenido a Aroma y Punto, $nombre"
./pregunta.sh
¿Cómo te llamas? Luis Bienvenido a Aroma y Punto, Luis

(En el manual, «Luis» es lo que se tecleó como respuesta.)

¿Funcionó? El código de salida

Todo comando, al terminar, deja un número llamado código de salida: 0 significa éxito y cualquier otro valor, error. $? guarda el del último comando:

ls menu.html
menu.html
echo $?
0
ls noexiste.html
ls: cannot access 'noexiste.html': No such file or directory
echo $?
2

En el capítulo 21 usarás estos códigos para que tus scripts tomen decisiones. Dentro de un script, exit 0 termina con éxito y exit 1, con error.

Regla de oro: empieza cada script con el shebang y un comentario que diga qué hace y cómo se usa. Dentro de seis meses, esa línea te ahorrará tener que leer todo el código para recordarlo.

Practica

BásicoCrea, solo con echo, un script hora.sh que muestre la hora actual; dale permiso de ejecución y ejecútalo.

Ver solución 1
echo '#!/usr/bin/env bash' > hora.sh
echo 'echo "Son las $(date +%H:%M)"' >> hora.sh
chmod u+x hora.sh
./hora.sh
Son las 09:00

Las comillas simples por fuera guardan el texto tal cual en el archivo; $(date …) se ejecuta recién al correr el script.

RetoEscribe args.sh, que diga cuántos argumentos recibió y cuáles fueron. Pruébalo con tres argumentos, uno de ellos con espacios.

Ver solución 2
printf '#!/usr/bin/env bash\necho "Recibí $# argumentos: $@"\n' > args.sh
chmod u+x args.sh
./args.sh café "pan con palta" jugo
Recibí 3 argumentos: café pan con palta jugo

«pan con palta» cuenta como un solo argumento gracias a las comillas.

Puntos clave

  • Un script es un archivo de texto con comandos; la primera línea es #!/usr/bin/env bash.
  • Se ejecuta con bash script.sh, o con ./script.sh tras chmod u+x.
  • Los argumentos llegan en $1, $2…; $# los cuenta.
  • read -p "pregunta" variable pide datos al usuario.
  • $? vale 0 si el último comando funcionó y otro número si falló.

21 · Decisiones: if y las pruebas

Intermedio ~20 min

Un script que siempre hace lo mismo es útil; uno que decide según la situación es mucho más poderoso. ¿El archivo existe? ¿Me dieron los argumentos que necesito? ¿El precio es alto o bajo? Con if tu script elige qué hacer, y con unas pocas validaciones deja de romperse cuando alguien lo usa mal.

En este capítulo aprenderás a:

  • escribir decisiones con if, elif y else;
  • probar archivos, textos y números con [[ ]];
  • validar argumentos y terminar con un error claro;
  • usar &&, || y el resultado de cualquier comando como condición.

if, then, else, fi

La estructura es «si se cumple esto, haz aquello; si no, haz lo otro». fi (if al revés) cierra el bloque. La condición va entre dobles corchetes, con espacios después de [[ y antes de ]]:

#!/usr/bin/env bash
# existe.sh — dice si un archivo existe: ./existe.sh nombre
if [[ -f "$1" ]]; then
  echo "Sí, $1 existe"
else
  echo "No encuentro $1"
fi
./existe.sh menu.html
Sí, menu.html existe
./existe.sh carta.html
No encuentro carta.html

-f pregunta «¿existe y es un archivo?». Con elif (else if) encadenas más casos:

#!/usr/bin/env bash
# precio.sh — clasifica un precio en soles: ./precio.sh 12
precio=$1
if [[ $precio -ge 12 ]]; then
  echo "S/ $precio: precio alto"
elif [[ $precio -ge 9 ]]; then
  echo "S/ $precio: precio medio"
else
  echo "S/ $precio: precio económico"
fi
./precio.sh 13
S/ 13: precio alto
./precio.sh 10
S/ 10: precio medio
./precio.sh 7
S/ 7: precio económico

Las pruebas más usadas

PruebaEs verdadera si…
[[ -e ruta ]]la ruta existe (archivo o carpeta)
[[ -f ruta ]] / [[ -d ruta ]]es un archivo / es una carpeta
[[ -z "$texto" ]] / -nel texto está vacío / no está vacío
[[ "$a" == "$b" ]] / !=los textos son iguales / distintos
[[ $n -eq 5 ]] / -neel número es igual / distinto
[[ $n -gt 5 ]] / -gemayor / mayor o igual
[[ $n -lt 5 ]] / -lemenor / menor o igual
[[ ! -f ruta ]]! invierte cualquier prueba
Números y textos se comparan distinto. Para números usa -eq, -lt, -gt…; == compara textos. [[ 10 < 9 ]] es verdadero: como texto, «1» va antes que «9».

Validar antes de trabajar

El script pagina.sh del capítulo 20 tenía un problema: sin argumentos, o con un archivo que ya existe, hacía cosas indeseadas (¡reemplazaba index.html!). Esta versión comprueba todo antes de actuar:

#!/usr/bin/env bash
# pagina.sh — versión segura: valida los argumentos antes de trabajar
if [[ $# -ne 2 ]]; then
  echo "Uso: $0 \"Título\" archivo.html" >&2
  exit 1
fi
if [[ -e "$2" ]]; then
  echo "Error: $2 ya existe; no lo voy a reemplazar" >&2
  exit 1
fi
echo "<h1>$1</h1>" > "$2"
echo "Creé $2"
./pagina.sh
Uso: ./pagina.sh "Título" archivo.html
./pagina.sh "Inicio" index.html
Error: index.html ya existe; no lo voy a reemplazar
echo $?
1
./pagina.sh "Contacto" contacto.html
Creé contacto.html
echo $?
0

>&2 envía el mensaje al canal de errores (capítulo 10) y exit 1 termina el script con código de error, así otros programas saben que falló.

Atajos: && y ||

a && b ejecuta b solo si a funcionó; a || b, solo si falló. Son un if en una línea:

[[ -d img ]] && echo "img es una carpeta"
img es una carpeta
[[ -f logo.png ]] || echo "falta logo.png aquí"
falta logo.png aquí
mkdir respaldo && echo "carpeta creada"
carpeta creada
mkdir respaldo && echo "carpeta creada"
mkdir: cannot create directory ‘respaldo’: File exists

Cualquier comando es una condición

if no necesita corchetes: en realidad pregunta por el código de salida (capítulo 20) del comando que le pongas. grep -q no muestra nada, solo indica con su código si encontró el texto:

#!/usr/bin/env bash
# vendido.sh — ¿se vendió este producto? ./vendido.sh Latte
if grep -q ",$1," ventas.csv; then
  echo "Sí: $1 tiene $(grep -c ",$1," ventas.csv) ventas"
else
  echo "No hay ventas de $1"
fi
./vendido.sh Latte
Sí: Latte tiene 3 ventas
./vendido.sh Frappé
No hay ventas de Frappé
Para muchas opciones: case. Si comparas una variable con varios valores posibles, case es más ordenado que muchos elif. Lo encontrarás en scripts de otras personas; el manual de Bash lo explica en la sección «Conditional Constructs».
Regla de oro: valida los argumentos al inicio de cada script y, si falta algo, muestra cómo se usa y termina con exit 1. Un script que se niega con un mensaje claro es mejor que uno que hace un desastre en silencio.

Practica

BásicoGuarda en una variable el stock de bolsas de café (4) y muestra «Pedir más café» si hay menos de 5, o «Stock suficiente» en caso contrario.

Ver solución 1
stock=4
if [[ $stock -lt 5 ]]; then
  echo "Pedir más café"
else
  echo "Stock suficiente"
fi
Pedir más café

Para comparar números se usa -lt (less than), no <.

RetoEscribe una decisión que cree la carpeta respaldo solo si no existe, y ejecútala dos veces seguidas.

Ver solución 2
if [[ -d respaldo ]]; then echo "respaldo ya existe"; else mkdir respaldo && echo "respaldo creada"; fi
if [[ -d respaldo ]]; then echo "respaldo ya existe"; else mkdir respaldo && echo "respaldo creada"; fi
respaldo creada respaldo ya existe

La primera vez la crea; la segunda, la prueba -d ya es verdadera.

Puntos clave

  • if [[ condición ]]; then … elif …; else …; fi, con espacios dentro de los corchetes.
  • Archivos: -e, -f, -d. Textos: ==, -z. Números: -eq, -gt, -lt…
  • Mensajes de error a >&2 y exit 1 al fallar.
  • && = «si funcionó»; || = «si falló».
  • if comando usa su código de salida; grep -q es ideal para eso.

22 · Repetir: bucles for y while

Intermedio ~20 min

Los comodines del capítulo 9 permitían aplicar un comando a muchos archivos. Los bucles van más allá: repiten un bloque completo de comandos para cada elemento de una lista, o mientras se cumpla una condición. Con ellos Ana podrá, por fin, sumar sus ventas (lo que en el capítulo 14 no pudimos hacer).

En este capítulo aprenderás a:

  • repetir comandos para cada elemento con for;
  • recorrer archivos y renombrarlos en lote;
  • hacer cálculos con $(( ));
  • repetir mientras se cumpla una condición y leer un archivo línea a línea con while.

for: para cada elemento

for variable in lista; do …; done ejecuta el bloque una vez por cada elemento, guardándolo en la variable:

for bebida in Espresso Americano Capuchino; do echo "Hoy hay $bebida"; done
Hoy hay Espresso Hoy hay Americano Hoy hay Capuchino

La lista puede generarse con llaves (capítulo 9):

for i in {1..3}; do echo "Mesa $i lista"; done
Mesa 1 lista Mesa 2 lista Mesa 3 lista

for con archivos

Con un comodín, la lista son los archivos que coinciden. Siempre conviene probar primero con echo qué haría el bucle (la misma idea del capítulo 7):

for foto in postre-*.png; do echo "Procesando $foto"; done
Procesando postre-a.png Procesando postre-b.png Procesando postre-c.png

Si la lista es correcta, cambias el echo por el comando real. Ana agrega el prefijo carta- a las fotos de postres:

for foto in postre-*.png; do mv -v "$foto" "carta-$foto"; done
renamed 'postre-a.png' -> 'carta-postre-a.png' renamed 'postre-b.png' -> 'carta-postre-b.png' renamed 'postre-c.png' -> 'carta-postre-c.png'

En un script (o en la terminal) el bucle se puede escribir en varias líneas, más fácil de leer:

for pagina in *.html; do
  lineas=$(wc -l < "$pagina")
  echo "$pagina tiene $lineas líneas"
done
index.html tiene 11 líneas menu.html tiene 6 líneas
Las comillas de "$foto" no son opcionales. Si un archivo se llamara mi foto.png, sin comillas mv recibiría dos argumentos (mi y foto.png). Dentro de los bucles, encierra siempre la variable entre comillas dobles.

Cálculos: $(( ))

Bash hace aritmética con números enteros dentro de $(( )). Dentro, las variables no necesitan $:

echo $(( 3 * 7 ))
21
precio=12
echo "Dos tortas: S/ $(( precio * 2 ))"
Dos tortas: S/ 24

while: mientras se cumpla

while condición; do …; done repite mientras la condición sea verdadera. Hay que asegurarse de que algo dentro del bucle la haga falsa en algún momento:

contador=3
while [[ $contador -gt 0 ]]; do
  echo "Abrimos en $contador..."
  contador=$(( contador - 1 ))
done
echo "¡Abierto!"
Abrimos en 3... Abrimos en 2... Abrimos en 1... ¡Abierto!
Bucle infinito. Si la condición nunca deja de cumplirse, el bucle no termina. Detenlo con Ctrl + C (capítulo 17) y revisa qué debía cambiar en cada vuelta.

Leer un archivo línea a línea

El uso estrella de while: con read, recorre un archivo y separa cada línea en variables. IFS=, indica que los campos se separan por comas. Por fin, el total de ventas de Ana:

#!/usr/bin/env bash
# total.sh — suma lo vendido en ventas.csv (cantidad × precio de cada línea)
total=0
while IFS=, read -r fecha producto cantidad precio pago; do
  if [[ $fecha == "fecha" ]]; then
    continue                     # salta la línea de encabezado
  fi
  total=$(( total + cantidad * precio ))
done < ventas.csv
echo "Total vendido: S/ $total"
./total.sh
Total vendido: S/ 296

continue salta al siguiente ciclo (aquí, para ignorar el encabezado) y break sale del bucle. Y combinando los dos bucles, el total de cada día:

#!/usr/bin/env bash
# por-dia.sh — total vendido en cada día
for dia in 2026-07-13 2026-07-14 2026-07-15; do
  total=0
  while IFS=, read -r fecha producto cantidad precio pago; do
    total=$(( total + cantidad * precio ))
  done < <(grep "^$dia" ventas.csv)
  echo "$dia: S/ $total"
done
./por-dia.sh
2026-07-13: S/ 88 2026-07-14: S/ 91 2026-07-15: S/ 117

<(comando) entrega la salida de un comando como si fuera un archivo, para que while la lea.

EstructuraRepite…
for x in a b c; do …; doneuna vez por cada elemento de la lista
for f in *.png; do …; doneuna vez por cada archivo que coincide
for i in {1..10}; do …; donepara una secuencia de números
while [[ cond ]]; do …; donemientras la condición sea verdadera
while read -r linea; do …; done < archivouna vez por cada línea del archivo
Regla de oro: antes de un bucle que modifica archivos (mv, rm, cp), ejecútalo una vez con echo delante del comando. Si la lista de acciones es la correcta, quita el echo.

Practica

BásicoCon un for, muestra el tamaño en bytes de cada página .html del proyecto.

Ver solución 1
for f in *.html; do echo "$f: $(wc -c < "$f") bytes"; done
index.html: 215 bytes menu.html: 104 bytes

wc -c < archivo da solo el número, sin el nombre.

RetoRecorre ventas.csv con while y calcula cuánto se vendió solo de Capuchino (cantidad × precio).

Ver solución 2
total=0
while IFS=, read -r fecha producto cantidad precio pago; do
  if [[ $producto == "Capuchino" ]]; then
    total=$(( total + cantidad * precio ))
  fi
done < ventas.csv
echo "Capuchino: S/ $total"
Capuchino: S/ 70

El encabezado no molesta: su producto es «producto», no «Capuchino».

Puntos clave

  • for x in lista; do …; done repite para cada elemento (palabras, archivos, secuencias).
  • Variables de bucle siempre entre comillas: "$foto".
  • $(( )) calcula con enteros.
  • while repite mientras se cumpla la condición; cuidado con los bucles infinitos.
  • while IFS=, read -r a b c; do …; done < archivo.csv procesa un CSV línea a línea.

23 · Funciones y un script de respaldo de verdad

Avanzado ~22 min

Es hora de juntar todo en un script que Ana usará de verdad: un respaldo automático de su web, con fecha en el nombre, que además borre los respaldos viejos. Antes necesitas dos herramientas para scripts serios: las funciones, para no repetir código, y una línea de seguridad que todo script debería tener.

En este capítulo aprenderás a:

  • crear funciones para reutilizar código;
  • proteger tus scripts con set -euo pipefail;
  • comprimir y extraer carpetas con tar;
  • escribir y programar un script de respaldo completo.

Funciones

Una función es un bloque de comandos con nombre. Se define una vez y se usa como un comando más; dentro, recibe sus argumentos en $1, $2…, igual que un script:

saludar() { echo "Hola, $1. Bienvenido a Aroma y Punto"; }
saludar Ana
Hola, Ana. Bienvenido a Aroma y Punto
saludar Luis
Hola, Luis. Bienvenido a Aroma y Punto

Dentro de un script, define las funciones al principio y úsalas después. Para que una variable de la función no afecte al resto del script, declárala con local (por ejemplo, local nombre="$1").

El peligro de seguir después de un error

Por defecto, si un comando de un script falla, Bash sigue con el siguiente como si nada. Este script quiere borrar los temporales de la carpeta temporales:

#!/usr/bin/env bash
# limpiar.sh — borra los temporales de la carpeta temporales (¡versión peligrosa!)
cd temporales
rm -v *.tmp

Pero la carpeta no existe. Mira qué pasa (en el laboratorio del manual):

ls *.tmp
borrador.tmp
./limpiar.sh
./limpiar.sh: line 3: cd: temporales: No such file or directory removed 'borrador.tmp'
ls *.tmp
ls: cannot access '*.tmp': No such file or directory

cd falló, el script se quedó en la carpeta del proyecto y borró los temporales equivocados. Con rm -rf en lugar de rm, el daño podría haber sido enorme.

set -euo pipefail: el cinturón de seguridad

Agrega esta línea al comienzo de tus scripts:

#!/usr/bin/env bash
# limpiar.sh — versión segura
set -euo pipefail
cd temporales
rm -v *.tmp
./limpiar.sh
./limpiar.sh: line 4: cd: temporales: No such file or directory
echo $?
1
ls *.tmp
borrador.tmp

El script se detuvo en el primer error, con código 1, y no borró nada.

OpciónEfecto
-eDetiene el script en cuanto un comando falla
-uConsidera un error usar una variable que no existe (evita borrar "$CARPETA"/* con la variable vacía)
-o pipefailUna tubería falla si falla cualquiera de sus tramos, no solo el último

tar: empaquetar y comprimir

tar junta una carpeta completa en un solo archivo y, con -z, lo comprime (formato .tar.gz). -C le dice desde qué carpeta trabajar:

tar -czf aroma.tar.gz -C ~/proyectos aroma
ls -lh aroma.tar.gz
-rw-r--r-- 1 ana ana 546 Jul 15 08:59 aroma.tar.gz
tar -tzf aroma.tar.gz
aroma/ aroma/img/ aroma/img/logo.png aroma/img/local.jpg aroma/menu.html aroma/css/ aroma/css/estilos.css aroma/index.html
mkdir prueba
tar -xzf aroma.tar.gz -C prueba
ls prueba/aroma
css img index.html menu.html
OpciónSignifica
-c / -x / -tCrear / extraer / listar (create, extract, list)
-zComprimir o descomprimir con gzip
-f archivoEl archivo .tar.gz (va siempre al final de las opciones)
-C carpetaTrabajar desde esa carpeta

El script de respaldo

Todo lo del curso en un solo archivo, respaldo.sh:

#!/usr/bin/env bash
# respaldo.sh — guarda una copia comprimida del proyecto y conserva solo los 3 respaldos más recientes
set -euo pipefail

ORIGEN="$HOME/proyectos/aroma"
DESTINO="$HOME/respaldos"
CONSERVAR=3

mensaje() {
  echo "[$(date +%H:%M:%S)] $1"
}

if [[ ! -d "$ORIGEN" ]]; then
  echo "No existe $ORIGEN" >&2
  exit 1
fi

mkdir -p "$DESTINO"
archivo="$DESTINO/aroma_$(date +%F_%H%M).tar.gz"
mensaje "Respaldando $ORIGEN"
tar -czf "$archivo" -C "$HOME/proyectos" aroma
mensaje "Creado $archivo ($(du -h "$archivo" | cut -f1))"

for viejo in $(ls "$DESTINO"/aroma_*.tar.gz | sort -r | tail -n +$(( CONSERVAR + 1 ))); do
  rm "$viejo"
  mensaje "Borrado el respaldo antiguo $viejo"
done

Ana ya tenía tres respaldos de días anteriores. Al ejecutar el script, se crea el de hoy y se borra el más antiguo:

ls respaldos
aroma_2026-07-12_2000.tar.gz aroma_2026-07-14_2000.tar.gz aroma_2026-07-13_2000.tar.gz
./respaldo.sh
[09:00:00] Respaldando /home/ana/proyectos/aroma [09:00:00] Creado /home/ana/respaldos/aroma_2026-07-15_0900.tar.gz (4.0K) [09:00:00] Borrado el respaldo antiguo /home/ana/respaldos/aroma_2026-07-12_2000.tar.gz
ls respaldos
aroma_2026-07-13_2000.tar.gz aroma_2026-07-15_0900.tar.gz aroma_2026-07-14_2000.tar.gz

Repasa cada línea: el shebang (capítulo 20), set -euo pipefail, variables en mayúsculas para la configuración (capítulo 18), una función, una validación con if y exit 1 (capítulo 21), la fecha con $( ), tar, y un bucle for sobre una tubería (capítulos 11, 14 y 22) que conserva los tres nombres más recientes: como empiezan con la fecha, ordenarlos alfabéticamente es ordenarlos por antigüedad.

Programarlo: cron

En Linux y WSL, cron ejecuta comandos a horas fijas. crontab -e abre tu lista de tareas en el editor; cada línea indica minuto, hora, día del mes, mes y día de la semana (* = todos), y el comando:

crontab -e
# respaldo todos los días a las 20:00 (las salidas se agregan a un registro)
0 20 * * * $HOME/respaldo.sh >> $HOME/respaldos/registro.log 2>&1
Regla de oro: todo script que crea, mueve o borra archivos empieza con set -euo pipefail. Es una línea, y convierte un error silencioso en una parada segura.

Practica

BásicoCrea una función titulo que muestre su argumento entre líneas de guiones y úsala para encabezar el menú.

Ver solución 1
titulo() {
  echo "---------- $1 ----------"
}
titulo "Menú del día"
cat menu.html
---------- Menú del día ---------- <h1>Menú</h1> <ul> <li>Espresso S/ 7</li> <li>Americano S/ 8</li> <li>Capuchino S/ 10</li> </ul>

La función recibe «Menú del día» en $1.

RetoComprime solo la carpeta css del proyecto en css.tar.gz, lista su contenido y extráela en una carpeta restaurado.

Ver solución 2
tar -czf css.tar.gz -C proyectos/aroma css
tar -tzf css.tar.gz
mkdir restaurado
tar -xzf css.tar.gz -C restaurado
ls -R restaurado
css/ css/estilos.css restaurado: css restaurado/css: estilos.css

-C indica desde dónde empaquetar y adónde extraer.

Puntos clave

  • nombre() { …; } define una función; recibe sus argumentos en $1, $2…
  • Sin set -e, un script sigue después de un error, aunque sea peligroso.
  • set -euo pipefail: parar ante errores, variables inexistentes y tuberías que fallan.
  • tar -czf comprime, -tzf lista y -xzf extrae.
  • crontab -e programa scripts para que se ejecuten solos.

24 · La terminal en red y tu graduación

Intermedio ~20 min

La terminal no termina en tu computadora. Con unos pocos comandos puedes descargar archivos y consultar páginas web, entrar en un servidor al otro lado del mundo y enviarle tu proyecto. Así se publican la mayoría de los sitios web, incluido el de este curso. Después de eso, tu graduación.

En este capítulo aprenderás a:

  • descargar y consultar páginas con curl;
  • servir una carpeta como sitio web de prueba;
  • conectarte a un servidor con ssh y copiar archivos con scp y rsync;
  • repasar todo lo aprendido y elegir tu siguiente paso.

Tu web en tu computadora

Python trae un pequeño servidor web para pruebas. En una terminal, dentro de la carpeta del proyecto, ejecuta:

python3 -m http.server 8765

Mientras siga en marcha (se detiene con Ctrl + C), la web de Ana está disponible en http://localhost:8765: ábrela en el navegador. localhost significa «esta misma computadora» y 8765 es el puerto, una especie de número de puerta. Es solo para practicar, no para publicar.

curl: la web desde la terminal

En otra terminal, curl pide una página y muestra lo que el servidor responde. -s (silent) oculta la barra de progreso:

curl -s http://localhost:8765/menu.html
<h1>Menú</h1> <ul> <li>Espresso S/ 7</li> <li>Americano S/ 8</li> <li>Capuchino S/ 10</li> </ul>

Como es una salida más, se combina con todo lo que sabes; por ejemplo, contar los productos del menú publicado:

curl -s http://localhost:8765/menu.html | grep -c "<li>"
3

Con -o guardas lo descargado en un archivo:

mkdir -p ~/descargas
curl -s -o ~/descargas/inicio.html http://localhost:8765/index.html
head -n 4 ~/descargas/inicio.html
<!DOCTYPE html> <html lang="es"> <head> <title>Aroma y Punto</title>

-I pide solo los encabezados de la respuesta, cuya primera línea dice si todo salió bien; y con -w obtienes solo el código de estado (200 = bien, 404 = no existe):

curl -sI http://localhost:8765/menu.html | head -n 1
HTTP/1.0 200 OK
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8765/carta.html
404

Con internet funciona igual, solo cambia la dirección: curl -s https://webcode.net.pe/robots.txt. Muchas instrucciones de instalación (como la de Homebrew del capítulo 16) usan curl para descargar.

ssh: entrar en otra computadora

Un servidor web es una computadora sin pantalla en un centro de datos. Se administra a distancia con ssh (secure shell): te conectas y obtienes una terminal de esa máquina, donde todo lo de este curso funciona igual.

ssh ana@aromaypunto.pe            # conectarse (usuario@servidor)
# ... ahora estás en el servidor: pwd, ls, nano, tail -f ... ...
exit                              # volver a tu computadora

La primera vez, SSH te muestra la huella del servidor y pregunta si confías en él, igual que con GitHub en el curso de Git. Si generaste tus llaves SSH en ese curso, puedes instalar la pública en el servidor y entrar sin contraseña:

ssh-copy-id ana@aromaypunto.pe

scp y rsync: copiar archivos al servidor

scp copia como cp, pero entre computadoras; el destino remoto se escribe usuario@servidor:ruta. rsync va más lejos: solo envía lo que cambió, ideal para publicar un sitio una y otra vez.

scp menu.html ana@aromaypunto.pe:/var/www/html/
scp -r img ana@aromaypunto.pe:/var/www/html/
rsync -avz ~/proyectos/aroma/ ana@aromaypunto.pe:/var/www/html/
ComandoPara qué
curl URLPedir una página o un archivo a un servidor web
ssh usuario@servidorAbrir una terminal en otra computadora
scp origen usuario@servidor:destinoCopiar archivos entre computadoras
rsync -avz origen/ usuario@servidor:destino/Sincronizar carpetas enviando solo los cambios
Así se publica este curso. Cada capítulo que lees se subió al servidor con un rsync como el de arriba, después de comprobar con scripts que todo estuviera en orden. Lo que aprendiste no es teoría: es la herramienta diaria de quienes hacen la web.

Graduación

Empezaste sin saber qué era un prompt. Repasa lo que ya dominas:

ParteLo que dominas
I · Primeros pasosAbrir la terminal en cualquier sistema, leer un comando y moverte por el árbol de carpetas.
II · Archivos y carpetasCrear, copiar, mover, borrar con seguridad, leer archivos y usar comodines.
III · Texto y tuberíasRedirigir salidas, encadenar comandos, buscar con grep y find, y resumir datos.
IV · Tu sistemaPermisos, instalación de programas, procesos, variables, PATH y tu ~/.bashrc.
V · ScriptsProgramas propios con argumentos, decisiones, bucles, funciones y un respaldo automático.
VI · RedConsultar la web, conectarte a servidores y publicar archivos.

Tu proyecto de graduación: escribe un script para algo que hagas a mano todas las semanas (ordenar tus descargas por tipo, respaldar tus documentos, renombrar fotos con la fecha). Ponle shebang, set -euo pipefail, validación de argumentos y un comentario de uso. Antes de darlo por terminado, revísalo con ShellCheck, un revisor de scripts que detecta errores comunes (en Ubuntu: sudo apt install shellcheck).

Tu siguiente paso: el curso Git desde cero, que usa la terminal en cada capítulo. Ya tienes todo lo que necesitas para aprovecharlo. Para profundizar en Bash, el manual oficial de Bash y el de GNU coreutils son la referencia completa.

¡Felicitaciones! Ya no le tienes miedo a la pantalla negra: la usas para trabajar más rápido y automatizar lo repetitivo. Practica un poco cada día; en pocas semanas, abrir la terminal será lo primero que hagas al sentarte a programar.
Regla de oro: cada vez que te descubras repitiendo lo mismo en la terminal por tercera vez, conviértelo en un alias, una función o un script. Ese es el verdadero poder de la terminal.

Practica

BásicoCon el servidor de prueba en marcha en el puerto 8766, cuenta cuántas líneas tiene la página de inicio publicada.

Ver solución 1
curl -s http://localhost:8766/index.html | wc -l
11

La salida de curl se encadena como la de cualquier comando.

RetoDescarga la hoja de estilos publicada en estilos-copia.css, muéstrala, y averigua el código de estado de una página que no existe (promo.html).

Ver solución 2
curl -s -o estilos-copia.css http://localhost:8767/css/estilos.css
cat estilos-copia.css
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8767/promo.html
body { font-family: sans-serif; } h1 { color: brown; } 404

404 significa «no encontrado».

Puntos clave

  • curl pide páginas y archivos: -s silencioso, -o guardar, -I encabezados.
  • python3 -m http.server sirve una carpeta en localhost para pruebas.
  • ssh usuario@servidor abre una terminal remota; exit vuelve.
  • scp copia entre computadoras; rsync -avz sincroniza enviando solo los cambios.
  • Siguiente paso: el curso de Git, y escribir scripts para tus propias tareas.