Guia para alternar visualizações no código do Visual Studio

Gerenciando visualizações de arquivos no código VS:

No passado, usar o comando ‘Git: Open Changes’ no Visual Studio Code permitia que os usuários alternassem perfeitamente entre a visualização das alterações e o arquivo original. Esse fluxo de trabalho eficiente permitiu que os desenvolvedores voltassem rapidamente ao seu ambiente de codificação com facilidade.

Porém, atualizações recentes alteraram esse comportamento, causando frustração entre os usuários. Este artigo explora comandos e métodos alternativos para ajudá-lo a retornar à visualização sem alterações de um arquivo, garantindo a manutenção de um processo de desenvolvimento eficiente.

Compreendendo a funcionalidade do script

Os scripts criados acima foram projetados para restaurar a funcionalidade de alternar entre a visualização de alterações e a visualização do arquivo original no Visual Studio Code. O script JavaScript usa o vscode.window.activeTextEditor comando para recuperar o editor de texto atualmente ativo. Em seguida, modifica o URI do documento atual usando o uri.with método para acessar a visualização diff do Git. Se a visualização diff do Git já estiver aberta, o script tentará reverter para o arquivo original abrindo o documento de texto com vscode.workspace.openTextDocument e exibi-lo usando vscode.window.showTextDocument.

O script Python segue uma lógica semelhante, utilizando a API do Visual Studio Code por meio de uma extensão Python. Ele recupera o editor de texto ativo e modifica o URI para acessar a visualização diff do Git com uri.with_. O script então tenta abrir o URI modificado e exibir o documento. Se falhar, ele volta a abrir e exibir o documento original. Ambos os scripts registram seus comandos com vscode.commands.registerCommand e adicione-os às assinaturas da extensão para uma limpeza adequada, garantindo uma maneira eficiente de alternar entre visualizações de arquivos durante o desenvolvimento.

// This script uses the Visual Studio Code API to toggle between the changes view
// and the original file view for the currently open file.

const vscode = require('vscode');

function activate(context) {
  let disposable = vscode.commands.registerCommand('extension.toggleFileView', function () {
    const editor = vscode.window.activeTextEditor;
    if (editor) {
      const uri = editor.document.uri;
      const gitUri = uri.with({ scheme: 'git', query: 'diff' });

      vscode.workspace.openTextDocument(gitUri).then(doc => {
        vscode.window.showTextDocument(doc, { preview: true });
      }).catch(err => {
        vscode.workspace.openTextDocument(uri).then(doc => {
          vscode.window.showTextDocument(doc, { preview: true });
        });
      });
    }
  });

  context.subscriptions.push(disposable);
}

function deactivate() {}

module.exports = {
  activate,
  deactivate
};

# This script uses the Visual Studio Code API via a Python extension to toggle
# between the changes view and the original file view for the currently open file.

import vscode

def activate(context):
    def toggle_file_view():
        editor = vscode.window.active_text_editor
        if editor:
            uri = editor.document.uri
            git_uri = uri.with_(scheme='git', query='diff')

            try:
                vscode.workspace.open_text_document(git_uri).then(lambda doc: vscode.window.show_text_document(doc, preview=True))
            except:
                vscode.workspace.open_text_document(uri).then(lambda doc: vscode.window.show_text_document(doc, preview=True))

    context.subscriptions.append(vscode.commands.register_command('extension.toggleFileView', toggle_file_view))

Explorando métodos alternativos para visualizar arquivos no código VS

Além de usar scripts para alternar entre alterações e visualizações de arquivos originais no Visual Studio Code, existem extensões e plug-ins integrados que podem aprimorar essa funcionalidade. Por exemplo, extensões como "GitLens" oferecem recursos avançados para gerenciar repositórios Git, incluindo visualização de histórico e alterações de arquivos. Essas ferramentas podem ajudar os desenvolvedores a navegar entre diferentes versões de um arquivo com mais eficiência.

Outra abordagem é usar atalhos de teclado e personalizá-los para se adequar ao seu fluxo de trabalho. Ao criar atalhos de teclado personalizados, você pode agilizar seu processo de desenvolvimento e alternar rapidamente entre diferentes visualizações e arquivos. Compreender essas ferramentas e extensões integradas pode melhorar muito sua produtividade e garantir uma experiência de desenvolvimento tranquila.

Considerações finais sobre como gerenciar visualizações de arquivos

O gerenciamento eficiente de visualizações de arquivos no Visual Studio Code é crucial para um fluxo de trabalho de desenvolvimento tranquilo. Embora a função de alternância integrada para Git: Open Changes mudou, os desenvolvedores podem restaurar essa funcionalidade usando scripts ou extensões personalizados. Ao modificar o URI e aproveitar os comandos da API, é possível alternar entre a visualização diff e o arquivo original sem problemas.

Além disso, compreender e utilizar extensões como GitLens e personalizar os atalhos do teclado pode aumentar ainda mais a produtividade. Essas estratégias garantem que os desenvolvedores possam manter um fluxo de trabalho eficiente e organizado, levando a melhores experiências e resultados de codificação.