Git Staging: Quand monter sur scène? Que faire en cas de modification ultérieure

Je suis plutôt nouveau dans le vaste monde de Git. J'ai lu le manuel et j'ai pratiqué mais je suis confus sur peu d'aspects, que je n'ai pas pu comprendre après avoir cherché.

Je me demande:

• Dans un projet (post premier commit), quel est le bon moment pour mettre en scène les fichiers source? Juste avant de vous engager? Juste après avoir ajouté / supprimé ou modifié?

• Si les fichiers sont placés à mi-chemin entre deux validations, puis modifiés, que se passe-t-il avec Git? A-t-il besoin de se soucier des changements de contenu quand il a été déclaré et de ce qu'il est devenu depuis?

• Si je crée un nouveau fichier, le met en scène et que je souhaite ensuite le supprimer, pourquoi Git me demande-t-il d'utiliser l'indicateur "-f" et un simple "git -rm file.ext" ne fonctionnera pas?

J'ai lu "Quelle étape signifie" et divers autres sujets du manuel et d'autres tutoriels sur Git mais comme je l'ai dit, je ne comprends toujours pas les questions ci-dessus.

Donc, si vous le pouvez, veuillez répondre aux questions avec vos propres mots et exemples afin que je puisse avoir une meilleure chance de le comprendre.

Je vous remercie.

Le but de la zone de transit est d'avoir un espace flexible pour votre commit. Je pense que cela deviendra plus clair si vous comparez git à des systèmes de contrôle de version centralisés, tels que subversion.

Subversion

Dans subversion, vous pouvez choisir de valider certains fichiers de votre copie de travail. Mais seulement les fichiers complets. Maintenant: que se passe-t-il si vous souhaitez mettre en scène le fichier A, pas le fichier B, et les parties du fichier Cqui se rapportent au fichier Amais pas les parties qui dépendent des modifications du fichier B(car vous auriez alors un problème avec la cohérence de la validation).

Git

Git résout ce problème en fournissant la mise en scène comme deuxième copie de travail. Dans la zone de préparation, vous créez un instantané que vous allez valider (grosso modo).

Par conséquent, dans la zone de transfert, vous pouvez créer un instantané qui inclut des modifications Aet une version de fichier Cqui ne reflète que les modifications apportées A.

Pour les questions spécifiques

• Vous pouvez mettre en scène à tout moment que vous voulez. je préfère personnellement mettre en scène juste avant de lancer le commit.

• Lorsque vous modifiez un fichier par étapes, puis que vous modifiez ce fichier dans la copie de travail, vous n'avez bien sûr pas modifié le fichier intermédiaire. Vous pouvez soit décider de les mettre en scène également, soit de ne pas mettre en scène ces modifications. C'est-à-dire que si vous exécutez, git gui citoolvous verrez des différences de versions avec et sans étapes (des outils agréables et simples pour la mise en scène et la validation en ligne).

• Git est prudent ici, ce qui est probablement une bonne chose.

Stratégie de validation générale: validations granulaires

Je pense qu'en parlant de la question "Quand dois-je monter", il faut aussi parler des habitudes de commit.

VCS centralisé

Dans les systèmes de contrôle de version centralisés où vous vous engagez sur un serveur central, il était important pour vos collègues que vos validations soient complètes et bien testées. Les utilisateurs essaient donc de valider moins souvent, puis de valider l'état des fichiers complets pour minimiser la possibilité d'une erreur. Ainsi, un commit a tendance à être de gros morceaux qui incluent de nombreux changements (s'ils ne sont pas de simples correctifs). Les modifications d'un commit peuvent être totalement indépendantes.

Git

Dans Git, une validation est effectuée localement, uniquement les pousser vers un serveur les rend publics. Par conséquent, un commit est bon marché dans un sens. Un commit au sens de la subversion est plutôt comparable à plusieurs git commitsuivis de git push. Cette différence est importante.

Git vous permet de valider des lignes de code uniques, même si vous avez également modifié d'autres lignes dans le même fichier. Cela vous offre de nombreux avantages car vous pouvez par exemple valider un correctif de sécurité dans la ligne 100 tout en ayant modifié les lignes 300-350 en introduisant une nouvelle fonctionnalité.

• Vous pouvez séparer différentes modifications dans différentes validations. Cela les sépare bien dans l'historique de vos versions et vous permet même de revenir sur l'un mais pas sur l'autre.
• Votre commit ne doit pas nécessairement refléter un état de "compilation" de votre copie de travail (bien que j'essaie de le conserver de cette façon).

Alors, où est le "contrôle qualité" et la garantie de construction dans un commit auquel un utilisateur subversion s'attendrait? Il est déplacé vers d'autres actions dans git. Vous voulez toujours pousser un état de fonctionnement du programme dans un référentiel public. Par conséquent, vous vous assurez que les tests sont réussis et que le programme fonctionne avant de pousser vos modifications.

Essayez également d'utiliser les branches au maximum. Lors de la validation de nombreux petits changements, vous vous retrouverez avec un historique de version assez volumineux. Si vous travaillez dans des branches, vous pouvez classer ces validations granulaires par le nom de la branche, puis les fusionner (l'option --no-ffconservera également que ces fonctionnalités vivaient dans une branche unique).

C'est-à-dire que vous pouvez conserver l'habitude de fusionner avec la masterbranche uniquement si la branche est en bon état. Vous pouvez également utiliser des balises pour suivre les jalons et les versions.

Maintenant, revenons à la mise en scène: une fois que vous avez validé quelques lignes par commit, vous effectuerez une étape directement avant de valider. (C'est du moins ainsi que je le fais).

Je pense que vous le prenez trop au sérieux. La mise en scène consiste simplement à sélectionner les éléments que vous souhaitez inclure dans le prochain commit. Il est très rarement important de savoir quand ou comment vous effectuez la mise en scène; et si vous avez à un moment donné de nombreux changements échelonnés et non échelonnés, vous devrez probablement revoir votre processus de développement.

Dans un projet (post premier commit), quel est le bon moment pour mettre en scène les fichiers source? Juste avant de vous engager? Juste après avoir ajouté / supprimé ou modifié?

Je le fais généralement juste avant de commettre (sauf si je remarque une faute de frappe, je dois donc faire une correction de dernier moment et la mettre en scène aussi). Le processus est le suivant: éditer, exécuter des tests, étape, valider. Si vous effectuez une étape avant le test, il est probable que les tests échouent et vous devrez apporter des modifications et les mettre en scène également, alors pourquoi ne pas le laisser jusqu'au moment de la validation?

Si les fichiers sont placés à mi-chemin entre deux validations, puis modifiés, que se passe-t-il avec Git? A-t-il besoin de se soucier des changements de contenu quand il a été déclaré et de ce qu'il est devenu depuis?

Il vous montrera la différence entre l'état actuel du référentiel et (dernière validation + modifications par étapes). Lorsque vous effectuez certaines des nouvelles modifications, il recalcule simplement l'état (dernière validation + modifications par étapes).

Si je crée un nouveau fichier, le met en scène et que je souhaite ensuite le supprimer, pourquoi Git me demande-t-il d'utiliser l'indicateur "-f" et un simple "git -rm file.ext" ne fonctionnera pas?

Maintenant, je suppose ici, mais c'est probablement parce que les informations mises en scène peuvent être importantes (sinon vous ne les mettriez pas en scène), mais elles ne sont pas encore sous contrôle de version (comme un fichier que vous pouvez supprimer avec git -rm). Alors , gitveut assurer que vous savez ce que vous faites.