Guide de changement de vue dans Visual Studio Code

Gestion des vues de fichiers dans VS Code :

Dans le passé, l'utilisation de la commande « Git : Ouvrir les modifications » dans Visual Studio Code permettait aux utilisateurs de basculer de manière transparente entre l'affichage des modifications et le fichier d'origine. Ce flux de travail efficace a permis aux développeurs de revenir rapidement et facilement à leur environnement de codage.

Cependant, des mises à jour récentes ont modifié ce comportement, provoquant une frustration chez les utilisateurs. Cet article explore des commandes et méthodes alternatives pour vous aider à revenir à la vue non modifiée d'un fichier, vous garantissant ainsi de maintenir un processus de développement efficace.

Comprendre la fonctionnalité des scripts

Les scripts créés ci-dessus sont conçus pour restaurer la fonctionnalité de basculement entre la vue des modifications et la vue des fichiers d'origine dans Visual Studio Code. Le script JavaScript utilise le vscode.window.activeTextEditor commande pour récupérer l’éditeur de texte actuellement actif. Il modifie ensuite l'URI du document courant en utilisant le uri.with méthode pour accéder à la vue différentielle de Git. Si la vue Git diff est déjà ouverte, le script tente de revenir au fichier d'origine en ouvrant le document texte avec vscode.workspace.openTextDocument et l'afficher en utilisant vscode.window.showTextDocument.

Le script Python suit une logique similaire, utilisant l'API de Visual Studio Code via une extension Python. Il récupère l'éditeur de texte actif et modifie l'URI pour accéder à la vue différentielle de Git avec uri.with_. Le script tente ensuite d'ouvrir l'URI modifié et d'afficher le document. En cas d'échec, il revient à l'ouverture et à l'affichage du document original. Les deux scripts enregistrent leurs commandes avec vscode.commands.registerCommand et ajoutez-les aux abonnements de l'extension pour un nettoyage approprié, garantissant ainsi un moyen efficace de basculer entre les vues de fichiers pendant le développement.

// 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))

Explorer d'autres méthodes pour afficher les fichiers dans VS Code

Outre l'utilisation de scripts pour basculer entre les modifications et les vues de fichiers d'origine dans Visual Studio Code, il existe des extensions et des plugins intégrés qui peuvent améliorer cette fonctionnalité. Par exemple, des extensions telles que « GitLens » offrent des fonctionnalités riches pour gérer les référentiels Git, notamment l'affichage de l'historique et des modifications des fichiers. Ces outils peuvent aider les développeurs à naviguer plus efficacement entre les différentes versions d’un fichier.

Une autre approche consiste à utiliser des raccourcis clavier et à les personnaliser en fonction de votre flux de travail. En créant des raccourcis clavier personnalisés, vous pouvez rationaliser votre processus de développement et basculer rapidement entre différentes vues et fichiers. Comprendre ces outils et extensions intégrés peut améliorer considérablement votre productivité et garantir une expérience de développement fluide.

Réflexions finales sur la gestion des vues de fichiers

La gestion efficace des vues de fichiers dans Visual Studio Code est cruciale pour un flux de travail de développement fluide. Bien que la fonction de bascule intégrée pour Git: Open Changes a changé, les développeurs peuvent restaurer cette fonctionnalité à l'aide de scripts ou d'extensions personnalisés. En modifiant l'URI et en exploitant les commandes API, il est possible de basculer de manière transparente entre la vue différentielle et le fichier d'origine.

De plus, comprendre et utiliser des extensions telles que GitLens et la personnalisation des raccourcis clavier peut encore améliorer la productivité. Ces stratégies garantissent que les développeurs peuvent maintenir un flux de travail efficace et organisé, conduisant finalement à de meilleures expériences et résultats de codage.