Linux Sin Humo (Publicaciones sobre vim)

¿Cómo convertir tu configuración de init.vim a init.lua?

sebelk — Thu, 15 May 2025 19:01:18 GMT

Requisitos

Curiosidad. Es la condición más importante para leer este post. Si la tenés, con algo de esfuerzo sumado a algo de tiempo podrás aprender Vim, Neovim, etc.
Conocimientos básicos o intermedios de Vim y haber leído el post anterior.
Conocimientos básicos de vim-plug.

Repaso de conceptos importantes

En el post anterior vimos cómo un usuario de Vim puede comenzar a usar Neovim. En el presente artículo haremos la transición de Vim script a Lua. Ok, booting the post 😄 ...

Recordemos que Vim usa Vim script (aka VimL) como lenguaje de scripting nativo. Es un lenguaje específico que permite personalizar y extender su funcionalidad. Existe en dos formas: el Vim script tradicional (también llamado "legacy script") y Vim9script (introducido en Vim 9.0), que ofrece mejor rendimiento y una sintaxis más moderna. Sin embargo, Vim9script ni siquiera se usa de manera predeterminada en Vim 9.

Lua, en cambio, es un lenguaje de programación ligero, de alto nivel y multiparadigma, diseñado principalmente para ser incorporado en aplicaciones. Se destaca por su simplicidad, eficiencia y portabilidad. Neovim incorporó Lua como lenguaje de scripting de primera clase, lo que ha ganado popularidad debido a su mejor rendimiento y facilidad de uso comparado con Vim script tradicional.

Neovim usa una implementación de Lua llamada LuaJIT, que compila código Lua a código máquina nativo durante la ejecución. Es un detalle técnico relevante, pero no la razón principal para preferir Lua sobre Vim script en la configuración del editor — en ese terreno el cuello de botella suele estar en el startup time y en el diseño de los plugins, no en la velocidad del lenguaje.

Diferencia de idiosincrasia:

Vim script: scripting lineal, global y directo. Bueno para pequeños ajustes, pero difícil de escalar.
Lua (Neovim): lenguaje estructurado, orientado a modularizar, reusar y escalar. Favorece el uso de variables locales, tablas y funciones que mejoran el mantenimiento de la configuración.

Por qué importa esto en la práctica:

La API de Neovim en Lua es estructurada y predecible (tablas, namespaces como vim.api.*, vim.opt), donde Vim script ofrecía variables globales y comandos planos.
El ecosistema de plugins modernos asume Lua como lenguaje nativo — los gestores actuales (lazy.nvim, packer.nvim), los runtime helpers, los plugins de LSP y UI conviven mejor con configs en Lua.
La modularización con require permite dividir la configuración en archivos lógicos con scoping limpio, algo que Vim script soporta de forma rudimentaria.

LuaJIT existe y es rápido, pero esa rapidez rara vez es lo que el sysadmin nota al usar Neovim — lo que nota es que su configuración escala mejor y se integra con el ecosistema sin fricciones.

3 conceptos esenciales — lo mínimo que siempre debés recordar

Concepto	Por qué es esencial
Tablas (`table`)	Las tablas son la única estructura de datos compuesta en Lua. Opciones (`vim.o`, `vim.opt`), autocmds, comandos, mappings y configuraciones de plugins.
Variables locales (`local`)	Permiten organizar el código, evitar errores y mejorar el rendimiento. Imprescindible para no contaminar el entorno global.
*API de Neovim (`vim.api.`)**	Es la manera oficial y flexible de interactuar con Neovim: crear comandos, autocmds, mappings y manipular el editor desde Lua.

Si entendés estos 3 conceptos, podés crear y mantener cualquier configuración básica y muchas avanzadas.

¿Qué es una tabla y qué no en la configuración de Neovim (Lua)?

Tablas 🆗:

vim.g
vim.opt / vim.o
vim.api
Configuraciones de plugins
Listas/patrones

No son tablas ⚠:

Funciones
Comandos ejecutados
Strings, números, booleanos

El podio de las tablas globales más importantes en Neovim

Estas son las tres tablas globales más importantes del entorno Lua en Neovim:

🏅 vim

Es la tabla principal y núcleo del entorno Lua en Neovim. Contiene todo lo necesario para interactuar con el editor:

Subtablas como vim.api, vim.cmd, vim.opt, vim.g, vim.fn, etc.
Siempre disponible sin necesidad de importar.

🥈 _G

Es la tabla global del lenguaje Lua. Desde aquí podés definir funciones o variables globales accesibles desde cualquier parte de tu configuración:

_G.mi_funcion = function() ... end
También contiene vim como una de sus claves.

🥉 package (de Lua)

Maneja los módulos cargados por require. Es crucial para modularizar tu configuración:

package.loaded permite ver y recargar módulos.

Nota

Tablas como vim.api, vim.opt, vim.g son importantes, pero no son globales de nivel superior: viven dentro de vim. Lo mismo aplica para math, string, table, etc., que viven en _G.

→ Estas 3 (vim, _G, package) forman la base del entorno ejecutable de cualquier configuración Neovim moderna en Lua.

Subtablas más importantes

Tabla	Contiene	Ejemplo equivalente en Vim script
`vim.o`	Opciones globales	`set tabstop=4`
`vim.opt`	Acceso a opciones con métodos (`:append`, `:remove`, `:prepend`); requerido para listas	`set nrformats+=alpha`
`vim.cmd`	Comandos que se ejecutan en modo ex	`colorscheme PaperColor`
`vim.g`	Variables globales	`let g:loaded_perl_provider = 0`
`vim.keymap.set`	Asignación de atajos de teclado a una función o combinación de teclas	`nnoremap ñ :wq<CR>`
`vim.api.nvim_create_user_command`	Creación de comandos personalizados	`command Nbuild execute 'w \| Silent nikola build'`

Diccionario cruzado Vim script / Lua

Concepto	Vim script	Lua
Variable global	`let g:mi_var = 10`	`vim.g.mi_var = 10`
Variable local	`let l:var = 10` (function-local), `s:`, `b:`, `w:` por contexto	`local var = 10`
Lista	`let lista = [1,2,3]`	`lista = {1, 2, 3}`
Diccionario	`let dict = {'a':1}`	`dict = {a = 1}`
Función	`function! Hola() ... endfunction`	`function hola() ... end`
Función anónima	`{a, b -> a + b}` (lambda, desde Vim 8.0)	`function() ... end`
Autocomando	`autocmd BufWrite ...`	`vim.api.nvim_create_autocmd`
Mapping	`nnoremap`	`vim.keymap.set`
Comando	`command ...`	`vim.api.nvim_create_user_command`

Ejemplo de migración Vim script → Lua

Bueno, con la teoría suficiente, ✋✋ a la obra 😉. Supongamos que tenemos esta configuración del archivo init.vim:

set tabstop=4
set nrformats+=alpha

nnoremap ñ :wq<CR>

command -nargs=+ Silent execute 'silent !<args>' | redraw!
command Nbuild execute 'w | Silent nikola build'

filetype plugin on
runtime plugins.vim
colorscheme PaperColor

Es un archivo pequeño, pero que sirve de punto de partida para moverse a una configuración en Lua.

Crear el entorno para Neovim

Como vimos en el post anterior, mi recomendación es comenzar con un archivo init.vim. Una vez que ya estamos usando Neovim podemos realizar la migración a init.lua. Sin embargo, tenemos que crear los directorios para que Neovim guarde su configuración. Lo único que dejaremos por ahora en Vim script es la configuración de plugins con vim-plug. Por lo tanto ejecutamos:

mkdir -p ~/.config/nvim/lua/utils
mkdir -p ~/.local/share/nvim/site/autoload
# Suponiendo que usabas un archivo para gestionar plugins en Vim
mv ~/.vim/autoload/plug.vim ~/.local/share/nvim/site/autoload

El directorio ~/.config/nvim es obligatorio.
El directorio ~/.config/nvim/lua no es obligatorio, pero es muy útil para modularizar la configuración de Neovim.
Los nombres dados de los archivos y directorios dentro de ~/.config/nvim/lua son totalmente arbitrarios.

En Neovim tendremos una estructura más modular. Si bien podemos tener todo en init.lua, vamos a aprovecharnos de esta configuración que es mucho más flexible.

Archivo ~/.config/nvim/init.lua

-- Cargamos los plugins primero — algunas configuraciones
-- (como `colorscheme`) dependen de tenerlos disponibles en el runtimepath
vim.cmd('source ~/.config/nvim/plugins.vim')

-- Cargamos nuestros módulos (el require ejecuta el archivo;
-- el efecto viene del side-effect, no del valor capturado)
require('utils.commands')
require('utils.extracommands')
require('keymaps')
require('opciones')

Archivo ~/.config/nvim/lua/keymaps.lua

-- Alias
local map = vim.keymap.set
-- maps
map('n', 'ñ', ':wq<CR>')

Nota sobre vim.keymap.set: usa remap = false por default, así que map('n', 'ñ', ':wq<CR>') ya es equivalente a nnoremap (no a nmap). El "nore" que en VimL diferenciaba nnoremap de nmap está implícito en el default de la API Lua.

Archivo ~/.config/nvim/lua/opciones.lua

-- Alias
local vo = vim.o
local vop = vim.opt

-- Opciones
vo.tabstop = 4
vop.nrformats:append('alpha')

Archivo ~/.config/nvim/lua/utils/commands.lua

-- Comando auxiliar para correr cosas en shell silenciado
vim.api.nvim_create_user_command('Silent', function(opts)
  vim.cmd('silent !' .. table.concat(opts.fargs, ' '))
  vim.cmd('redraw!')
end, { nargs = '+' })

-- Build del sitio Nikola
vim.api.nvim_create_user_command('Nbuild', function()
  vim.cmd('w')
  vim.cmd('Silent nikola build')
end, {})

Archivo ~/.config/nvim/lua/utils/extracommands.lua

-- Alias
local vcmd = vim.cmd

-- Extra commands
vcmd('filetype plugin on')
-- Esta configuración es innecesaria porque ya está en init.lua
-- vcmd('runtime plugins.vim')
vcmd('colorscheme PaperColor')

Archivo ~/.config/nvim/plugins.vim

Este es el único archivo que dejamos en Vim script (con código Lua embebido):

"Plugins (Plug)
call plug#begin('~/.vim/plugged')

Plug 'itchyny/lightline.vim'
Plug 'nyngwang/NeoTerm.lua'
Plug 'NLKNguyen/papercolor-theme'

call plug#end()

lua << EOF                                                       
require("neo-term").setup {
  exclude_filetypes = { "oil" }
}                          
EOF

nnoremap <F4> :NeoTermToggle<CR>
tnoremap <F4> <C-\><C-n>:NeoTermToggle<CR>
tnoremap <Esc> <C-\><C-n>:NeoTermEnterNormal<CR>

Y listo...

Explicación

¿Por qué definimos alias en los archivos de módulos?

Los alias son básicamente variables. Los definimos porque este es un ejemplo de tipo "esqueleto" de configuración. Cuando comiences a agregar más opciones, atajos de teclado y comandos personalizados, no querrás tipear tanto 😉.

Nota sobre redefinición de comandos

vim.api.nvim_create_user_command sobrescribe por default un comando con el mismo nombre (la opción force tiene valor true por defecto, según la doc oficial de la API). Es decir: podés llamar dos veces a nvim_create_user_command('Nbuild', ...) y la segunda definición reemplaza a la primera sin error. No hace falta borrar antes con nvim_del_user_command. Esto es distinto del :command de VimL, que sí requiere command! para sobrescribir — la API Lua no hereda esa restricción.

El ejemplo de Nbuild deja ver diferencias más grandes entre VimL y Lua. Las analizamos en cinco dimensiones:

1. Brevedad vs mantenibilidad

VimL:

vim command -nargs=+ Silent execute 'silent !<args>' | redraw! command Nbuild execute 'w | Silent nikola build'

Es breve, directo y funciona. Pero:

Es poco expresivo
No permite manejar errores fácilmente
No escala bien con lógica compleja
Lua:

lua vim.api.nvim_create_user_command('Silent', function(opts) vim.cmd('silent !' .. table.concat(opts.fargs, ' ')) vim.cmd('redraw!') end, { nargs = '+' })

Es más verboso, sí, pero:

La función puede ser más compleja si se necesita
Es programable y reutilizable
Puede integrarse con condicionales, bucles, o lógica externa

2. Control de errores y depuración

En VimL: si un comando falla, tenés poco margen para capturar y manejar el error.
En Lua: podés usar pcall, vim.notify, vim.fn.systemlist, y construir mensajes personalizados o fallback si algo sale mal.

local ok, _ = pcall(function()
  vim.cmd('silent !nikola build')
end)
if not ok then
  vim.notify('Error al ejecutar nikola build', vim.log.levels.ERROR)
end

3. Modularización

En Lua podés agrupar comandos en módulos, con require(...).
En VimL tenés que recurrir a runtime, source, y no hay namespaces claros.

require('utils.commands')        -- registra los user commands al cargarse
require('utils.extracommands')   -- aplica colorscheme y filetype detection
require('keymaps')               -- registra los atajos de teclado
require('opciones')              -- opciones generales de configuración

Esto facilita dividir la configuración en archivos lógicos, más fácil de leer, mantener y compartir.

4. Compatibilidad futura y ecosistema Neovim

Neovim ha declarado que Lua es su lenguaje de configuración nativo moderno.
La mayoría de los plugins modernos están escritos en Lua.
VimL sigue siendo soportado, pero está siendo superado funcionalmente.

5. Legibilidad a largo plazo

Aunque VimL sea más corto, en un entorno de colaboración o con configuraciones grandes, Lua:
Es más explícito.
Permite documentar.
La API de Neovim en Lua permite un uso más explícito y predecible de tipos de datos.
Es más fácil de extender con lógica externa.

Conclusión

Si sabés migrar opciones, mappings, comandos y cargar plugins → podés convertir el 80% o más de tu init.vim (equivalente al viejo .vimrc) a init.lua.

Migrar de Vim script a Lua no es una mejora cosmética: cambia las posibilidades de la configuración. Lo que en Vim script son comandos breves, en Lua son funciones programables — más verbosas, sí, pero abiertas a control de errores con pcall, modularización con require y un ecosistema de plugins que ya asume Lua como lenguaje nativo.

La estructura mostrada acá es una entre muchas. El esqueleto init.lua + módulos en lua/ se sostiene porque escala: cada archivo crece sin contaminar al resto, y la configuración deja de ser una pared de líneas para volverse un conjunto de piezas que podés rearmar cuando lo necesites.

Lo que no migramos en este post es la configuración de plugins, que dejamos en plugins.vim. Reemplazar vim-plug por un gestor en Lua como lazy.nvim es el siguiente paso natural — y tema de este otro post.

Al cierre del post dejé un resumen de 10 conceptos clave para tener a mano cuando empieces a extender tu config.

Apéndice: Los 10 conceptos fundamentales de Lua (resumen)

Resumen de los 10 conceptos clave de Lua en Neovim. Los 3 marcados como (esencial) son los que vimos al principio; el resto extiende esa base:

Concepto	Descripción breve
Tablas (`table`) (esencial)	Estructuras clave-valor o listas. Base de toda la configuración.
Variables locales (`local`) (esencial)	Para mantener el código limpio y evitar contaminación global.
Funciones anónimas	Permiten definir acciones sin nombre, usadas en mappings, autocmds y comandos.
*API de Neovim (`vim.api.`)** (esencial)	Puente entre Lua y Neovim: crear comandos, mappings, autocmds.
`vim.opt` vs `vim.o`	`vim.o` da acceso directo al valor; `vim.opt` lo envuelve en un objeto type-aware con métodos (necesario para listas).
`require`	Para cargar módulos externos y dividir la configuración.
Paréntesis en llamadas	Obligatorio usar `()` al llamar funciones.
Referencias	Asignar una tabla a otra variable sin copiarla (ejemplo: `local vg = vim.g`).
`_G (global)`	Tabla especial que contiene las variables y funciones globales accesibles en toda la configuración.
`package.loaded`	Permite ver o manipular qué módulos están cargados, útil para recargar configuraciones dinámicamente.

Fuentes y más Recursos

Lua en Neovim (:help lua) — referencia completa de la API Lua de Neovim.
Guía de Lua para Neovim (:help lua-guide) — survival kit oficial para configurar Neovim en Lua.
Manual de referencia de Lua 5.1 — definición oficial del lenguaje (LuaJIT, que usa Neovim, está basado en esta versión).
Recursos de Lua recomendados por Neovim — curaduría oficial de tutoriales y libros.
A pragmatic approach to migrating from VSCode to Neovim — otra mirada sobre migración hacia Neovim+Lua, desde VSCode.
NeoVim Is Better, But Why Developers Aren't Switching To It? — perspectiva crítica sobre la adopción de Neovim.

Cómo pegar texto en VIM usando Ctrl-v

sebelk — Wed, 25 Dec 2019 23:03:22 GMT

Cuando copiamos un texto desde otro programa y lo queremos pegar en VIM, no podemos usar el atajo de teclado Ctrl-v. Sin embargo, podemos usar la siguiente configuración para poder hacerlo

imap <C-v> <C-o>"+p

Dicha configuración hay que guardarlo en el archivo ~/vimrc (en el caso de neovim usar ~/.config/nvim/init.vim).

¡Eso es todo!

VIM + Markdown = Sorprendente

sebelk — Sat, 08 Dec 2018 20:24:44 GMT

¿Qué es?

En artículos anteriores ya habíamos hablado acerca de Markdown. VNote es una aplicación para tomar notas, diseñado especialmente para Markdown. Pero no es otro editor más. No posee doble panel como ReText o Haroopad. Tampoco es WYSIWYG como Typora o Mark Text. El problema con el primer enfoque es que contar con dos paneles no favorece a la concentración. La segunda táctica contradice en cierta manera el espíritu de markdown que es la capacidad de tener control sobre lo que se está escribiendo.

El intento de VNote por acortar la distancia entre escritura y lectura que ofrece Markdown es muy ingenioso. Recuerda al WYSIWYM del editor LyX. Claro, la diferencia es que markdown es por lejos, mucho más amigable que LaTeX.

VNote usa libretas, carpetas y notas para la jerarquía de las notas para administrar las notas. Este principio de una 1 nota, 1 archivo favorece la gestión por parte del usuario. Algo que no ocurre con otros intentos como MindForger, por citar un ejemplo.

Ficha

VNote
Author: Le Tan
Licencia: MIT
Sitio Web: tamlok.github.io/vnote

¿Para qué sirve?

Para escribir notas y organizarlas
Los siguientes usos no fueron parte principal del propósito que tuvo en mente el desarrollador, no obstante, se puede adaptar bastante bien para:*
- Para escribir artículos técnicos
- Para escribir posts para un blog
- Para escribir documentación

Funcionalidades

Facilita el ingreso de textos frecuente (Snippets)
Expansión de palabras permite el ingreso de la fecha actual, nombres y otros textos de manera rápida (Word Magic). Viene con una lista predeterminada, pero se pueden agregar más a la misma
Plantillas
Temas y estilos
Guarda sesiones, es decir permite seguir trabajando con los mismos archivos que teníamos abierto en la sesión anterior
Exportación: Markdown con sus imágenes y adjuntos en una carpeta para distribuir, motor interno para convertir a pdf. También soporta la conversión usando wkhtmltopdf u otro comando personalizado.
Potente motor de búsqueda, que permite buscar entre una o más notas e incluso por tags de las mismas.
MathJax para interpretar ecuaciones matemáticas $$ a^2 + b^2 = c^2 $$
Diagramas mediante Mermaid o Flowchart

graph TD
A(VNote)-->B[Qué es];
     A-->C[Para qué se usa];
     A-->D[Funcionalidades];
     A-->E[Como instalarlo];
     A-->F(Conclusión);

Soporte para emojis

**Por favor no vote a un :cat: **

Pestañas
Modo vim

Conclusiones

Me gusta que tenga un modo lectura y un modo edición, en lugar de código puro y panel para previsualizar, el modo Vim es sorprendente y para mis preferencias y necesidades lo convierte en un claro ganador frente a otras alternativas. Asimismo, la impresión que genera VNote es la de un proyecto que se ha interesado en detalles que a veces se pasan por alto en proyectos Open Source.

¿Buscando Más?

Lo viejo, lo bueno y lo nuevo en Neovim

sebelk — Mon, 20 Nov 2017 16:25:51 GMT

Características

El editor Neovim se presenta como el sucesor del editor Vim.

El conector entre componentes de software, MessagePack de manera eficiente intercambia datos en binario y sirve para intercambiarlos en lenguajes tales como JSON.
Los plugins remotos son coprocesos que tienen un canal de comunicación por medio de RPC con el proceso de neovim. Estos plugins además se ejecutan de manera asíncrona, mejorando así el rendimiento.
Una configuración predeterminada más potente y amigable.

La configuración predeterminada incluye las siguientes funcionalidades:

Cuando se detecta que un archivo ha sido cambiado dentro de Vim, automáticamente lo lee de vuelta.
Permite borrar una autoindentación, saltos de línea y al comienzo de inserción.
Ahora los directorios de backup están en ~/.local/share/nvim/backup siguiendo las directrices xdg [^{^1}]
Resalta los resultados coincidentes de búsquedas
Realiza búsquedas incrementales
Muestra siempre la línea de estado
Ahora se pueden ver mejor las tabulaciones y espacios al final de cada línea
Muestr el comando que se está ejecutando
Manejo más inteligente de tabulaciones
Asume una terminal de conexión rápida
La campanilla está deshabilitada para todos los eventos
El directorio para temporales está en ~/.local/share/nvim/swap [^{^1}].
El comando display muestra la última línea de los registros.
Justifica automáticamente usando el ancho del texto, inserción y borrado inteligente de caracteres de comentarios.

Configuración

En $HOME creamos un enlace:

lrwxrwxrwx 1 sergio sergio 19 nov 5 23:30 init.vim -> /home/sergio/.vimrc

Y también en $HOME/.config:

lrwxrwxrwx 1 sergio sergio 17 nov 5 23:30 nvim -> /home/sergio/.vim

En \$HOME/.vimrc

if has('nvim') 
  Plug 'Shougo/deoplete.nvim', { 'do': ':UpdateRemotePlugins' } 
  Plug 'vim-airline/vim-airline' 
else 
  Plug 'Shougo/deoplete.nvim' 
  Plug 'roxma/nvim-yarp' 
  Plug 'roxma/vim-hug-neovim-rpc' 
  python3 from powerline.vim import setup as powerline_setup 
  python3 powerline_setup() 
  python3 del powerline_setup 
  set laststatus=2 
  set t_Co=256 
endif

let g:deoplete#enable_at_startup = 1

neoterm 
Plug 'kassio/neoterm'

"call vundle#end()            " required 
call plug#end()

Nuevas funcionalidades provenientes de plugins

Algunos de estos plugins son:

far.vim: Buscar y remplazar, abre un panel de vista previa.
deoplete.nvim: Autocompletar.
floobits: Etherpad usando neovim.
neoterm: Terminal embebida.
vim-pandoc: Integración con el conversor de lenguajes de marcas ligeros pandoc.

Conclusión

El editor VIM es una extraordinaria herramienta, no obstante adolece de disparidad en sus configuraciones predeterminadas, algunos inconvenientes de rendimiento e integración con otros componentes de software. Neovim viene a responder a estos inconvenientes y por ahora lo está haciendo muy bien. De hecho, VIM en su versión 8, incorporó muchas mejoras provenientes de Neovim. El tiempo dirá si los proyectos se terminan fusionando. Lo importante es que tenemos una alternativa moderna al casi treintañero VIM.

Notas

[ _^1 ]: Freedesktop.org

5 ejemplos: Usar la shell sin salir de vim

sebelk — Sun, 24 Sep 2017 12:38:45 GMT

A veces estamos trabajando con un archivo y queremos ejecutar una serie de comandos, pero sin salir del editor. Veremos varias maneras de hacerlo.

1. El comando Ex shell (sh)

Este comando ((sh)ell)) sirve para abrir una shell sin cerrar el editor.

Importante: Para volver de la shell al editor se puede usar el atajo de teclado o Ctrl-d o bien el comando exit

2. Edición de archivos de la shell

Aquí estamos editando el archivo .bashrc, para que se apliquen los cambios podemos ir a la shell en modo login con:

:set shell=bash\ -login

3. Guardar e ir a la shell

En este ejemplo vemos como se puede aplicar los cambios en un servicio

:w | sh

Aquí la clave es el carácter “|” el cual sirve para ejecutar el comando (sh)ell luego de w.

4. Ejecución de bajo perfil

El comando silent ejecuta el comando de manera silenciosa y el comando redraw! limpia y actualiza la pantalla.

5. Ejecutar el archivo en edición

Al escribir un script en lugar de guardar, salir, ejecutar el script y volver a editarlo, podemos ejecutarlo directamente desde vim:

La clave en cuestión aquí es el carácter ‘%‘ que indica el buffer de la ventana actual.

10 cosas extraordinarias que podés hacer con VIM

sebelk — Sun, 10 Apr 2016 08:52:29 GMT

Últimamente este editor ha comenzado a tener mala prensa. Se dice que es difícil, anticuado.
En este artículo intentaremos mostrar 10 características distintivas de vim. Muchos creen que VIM es parte de un caprichoso rito de iniciación al mundo UNIX/Linux. Usar VIM no es un hábito snob de algunos geeks, sino una manera de aumentar la productividad.
La cuestión es que algunas distribuciones incluyen de manera predeterminada vi en lugar de VIM. El usuario principiante entonces, al tropezar con aquel, huye hacia otros editores en apariencia más fáciles pero mucho menos potentes. Aquí mostraremos 10 funcionalidades que posee VIM que difícilmente otro editor de texto puede ofrecer, al menos todas juntas.

Cabe aclarar que el siguiente listado es para usuarios que poseen un conocimiento básico de VIM. ¿Todavía no lo tenés? ¡Usá la herramienta vimtutor!

0. Concentrarte en el texto

Muchos editores poseen una gran cantidad de botones y de menús, pero eso muchas veces quita espacio en la pantalla, además de distraernos. VIM está libre de esas interferencias.
Incluso, tiene plugins y configuraciones para acentuar estas características.¹²

¿Queremos leer y/o editar archivos de texto o tener que aprendernos para que sirve cada botoncito u opción de cada menú? ¿Qué sentido tiene?

1. Comprobar la ortografía

El comando en modo ex:

:setlocal spell spelllang=es_MX

Establece el idioma que utilizará ViM para la corrección ortográfica. El corrector resaltará las palabras con errores. Al situar el cursor en la palabra mal escrita y usar el comando z= aparecerá una lista de palabras alternativas para reemplazar la incorrecta.

2. Operaciones con bloques

Es común al editar archivos con código fuente encontrarnos con porciones de texto encerrados entre algunos de estos caracteres:

\<Esto es un Ejemplo>
“Esto es un Ejemplo”
‘Esto es un ejemplo’
(Esto es un ejemplo)
[Esto es un ejemplo]
{Esto es un ejemplo}

Para seleccionar el texto encerrado entre signos “\<” y “>” podemos usar el siguiente comando:

vi<

Si quisieramos seleccionar el texto incluyendo los signos deberíamos usar:

va<

En castellano una regla mnemotécnica útil es:

i: interior
a: afuera (inclusive)

Para seleccionar cualquiera de los otros bloques, sencillamente hay que reemplazar el caracter delimitador del bloque.

Esto es muy útil para archivos html, en la siguiente imagen se muestra como se puede seleccionar todo un tag mediante el comando vat:

Por supuesto en lugar del comando inicial v se pueden usar otros tales d, y y c.

3. Viajar en el tiempo (controlar ediciones… casi como si fuera GIT)

Esta es una funcionalidad que ya presenté en un artículo anterior, pero que tiene sentido mencionar una vez más:

Con Vim se puede volver al estado que tenía el archivo 10 minutos atrás con el comando en el comando en modo ex:

:earlier 10m

Por supuesto, se puede volver al futuro con:

:later 10m

¿Qué pasa si no se pone ‘m’? En eseo caso se retrocede o avanza la cantidad de ediciones especificada.

4. Automatización de operaciones

Hay una manera muy sencilla de repetir operaciones: y es a través del comando .
Dicho comando repite el último comando y repetirlo la cantidad que sea necesaria, sencillamente usando el “punto” las veces que sea necesario. Cuando el comando a repetir es muy complejo es una función de extrema utilidad.

Otra manera de repetir operaciones es anteponiendo un número de veces. Por ejemplo, el comando 10p pega 10 veces el contenido del buffer.

También se pueden usar macros para automatizar tareas utilizando macros:

Prendemos la grabadora con qa
Ejecutamos los comandos deseados
Detenemos la grabadora con q
Reproducimos el comando con @a

Por ejemplo podríamos usarlo para estructurar un documento en markdown de la siguiente manera:

:set nf+=alpha (Para habilitar el incremento de caracteres alfabéticos)
Tipeamos ## A. (sin las comillas)
qa
yyp
Usamos el atajo de teclado Ctrl-a (Para incrementar)
q
Utilizamos 10@a (el número 10 es un ejemplo)

5. Abrir dos archivos al mismo tiempo

Esta función es extremadamente útil. Hay varias maneras de hacerlo, aquí mostraré una manera de hacerlo.

Por ejemplo, si tenemos un archivo y queremos copiar el contenido de otro archivo, debemos ejecutar este comando en modo ex:

:split /etc/squid3/squid.CONF

Desde luego la ruta del archivo es un ejemplo. Luego podemos copiar, cortar, pegar entre las diferentes como es habitual. Lo más importante es saber como pasar entre ventanas: primero se emplea el atajo de comandos Ctrl-w y luego la tecla de la flecha en dirección a la ventana deseada.

Si esto parece complicado, se puede usar incluso el modo ex:

:wincmd j

6. Editar un archivo web al vuelo

Supongamos que estamos copiando código libre de un sitio web a un archivo, podríamos usar el comando siguiente:

vim http://www.fsf.org/index.html

Luego de presionar Enter se descarga el archivo html y se abre una copia en el editor. ¿No es maravilloso?

7. Editar un archivo remoto a través de ssh

Este método es múy útil en particular cuando se utilizan claves públicas para autenticar. Hay que hacer así:

vim scp://root@192.168.80.148//etc/squid3/squid.conf

A diferencia del ejemplo anterior este comando edita efectivamente el archivo remoto. Obviamente usa un archivo local de manera temporaria hasta que guardamos los cambios…

8. Explorar archivos

Aquí mediante el comando

:e .

Se abre un explorador de archivos que permite por ejemplo copiar archivos de un directorio a otro.
El procedimiento es tal vez contraintuitivo, pero no por eso es complejo.

Se navega como es habitual en gestor de archivos hasta encontrar el directorio de destino. Ubicado allí el cursor se usa el comando mt.

Luego buscamos el archivo que queremos copiar y usamos los comandos mf y mc.

¡Listo! Se copió el archivo al directorio de destino.

9. Autocompletar texto

Si tenemos que volver a tipear una palabra larga podemos hacerlo rápida y fácilmente con el atajo de teclado Ctrl-p.

En el ejemplo siguiente queremos ingresar rápidamente la función isunordered:

VIM tiene además, otras maneras de completar téxto fácilmente mediante el atajo de teclado Ctrl-x. Por ejemplo ingresando luego el atajo de teclado Ctrl-f, podremos escribir rutas de archivos velozmente:

Cabe aclarar que todos estos atajos se usan en modo Insert.

¡Qué lo disfruten!

Cosas sorprendentes con ViM

sebelk — Mon, 27 Sep 2010 06:54:18 GMT

Sorpresa 1

Abrir directamente un archivo en un determinado número de linea, por ejemplo: línea 247:

vim +247 /ruta/al/archivo

Sorpresa 2

Ejecutar un comando en modo Ex al abrir un archivo:

vim +:set nu /ruta/al/archivo

Sorpresa 3

Con Vim se puede volver al estado que tenía el archivo 10 minutos atrás con el comando en el comando en modo ex:

:earlier 10m

Por supuesto, se puede volver al futuro con:

:later 10m

¿Qué pasa si no se pone ‘m’? En eseo caso se retrocede o avanza la cantidad de ediciones especificada.

Sorpresa 4

Convertir un archivo en html en modo ex se hace así:

:TOhtml

El resultado es un ejemplo de un archivo Makefile.in convertido a HTML.

Sorpresa 5

Editar un archivo de manera remota:

vim ftp://remotehostname.com/myfile