Travailler avec les fichiers et la zone de préparation (Staging Area)

Introduction

Bienvenue de retour, futur voyageur dans le temps! Maintenant, il est temps d'améliorer vos compétences en Git et d'explorer le monde fascinant de la zone de préparation (staging area).

Dans ce laboratoire (lab), nous approfondirons les capacités de gestion de fichiers de Git. Vous apprendrez à ajouter et à supprimer des fichiers de votre projet, à ignorer les fichiers que vous ne souhaitez pas suivre, à visualiser les modifications avant de les valider (commit) et même à annuler les modifications en cas d'erreur. Ces compétences sont comme une mise à niveau de votre machine à voyager dans le temps - elles vous donneront plus de contrôle et de flexibilité lors de votre navigation dans l'historique de votre projet.

À la fin de ce laboratoire (lab), vous aurez une meilleure compréhension de la zone de préparation (staging area) de Git et de la façon dont elle vous aide à créer des validations (commits) plus organisées et significatives. Alors, allumons nos terminaux et entreprenons ce voyage passionnant!

Skills Graph

Configuration de votre espace de travail

Commençons par créer un nouveau répertoire pour ce laboratoire (lab). Ouvrez votre terminal et tapez ces commandes :

cd ~/project
mkdir git-staging-lab
cd git-staging-lab
git init

Ces commandes créent un nouveau répertoire appelé git-staging-lab, vous y déplacent et initialisent un nouveau dépôt Git.

Maintenant, créons un simple script Python avec lequel travailler :

echo "print('Hello, Git!')" > hello.py

Cette commande crée un fichier nommé hello.py avec une simple instruction d'impression Python.

Ajout de fichiers à la zone de préparation (staging area)

Maintenant que nous avons notre fichier hello.py, ajoutons-le à la zone de préparation (staging area). La zone de préparation est comme une zone de préparation où vous rassemblez toutes les modifications que vous souhaitez inclure dans votre prochaine validation (commit).

Exécutez la commande suivante :

git add hello.py

Cette commande indique à Git de commencer à suivre le fichier hello.py et de l'inclure dans la prochaine validation (commit).

Maintenant, vérifions l'état de notre dépôt :

git status

Vous devriez voir une sortie similaire à celle-ci :

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   hello.py

Cette sortie nous indique que hello.py est maintenant dans la zone de préparation (staging area), prêt à être validé (committed).

Pourquoi avons-nous besoin d'une zone de préparation (staging area)? Imaginez que vous prépariez un voyage. La zone de préparation est comme votre valise - vous pouvez y ajouter des objets (modifications), en supprimer si vous changez d'avis, et lorsque vous êtes satisfait de tout ce qui est dans la valise, vous la fermez (effectuez une validation - commit). Cela vous permet de sélectionner soigneusement ce qui va dans chaque validation (commit), rendant l'historique de votre projet plus organisé et plus significatif.

Ignorer des fichiers avec.gitignore

Parfois, il existe des fichiers que vous ne voulez pas que Git suive, comme des fichiers temporaires ou des informations sensibles. Git vous permet d'ignorer ces fichiers en utilisant un fichier spécial appelé .gitignore.

Créons un fichier .gitignore :

echo "*.log" > .gitignore

Cette commande crée un fichier .gitignore qui indique à Git d'ignorer tout fichier ayant une extension .log.

Maintenant, créons un fichier de journal (log) pour tester notre .gitignore :

echo "This is a log file" > debug.log

Vérifiez l'état de votre dépôt :

git status

Vous devriez voir que debug.log n'est pas répertorié dans la sortie, mais que .gitignore l'est :

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   hello.py

Untracked files:
  (use "git add <file>..." to include in what will be committed)
       .gitignore

Le fichier .gitignore est très puissant. Il peut ignorer des fichiers spécifiques, des répertoires entiers ou utiliser des motifs de correspondance pour ignorer les fichiers correspondant à certains critères. Cela est incroyablement utile dans les projets réels où vous pourriez avoir des artefacts de construction, des fichiers de cache ou des fichiers de configuration spécifiques à l'environnement qui ne devraient pas faire partie de votre dépôt Git.

Ajoutons et validons (commit) nos modifications :

git add.gitignore
git commit -m "Initial commit with hello.py and.gitignore"

Visualisation des modifications avec git diff

Au fur et à mesure que votre projet grandit, vous aurez souvent envie de réviser vos modifications avant de les valider (commit). Git propose une commande puissante à cet effet : git diff.

Modifions notre fichier hello.py :

echo "print('Hello, Git! Welcome to the staging area.')" > hello.py

Maintenant, utilisons git diff pour voir ce qui a changé :

git diff

Vous devriez voir une sortie similaire à celle-ci :

diff --git a/hello.py b/hello.py
index ed51d3f..1385fe3 100644
--- a/hello.py
+++ b/hello.py
@@ -1 +1 @@
-print('Hello, Git!')
+print('Hello, Git! Welcome to the staging area.')

Cette sortie nous montre exactement ce qui a changé dans notre fichier. La ligne commençant par - indique ce qui a été supprimé, et la ligne commençant par + indique ce qui a été ajouté.

git diff est comme le carnet de bord d'une machine à voyager dans le temps. Il vous permet de voir les modifications exactes que vous avez apportées, ce qui est incroyablement utile lorsque vous essayez de vous rappeler ce que vous avez fait ou lorsque vous révisez les modifications avant une validation (commit). git diff --staged est une autre variante utile de cette commande. Elle montre les modifications que vous avez préparées (staged) mais pas encore validées (committed). Cela est utile lorsque vous voulez réviser vos modifications avant de faire une validation (commit).

Appuyez sur q pour quitter la vue git diff.

Annuler la préparation (unstaging) des modifications

Parfois, vous pourriez ajouter un fichier à la zone de préparation (staging area) puis changer d'avis. Git vous permet d'annuler la préparation (unstaging) des modifications facilement.

Tout d'abord, préparons (stage) nos modifications apportées à hello.py :

git add hello.py

Maintenant, disons que nous avons changé d'avis et que nous ne voulons pas inclure ces modifications dans notre prochaine validation (commit). Nous pouvons annuler la préparation (unstaging) du fichier en utilisant la commande git restore :

git restore --staged hello.py

Vérifions l'état :

git status

Vous devriez voir que hello.py est maintenant répertorié sous "Changes not staged for commit" au lieu de "Changes to be committed".

Cette capacité à déplacer des fichiers dans et hors de la zone de préparation (staging area) vous donne un contrôle précis sur vos validations (commits). C'est comme pouvoir emballer et déballer votre valise autant de fois que vous le souhaitez avant de partir réellement en voyage.

Résumé

Félicitations, explorateur Git! Vous venez d'améliorer vos compétences en contrôle de version. Récapitulons ce que vous avez appris dans ce laboratoire :

1. Comment ajouter des fichiers à la zone de préparation (staging area) en utilisant git add
2. Comment ignorer les fichiers que vous ne voulez pas suivre en utilisant .gitignore
3. Comment visualiser les modifications dans vos fichiers avant de les valider (commit) avec git diff
4. Comment annuler la préparation (unstaging) des modifications en utilisant git restore --staged

Ces compétences vous donnent beaucoup plus de contrôle sur votre flux de travail Git. La zone de préparation (staging area), en particulier, est une fonctionnalité puissante qui vous permet de créer des validations (commits) plus significatives en sélectionnant soigneusement les modifications à inclure.

Voici pourquoi ces compétences sont si importantes :

1. Validations sélectives (Selective Commits) : La zone de préparation (staging area) vous permet de valider (commit) seulement certaines de vos modifications, vous aidant à créer des validations plus petites et plus ciblées.
2. Ignorer des fichiers : .gitignore vous aide à garder votre dépôt propre en excluant les fichiers qui n'ont pas besoin d'être gérés par le contrôle de version.
3. Révision des modifications : git diff vous permet de vérifier vos modifications avant de les valider (commit), vous aidant à détecter les erreurs tôt.
4. Flexibilité : La capacité d'annuler la préparation (unstaging) des modifications vous donne la liberté de changer d'avis, rendant Git moins intimidant à utiliser.

Au fur et à mesure de votre parcours avec Git, vous trouverez ces compétences inestimables. Elles constituent la base d'un flux de travail Git plus avancé, vous permettant de gérer facilement des projets complexes.

N'oubliez pas que devenir compétent avec Git nécessite de la pratique. N'ayez pas peur d'expérimenter et de faire des erreurs - c'est ainsi que nous apprenons! Continuez à explorer, continuez à valider (commit) vos modifications, et observez comment vos projets évoluent avec le temps.

Votre prochaine aventure dans le monde de Git est à portée de main. Gardez votre curiosité en vie et bon codage!