Post

Guia Completo de Uso Avançado e Personalização do Vim

Posted
By Gean Martins
22 min read
Guia Completo de Uso Avançado e Personalização do Vim

Sumário

Introdução

O Vim é conhecido por sua eficiência e flexibilidade, tornando-se a escolha preferida de muitos desenvolvedores. No entanto, para tirar o máximo proveito desse editor de texto poderoso, é essencial configurar e personalizar o ambiente de acordo com suas necessidades de trabalho. Este guia foi elaborado para ajudar você a explorar o potencial completo do Vim, abordando desde configurações básicas no .vimrc até automações avançadas com Vimscript. Você aprenderá a gerenciar janelas e buffers, instalar plugins essenciais, configurar o Vim para diversas linguagens de programação, e criar atalhos e automações que aumentam a produtividade. Ao final deste guia, você estará equipado com as ferramentas necessárias para transformar o Vim em um ambiente de desenvolvimento robusto e otimizado.

Configuração do Arquivo .vimrc para Produtividade

O arquivo .vimrc é o coração da configuração do Vim. Com ajustes personalizados, podemos tornar o editor muito mais eficiente, aumentando a produtividade e personalizando o ambiente para tarefas específicas. Nesta seção, vamos explorar as principais configurações de produtividade, desde mapeamentos de teclas até temas e plugins.

Estrutura Básica do .vimrc

O .vimrc armazena as configurações que o Vim carrega ao iniciar. Abaixo está uma estrutura básica que inclui algumas configurações comuns para começar:

1
2
3
4
5
6
7
8
9
10
11
12
13

" Ativando o modo relativenumber para melhorar a navegação
set number
set relativenumber

" Habilitando sintaxe e cores
syntax on
set t_Co=256

" Definindo espaçamento e tabulação para código
set tabstop=4       " Cada tabulação tem 4 espaços
set shiftwidth=4    " Indenta 4 espaços
set expandtab       " Converte tabs para espaços
set autoindent      " Mantém a indentação automática

Essas opções melhoram a organização e a legibilidade do código, essencial para qualquer desenvolvedor.

Mapeamentos de Teclas (Key Mappings)

Mapear comandos para teclas específicas pode economizar tempo e evitar digitação repetitiva. No Vim, nnoremap, inoremap, e vnoremap são usados para mapear teclas em diferentes modos: normal, inserção e visual.

Exemplos de Mapeamentos Úteis:

  1. Salvando e Saindo com Teclas Rápidas:
1
2
3

nnoremap <leader>w :w<CR>        " Salva com <leader>w
nnoremap <leader>q :q<CR>        " Sai com <leader>q
nnoremap <leader>x :wq<CR>       " Salva e sai com <leader>x
  1. Navegando entre Janelas com o Ctrl + Arrow:
1
2
3
4

nnoremap <C-Left> :wincmd h<CR>
nnoremap <C-Down> :wincmd j<CR>
nnoremap <C-Up> :wincmd k<CR>
nnoremap <C-Right> :wincmd l<CR>
  1. Comentando e Descomentando Linhas:
1
2

nnoremap <leader>c I#<Esc>       " Adiciona # no início da linha para comentar
vnoremap <leader>c :s/^/#/<CR>   " Comenta múltiplas linhas selecionadas

Dica Prática: Use <leader> para comandos comuns. O <leader> é uma tecla definida (normalmente \) que agiliza a execução de comandos no Vim.

Alias para Comandos

Aliases são atalhos que permitem renomear comandos para abreviá-los ou personalizá-los. No .vimrc, você pode criar aliases que simplifiquem tarefas repetitivas.

Exemplos de Alias Úteis:

1
2
3
4
5
6
7
8

" Alias para salvar
command W :w

" Alias para sair
command Q :q

" Alias para salvar e sair
command WQ :wq

Autocompletes e Sugestões

O Vim permite configurar autocompletes que tornam a edição de código mais rápida. Abaixo está uma configuração básica para habilitar autocompletes com o <C-n> e <C-p>:

1
2

set completeopt=menu,menuone,noselect
inoremap <expr> <Tab> pumvisible() ? "\<C-n>" : "\<Tab>"

Dica: Este comando ajusta o menu de sugestões para melhorar a experiência de autocompletar.

Configuração de Temas e Cores

Adicionar temas e configurações de cores ao Vim melhora a legibilidade e reduz o cansaço visual. Abaixo, um exemplo de configuração de cores.

  1. Configuração de Cores com o Solarized:
1
2

set background=dark
colorscheme solarized

Dica Prática: Use set background=dark para temas escuros ou set background=light para temas claros.

Integração com Plugins

No .vimrc, você pode definir plugins com gerenciadores como o Vim-Plug. Veja a configuração básica para adicionar plugins:

  1. Instalando o Vim-Plug:
1
2

curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
       https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
  1. Adicionando Plugins no .vimrc com Vim-Plug:
1
2
3
4
5
6
7
8

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

" Plugins recomendados
Plug 'preservim/nerdtree'          " Gerenciador de arquivos em árvore
Plug 'ctrlpvim/ctrlp.vim'          " Navegação de arquivos
Plug 'tpope/vim-fugitive'          " Plugin para integração com Git

call plug#end()

Para carregar novos plugins, entre no Vim e use o comando :PlugInstall.

Gerenciamento de Janelas e Buffers no Vim

Gerenciar múltiplas janelas e buffers no Vim permite trabalhar com vários arquivos e seções de código ao mesmo tempo, aumentando a eficiência e a produtividade. O Vim facilita essa navegação com comandos específicos para abrir, dividir, alternar e fechar janelas e buffers.

Dividindo a Tela com :split e :vsplit

Os comandos :split (divisão horizontal) e :vsplit (divisão vertical) são essenciais para visualizar múltiplos arquivos ou partes de um arquivo em janelas diferentes.

Comando Descrição Exemplo de Uso
:split nome Abre o arquivo nome em uma divisão horizontal. :split README.md abre o README.md na divisão superior.
:vsplit nome Abre o arquivo nome em uma divisão vertical. :vsplit app.js abre app.js na coluna à direita.
Ctrl-w s Divide a janela atual horizontalmente. Pressione Ctrl-w s para ver o mesmo arquivo em duas janelas.
Ctrl-w v Divide a janela atual verticalmente. Ctrl-w v permite a visão de duas colunas do mesmo arquivo.

Exemplo Prático: Para editar um README enquanto visualiza um arquivo de código, use :vsplit README.md. Isso ajuda a ter documentação e código lado a lado.

O Vim oferece uma série de comandos para facilitar a navegação entre janelas abertas, essencial para alternar rapidamente sem precisar do mouse.

Comando Descrição Exemplo de Uso
Ctrl-w h Move para a janela à esquerda. Use Ctrl-w h para pular para a janela da esquerda.
Ctrl-w j Move para a janela abaixo. Ctrl-w j leva o cursor para a janela inferior.
Ctrl-w k Move para a janela acima. Ctrl-w k posiciona o cursor na janela superior.
Ctrl-w l Move para a janela à direita. Ctrl-w l alterna para a janela da direita.

Dica Prática: Configure esses comandos em seu .vimrc com Ctrl + setas, mapeando como mostrado na seção anterior.

Redimensionando Janelas

Para organizar as janelas de forma eficiente, o Vim permite redimensioná-las com comandos simples, o que é útil ao ajustar o espaço para diferentes tipos de arquivos ou conteúdo.

Comando Descrição Exemplo de Uso
Ctrl-w = Ajusta todas as janelas para o mesmo tamanho. Ctrl-w = uniformiza o tamanho de todas as janelas.
Ctrl-w + Aumenta a altura da janela atual. Ctrl-w + amplia a altura para mais visualização.
Ctrl-w - Diminui a altura da janela atual. Ctrl-w - reduz a altura da janela.
Ctrl-w > Aumenta a largura da janela atual. Ctrl-w > expande a largura horizontal.
Ctrl-w < Diminui a largura da janela atual. Ctrl-w < diminui a largura horizontal.

Trabalhando com Buffers

Buffers no Vim representam arquivos abertos na sessão atual. É possível alternar entre eles sem precisar abrir várias janelas, o que torna a edição de múltiplos arquivos mais organizada.

Comando Descrição Exemplo de Uso
:bnext ou :bn Vai para o próximo buffer na lista. :bn troca para o próximo arquivo aberto.
:bprevious ou :bp Volta para o buffer anterior. :bp alterna para o arquivo anterior.
:buffer <n> Abre o buffer pelo número <n>. :buffer 2 abre o segundo buffer.
:ls ou :buffers Lista todos os buffers abertos. :ls mostra todos os arquivos na sessão atual.
:bdelete <n> ou :bd <n> Fecha o buffer especificado, liberando memória. :bd 2 fecha o segundo buffer sem afetar os demais.

Exemplo Prático: Quando editando múltiplos arquivos, use :ls para listar os buffers e :buffer <n> para alternar rapidamente entre eles, agilizando a navegação.

Fechando Janelas e Buffers

Fechar janelas e buffers é essencial para limpar o espaço de trabalho e liberar memória no Vim.

Comando Descrição Exemplo de Uso
:close Fecha a janela atual. :close fecha a divisão onde o cursor está.
:only Fecha todas as outras janelas, mantendo apenas a atual. :only remove todas as divisões, focando em uma só.
:bdelete <n> ou :bd <n> Fecha o buffer específico. :bd 3 fecha o terceiro buffer.
:qa Fecha todas as janelas e termina a sessão do Vim. :qa é útil para finalizar rapidamente.

Instalação e Configuração de Plugins Essenciais no Vim

O Vim pode ser transformado em um ambiente de desenvolvimento completo com a ajuda de plugins. Plugins populares, como NerdTree, CtrlP e Fugitive, adicionam funcionalidades que facilitam a navegação, pesquisa e controle de versão. Nesta seção, vamos ver como instalar e configurar esses plugins usando o Vim-Plug como gerenciador.

Instalando o Gerenciador de Plugins Vim-Plug

O Vim-Plug é um gerenciador de plugins rápido e flexível, ideal para manter os plugins organizados e atualizados. Para instalar:

  1. Execute o comando a seguir no terminal para instalar o Vim-Plug:

    1
2

    curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

  2. Adicione a estrutura do Vim-Plug no .vimrc:

    1
2
3
4
5

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

" Adicione aqui os plugins

call plug#end()

Dica: Coloque a definição de cada plugin entre plug#begin e plug#end.

Plugin de Navegação de Arquivos - NerdTree

O NerdTree permite navegar pelos diretórios e arquivos do sistema como em um explorador de arquivos. Ele é útil para projetos grandes com múltiplos arquivos e pastas.

  1. Adicionando o NerdTree ao .vimrc:

    1

    Plug 'preservim/nerdtree'

  2. Instalando e Usando o NerdTree:

    • Abra o Vim e digite :PlugInstall para instalar.
    • Use :NERDTreeToggle para abrir ou fechar a janela do NerdTree.

  3. Mapeamento de Tecla para NerdTree:

    Adicione o seguinte ao .vimrc para ativar o NerdTree com <leader>n:

    1

    nnoremap <leader>n :NERDTreeToggle<CR>

Exemplo Prático: Ao trabalhar em um projeto, abra o NerdTree com <leader>n, navegue até o arquivo desejado e pressione Enter para abri-lo em uma nova janela.

Plugin de Pesquisa - CtrlP

O CtrlP é um plugin de busca rápida de arquivos que permite encontrar arquivos por nome em todo o projeto. Ele é ideal para projetos com muitos arquivos.

  1. Adicionando o CtrlP ao .vimrc:

    1

    Plug 'ctrlpvim/ctrlp.vim'

  2. Instalando e Usando o CtrlP:

    • Após adicionar o plugin, rode :PlugInstall no Vim.
    • Use <leader>p para abrir o CtrlP e começar a buscar arquivos pelo nome.

  3. Mapeamento de Tecla para o CtrlP:

    Adicione o mapeamento para abrir o CtrlP rapidamente:

    1

    nnoremap <leader>p :CtrlP<CR>

Exemplo Prático: Pressione <leader>p e comece a digitar o nome de um arquivo. O CtrlP apresentará opções correspondentes, facilitando o acesso a arquivos específicos.

Plugin de Integração com Git - Fugitive

O Fugitive é um plugin Git completo para o Vim, oferecendo funcionalidades de controle de versão, como adicionar, commitar, fazer push e pull diretamente do editor.

  1. Adicionando o Fugitive ao .vimrc:

    1

    Plug 'tpope/vim-fugitive'

  2. Instalando e Usando o Fugitive:

    • Instale o plugin com :PlugInstall.
    • Comandos Git podem ser executados diretamente no Vim, como :Gstatus para ver o status, :Gcommit para commitar mudanças, :Gpush para enviar commits, etc.

Exemplo Prático: Para revisar o status do repositório, use :Gstatus. Para adicionar e commitar alterações, execute :Gwrite seguido de :Gcommit.

Atualizando e Removendo Plugins com o Vim-Plug

Para manter os plugins atualizados e gerenciá-los:

  • Atualizar plugins: No Vim, execute :PlugUpdate para atualizar todos os plugins.
  • Remover um plugin: Apague a linha correspondente no .vimrc e execute :PlugClean para desinstalar o plugin.

Dica Prática: Revise os plugins periodicamente, atualizando ou removendo os que não estão mais em uso para manter o Vim leve e eficiente.

Otimização do Vim para Programação

Para transformar o Vim em um ambiente de desenvolvimento completo, é essencial configurá-lo com práticas e ajustes que facilitam o trabalho com código. Nesta seção, exploraremos como otimizar o Vim para desenvolvimento, com plugins e configurações específicas para linguagens como Python, JavaScript e C++.

Configurações Gerais para Programação

Essas configurações são úteis para qualquer linguagem de programação, melhorando a legibilidade e a organização do código.

  1. Indentação Automática:

    Definir a indentação para o estilo de código desejado, como o uso de 4 espaços para linguagens como Python:

    1
2
3
4

    set tabstop=4          " Define o número de espaços que cada tab ocupa
set shiftwidth=4       " Define o número de espaços para indentação
set expandtab          " Converte tabs para espaços
set autoindent         " Mantém a indentação da linha anterior

  2. Realce de Sintaxe:

    O realce de sintaxe é ativado automaticamente com syntax on, mas pode ser configurado para usar temas que facilitam a leitura:

    1
2
3

    syntax on
set background=dark    " Para temas escuros
colorscheme gruvbox    " Exemplo de tema popular para programação

  3. Números Relativos:

    Ativar números relativos facilita a navegação entre linhas, permitindo movimentos rápidos:

    1

    set relativenumber

Configurações Específicas para Linguagens

Cada linguagem tem suas próprias necessidades. Abaixo estão algumas configurações específicas para Python, JavaScript e C++.

Python

  1. Indentação e Estrutura:

    Python depende de indentação para definir blocos de código. As configurações a seguir ajudam a manter o código organizado:

    1

    autocmd FileType python setlocal expandtab shiftwidth=4 tabstop=4

  2. Linter Automático para Python:

    Configure um linter automático, como o ALE (Asynchronous Lint Engine), para verificar erros e formatação no código:

    1
2

    Plug 'dense-analysis/ale'
let g:ale_linters = {'python': ['flake8']}

  3. Atalho para Executar Scripts Python:

    Adicione um mapeamento para rodar scripts Python com <leader>r:

    1

    nnoremap <leader>r :w<CR>:!python3 %<CR>
JavaScript

  1. Indentação para JavaScript:

    O código JavaScript geralmente segue a convenção de dois espaços por tabulação:

    1

    autocmd FileType javascript setlocal expandtab shiftwidth=2 tabstop=2

  2. Plugin de Autocompletar para JavaScript:

    Instale o coc.nvim para adicionar autocompletar e sugestões de código para JavaScript e outras linguagens:

    1

    Plug 'neoclide/coc.nvim', {'branch': 'release'}

  3. Configurar Linter para JavaScript:

    Use o ALE para habilitar um linter JavaScript como eslint:

    1

    let g:ale_linters = {'javascript': ['eslint']}
C++

  1. Configuração de Compilação Rápida:

    Para compilar e rodar código C++ diretamente no Vim, crie um mapeamento com <leader>c:

    1

    nnoremap <leader>c :w<CR>:!g++ % -o %:r && ./%:r<CR>

  2. Configuração de Indentação para C++:

    Use quatro espaços como tabulação padrão:

    1

    autocmd FileType cpp setlocal expandtab shiftwidth=4 tabstop=4

  3. Autocompletar para C++ com YCM (YouCompleteMe):

    Para autocompletar em C++, o plugin YouCompleteMe é recomendado:

    1

    Plug 'ycm-core/YouCompleteMe'

Dica: Instale o clangd para melhorar a precisão do autocompletar com C++.

Personalização do Linter com o Plugin ALE

O ALE (Asynchronous Lint Engine) permite verificar erros de sintaxe e aplicar autoformatação em várias linguagens de programação. Além de Python e JavaScript, o ALE suporta outras linguagens, tornando-o ideal para projetos multi-linguagem.

  1. Configuração Básica para ALE no .vimrc:

    1
2

    let g:ale_fix_on_save = 1                 " Auto-fix ao salvar
let g:ale_fixers = {'python': ['black'], 'javascript': ['prettier']}

  2. Ativando Linting Assíncrono:

    O ALE lida com a verificação de erros enquanto você edita o código, evitando atrasos:

    1

    let g:ale_lint_on_text_changed = 'always'

Configuração do Vim para Infrastructure as Code (IaC)

Profissionais que trabalham com Infrastructure as Code (IaC) frequentemente utilizam linguagens como YAML, JSON, e ferramentas como Terraform e Ansible. Abaixo estão configurações e plugins que otimizam o Vim para edição de arquivos IaC, com destaque para autocompletar, validação de sintaxe, e formatação.

YAML e JSON

Para configurar o Vim de forma que ele reconheça e facilite o trabalho com arquivos YAML e JSON, seguem algumas recomendações.

  1. Configurações Básicas para YAML e JSON:

    Para trabalhar com YAML, configure o recuo para dois espaços, que é o padrão para arquivos .yml e .yaml.

    1
2

    autocmd FileType yaml setlocal expandtab shiftwidth=2 tabstop=2
autocmd FileType json setlocal expandtab shiftwidth=2 tabstop=2

  2. Validação de Sintaxe com ALE:

    Configure o ALE para habilitar linters e validadores de sintaxe automáticos para YAML e JSON.

    1
2
3
4

    let g:ale_linters = {
    \ 'yaml': ['yamllint'],
    \ 'json': ['jsonlint']
\}

  3. Plugin para Realce de Sintaxe em JSON e YAML:

    Adicione o vim-json para realçar sintaxe JSON e vim-yaml para YAML:

    1
2

    Plug 'elzr/vim-json'
Plug 'stephpy/vim-yaml'

Dica: Essas configurações são úteis ao trabalhar com ferramentas como Ansible, que utiliza YAML para definir playbooks.

Terraform

Para usuários de Terraform, o plugin vim-terraform ajuda a realçar a sintaxe, formatação e também permite executar comandos do Terraform dentro do Vim.

  1. Instalando o Plugin vim-terraform:

    Adicione o plugin ao .vimrc:

    1

    Plug 'hashivim/vim-terraform'

  2. Formatar e Validar Código Terraform:

    O vim-terraform oferece comandos para formatar e validar código de maneira rápida:

    1

    autocmd FileType terraform setlocal expandtab shiftwidth=2 tabstop=2

  3. Atalho para Formatação e Validação com <leader>tf:

    Adicione um mapeamento para formatar e validar o código com um comando direto:

    1

    nnoremap <leader>tf :!terraform fmt % && terraform validate %<CR>

Exemplo Prático: Use <leader>tf para formatar e validar o código antes de aplicar as alterações, garantindo que ele esteja correto.

Ansible

Para profissionais que trabalham com Ansible, configurar o Vim para reconhecer YAML é essencial. Além disso, é possível adicionar plugins que melhoram a experiência com o Ansible especificamente.

  1. Plugin vim-ansible-yaml:

    Este plugin ajuda no realce de sintaxe específico do Ansible e reconhece as keywords do Ansible em arquivos YAML:

    1

    Plug 'pearofducks/ansible-vim'

  2. Validação com Ansible-lint:

    Configure o ALE para utilizar o ansible-lint, que verifica erros em playbooks Ansible:

    1
2
3

    let g:ale_linters = {
    \ 'yaml': ['ansible-lint']
\}

  3. Mapeamento para Executar Playbooks Ansible:

    Configure um mapeamento para rodar playbooks Ansible rapidamente com <leader>ap:

    1

    nnoremap <leader>ap :w<CR>:!ansible-playbook %<CR>

Exemplo Prático: Após escrever um playbook, use <leader>ap para executá-lo diretamente do Vim e verificar a execução.

Dicas e Truques para Produtividade no Vim

O Vim oferece inúmeros atalhos e ajustes que podem aumentar a produtividade e tornar o fluxo de trabalho mais eficiente. Nesta seção, exploramos algumas dicas e truques, desde mapeamentos de teclas até plugins úteis para agilizar o desenvolvimento.

Mapeamentos de Teclas para Ações Frequentes

Mapear teclas para ações comuns reduz o tempo gasto em operações repetitivas. Aqui estão alguns mapeamentos úteis que você pode adicionar ao .vimrc.

  1. Salvar e Fechar Rápido:

    Esses mapeamentos ajudam a salvar e sair do arquivo sem precisar digitar os comandos completos:

    1
2
3

    nnoremap <leader>w :w<CR>          " Salvar com <leader>w
nnoremap <leader>q :q<CR>          " Sair com <leader>q
nnoremap <leader>x :x<CR>          " Salvar e sair com <leader>x

  2. Alternar Entre Arquivos Recentes:

    Alternar rapidamente entre o arquivo atual e o último arquivo editado:

    1

    nnoremap <leader><Tab> <C-^>

  3. Duplicar Linha:

    Duplicar uma linha é útil ao editar código. Este mapeamento copia e cola a linha atual abaixo dela:

    1

    nnoremap <leader>d Yp

Atalhos para Edição de Texto

Esses atalhos aceleram edições comuns e facilitam a manipulação de texto.

  1. Comentário Rápido:

    O seguinte mapeamento adiciona # no início da linha para comentar rapidamente. É especialmente útil para código.

    1
2

    nnoremap <leader>c I#<Esc>
vnoremap <leader>c :s/^/#/<CR>

  2. Substituição Rápida na Linha Atual:

    Realizar uma substituição apenas na linha onde o cursor está posicionado:

    1

    nnoremap <leader>s :s/antigo/novo/g<CR>

Dica Prática: Substitua antigo e novo pelos valores desejados ou use o comando com / no modo normal para personalizar a busca antes de confirmar.

A navegação eficiente no Vim é fundamental, especialmente em arquivos grandes.

  1. Plugin EasyMotion para Navegação Rápida:

    EasyMotion permite saltar rapidamente entre palavras e linhas no arquivo.

    1

    Plug 'easymotion/vim-easymotion'

    Após instalar, use <leader><leader>w para saltar até uma palavra específica. EasyMotion marca o caminho com caracteres, permitindo que você navegue rapidamente.

  2. Linhas Favoritas com Plugin Marks:

    vim-signature permite marcar linhas específicas no código, facilitando o retorno a pontos importantes.

    1

    Plug 'kshenoy/vim-signature'

Exemplo Prático: Após configurar vim-signature, marque uma linha pressionando m seguido de uma letra. Retorne à linha marcada pressionando ' e a letra da marca.

Automação de Tarefas Repetitivas com Macros

Os macros do Vim permitem gravar sequências de comandos e executá-las em qualquer parte do texto.

  1. Gravando um Macro:

    • Pressione q seguido de uma letra (por exemplo, qa).
    • Execute as ações que deseja gravar.
    • Pressione q novamente para finalizar a gravação.

  2. Executando o Macro:

    Pressione @ seguido da letra usada para gravar o macro (ex.: @a).

Exemplo Prático: Grave um macro qa que altera o primeiro caractere de várias linhas e o execute em várias linhas com 10@a para repetir o macro 10 vezes.

Atalhos para Git com o Plugin Fugitive

Para aqueles que trabalham com Git, o Fugitive é uma adição essencial, tornando o Vim uma interface prática para o controle de versão.

  1. Comandos Básicos do Fugitive:

    • :Gstatus: Exibe o status do repositório.
    • :Gdiff: Mostra as diferenças no arquivo atual.
    • :Gcommit: Abre uma janela para adicionar uma mensagem de commit.
    • :Gpush: Realiza push das alterações para o repositório remoto.

  2. Mapeamentos para Ações Frequentes de Git:

    Configure atalhos para os comandos Git mais usados, facilitando o controle de versão.

    1
2
3

    nnoremap <leader>gs :Gstatus<CR>
nnoremap <leader>gc :Gcommit<CR>
nnoremap <leader>gp :Gpush<CR>

Exemplo Prático: Ao finalizar uma alteração, use <leader>gs para revisar o status e <leader>gc para commitar diretamente do Vim.

Introdução ao Vimscript para Personalização Avançada

O Vimscript é a linguagem de script nativa do Vim, permitindo personalizar e automatizar operações dentro do editor. Com o Vimscript, você pode criar funções, loops, condicionais e até comandos personalizados que melhoram a experiência e eficiência no Vim. Nesta última seção, veremos como usar o Vimscript para ajustar o Vim às suas necessidades específicas.

Estrutura Básica do Vimscript

No Vimscript, comandos são executados linha por linha. Variáveis, funções e condicionais são alguns dos elementos principais.

  1. Variáveis:

    O Vimscript suporta variáveis globais e locais. Variáveis globais começam com g:, enquanto variáveis locais a uma função começam com l:.

    1
2

    let g:minha_variavel = 10       " Variável global
let l:minha_variavel_local = 20 " Variável local

  2. Condicionais:

    As condicionais permitem verificar condições e executar comandos com base nelas.

    1
2
3
4
5

    if g:minha_variavel == 10
    echo "A variável é 10"
else
    echo "A variável não é 10"
endif

  3. Loops:

    Loops são úteis para repetir comandos várias vezes.

    1
2
3
4
5

    let i = 1
while i <= 5
    echo "Loop número " . i
    let i += 1
endwhile

Exemplo Prático: Use loops para executar comandos repetitivos, como formatar várias linhas com um padrão específico.

Criando Funções Personalizadas

Funções no Vimscript permitem encapsular lógica para reutilizar comandos. Uma função é definida com function! e finalizada com endfunction.

  1. Definindo uma Função Simples:

    Abaixo, uma função que exibe uma mensagem no Vim:

    1
2
3

    function! OlaVim()
    echo "Olá, Vim!"
endfunction
    • Chame a função digitando :call OlaVim().

  2. Função com Parâmetros:

    Funções podem receber parâmetros para personalização.

    1
2
3

    function! Saudar(nome)
    echo "Olá, " . a:nome . "!"
endfunction
    • Chame com :call Saudar("João"), e a saída será Olá, João!.

Dica Prática: Use funções com parâmetros para ações como definir temas, ajustar configurações ou executar ações específicas de projeto.

Criando Comandos Customizados

No Vimscript, você pode definir comandos personalizados com command!, permitindo criar atalhos para operações repetitivas.

  1. Comando para Alternar Entre Tema Claro e Escuro:

    O comando abaixo alterna entre temas dark e light.

    1
2
3
4
5
6
7
8
9

    command! AlternarTema call AlternarTema()

function! AlternarTema()
    if &background == 'dark'
        set background=light
    else
        set background=dark
    endif
endfunction
    • Chame com :AlternarTema para trocar o tema atual.

  2. Comando Customizado para Remover Linhas em Branco:

    Esse comando apaga todas as linhas em branco do arquivo atual:

    1

    command! RemoverLinhasEmBranco :g/^$/d
    • Use :RemoverLinhasEmBranco para limpar as linhas em branco.

Automatizando com Autocommands

Autocommands (ou autocmd) permitem que comandos sejam executados automaticamente com base em eventos, como a abertura ou salvamento de arquivos.

  1. Executar um Comando ao Abrir um Arquivo Específico:

    Abaixo, um autocomando que ajusta a indentação ao abrir um arquivo .py:

    1

    autocmd BufRead,BufNewFile *.py setlocal expandtab shiftwidth=4 tabstop=4

  2. Destacar Espaços em Branco ao Salvar o Arquivo:

    Este autocomando exibe espaços em branco quando um arquivo é salvo:

    1

    autocmd BufWritePre * match Error /\s\+$/

Exemplo Prático: Use autocomandos para definir configurações específicas para diferentes tipos de arquivo, como ajustar indentação para JSON, ou ativar realce de sintaxe ao abrir arquivos Markdown.

Integração de Funções e Autocommands no Workflow

Combinar funções personalizadas e autocommands cria um fluxo de trabalho ainda mais poderoso. Aqui está um exemplo para automação de formatação:

  1. Função para Formatar e Validar Código Python:

    1
2
3
4
5
6
7
8

    function! FormatarPython()
    execute 'black %'        " Usa o black para formatar
    execute 'flake8 %'       " Valida com flake8
    echo "Código formatado e validado!"
endfunction

" Mapeamento para a função
nnoremap <leader>fp :call FormatarPython()<CR>

  2. Autocomando para Formatar Automaticamente ao Salvar:

    Execute a função de formatação automaticamente ao salvar arquivos Python:

    1

    autocmd BufWritePre *.py call FormatarPython()

Exemplo Prático: Ao editar um arquivo Python, a função de formatação será executada automaticamente ao salvar, mantendo o código padronizado sem esforço.

Conclusão

Personalizar o Vim pode parecer um desafio no começo, mas as configurações e técnicas avançadas apresentadas neste guia revelam o quanto o Vim pode ser adaptado a diferentes fluxos de trabalho e necessidades de desenvolvimento. Com a configuração de plugins, atalhos personalizados, e comandos criados com Vimscript, você pode aproveitar ao máximo o poder do Vim, tornando o processo de edição e gerenciamento de código mais eficiente e produtivo. Continue explorando o Vim e testando novas personalizações para aprimorar ainda mais sua experiência e se adaptar às demandas de cada projeto. Lembre-se: o Vim é uma ferramenta que cresce junto com você, permitindo configurações que refletem seu estilo e necessidades ao longo do tempo.

Vim
Vim
This post is licensed under CC BY 4.0 by the author.