7. Editar en la terminal: nano y supervivencia en vim

Descripción

Al final de esta lección vas a poder abrir un archivo directamente desde la terminal, escribirle una línea, buscar un texto dentro de él, guardarlo y salir — con nano, sin ayuda. Y si terminas dentro de vim sin haberlo pedido, vas a saber salir con vida: entender por qué no puedes escribir de inmediato, cómo entrar a modo de escritura, y cómo guardar o descartar el cambio sin cerrar la ventana a la fuerza.

Esto importa el día que menos te lo esperas. Eres el ingeniero de guardia, son las dos de la mañana, nginx está devolviendo 502 en producción y te conectas por SSH al servidor. No hay VS Code ahí adentro: hay una terminal y un archivo de configuración que necesitas tocar en el momento. O más simple todavía: corres git commit sin -m y, sin previo aviso, tu pantalla se llena de líneas con ~ a la izquierda y no reacciona a lo que escribes. Ambos casos son el mismo problema — necesitas editar texto sin salir de la terminal — y ambos tienen una herramienta hecha exactamente para eso.

Conexión con el módulo: en la lección anterior usaste grep para encontrar la línea exacta que te interesaba dentro de un proyecto entero. Pero encontrar no es lo mismo que corregir: grep te dice dónde está la aguja, no te deja sacarla del pajar. Esta lección cierra ese círculo. Es también la última pieza suelta antes del proyecto del módulo, donde vas a combinar todo lo que aprendiste —crear estructura, copiar y borrar con criterio, leer archivos completos, encontrarlos, buscar dentro de ellos y ahora editarlos— en una sola auditoría real.

Cuándo editar desde la terminal (y cuándo no)

Piénsalo como la diferencia entre un destornillador de precisión y tu banco de herramientas completo. El destornillador de precisión es exactamente lo que necesitas para un tornillo específico, en un motor al que no le puedes llevar el banco entero — pero nadie arma un mueble completo con él. Un editor de terminal es tu destornillador de precisión: perfecto para tocar un archivo puntual en una máquina donde no tienes (o no quieres) interfaz gráfica. Tu editor de siempre —VS Code o el que uses— es el banco completo: autocompletado, control de versiones integrado, extensiones, y la capacidad de tener veinte archivos abiertos a la vez. Para tu proyecto real, ese banco gana siempre.

La fila del medio es la que sorprende la primera vez: hay comandos que abren un editor de terminal por su cuenta, sin que tú hayas escrito nano ni vim. Vuelve más adelante en esta misma lección.

nano: crear, escribir, buscar, guardar y salir

nano es el editor de terminal pensado para no tener que aprender nada antes de usarlo: abres, escribes, y la ayuda que necesitas está siempre visible en la pantalla, en la última línea. Esa es su promesa completa — no hay modos que memorizar, no hay comandos ocultos. Lo que ves es lo que hay.

Ejemplo trabajado: editar un archivo de configuración con nano

Estás conectado por SSH a un servidor remoto y quieres agregar un alias a tu ~/.bashrc.

nano ~/.bashrc

Qué esperar (la pantalla se llena por completo; esto es lo que verías, con el contenido real de tu archivo en el medio):

GNU nano 9.1                        /home/ana/.bashrc

# ~/.bashrc: executed by bash(1) for non-login shells.

export PATH="$HOME/.local/bin:$PATH"



^G Help    ^O Write Out ^W Where Is  ^K Cut       ^X Exit

Lee esa última línea como el mapa de la herramienta: ^ significa Ctrl, y la letra que sigue es el atajo. ^G Help es Ctrl+G para pedir ayuda, ^O Write Out es Ctrl+O para guardar, y así con cada uno. Nano siempre te muestra en pantalla los atajos disponibles — no hace falta memorizarlos de entrada, solo saber leer esa barra.

1. Moverte y escribir. Usa las flechas para bajar hasta la última línea con contenido y agrega una nueva:

   alias gs='git status'

   En cuanto escribes algo, nano marca el archivo como modificado (lo indica en el encabezado, junto al nombre).

2. Buscar un texto existente. Presiona Ctrl+W (Where Is). Nano te pide el término en la parte inferior:

   Search: PATH
   

   Escribe PATH y presiona Enter — el cursor salta a la primera coincidencia. Si hay varias, Ctrl+W y Enter otra vez repite la última búsqueda y avanza a la siguiente.

3. Guardar. Presiona Ctrl+O (Write Out). Nano confirma el nombre de archivo antes de escribir:

   File Name to Write: /home/ana/.bashrc
   

   Presiona Enter para confirmar ese mismo nombre y el archivo queda guardado en disco. Ojo: Ctrl+O guarda, pero no te saca del editor.

4. Salir. Presiona Ctrl+X (Exit). Como ya guardaste en el paso anterior, nano cierra directo y te devuelve al prompt. Si en cambio salieras con cambios sin guardar, nano pregunta antes de perder algo:

   Save modified buffer?
    Y Yes
    N No           ^C Cancel
   

   Y guarda y sale, N descarta el cambio y sale, Ctrl+C te devuelve al archivo sin decidir todavía.

Con esos cuatro movimientos —escribir, Ctrl+W para buscar, Ctrl+O para guardar, Ctrl+X para salir— cubres el 90% del uso real de nano. El resto de la barra (Ctrl+K para cortar una línea, Ctrl+U para pegarla, Ctrl+_ para saltar a un número de línea) lo vas descubriendo sobre la marcha, siempre visible en pantalla.

Un detalle si estás en macOS: el comando nano de tu Terminal puede en realidad ser pico (su antecesor de los años 90), no GNU nano — Apple dejó de actualizarlo por un cambio de licencia hace años. Los atajos que acabas de ver funcionan igual, porque nano nació como un clon de pico. Si quieres el GNU nano completo y actualizado, brew install nano lo resuelve.

Profundización: supervivencia en vim

Nadie decide aprender vim un martes cualquiera. A casi todos les llega igual: corren un comando, la terminal cambia de pantalla, y de repente están atrapados en algo que no responde como esperaban. Eso es exactamente lo que va a pasarte, así que vamos a preparar la salida antes que la entrada.

Piensa en vim como un walkie-talkie con un botón para hablar. Mientras no lo presionas, estás en modo Normal: cada tecla que tocas es un comando — moverte, borrar una línea, copiar, deshacer. Nada de lo que presionas se escribe en el archivo. Cuando presionas el botón —en vim, la tecla i— entras a modo Insertar: ahora sí, cada tecla que tocas se escribe como texto, igual que en cualquier editor normal. Sueltas el botón con Esc, que te devuelve a modo Normal desde cualquier lugar. Hay un tercer modo, el de línea de comandos, al que entras escribiendo : desde modo Normal — ahí es donde guardas y sales.

Lo que rompe a los principiantes es esto: vim siempre abre en modo Normal, nunca en Insertar. Si empiezas a escribir tu texto de inmediato, en realidad estás ejecutando comandos, uno por letra.

Con eso como mapa, estos son los comandos que necesitas para sobrevivir cualquier encuentro con vim:

¿Por qué vim se abre sin que lo pidas? Varios comandos de uso diario delegan la edición de texto a "el editor configurado en tu sistema" — la variable $VISUAL o $EDITOR, o la opción core.editor de Git. Cuando ninguna de esas está definida (que es la situación por defecto en muchísimas instalaciones), el sistema recurre a vi — el ancestro de vim, y en la práctica el propio vim en casi cualquier máquina moderna. Los disparadores más comunes que vas a encontrar:

• git commit sin -m — abre el editor para que escribas el mensaje.
• git rebase -i — abre el editor para que reordenes o edites commits.
• crontab -e — abre el editor para que edites tus tareas programadas.
• sudo visudo — abre el editor para editar permisos de sudo de forma segura.

Ninguno de estos comandos "eligió" vim al azar: heredaron la falta de configuración, y el sistema cayó en su opción por defecto.

Ejemplo trabajado: sobrevivir un commit que abre vim

git add README.md
git commit

Qué esperar (la terminal cambia de pantalla por completo y muestra algo así):

# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
#
# On branch master
# Changes to be committed:
#	modified:   README.md
#

Estás en modo Normal. Si en este momento empiezas a teclear tu mensaje directamente, no pasa lo que esperas: por ejemplo, teclear una d dos veces seguidas (dd) borraría la línea donde está el cursor, no escribiría las letras "d" y "d". Este es exactamente el punto donde hay que detenerse y seguir el modelo de modos.

1. Presiona i para entrar a modo Insertar. No verás ningún cambio visual grande, pero en la esquina inferior izquierda aparece -- INSERT --.

2. Con el cursor en la primera línea (encima de los comentarios), escribe tu mensaje:

   fix: correct typo in README
   

3. Presiona Esc para volver a modo Normal.

4. Escribe :wq y presiona Enter — guarda el mensaje y sale.

Vim se cierra y te devuelve a la terminal, donde Git confirma el commit:

[master 3f2a9c1] fix: correct typo in README
 1 file changed, 1 insertion(+), 1 deletion(-)

Si en cambio te hubieras arrepentido y quisieras abortar el commit sin guardar nada, la salida es Esc y luego :q! — Git interpreta que no escribiste ningún mensaje y cancela el commit sin quejarse.

Errores comunes

Escribir de inmediato, sin saber que vim empieza en modo Normal (conceptual). Es el tropiezo número uno: alguien abre vim (a veces sin haberlo pedido, como en el ejemplo del commit) y empieza a teclear su texto directo, letra por letra. Como está en modo Normal, cada letra es un comando: x borra el carácter bajo el cursor, dd borra la línea completa, o abre una línea nueva debajo y ahí sí entra a Insertar (lo que confunde más, porque parece que "a veces funciona"). Se detecta porque no ves -- INSERT -- en la esquina inferior izquierda y el contenido del archivo cambia de forma que no esperabas. Se corrige con Esc para asegurar que estás en Normal, u las veces que haga falta para deshacer lo que se rompió, y recién ahí i antes de escribir.

Confundir Ctrl+O (guardar) con Ctrl+X (salir) en nano, sin leer el prompt. Ctrl+O es "Write Out" —guardar— y Ctrl+X es "Exit" —salir—; son acciones distintas, aunque suene natural pensar que una sola tecla debería bastar. Si presionas Ctrl+X con cambios sin guardar, nano pregunta "Save modified buffer? Y/N" antes de perder algo, pero es fácil responder sin leer y perder el cambio que creías haber hecho. Se detecta revisando el archivo después de salir (cat archivo) y notando que el cambio no está. Se corrige guardando siempre explícito con Ctrl+O y confirmando el nombre con Enter, y solo después saliendo con Ctrl+X — en ese punto sale directo, porque ya no queda nada pendiente.

Ver E37: No write since last change en vim y forzar el cierre de la terminal. Intentas :q con cambios sin guardar y vim se niega, mostrando literalmente E37: No write since last change (add ! to override). En pánico, algunos cierran la pestaña de la terminal o matan la sesión SSH, lo que puede dejar el proceso de vim colgado del lado del servidor en vez de resuelto. Se detecta por ese mensaje exacto en la línea de estado. Se corrige decidiendo a conciencia: :wq si quieres guardar el cambio, o :q! si quieres descartarlo — nunca hace falta forzar el cierre de la ventana.

Ejercicios

1. El flujo completo de nano

Con nano, crea un archivo llamado notes.txt con estas dos líneas:

task: write the report
task: review the pull request

Después busca la palabra review, guarda el archivo y sal. Escribe la secuencia completa de comandos y atajos, en orden.

nano notes.txt

2. El botón de pánico en vim

Terminas dentro de vim sin querer — por ejemplo, tecleaste vim en vez de otro comando por accidente. Ves un archivo vacío, con columnas de ~ a la izquierda, y la línea de estado dice "scratch.txt" [New File]. No quieres cambiar ni crear nada. ¿Qué secuencia de teclas usas para salir?

Esc
:q!
Enter

3. El mensaje de commit, paso a paso

Corriste git commit sin -m y vim se abrió mostrando el archivo COMMIT_EDITMSG, con varias líneas que empiezan con # (comentarios de Git) y el resto vacío. Quieres dejar el mensaje fix: correct typo in README. Escribe la secuencia de teclas completa.

i
fix: correct typo in README
Esc
:wq
Enter

4. Explica el modelo de modos con tus palabras

¿Por qué presionar dd en modo Normal no es lo mismo que "escribir las letras d y d"? Explica la diferencia usando el modelo de modos de vim.

Resumen y siguiente paso

Antes de avanzar deberías poder:

• decidir si un archivo se edita desde la terminal o en tu editor de siempre, según dónde estás parado y cuánto vas a tocar;
• abrir, escribir, buscar (Ctrl+W), guardar (Ctrl+O) y salir (Ctrl+X) de nano sin ayuda, leyendo la barra de atajos que siempre está en pantalla;
• reconocer que vim abre en modo Normal, entrar a Insertar con i, volver con Esc, y guardar o salir con :w, :q, :wq o :q!;
• moverte de punta a punta de un archivo en vim con gg y G, y deshacer un cambio con u;
• salir de vim vivo cuando se abre sin que lo pidas —un git commit sin -m, un crontab -e— sin cerrar la terminal a la fuerza.

Ya tienes las siete piezas del módulo: crear estructura con mkdir y touch, copiar/mover/borrar con criterio de seguridad, leer archivos de cualquier tamaño, encontrarlos con find, buscar dentro de ellos con grep, y ahora editarlos sin salir de la terminal. El proyecto que sigue no te enseña nada nuevo — junta esas siete piezas para reconstruir y auditar, con evidencia, un proyecto que no conoces.

Recursos

• GNU nano — Keyboard Shortcuts (cheatsheet oficial) — referencia completa de atajos; nota que la vigente por defecto sigue siendo la clásica (Ctrl+O, Ctrl+X, Ctrl+W, Ctrl+K), no el esquema --modernbindings que también documenta.
• GNU nano — documentación oficial — manual completo, incluida la configuración vía ~/.nanorc.
• Vim User Manual — usr_02.txt: "The first steps in Vim" — el capítulo oficial que cubre exactamente el modelo de modos, i, Esc, guardar y salir.
• vimtutor — el tutorial interactivo que viene instalado junto con vim; se corre escribiendo vimtutor en la terminal y toma unos 30 minutos.
• Git — git-var (resolución de $GIT_EDITOR) — el orden exacto en que Git decide qué editor abrir ($GIT_EDITOR → core.editor → $VISUAL → $EDITOR → vi por defecto).