Ditch Git Checkout : utilisez plutôt Git Switch et Git Restore

Si vous utilisez Git dans votre travail quotidien, git checkout est une commande courante. Il est souvent utilisé pour changer de branche, et si vous regardez la documentation, vous pouvez voir la phrase "changer de branche ou restaurer les fichiers d'arborescence de travail". Mais UNIX devrait être Faites une chose et faites-la bien. C'était déroutant, alors Git 2.23 a apporté une paire de commandes pour le remplacer.

---

Avant de présenter son fonctionnement, nous devons comprendre brièvement les concepts Git associés.

• Copie de travail (fichier d'arborescence de travail) : Il s'agit du fichier du référentiel qui apparaît sur le disque dur.

• Index (zone de transit ou cache) : il fait référence à votre ajout de git, ou à ce qui serait validé si vous deviez exécuter git commit.

• HEAD : Il fait référence à la branche « actuelle » ou « active », lorsque nous devons extraire une branche (en référence à votre tentative de faire correspondre la branche avec ce qui est dans la copie de travail), une seule peut être vérifié à la fois.

git checkout peut extraire une branche ou créer une nouvelle branche et y effectuer une extraction :

# Switched to branch 'test'
$ git checkout test

# Switched to a new branch 'test'
$ git checkout -b test

# Switch back to the previous branch
$ git checkout -

# Switched to a commit
$ git checkout master~1

Et git switch est utilisé pour prendre en charge les branchements liés, il peut donc également faire :

# Switched to branch 'test'
$ git switch test

# Switched to a new branch 'test'
$ git switch -c test

# Switch back to the previous branch
$ git switch -

# Switched to a commit
$ git switch -d master~1

Et comme nous l'avons dit au début, git checkout peut également restaurer les fichiers d'arborescence fonctionnels. Cette partie de la fonctionnalité est reprise par git restaurer.

Dans le passé, nous pouvions utiliser git checkout -- main.c pour restaurer le fichier d'arborescence de travail à partir de l'index, la syntaxe était git checkout [treeish] -- , où treeish pouvait être spécifié comme source . Exemples simples :

# Restoring the working tree from the index
$ git checkout -- ./main.c

# Restoring index content from HEAD
$ git reset -- ./main.c

# Restoring the working tree and index from HEAD
$ git checkout HEAD -- ./main.c

Notez que lors de la restauration du contenu de l'index à partir de HEAD, nous ne pouvons utiliser que git reset, et git checkout n'a pas d'option correspondante.

Afficher avec un graphique :

git recovery permet de déterminer plus facilement quels fichiers seront restaurés et où ils seront restaurés. Les options suivantes spécifient l'emplacement de restauration :

-W
--worktree
-S
--staged

Par défaut, -W et --worktree restaureront l'arborescence de travail à partir de l'index, comme si aucune option n'était spécifiée (comme git restaurer -- ./main.c ). Alors que -S et --staged restaureront le contenu de l'index à partir de HEAD. Lors du passage des deux, l'index et l'arbre de travail seront restaurés à partir de HEAD.

Par exemple :

# Restoring the working tree from the index
$ git restore -- ./main.c
# Equivalent to
$ git restore --worktree -- ./main.c

# Restoring index content from HEAD
$ git restore --staged -- ./main.c

# Restoring the working tree and index from HEAD
$ git restore --staged --worktree ./main.c

Afficher avec un graphique :

Ce qui précède est la valeur par défaut, si nous voulons restaurer à partir d'un autre commit, nous pouvons utiliser l'option --source. Par exemple :

# Restore `./main.c` in the working tree with the last commit
$ git restore -s HEAD^ -- ./main.c
# Equivalent to
$ git restore --source=HEAD^ -- ./main.c

Un autre cas de restauration git utile pourrait consister à restaurer un fichier mal géré. Par exemple :

# Incorrectly deleted files
$ rm -f ./main.c

# Quickly restore main.c from index
$ git restore ./main.c

Pour la récupération par lots :

# Restore all C source files to match the version in the index
$ git restore '*.c'

# Restore all files in the current directory
$ git restore .

# Restore all working tree files with top pathspec magic
$ git restore :/

Conclusion

Les fonctionnalités de git checkout sont clairement séparées : git switch est utilisé pour changer de branche, tandis que git recovery est utilisé pour restaurer les fichiers de l'arborescence de travail. Ils fournissent une sémantique plus explicite, conforme à la philosophie UNIX.

Les deux commandes ont été proposées en 2019, et pour l'instant, elles sont expérimentales. Il peut y avoir des changements, mais généralement pas beaucoup, vous pouvez donc les utiliser maintenant, ils sont plus faciles à comprendre et moins déroutants.

Si vous avez trouvé cela utile, pensez à à vous abonner à ma newsletter pour des articles et des outils plus utiles sur le développement Web. Merci d'avoir lu !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!