Gérer les modifications de fichiers avec Git

Git fonctionne d'une manière intéressante pour porter un historique des modifications de fichiers. Bien qu'il puisse sembler qu'il recherche les changements dans chacun d'entre eux, ce qu'il fait en réalité est de transporter un fichier appelé indice, dans lequel les changements qui se produisent sont insérés. De cette façon, juste en lisant le fichier indice vous pouvez savoir quels fichiers et quel contenu ont été modifiés.

Une fois que nous comprenons ce concept de comment Git Il prend les modifications enregistrées, c'est à ce moment-là que nous pouvons commencer à profiter pleinement de l'outil, car c'est à ce moment-là que nous pourrons commencer à utiliser les différentes commandes pour prendre les modifications de notre référentiel et les gérer à partir d'une logique perspective.

Classer les fichiers dans Git

Avant de continuer avec des points plus profonds, nous devons voir comment Git classe vos fichiers. Il ne s'agit pas d'un classement par type de fichier du fait de son extension, mais plutôt par son statut par rapport à notre référentiel et son indice.

Nous avons essentiellement trois types de fichiers dans GIT, chacun a son propre moment dans le référentiel, voyons ce que c'est :

SuiviCe type de fichier est déjà ajouté à notre référentiel et est pris en compte par le indice et un fichier prend cet état une fois que nous l'avons ajouté avec la commande suivante.

 git ajouter un nom de fichier

IgnoréDans cette classification un fichier ignoré n'est pas pris en compte par Git Lors de modifications, les fichiers qui subissent de nombreuses modifications ou qui ne sont pas vitaux pour la stabilité du projet sont normalement classés de cette manière, par exemple les fichiers images en raison de leur poids ou peut-être des scripts de Base de données que nous ne devons pas toujours modifier. Pour ignorer un fichier, son nom doit être inclus dans un fichier appelé .gitignore et l'ajouter à notre référentiel.

Non suiviCe type de fichier n'appartient pas encore à notre référentiel car nous ne l'avons pas encore ajouté et il est nouveau dans le système de fichiers, cela arrive généralement lorsque nous créons un nouveau fichier dans un référentiel déjà initialisé ou lorsque nous initialisons un référentiel dans un dossier qui a des fichiers existants.

Exemple pratique de classement de fichiers

Voyons maintenant un petit exemple pratique de la façon dont nous pouvons détecter les types de fichiers dans un référentiel Git, pour cela nous devons suivre les étapes suivantes :

1- Nous allons créer un nouveau dossier sur notre ordinateur appelé fichiers git.

2- Une fois le dossier créé nous allons le saisir depuis notre console et là nous allons exécuter la commande git init et puis on fait statut git Pour voir l'état de notre référentiel, voyons à quoi ressemble l'application des commandes précédentes :

3- Lorsque nous aurons terminé l'étape précédente, nous aurons un référentiel Git initialisé et prêt à travailler, alors nous pouvons créer un nouveau fichier dans ce dossier et nous le ferons à nouveau statut git pour voir le changement, nous devons avoir notre nouveau dossier sous la classification non suivi.

4- Nous allons répéter l'étape précédente et créer un nouveau fichier, si nous voyons le résultat de le refaire statut git on comptera les deux fichiers, voyons :

5- Nous allons maintenant créer un nouveau fichier appelé .gitignore, notez le point avant le fichier et à l'intérieur on va placer le nom d'un de nos précédents fichiers, on recommence statut git et nous verrons que maintenant nous n'obtenons que le fichier qui n'y est pas .gitignore et le fichier .gitignore nous venons de créer :

6- Ensuite, nous ferons un git ajouter. afin d'ajouter tous nos fichiers et enfin nous exécuterons un git commit -m "validation initiale" avec cela en ajoutant nos fichiers au référentiel, si nous apportons une modification au fichier que nous ne plaçons pas dans le .gitignore et nous le sauvons, si nous courons à nouveau statut git nous verrons un fichier en statut ou en classification suivi.

La commande git add

Dans l'exemple précédent, nous avons pu voir l'utilisation de la git ajouter et peut-être qu'on peut penser que c'est une maîtrise de plus de notre outil mais c'est très important, c'est celui qui nous permet ajouter un fichier à notre référentiel s'il n'existe pas encore dans celui-ci et il nous permet également d'ajouter les modifications apportées à un fichier existant dans notre référentiel.

Comment utiliser?Il a plusieurs façons d'être utilisé, le plus commun est de faire git ajouter un nom de fichier, où on lui dit quel fichier ajouter ou si on ne peut pas faire git ajouter. où le point représente tous les fichiers qui ont été modifiés ou ne sont pas dans le référentiel.

Il est très important qu'après avoir apporté des modifications au référentiel, nous ajoutions les fichiers avec git ajouter, car sinon, nous ne pourrons pas enregistrer nos modifications, en plus de créer différentes versions du fichier, ce qui peut entraîner un éventuel conflit à l'avenir.

Utilisation de git add

Dans notre dossier fichiers git que nous avons créé dans l'exemple précédent du tutoriel, nous allons ajouter un nouveau fichier que nous placerons nouveauFichier3 puis dans le fichier existant qui n'y est pas .gitignore faisons un changement.

Ce que nous voulons réaliser avec ceci est de tester comment utiliser notre commande git ajouter, voyons à quoi cela ressemble dans notre console de commande :

Après avoir suivi les instructions précédentes, nous aurions dû obtenir quelque chose comme ci-dessus à l'écran, où l'on nous montre un fichier modifié et un tout nouveau fichier dans le référentiel.

Nous allons maintenant ajouter le nouveau fichier au référentiel, mais nous ne le ferons pas avec le fichier existant ou celui que nous avons modifié précédemment. Pour cela, nous n'avons qu'à faire git ajouter notre nom de fichier. Ensuite, nous ferons statut git. Voyons:

Comme on peut le voir, notre référentiel prend déjà en compte le fichier que nous avons ajouté avec git ajouter, c'est ainsi que nous pouvons essentiellement travailler sur les modifications apportées à nos fichiers.

Supprimer des fichiers du référentiel

La prochaine action que nous devons savoir comment effectuer est d'éliminer les fichiers de notre référentiel, car il est très courant que nous ayons créé quelque chose par erreur ou que nous y mettions simplement de l'ordre.

Il y a deux choses à prendre en compte, nous pouvons supprimer le fichier de l'index de notre référentiel mais gardez ledit fichier dans le système de notre dossier, donc si nous faisons un statut git Nous le verrons à nouveau disponible. Ou si nous ne pouvons pas supprimer le fichier à la fois de notre dossier et de indice depuis notre référentiel, pour cela nous pouvons utiliser la commande git rm.

La commande git rm - -cached

En utilisant la commande rm avec l'option supplémentaire de mis en cache, ce que nous faisons est de supprimer le fichier en question du indiceCependant, nous la conserverons sur notre ordinateur, cette commande est beaucoup utilisée lorsque nous ne voulons pas encore ajouter ce fichier à notre référentiel mais que nous devons enregistrer les autres modifications.

Pour l'utiliser, nous faisons simplement la commande lorsque nous avons déjà ajouté avec git ajouter un fichier, voyons à quoi cela ressemble dans notre console de commande :

Notons que le fichier nouveauFichier3 que nous avions ajouté à notre référentiel maintenant n'est pas là et a la classification non suivi.

La commande Git rm

Voyons maintenant comment utiliser la commande git rm, cette commande est beaucoup plus puissante puisqu'elle supprime directement le fichier du indice et de la dossier, c'est pourquoi nous devons être prudents lorsque nous décidons de l'utiliser dans notre référentiel, il est très probable qu'une fois appliqué nous ne pourrons pas récupérer le changement.

Voyons dans l'exemple suivant comment cela fonctionne lorsque nous l'appliquons à un fichier, dans ce cas nous allons ajouter nouveauFichier3 avec git ajouter et puis nous appliquerons sur ce git rm:

On voit que quand on le fait directement git nous montre une erreur et nous demande de faire une suppression forcée lors de l'ajout du paramètre -F à l'instruction cela est dû à l'importance du changement, enfin nous ferons un statut git et nous remarquerons que ledit fichier a disparu de notre référentiel dans son intégralité.

Plus de .gitignore

Nous avons pu voir que nous pouvons ajouter un fichier spécifique à notre fichier .gitignoreCependant, lorsque nous travaillons dans un environnement dans lequel nous manipulons des centaines voire des milliers de fichiers, ce n'est pas très pratique, c'est pourquoi nous pouvons utiliser des modèles.

Un patron nous permettra d'indiquer à Git qu'un fichier qui correspond à la séquence de caractères ou d'expression doit être ignoré, ce qui nous permet d'indiquer des extensions spécifiques, soit dans l'ensemble du projet, soit dans un dossier spécial. Regardons un exemple de ceci.

* .jpg.webp il ignorera tous les fichiers .jpg.webp de notre projet, mais si on veut garder la trace d'un en particulier il suffit d'ajouter :

 ! nom de fichier.jpg.webp

C'est aussi simple que cela, nous avons une structure solide et complexe qui nous permet de garder notre référentiel organisé.

Avec cela, nous terminons ce tutoriel, nous avons vu de manière approfondie la façon dont Git porte ou gère les changements dans nos fichiers, il est important de maîtriser cette matière, car avec cela nous pourrons travailler plus efficacement dans des environnements d'équipe où elle est gérée Git en tant que contrôleur de version.