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.
1 · Qué es la terminal y por qué aprenderla
Básico ~12 minHasta 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:
| Palabra | Qué es | Ejemplos |
|---|---|---|
| Terminal | La ventana donde escribes y lees texto. | Terminal de Ubuntu o de macOS, Windows Terminal |
| Shell | El programa que interpreta lo que escribes y lo ejecuta. | Bash, zsh, PowerShell |
| Prompt | El texto que el shell muestra cuando espera una orden; suele terminar en $. | ana@laptop:~$ |
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"datewhoamiecho 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.
¿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 fotosNo 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ón | Con la terminal |
|---|---|
| Fácil de empezar | Requiere aprender unos comandos |
| Repetir 100 veces es repetir 100 veces | Repetir 100 veces es un solo comando |
| Cada programa tiene sus menús | Todos los programas se combinan entre sí |
| No sirve en un servidor sin pantalla | Funciona 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.
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
| Parte | Aprenderás a… |
|---|---|
| I · Primeros pasos | abrir la terminal, entender un comando y moverte entre carpetas. |
| II · Archivos y carpetas | crear, copiar, mover, borrar y leer archivos; trabajar con muchos a la vez. |
| III · Texto y tuberías | guardar resultados, encadenar comandos, buscar y resumir información. |
| IV · Tu sistema por dentro | permisos, instalación de programas, procesos y configuración de tu terminal. |
| V · Scripts de Bash | escribir tus propios programas que automatizan tareas. |
| VI · Graduación | usar la terminal en red y dar el salto a Git y GitHub. |
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
whoamiEn 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{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 minToda 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
bashy 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 Bash | WSL (Subsistema de Windows para Linux) | |
|---|---|---|
| Qué es | Bash y las herramientas básicas de Linux, empaquetados con Git | Un Linux completo (Ubuntu) dentro de Windows |
| Instalación | Viene con Git for Windows | wsl --install y reiniciar |
| Tus archivos de Windows | En /c/Users/tu-usuario | En /mnt/c/Users/tu-usuario |
| Ideal para | Empezar ya y trabajar con Git | Programar 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 --installReinicia 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.
Comprueba tu Bash
Abre tu terminal y escribe:
bash --versionLa 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 $0echo $BASH_VERSIONSi 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$| Parte | Significa |
|---|---|
ana | Tu usuario |
laptop | El nombre de la computadora (en un servidor, el del servidor) |
~/proyectos | La 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.
Practica
BásicoComprueba qué shell estás usando y qué versión de Bash tienes.
Ver solución 1
echo $0
echo $BASH_VERSIONSi 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"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 --installen PowerShell como administrador e instala Ubuntu. bash --versionmuestra tu versión yecho $0qué 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 minTodos 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.
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 holaecho hola mundoEn 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:
lsls -Fls -l-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 -Fls -lFls --classifyOpciones 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.htmlLos 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
lsmkdir "mis fotos"
lsEl 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 Puntoecho "Aroma y Punto"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:
LSls -zls carpeta-que-no-existe| Mensaje | Significa | Qué hacer |
|---|---|---|
command not found | No existe un comando con ese nombre | Revisa la ortografía y las mayúsculas, o instala el programa |
invalid option | El comando no tiene esa opción | Consulta la ayuda, como sugiere el propio mensaje |
No such file or directory | El 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:
| Forma | Para qué | Ejemplo |
|---|---|---|
comando --help | Resumen de opciones de casi cualquier programa | ls --help |
man comando | El manual completo (no está en Git Bash) | man ls |
help comando | Ayuda de las órdenes propias de Bash | help cd |
help pwdman 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 cdtype lstype typecd 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).
--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 -FSin 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.htmltype 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:
LSno esls. - Ayuda:
--help,man(salir con q) yhelppara las órdenes de Bash.
4 · Moverte por el sistema de archivos: pwd, ls y cd
Básico ~18 minEn 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.
/. La carpeta personal de Ana es /home/ana (~) y su proyecto está en /home/ana/proyectos/aroma.| Carpeta | Qué contiene |
|---|---|
/ | La raíz: todo lo demás cuelga de aquí |
/home/ana | La carpeta personal de Ana. En macOS es /Users/ana |
/etc | Archivos de configuración del sistema |
/usr/bin | Los programas, como ls (capítulo 3) |
/tmp | Archivos temporales que se borran al reiniciar |
/c/Users/ana | En Git Bash: la carpeta de Windows C:\Users\ana |
/mnt/c/Users/ana | En 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:
pwdlsls proyectosls proyectos/aromaRutas 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/cssls ~/proyectos/aroma/imgMoverse: cd
cd (change directory) te lleva a otra carpeta. .. significa «la carpeta de
arriba» (la que contiene a la actual):
cd proyectos
pwdcd aroma/css
pwdcd ..
pwdcd ../..
pwdComo 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
pwdcd -cd ~/proyectos
pwd. 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 -als ..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 -lhls -RErrores típicos
cd menu.htmlcd Css«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.
| Atajo | Qué hace |
|---|---|
| Tab | Completa nombres de carpetas, archivos y comandos |
| Tab Tab | Muestra todas las opciones posibles |
| ↑ / ↓ | Recorre los comandos que ya escribiste |
Ctrl + L o clear | Limpia la pantalla |
| Ctrl + C | Cancela el comando o la línea actual |
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).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 -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 ../../..
pwdDesde 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~. pwddice dónde estás,lsqué hay ycdte mueve.- Ruta absoluta: empieza con
/. Relativa: desde donde estás...sube un nivel. cdsolo vuelve a casa;cd -regresa a la carpeta anterior.ls -amuestra ocultos,-ldetalles,-htamaños legibles y-Rsubcarpetas.
5 · Crear carpetas y archivos (y editarlos con nano)
Básico ~16 minYa 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¿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/tortasmkdir -p carta/postres/tortas
ls -R cartamkdir acepta varios nombres a la vez, y con -v (verbose) te cuenta lo que hace:
mkdir -v fuentes videosCrear 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.txtEscribir 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.txtecho "Domingos: cerrado" >> horario.txt
cat horario.txt> lo borra por completo y escribe lo nuevo, sin preguntar:echo "Cerrado por vacaciones" > horario.txt
cat horario.txtLas 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.pnglogo.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.txtEscribe normalmente y muévete con las flechas. En la parte inferior verás los atajos; ^ significa
Ctrl:
| Atajo | Acción |
|---|---|
| Ctrl + O, luego Enter | Guardar (write Out) |
| Ctrl + X | Salir (si hay cambios sin guardar, pregunta: Y sí, N no) |
| Ctrl + K | Cortar la línea actual |
| Ctrl + U | Pegar lo cortado |
| Ctrl + W | Buscar texto |
| Ctrl + G | Ayuda completa |
nano abre un editor muy parecido llamado pico, con los mismos atajos para guardar y salir. Si quieres el nano original: brew install nano.> 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 jsSin -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.txtLa primera línea usa > (crea) y la segunda >> (agrega). Con > en ambas, solo quedaría el correo.
Puntos clave
mkdircrea carpetas;-pcrea todo el camino y-vinforma.touchcrea archivos vacíos (o actualiza la fecha de uno existente).echo "texto" > archivoreemplaza;>>agrega al final.filedice 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 minHacer 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é
cpymvpueden 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
lsSi 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/ls respaldoCopiar carpetas: cp -r
Para copiar una carpeta con todo su contenido necesitas -r (recursive); sin ella, cp la omite:
cp css css-v2cp -r css css-v2
ls -FRenombrar 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
lsSi el destino es otra carpeta, mueve:
mkdir archivo
mv -v carta.html archivo/lsls archivoCon carpetas funciona igual y no necesita -r:
mv img imagenes
lsindex.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.txtcp precios-ana.txt precios.txt
cat precios.txtLa 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.txtcat precios.txt| Comando | Qué hace |
|---|---|
cp a.txt b.txt | Copia a.txt con el nombre b.txt |
cp a.txt b.txt carpeta/ | Copia varios archivos a una carpeta |
cp -r carpeta copia | Copia una carpeta completa |
mv viejo.txt nuevo.txt | Renombra |
mv a.txt carpeta/ | Mueve a otra carpeta |
-i / -v | Preguntar antes de reemplazar / informar cada paso |
-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 respaldoPoner 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-v funciona en cp y en mv. Con -r, cp informa la carpeta y cada archivo.
Puntos clave
cp origen destinocopia; con-rcopia carpetas.mvrenombra (mismo lugar) o mueve (otra carpeta); con carpetas no necesita-r.- Varios orígenes: el último argumento es la carpeta de destino.
cpymvreemplazan archivos existentes sin avisar;-ipide confirmación.
7 · Borrar con cuidado: rm no tiene papelera
Intermedio ~16 minBorrar 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
rmy carpetas conrmdiryrm -r; - pedir confirmación con
-i; - entender por qué
rm -rftiene 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.txtlsSi el archivo no existe, rm se queja. Con -f (force) no se queja de nada y nunca pregunta:
rm promo.txtrm -f promo.txtBorrar 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 imgrmdir imgrmdir vacia
rm -r img
lsrm -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.txtlsCon una carpeta, rm -ri pregunta si entrar en ella, por cada archivo y por la carpeta misma:
rm -ri pruebasrm -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:
lsrm * .baklsPor 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.)
/ 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 *.bakrm -v *.bakls| Comando | Qué borra | Pregunta |
|---|---|---|
rm archivo | Archivos | No |
rm -i archivo | Archivos | Sí, uno por uno |
rmdir carpeta | Una carpeta vacía | No (falla si no está vacía) |
rm -r carpeta | Una carpeta y todo su contenido | No |
rm -rf carpeta | Todo, sin quejarse de nada | Nunca |
¿Y si quieres una papelera de verdad? En Ubuntu con escritorio puedes enviar archivos a la papelera desde la terminal:
gio trash borrador.txtY 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.
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
lsCon -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 pruebasPrimero mirar, después borrar. rm -rv informa cada archivo y cada carpeta que elimina.
Puntos clave
rmborra para siempre: no hay papelera.rmdirborra carpetas vacías;rm -r, carpetas con contenido.-ipregunta antes de borrar;-fnunca pregunta.- Un espacio de más en un patrón (
rm * .bak) puede borrarlo todo. - Hábito:
ls patrónprimero,rm patróndespués.
8 · Leer archivos: cat, less, head y tail
Básico ~15 minLos 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
headytail; - 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.csscat -n menu.htmlSu 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.htmlcat 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| Tecla | Acción |
|---|---|
| ↓ / ↑ | Una línea abajo / arriba |
| Espacio / b | Una página abajo / arriba |
| g / G | Ir al inicio / al final |
| /texto Enter | Buscar «texto»; n salta a la siguiente coincidencia |
| q | Salir |
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.loghead -n 3 pedidos.logtail hace lo mismo con el final, que en un registro son los eventos más recientes:
tail -n 3 pedidos.logCon -n +N, tail muestra desde la línea N hasta el final:
tail -n +28 pedidos.logtail -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/syslogtail -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 corto | cat archivo |
| Ver con números de línea | cat -n archivo |
| Leer uno largo con calma | less archivo |
| Las primeras / últimas N líneas | head -n N / tail -n N |
| Seguir un registro en vivo | tail -f archivo |
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.logEn 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.txtcat une archivos y > guarda el resultado en uno nuevo.
Puntos clave
catmuestra todo (y une varios archivos);-nnumera.lessrecorre archivos largos: / busca, q sale.headytailmuestran el principio y el final (10 líneas por defecto,-npara cambiar).tail -fsigue un archivo en vivo hasta Ctrl + C.
9 · Comodines: muchos archivos a la vez
Intermedio ~18 minEn 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
echoantes 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)»:
lsls *.pngls plato*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 *.pngecho 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?.jpgls plato1?.jpg[ ] equivale a un carácter de la lista o del rango que pongas dentro:
ls plato0[1-4].jpgls postre-[ab].pngTres trampas
1. Los ocultos no entran. * no incluye los archivos que empiezan con punto:
ls -aecho *.jpg2. 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 *.gifecho *.gif3. Entre comillas no es comodín. Las comillas (dobles o simples) desactivan el reemplazo:
echo "*.png"echo '*.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}.jpgecho plato{01..12}.jpgecho {a..e}echo postre-{torta,flan,helado}.pngCombinadas con mkdir o touch, crean estructuras completas en un paso:
mkdir -p semana/{lunes,martes,miercoles}
ls semanaTodo junto
Ana guarda un respaldo solo de los postres:
mkdir -p respaldo/postres
cp -v img/postre-*.png respaldo/postres/| Patrón | Significa | Ejemplo | Coincide con |
|---|---|---|---|
* | Cualquier texto | *.png | postre-a.png, postre-b.png… |
? | Un carácter | plato0?.jpg | plato01.jpg … plato09.jpg |
[ ] | Un carácter de la lista | plato0[1-4].jpg | plato01.jpg … plato04.jpg |
{ , } | Genera cada opción | {lunes,martes} | lunes martes (existan o no) |
{ .. } | Genera una secuencia | {01..03} | 01 02 03 |
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[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/*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:
echote 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 minHasta 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.
>: 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 imgls img > lista.txt
cat lista.txtRecuerda (capítulo 5): > crea el archivo o lo reemplaza, y >> agrega al final:
ls css >> lista.txt
cat lista.txtLos errores van por otro canal
Fíjate qué pasa cuando un comando produce resultados y errores a la vez:
ls img noexiste > salida.txtcat salida.txtEl 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.txtcat errores.txtPara guardar las dos cosas en el mismo archivo, usa &>:
ls img noexiste &> todo.txt
cat todo.txt/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<: 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.logwc -l < pedidos.logCon <, 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.txtcat lista.txtPara activarla siempre, se agrega set -o noclobber al archivo de configuración de Bash (capítulo 19). Si de
verdad quieres reemplazar, usa >|.
| Símbolo | Qué hace | Ejemplo |
|---|---|---|
> | Salida a un archivo (lo reemplaza) | ls > lista.txt |
>> | Salida al final de un archivo | echo hola >> notas.txt |
2> | Errores a un archivo | cmd 2> errores.txt |
&> | Salida y errores al mismo archivo | cmd &> todo.txt |
2> /dev/null | Descartar los errores | cmd 2> /dev/null |
< | Un archivo como entrada | wc -l < pedidos.log |
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.>, 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.txtCon <, 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.txtCada 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/nulllos descarta.<entrega un archivo como entrada estándar.set -o noclobberevita reemplazar archivos con>.
11 · Tuberías: encadenar comandos
Intermedio ~18 minEste 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 -lls 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 3Cada 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 3tail 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-ZLas tuberías pueden tener todos los tramos que necesites:
tail -n +11 pedidos.log | head -n 3 | tr a-z A-Z| 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¿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 -lhead -n 3 lista.txtLos errores no entran en la tubería
| solo conecta la salida estándar. Los errores siguen yendo a la pantalla:
ls noexiste | wc -lls noexiste 2>&1 | wc -lEn 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ía | Qué hace |
|---|---|
ls | wc -l | Cuenta los elementos de una carpeta |
ls | head -n 5 | Muestra solo los primeros |
tail -n +11 archivo | head -n 3 | Muestra las líneas 11 a 13 |
comando | tee copia.txt | … | Guarda una copia y sigue procesando |
comando | less | Recorre una salida larga |
comando 2>&1 | … | Incluye también los errores |
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 3El 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.txttee al final de la tubería escribe en el archivo y también en la pantalla.
Puntos clave
a | benvía la salida deacomo entrada deb.- Comandos pequeños + tuberías = soluciones a medida (filosofía Unix).
- Las redirecciones van al final:
a | b > archivo. teeguarda una copia sin interrumpir la tubería.- Los errores no pasan por
|salvo que agregues2>&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.logAdemá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.loggrep -n Latte pedidos.loggrep distingue mayúsculas: latte no encuentra nada (y no muestra nada). Con -i ignora
la diferencia:
grep latte pedidos.loggrep -i latte pedidos.log | head -n 2-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.csvBuscar 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/" .grep -rl Espresso .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.csvgrep "yape$" ventas.csv | wc -lLos corchetes funcionan como en los comodines del capítulo 9: un carácter de la lista.
grep "#00[1-3]" pedidos.logCon -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| Símbolo | Significa | Ejemplo |
|---|---|---|
^ | Inicio de línea | grep "^2026" ventas.csv |
$ | Fin de línea | grep "yape$" ventas.csv |
. | Un carácter cualquiera | grep "L.tte" |
[ ] | Un carácter de la lista | grep "#00[1-3]" |
a|b (con -E) | Una cosa u otra | grep -E "Latte|Mocaccino" |
* 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 postregrep como un alias de grep --color=auto, que resalta en color el texto encontrado (lo verás en el capítulo 19).| Opción | Qué hace |
|---|---|
-i | Ignora mayúsculas y minúsculas |
-n | Muestra el número de línea |
-c | Cuenta las líneas que coinciden |
-v | Muestra las líneas que NO coinciden |
-w | Solo palabras completas (Latte no coincide con Lattes) |
-r / -l | Busca en carpetas / solo nombres de archivo |
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-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$"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" archivomuestra las líneas que contienen el texto.-i,-n,-c,-vy-wcubren casi todas las búsquedas diarias.grep -rbusca en carpetas;-llista solo los archivos.^inicio,$fin,[ ]lista;-Epermitea|b.- En una tubería,
grepfiltra la salida de cualquier comando.
13 · Buscar archivos con find
Intermedio ~18 mingrep 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
findy cuándogrep.
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"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*" | sortfind . -name "*.jpg" | wc -l-iname hace lo mismo sin distinguir mayúsculas:
find . -iname "MENU*"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 dfind . -type f -name "*.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 4find . -type f -size +500cA diferencia de ls y de los comodines, find sí encuentra los archivos ocultos:
find . -name ".*" -type fLimitar 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"find . -maxdepth 1 -name "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 {} \;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"find . -name "*.bak" -delete
find . -name "*.bak" | wc -l-delete siempre al final y solo después de comprobar la lista sin él.find o grep
| Quiero… | Uso |
|---|---|
| Archivos cuyo NOMBRE cumple algo | find . -name "*.png" |
| Archivos cuyo CONTENIDO incluye algo | grep -rl "texto" . |
| Líneas que contienen algo | grep "texto" archivo |
grep -rl "Capuchino" .find exige indicar la carpeta: escribe siempre find . -name …, nunca find -name …. Así tus comandos funcionan en cualquier sistema.| Condición | Significa |
|---|---|
-name "*.jpg" / -iname | Nombre que cumple el patrón (sin distinguir mayúsculas) |
-type f / -type d | Solo archivos / solo carpetas |
-empty | Vacío |
-size +1M | Más de 1 megabyte |
-maxdepth 1 | Sin bajar a subcarpetas |
-exec cmd {} \; | Ejecuta un comando por archivo |
-delete | Borra lo encontrado |
-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 -lfind 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 -lPrimero la lista, después -delete al final del mismo comando.
Puntos clave
find carpeta condicionesbusca archivos por nombre, tipo, tamaño…- Patrón siempre entre comillas;
-inameignora mayúsculas. findno ordena: agrega| sortsi lo necesitas.-exec cmd {} \;actúa sobre cada archivo;-deletelos borra.findbusca nombres;grep -rbusca contenidos.
14 · Ordenar, contar y recortar: sort, uniq, cut y wc
Intermedio ~20 minAna 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.csvwc -l ventas.csv19 líneas: el encabezado y 18 ventas. Así se ve el comienzo del archivo:
head -n 4 ventas.csvcut: 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 5cut -d, -f1,5 ventas.csv | head -n 3sort: 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 | sortuniq: 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» 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 | uniqCon -c, además cuenta cuántas veces apareció cada uno:
cut -d, -f2 ventas.csv | tail -n +2 | sort | uniq -cEl 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 -rnCambiando solo la columna, Ana sabe cómo le pagan (la quinta columna):
cut -d, -f5 ventas.csv | tail -n +2 | sort | uniq -c | sort -rnawk, 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 3tail -n +2 ventas.csv | sort -t, -k4 -nr | head -n 3Y combinando con grep, cuántas ventas hubo el 15 de julio:
grep "^2026-07-15" ventas.csv | wc -l| Comando | Qué hace |
|---|---|
wc -l | Cuenta líneas (-w palabras, -c bytes) |
cut -d, -f2 | Columna 2, separadas por comas (-f1,5 varias) |
sort / sort -r | Ordena / al revés |
sort -n | Ordena como números |
sort -t, -k4 -n | Ordena por la columna 4, numérica |
uniq / uniq -c | Quita repetidos juntos / y los cuenta |
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 -cMismo 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 -rngrep filtra las filas, cut se queda con el producto y el resto es el ranking del capítulo.
Puntos clave
wc -lcuenta líneas;cut -d, -fNextrae columnas.sortordena;-nnumérico,-rinverso,-ty-kpor columna.uniqsolo detecta repetidos adyacentes: va después desort.- El patrón clásico de ranking:
sort | uniq -c | sort -rn.
15 · Usuarios y permisos: ls -l y chmod
Intermedio ~20 minLinux 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
chmoden forma simbólica y numérica; - saber qué significan los permisos en una carpeta.
Las columnas de ls -l
ls -l| Columna | Ejemplo | Significa |
|---|---|---|
| Tipo y permisos | -rw-r--r-- | Qué es y quién puede hacer qué (ver abajo) |
| Enlaces | 1 | Cuántos nombres apuntan a este archivo (no lo necesitarás por ahora) |
| Dueño | ana | El usuario propietario |
| Grupo | ana | El grupo propietario (en Ubuntu, cada usuario tiene un grupo con su nombre) |
| Tamaño | 215 | En bytes (con -h, en K, M, G) |
| Fecha | Jul 15 08:59 | Última modificación |
| Nombre | index.html | El archivo o la carpeta |
- 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.| Letra | En un archivo | En una carpeta |
|---|---|---|
r (read) | Leer el contenido | Listar lo que contiene |
w (write) | Modificarlo | Crear, renombrar o borrar dentro |
x (execute) | Ejecutarlo como programa | Entrar 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./saludo.shchmod u+x saludo.sh
ls -l saludo.sh./saludo.shEl ./ 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.htmlecho "<p>Nuevo</p>" >> menu.htmlchmod u+w menu.html
echo "<p>Nuevo</p>" >> menu.htmlPermisos 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úmero | Permisos | Uso típico |
|---|---|---|
644 | rw-r--r-- | Archivos normales: tú editas, los demás leen |
755 | rwxr-xr-x | Scripts y carpetas: todos pueden ejecutar o entrar |
600 | rw------- | Archivos privados: solo tú (claves, configuraciones) |
700 | rwx------ | 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.html600: 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 imgchmod u-x img
ls imgcd imgchmod u+x imgTu propia carpeta personal es un buen ejemplo: en Ubuntu tiene permisos 750, así que otros usuarios del sistema
no pueden entrar.
whoamils -ld ~chmod casi no tiene efecto en Git Bash. Para practicar este capítulo, usa WSL, Linux o macOS.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.shSin 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 publico600 = 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 -lmuestra tipo, permisos, dueño, grupo, tamaño, fecha y nombre.- Permisos
rwxpara dueño, grupo y otros; en carpetas,xpermite entrar. chmod u+x archivoagrega ejecución;a-wquita 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 minInstalar 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
sudosin 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 updateLa 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| Comando | Qué hace | ¿Necesita sudo? |
|---|---|---|
apt search palabra | Busca paquetes | No |
apt show paquete | Describe un paquete | No |
sudo apt update | Actualiza la lista de paquetes disponibles | Sí |
sudo apt install paquete | Instala | Sí |
sudo apt upgrade | Actualiza todos los programas instalados | Sí |
sudo apt remove paquete | Desinstala | Sí |
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¿Cómo saber si un programa ya está instalado? command -v muestra dónde está, o nada si no existe:
command -v treecommand -v programa-que-no-existe || echo "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 HomebrewWindows: 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
sudosolo 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
sudoconrm -rfsin 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.
sudo, escribe sudo !!: Bash reemplaza !! por el comando anterior completo.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/cssSi 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-d muestra solo carpetas (directories) y -L 1 limita la profundidad (level).
Puntos clave
- root puede todo;
sudote da ese poder para un solo comando y pide TU contraseña (no se ve al escribirla). - Ubuntu/WSL:
sudo apt updateysudo apt install programa. - macOS: Homebrew (
brew install, sin sudo). Windows: winget desde PowerShell. command -v programadice si está instalado.- Nunca uses sudo «por si acaso» ni con comandos que no entiendes.
17 · Procesos: ver, pausar y detener programas
Intermedio ~18 minCada 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,topyhtop; - ejecutar comandos en segundo plano con
&y manejarlos conjobs,fgybg; - 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:
psHay dos: Bash (tu shell) y el propio ps, que estaba en marcha mientras se mostraba la lista.
TTY es el nombre de tu terminal.
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 &sleep 500 &jobspsjobs 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ón | Qué hace |
|---|---|
| Ctrl + C | Cancela el comando en primer plano |
| Ctrl + Z | Lo pausa (queda «Stopped») y te devuelve la terminal |
fg / fg %2 | Trae un trabajo al primer plano |
bg / bg %2 | Reanuda un trabajo pausado en segundo plano |
jobs | Lista 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
jobsbg %1jobskill %1kill: 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 -lkill %1jobsSi 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 -lkill -9 %1top 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
htopPara 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 aux | Significa |
|---|---|
USER | Dueño del proceso |
PID | Número de proceso |
%CPU / %MEM | Uso de procesador y de memoria |
STAT | Estado: R ejecutándose, S esperando, T detenido |
COMMAND | El comando que lo inició |
nohup, tmux o los servicios del sistema, que verás en cursos posteriores.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 %2Bash 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 %1kill -9 (KILL) termina el proceso sin darle opción: Bash informa «Killed».
Puntos clave
- Cada proceso tiene un PID;
pslista los de tu terminal yps aux, todos. comando &lo ejecuta en segundo plano;jobslista los trabajos.- Ctrl+C cancela, Ctrl+Z pausa;
fgybglos reanudan. kill %1okill PIDpide terminar;kill -9obliga.topyhtopmuestran el sistema en vivo (salir con q).
18 · Variables de entorno y el PATH
Intermedio ~18 minYa 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
HOMEyUSER; - crear tus variables y usarlas dentro de textos;
- guardar la salida de un comando en una variable con
$( ); - entender el
PATHy 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 $HOMEecho $USERecho $PWD| Variable | Contiene |
|---|---|
HOME | Tu carpeta personal (lo mismo que ~) |
USER | Tu nombre de usuario |
PWD | La carpeta actual (lo que muestra pwd) |
PATH | Dónde buscar los programas (más abajo) |
SHELL | Tu 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 $cafeecho "Bienvenido a $cafe"echo '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"Si justo después del nombre viene más texto, usa llaves para marcar dónde termina:
plato=torta
echo "Hoy hay $platos"echo "Hoy hay ${plato}s"$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"echo "Hay $(ls | wc -l) 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"'export sabor
bash -c 'echo "Sabor: $sabor"'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 $PATHcommand -v ls cp datePATH, 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 ~/binbuendiaexport PATH="$HOME/bin:$PATH"
buendiacommand -v buendiaEste 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.
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."$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'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"$( ) guarda la salida de un comando; puede ir también directamente dentro de un texto.
Puntos clave
nombre=valorsin espacios; se lee con$nombreo${nombre}.- Comillas dobles reemplazan variables; simples, no.
$(comando)inserta la salida de un comando.exporthace que los programas lanzados vean la variable.PATHlista dónde se buscan los comandos; se amplía conPATH="carpeta:$PATH".
19 · Personaliza tu terminal: alias, historial y .bashrc
Básico ~16 minLlevas 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/aromaaliasunalias ll
llalias sin argumentos lista los que tienes y unalias borra uno. Los alias creados así duran hasta
cerrar la terminal.
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:
| Atajo | Qué hace |
|---|---|
history | Lista los últimos comandos, numerados |
history | grep cp | Busca en el historial (capítulo 12) |
!! | Repite el último comando (útil: sudo !!) |
!125 | Repite el comando número 125 del historial |
| Ctrl + R | Bú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 ~/.bashrcsource ~/.bashrc
aroma
pwdLos cambios se aplican en las terminales que abras desde ahora. Para aplicarlos en la actual, sin cerrarla, se usa
source ~/.bashrc.
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ódigo | Muestra |
|---|---|
\u | Tu usuario |
\h | El nombre de la computadora |
\w | La carpeta actual (con ~) |
\W | Solo 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 $| Archivo | Cuándo se lee |
|---|---|
~/.bashrc | Al abrir una terminal con Bash (Linux, WSL, Git Bash) |
~/.bash_profile / ~/.profile | Al iniciar sesión (en muchos sistemas, cargan ~/.bashrc) |
~/.zshrc | Al abrir una terminal con zsh (macOS) |
~/.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
cuentaUn 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
menuComillas 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;aliaslos lista yunaliaslos borra.- Historial:
history,!!,!ny sobre todo Ctrl + R. ~/.bashrcse ejecuta al abrir cada terminal: ahí van alias, PATH y opciones.source ~/.bashrcaplica los cambios sin cerrar la terminal.- El prompt se personaliza con
PS1(\u,\w,\$…).
20 · Tu primer script
Intermedio ~18 minTodo 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 conread; - 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ínea | Para qué |
|---|---|
#!/usr/bin/env bash | El 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 resto | Comandos 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./saludo.shchmod u+x saludo.sh
./saludo.shPATH (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.htmlcat postres.html| Variable | Contiene |
|---|---|
$0 | El 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(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.htmlecho $?ls noexiste.htmlecho $?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.
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.shLas 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«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.shtraschmod u+x. - Los argumentos llegan en
$1,$2…;$#los cuenta. read -p "pregunta" variablepide datos al usuario.$?vale 0 si el último comando funcionó y otro número si falló.
21 · Decisiones: if y las pruebas
Intermedio ~20 minUn 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,elifyelse; - 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./existe.sh 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./precio.sh 10./precio.sh 7Las pruebas más usadas
| Prueba | Es verdadera si… |
|---|---|
[[ -e ruta ]] | la ruta existe (archivo o carpeta) |
[[ -f ruta ]] / [[ -d ruta ]] | es un archivo / es una carpeta |
[[ -z "$texto" ]] / -n | el texto está vacío / no está vacío |
[[ "$a" == "$b" ]] / != | los textos son iguales / distintos |
[[ $n -eq 5 ]] / -ne | el número es igual / distinto |
[[ $n -gt 5 ]] / -ge | mayor / mayor o igual |
[[ $n -lt 5 ]] / -le | menor / menor o igual |
[[ ! -f ruta ]] | ! invierte cualquier prueba |
-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./pagina.sh "Inicio" index.htmlecho $?./pagina.sh "Contacto" contacto.htmlecho $?>&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"[[ -f logo.png ]] || echo "falta logo.png aquí"mkdir respaldo && echo "carpeta creada"mkdir respaldo && echo "carpeta creada"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./vendido.sh Frappé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».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"
fiPara 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"; fiLa 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
>&2yexit 1al fallar. &&= «si funcionó»;||= «si falló».if comandousa su código de salida;grep -qes ideal para eso.
22 · Repetir: bucles for y while
Intermedio ~20 minLos 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"; doneLa lista puede generarse con llaves (capítulo 9):
for i in {1..3}; do echo "Mesa $i lista"; donefor 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"; doneSi 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"; doneEn 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"
donemi 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 ))precio=12
echo "Dos tortas: S/ $(( precio * 2 ))"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!"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.shcontinue 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<(comando) entrega la salida de un comando como si fuera un archivo, para que while la lea.
| Estructura | Repite… |
|---|---|
for x in a b c; do …; done | una vez por cada elemento de la lista |
for f in *.png; do …; done | una vez por cada archivo que coincide |
for i in {1..10}; do …; done | para una secuencia de números |
while [[ cond ]]; do …; done | mientras la condición sea verdadera |
while read -r linea; do …; done < archivo | una vez por cada línea del archivo |
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"; donewc -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"El encabezado no molesta: su producto es «producto», no «Capuchino».
Puntos clave
for x in lista; do …; donerepite para cada elemento (palabras, archivos, secuencias).- Variables de bucle siempre entre comillas:
"$foto". $(( ))calcula con enteros.whilerepite mientras se cumpla la condición; cuidado con los bucles infinitos.while IFS=, read -r a b c; do …; done < archivo.csvprocesa un CSV línea a línea.
23 · Funciones y un script de respaldo de verdad
Avanzado ~22 minEs 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 Anasaludar LuisDentro 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 *.tmpPero la carpeta no existe. Mira qué pasa (en el laboratorio del manual):
ls *.tmp./limpiar.shls *.tmpcd 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.shecho $?ls *.tmpEl script se detuvo en el primer error, con código 1, y no borró nada.
| Opción | Efecto |
|---|---|
-e | Detiene el script en cuanto un comando falla |
-u | Considera un error usar una variable que no existe (evita borrar "$CARPETA"/* con la variable vacía) |
-o pipefail | Una 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.gztar -tzf aroma.tar.gzmkdir prueba
tar -xzf aroma.tar.gz -C prueba
ls prueba/aroma| Opción | Significa |
|---|---|
-c / -x / -t | Crear / extraer / listar (create, extract, list) |
-z | Comprimir o descomprimir con gzip |
-f archivo | El archivo .tar.gz (va siempre al final de las opciones) |
-C carpeta | Trabajar 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"
doneAna 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./respaldo.shls respaldosRepasa 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>&1set -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.htmlLa 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-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 -czfcomprime,-tzflista y-xzfextrae.crontab -eprograma scripts para que se ejecuten solos.
24 · La terminal en red y tu graduación
Intermedio ~20 minLa 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
sshy copiar archivos conscpyrsync; - 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 8765Mientras 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.htmlComo 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>"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-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 1curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8765/carta.htmlCon 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 computadoraLa 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.pescp 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/| Comando | Para qué |
|---|---|
curl URL | Pedir una página o un archivo a un servidor web |
ssh usuario@servidor | Abrir una terminal en otra computadora |
scp origen usuario@servidor:destino | Copiar archivos entre computadoras |
rsync -avz origen/ usuario@servidor:destino/ | Sincronizar carpetas enviando solo los cambios |
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:
| Parte | Lo que dominas |
|---|---|
| I · Primeros pasos | Abrir la terminal en cualquier sistema, leer un comando y moverte por el árbol de carpetas. |
| II · Archivos y carpetas | Crear, copiar, mover, borrar con seguridad, leer archivos y usar comodines. |
| III · Texto y tuberías | Redirigir salidas, encadenar comandos, buscar con grep y find, y resumir datos. |
| IV · Tu sistema | Permisos, instalación de programas, procesos, variables, PATH y tu ~/.bashrc. |
| V · Scripts | Programas propios con argumentos, decisiones, bucles, funciones y un respaldo automático. |
| VI · Red | Consultar 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.
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 -lLa 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.html404 significa «no encontrado».
Puntos clave
curlpide páginas y archivos:-ssilencioso,-oguardar,-Iencabezados.python3 -m http.serversirve una carpeta enlocalhostpara pruebas.ssh usuario@servidorabre una terminal remota;exitvuelve.scpcopia entre computadoras;rsync -avzsincroniza enviando solo los cambios.- Siguiente paso: el curso de Git, y escribir scripts para tus propias tareas.