Comment vérifier si un fichier est binaire dans Git

GitGitBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, vous apprendrez à déterminer si un fichier est considéré comme binaire par Git. Nous allons explorer deux méthodes : utiliser la commande git diff --numstat pour observer comment Git résume les modifications, et utiliser la commande standard Linux file pour identifier le type de fichier. À la fin de ce laboratoire, vous comprendrez comment Git fait la distinction entre les fichiers texte et binaires et comment vérifier cette distinction vous-même.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/diff("Compare Changes") subgraph Lab Skills git/add -.-> lab-560025{{"Comment vérifier si un fichier est binaire dans Git"}} git/status -.-> lab-560025{{"Comment vérifier si un fichier est binaire dans Git"}} git/diff -.-> lab-560025{{"Comment vérifier si un fichier est binaire dans Git"}} end

Utiliser git diff --numstat pour vérifier

Dans cette étape, nous allons explorer comment utiliser git diff --numstat pour comprendre les modifications entre différentes versions de vos fichiers. Cette commande fournit un résumé des modifications, affichant le nombre de lignes ajoutées et supprimées pour chaque fichier.

Tout d'abord, assurons-nous que nous sommes dans le répertoire de notre projet. Ouvrez votre terminal et accédez au répertoire my-time-machine :

cd ~/project/my-time-machine

Maintenant, modifions notre fichier message.txt. Nous allons y ajouter une nouvelle ligne :

echo "Hello, Past Me" >> message.txt

L'opérateur >> ajoute le texte au fichier existant, plutôt que de le remplacer.

Vérifions à nouveau l'état de notre dépôt :

git status

Vous devriez voir que message.txt a été modifié :

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   message.txt

no changes added to commit but untracked files present (use "git add" to track)

Maintenant, utilisons git diff --numstat pour voir le résumé des modifications que nous avons apportées :

git diff --numstat

La sortie devrait ressembler à ceci :

1       0       message.txt

Cette sortie nous indique que dans message.txt, 1 ligne a été ajoutée et 0 ligne a été supprimée. C'est un moyen concis de voir l'impact global de vos modifications sur plusieurs fichiers.

Comprendre git diff --numstat est utile lorsque vous souhaitez avoir un aperçu rapide de l'importance des modifications apportées à un fichier sans voir le contenu exact des modifications. Cela est particulièrement utile lors de la revue des modifications apportées par d'autres personnes ou lorsque vous souhaitez voir l'échelle des modifications dans votre propre travail.

Exécuter la commande file sur un fichier

Dans cette étape, nous allons apprendre à utiliser la commande file, un outil utile sous Linux qui vous indique le type d'un fichier. Cela est important car Git gère différemment les fichiers texte et les fichiers binaires.

Tout d'abord, assurez-vous que vous êtes dans le répertoire de votre projet :

cd ~/project/my-time-machine

Maintenant, utilisons la commande file sur notre fichier message.txt :

file message.txt

Vous devriez voir une sortie similaire à ceci :

message.txt: ASCII text

Cela nous indique que message.txt est un fichier texte. Git est conçu pour fonctionner très bien avec les fichiers texte car il peut facilement suivre les modifications ligne par ligne.

Et pour les autres types de fichiers ? Créons un simple fichier binaire. Nous pouvons utiliser la commande head pour extraire les premiers octets d'un fichier système et les rediriger vers un nouveau fichier dans notre projet. Par exemple, créons un petit fichier "binaire" à partir de l'exécutable /bin/ls :

head -c 1024 /bin/ls > binary_file

Cette commande prend les premiers 1024 octets du fichier /bin/ls et les enregistre sous le nom binary_file dans votre répertoire actuel.

Maintenant, utilisons la commande file sur ce nouveau fichier :

file binary_file

La sortie sera différente, indiquant qu'il s'agit d'un fichier binaire. Elle pourrait ressembler à ceci :

binary_file: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=..., for GNU/Linux 3.2.0, BuildID[sha1]=..., stripped

Cette sortie confirme que binary_file n'est pas un simple fichier texte. Git traite les fichiers binaires différemment car il ne peut pas facilement déterminer les modifications ligne par ligne. Au lieu de cela, il stocke généralement l'intégralité du fichier binaire pour chaque version.

Comprendre la différence entre les fichiers texte et binaires est crucial lorsque vous travaillez avec Git, en particulier lorsque vous manipulez des fichiers tels que des images, des programmes compilés ou des archives compressées. Les puissantes fonctionnalités de comparaison et de fusion de Git sont principalement conçues pour les fichiers texte.

Tester les fichiers texte par rapport aux fichiers binaires

Dans cette étape, nous allons voir comment Git gère les modifications dans les fichiers texte par rapport aux fichiers binaires. Cela mettra en évidence pourquoi les capacités de comparaison de Git sont principalement conçues pour le texte.

Tout d'abord, assurez-vous que vous êtes dans le répertoire de votre projet :

cd ~/project/my-time-machine

Nous avons déjà notre fichier message.txt (fichier texte) et notre fichier binary_file. Modifions à nouveau message.txt :

echo "Another line for the future" >> message.txt

Maintenant, ajoutons les deux fichiers à la zone de préparation (staging area) et validons-les. Tout d'abord, ajoutons les fichiers :

git add message.txt binary_file

Vérifions l'état pour confirmer que les deux fichiers sont dans la zone de préparation :

git status

Vous devriez voir les deux fichiers répertoriés sous "Changes to be committed" (Modifications à valider) :

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   message.txt
        new file:   binary_file

Maintenant, validons ces modifications :

git commit -m "Add binary file and update message"

Vous verrez une sortie confirmant la validation, y compris les modifications apportées aux deux fichiers :

[master ...] Add binary file and update message
 2 files changed, 2 insertions(+)
 create mode 100644 binary_file

Maintenant, apportons une petite modification au fichier binary_file. Nous pouvons ajouter un seul octet à ce fichier :

echo -n "a" >> binary_file

Le drapeau -n empêche echo d'ajouter un caractère de nouvelle ligne.

Vérifions à nouveau l'état :

git status

Git indiquera que le fichier binary_file a été modifié :

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   binary_file

no changes added to commit but untracked files present (use "git add" to track)

Maintenant, essayons de voir la différence en utilisant git diff :

git diff

Au lieu de montrer les modifications ligne par ligne, Git vous indiquera probablement que le fichier binaire est différent :

warning: LF will be replaced by CRLF in binary_file.
The file has no newline at the end of the file.
diff --git a/binary_file b/binary_file
index ... ...
Binary files a/binary_file and b/binary_file differ

Cette sortie montre clairement que Git ne tente pas d'afficher les modifications détaillées dans le fichier binaire. Il indique simplement que les fichiers sont différents. C'est une différence clé dans la façon dont Git gère les fichiers texte par rapport aux fichiers binaires. Pour les fichiers texte, Git peut vous montrer exactement quelles lignes ont été ajoutées, supprimées ou modifiées. Pour les fichiers binaires, il ne peut seulement vous indiquer qu'une modification s'est produite.

Cette étape démontre pourquoi les puissants outils de comparaison et de fusion de Git sont les plus efficaces avec le contenu basé sur le texte, qui est courant dans le code source et les fichiers de configuration.

Résumé

Dans ce laboratoire (lab), nous avons appris à déterminer si un fichier est binaire dans Git. Nous avons exploré deux méthodes principales. Tout d'abord, nous avons utilisé la commande git diff --numstat pour examiner les modifications entre les versions de fichiers, en observant comment elle résume les ajouts et les suppressions, ce qui peut indiquer indirectement la nature du fichier en fonction de l'échelle des modifications.

Deuxièmement, nous avons appris à propos de la commande file, un utilitaire standard Linux, et à l'utiliser pour identifier directement le type d'un fichier, en distinguant les formats texte et binaire. Cette approche directe est cruciale car la gestion des fichiers binaires par Git diffère considérablement de celle des fichiers texte.