Dicas para usar macros de teclado para automações repetitivas no editor

1. Introdução às Macros de Teclado no Contexto do Editor

Macros de teclado são sequências gravadas de comandos que podem ser reproduzidas com um único atalho, eliminando a necessidade de repetir manualmente operações idênticas dezenas ou centenas de vezes. No contexto de automações repetitivas no editor, elas funcionam como pequenos programas que executam tarefas como formatação em lote, refatoração rápida e inserção de padrões predefinidos.

A principal diferença entre macros nativas do editor e extensões de terceiros está na flexibilidade. Editores como Vim e Emacs possuem sistemas de macros embutidos extremamente poderosos, enquanto VS Code depende de extensões como "Macros for VS Code" ou "multi-command" para alcançar funcionalidade similar. Cenários comuns incluem: aplicar formatação consistente em múltiplos arquivos, gerar blocos de código repetitivos e realizar substituições complexas que exigem múltiplos passos.

2. Configurando Macros no VS Code com Extensões Especializadas

Para começar no VS Code, instale a extensão "Macros for VS Code" (porgeddski). Após a instalação, configure o arquivo settings.json:

{
  "macros": {
    "formatAndComment": [
      "editor.action.formatDocument",
      "editor.action.addCommentLine"
    ]
  }
}

Para gravar e salvar uma macro simples que combina indentação e comentário, adicione o atalho de teclado em keybindings.json:

{
  "key": "ctrl+shift+f",
  "command": "macros.formatAndComment"
}

Agora, ao pressionar Ctrl+Shift+F, o editor primeiro formata o documento inteiro e depois comenta a linha atual. Esse encadeamento básico já economiza segundos preciosos em cada operação.

3. Criando Macros com Múltiplos Comandos do Editor

Macros mais avançadas podem encadear seleção, cópia, navegação e colagem. Exemplo prático: macro para duplicar uma linha e renomear variável automaticamente:

{
  "macros": {
    "duplicateAndRename": [
      "editor.action.copyLinesDownAction",
      "cursorHome",
      "cursorRight",
      "editor.action.addSelectionToNextFindMatch",
      "editor.action.changeAll"
    ]
  }
}

Essa macro duplica a linha atual, posiciona o cursor no início da linha duplicada e aciona o comando "Change All Occurrences" para renomear rapidamente a variável. O uso de comandos da Command Palette dentro de macros é especialmente útil com editor.action.insertSnippet:

{
  "macros": {
    "insertTryCatch": [
      {
        "command": "editor.action.insertSnippet",
        "args": {
          "snippet": "try {\n\t$1\n} catch ($2) {\n\t$3\n}"
        }
      }
    ]
  }
}

4. Macros com Variáveis de Contexto e Placeholders

Para inserir data/hora, nome do arquivo ou seleção atual, combine macros com snippets inteligentes. Exemplo: macro que gera um template de commit com timestamp e branch atual:

{
  "macros": {
    "commitTemplate": [
      {
        "command": "editor.action.insertSnippet",
        "args": {
          "snippet": "// Commit: $CURRENT_YEAR-$CURRENT_MONTH-$CURRENT_DATE $CURRENT_HOUR:$CURRENT_MINUTE\n// Branch: ${TM_CURRENT_LINE}\n// Descrição: $1"
        }
      }
    ]
  }
}

Para maior flexibilidade, use variáveis como ${TM_SELECTED_TEXT} para capturar a seleção atual e inseri-la em múltiplos pontos da macro. Isso é particularmente útil para gerar documentação automática ou wrappers de funções.

5. Automatizando Tarefas de Formatação e Limpeza de Código

Uma macro poderosa para limpeza de código TypeScript pode combinar múltiplos comandos:

{
  "macros": {
    "cleanAndFormat": [
      "editor.action.sortLinesAscending",
      "editor.action.removeCommentLine",
      "editor.action.formatDocument",
      "editor.action.trimTrailingWhitespace",
      "files.save"
    ]
  }
}

Essa sequência ordena imports, remove comentários desnecessários, aplica formatação (Prettier/ESLint), remove espaços em branco no final das linhas e salva o arquivo. Para ordenar imports especificamente, use:

{
  "macros": {
    "organizeImports": [
      "editor.action.organizeImports",
      "editor.action.formatDocument",
      "files.save"
    ]
  }
}

Essas macros garantem consistência em todo o projeto sem esforço manual repetitivo.

6. Macros para Navegação e Edição em Múltiplos Arquivos

Para percorrer arquivos abertos e aplicar alterações em lote, crie uma macro que busca e substitui texto em todo o workspace:

{
  "macros": {
    "searchReplaceAll": [
      "workbench.action.findInFiles",
      {
        "command": "editor.action.rename",
        "args": {
          "query": "oldFunctionName",
          "replace": "newFunctionName",
          "isRegex": false
        }
      }
    ]
  }
}

Combine com multi-cursor para edição simultânea em pontos não adjacentes:

{
  "macros": {
    "addConsoleLog": [
      "editor.action.selectAll",
      "editor.action.insertCursorAtEndOfEachLineSelected",
      "cursorLineEnd",
      {
        "command": "type",
        "args": { "text": " // debug" }
      }
    ]
  }
}

7. Dicas Avançadas: Depuração e Compartilhamento de Macros

Para depurar macros que falham, ative logs de comandos no VS Code:

{
  "macros.debug": true
}

Execute a macro em um ambiente isolado (arquivo temporário) e verifique o output no console do desenvolvedor (Help > Toggle Developer Tools). Exporte macros como configurações JSON para sincronização entre máquinas:

{
  "macros": {
    "myMacro": ["command1", "command2"]
  }
}

Integre com Settings Sync para consistência em projetos em equipe, garantindo que todos usem as mesmas automações.

8. Boas Práticas e Limitações ao Usar Macros de Teclado

Evite macros muito longas ou complexas (mais de 10 comandos). Prefira scripts Python/Node.js ou extensões dedicadas para tarefas pesadas. Documente cada macro em um arquivo MACROS.md no repositório:

# Macros do Projeto
## cleanAndFormat (Ctrl+Shift+C)
Ordena imports, formata e salva o arquivo atual.

## commitTemplate (Ctrl+Shift+T)
Insere template de commit com timestamp.

Quando optar por macros vs. tarefas automatizadas: use macros para ações rápidas no editor (5-10 segundos), tasks.json para builds e testes, e extensões completas para automações complexas que exigem UI ou configuração avançada.

Referências