Comment éviter git conflits dans une équipe?

Nous sommes certains développeurs qui travaillent sur un même projet et nous utilisons git pour le projet. Si deux ou plus d'entre nous arrive de travailler sur le même fichier, nous recevons git conflits qui sont difficiles à traiter avec, parfois, des changements fait par un développeur sont perdus lors de ces conflits se produisent.

Comment fonctionnent-ils avec git dans une équipe? Ce qui devrait être le bon écoulement afin d'éviter git conflits ?

Merci d'avance.

InformationsquelleAutor Dev01 | 2013-05-10
  1. 51

    Avant de creuser profondément dans votre flux de travail, avant de vous passer à un moment ou à un dollar de l'argent de la reconstruction de votre processus de communication, demandez à votre équipe de trois questions:

    1. - Nous appliquer les espaces conventions?
    2. Si nous utilisons des IDEs, ils utilisent tous la même mise en forme et les paramètres de mots clés? Par exemple, Eclipse peut automatiquement finaliser les paramètres.
    3. Fait-on pour générer textuelle construire des artefacts? Par exemple, ne nous rapetisser js, de générer des règles css de .sass ou .scss fichiers, ou de construire des configurations xml à la volée? - Nous vérifier?

    Après des années de générer des conflits et d'aider les autres à résoudre dans centralisée des flux de travail, je vous soumets ces trois choses l'origine de la grande majorité de nos conflits collectifs de la douleur:

    Comment éviter git conflits dans une équipe?

    Dans l'image ci-dessus, le '!' tranche représente légitimes des conflits de fusion. Le vaste majorité des affreux fusionne viennent de paresseux espaces conventions ou trop agressif IDEs (ou, parfois, trop refactory les développeurs). Avant de faire quoi que ce soit d'autre, de normaliser votre IDE paramètres et les espaces conventions. Alors tout le monde tapez cette commande dans leurs référentiels:

    # Enable the repository's stock pre-commit hook
mv .git/hooks/pre-commit.sample .git/hooks/pre-commit

    Que pre-commit hook va effectuer une série de contrôles à chaque fois que vous émettez git commit, y compris une version de git diff --check, une commande qui vérifie si votre commis des changements d'introduire des espaces erreurs. La validation sera rejetée si elle n'. Si vous avez vraiment besoin de vous déplacer, vous pouvez émettre des git commit --no-verify, mais n'est pas le cas: les Espaces les erreurs sont comme les munitions non explosées de contrôle de version. Ils sont les conflits de fusion en attente de se produire.

    Si vous voulez nettoyer les espaces, refactoriser un fichier afin d'améliorer sa mise en retrait, ou sinon faire une grande série de purement modifications de mise en forme, de le faire dans isolés s'engage, et d'en avertir l'équipe de vérifier dans leur conflit de travail en progrès le premier.

    Si vous effectuer des revues de code, rendre ces la première des questions à chaque examinateur demande: "ce changement touche rien il n'était pas censé? Il l'a fait de nettoyer toute la mise en forme? Il l'a fait inutilement refactoriser une méthode?" Si elle le faisait, échouent à l'examen. Ou si vous ne pouvez pas, assurez-vous que ces changements sont suffisamment isolées à partir de la logique des changements (c'est à dire dans les différents commits), pour faire de votre histoire utile.

    De la feuille de style de langues, RequireJS, et js minifiers également provoquer des conflits, si leurs cibles générées sont archivés. Les fichiers créés par ces technologies sont de construire des artefacts. Vous ne cochez pas dans une GUERRE d'archives; ne pas vérifier dans un SASS-compilé le fichier CSS. Ou, si vous sentez que vous devez, utiliser un .gitattributes fichier laisser git de les traiter comme des fichiers binaires.

    Si après avoir fait toutes ces choses, vous avez encore des conflits de fusion, institut améliorations des processus. Gary Fixler la réponse est tout à fait juste: la Légitime fusion des conflits surviennent parce que les équipes ne peuvent pas ou ne communique pas bien sur la portée de leurs projets. Assurez-vous seulement ses pas mal appliquée règles de mise en forme première.

    • Je suis venu à cette question avec snark dans mon cœur, et vous me gagné plus avec la qualité de votre réponse a été!
    • Merci pour la grande réponse 🙂
    InformationsquelleAutor Christopher
  2. 13

    Bien, pour être vraiment honnête, le bon flux de travail implique une bonne communication et de gestion. Les membres de l'équipe ne devrait pas souvent travailler sur la même chose et à l'origine des conflits. Des choses comme le quotidien standups, et d'une qualité d'écoute manager qui sait ce que chaque membre de l'équipe est jusqu'à - au moins en général - ira un long chemin dans de nombreux cas, à la limite de ce.

    Il dépend de la nature exacte du produit, bien sûr, mais c'est plus un problème d'organisation que d'un git question. En fait, les conflits sont souvent considérées comme de "bonnes" choses, parce qu'ils amener les gens à se lever de leur bureau, ou appeler les uns les autres jusqu'à parler de pourquoi il y avait un conflit, et ce qui devrait être fait à ce sujet à l'avenir. C'est une chance de comprendre qu'une personne doit posséder un domaine, ou un ensemble de fichiers, ou au moins être le point de contact pour discuter des modifications à cet article.

    En dehors de faire un plan, il n'y a aucun moyen d'éviter git conflits, mais ce serait le même problème dans un système de gestion de versions. Toute fois, deux personnes modifient la même section de code, vous devez déterminer qui gagne. C'est pourquoi il n'est pas vraiment approprié pour regarder en direction du versioner pour la solution, mais à regarder de votre équipe méthodes et des pratiques. Deux voitures ne peuvent pas passer à travers une intersection en même temps, mais il est extrêmement difficile d'inventer des voitures qui peuvent passer à travers les uns des autres, au lieu de cela, nous avons inventé les systèmes de contrôle de panneaux d'arrêt et des feux de circulation. C'est un problème similaire. Nous ne pouvons pas vraiment faire deux changements à la même chose, pas de conflit, nous devons contrôler la façon dont nous travaillons avec les fichiers.

    Vous pourrait considérer les frontaux qui permet le verrouillage de git, mais je n'ai pas vraiment d'accord avec le concept, à l'extérieur de la non fusionnables types de fichiers. Je pense qu'il est préférable de trouver une meilleure équipe du flux de travail, et pendant ce temps, utiliser cela comme une occasion d'obtenir de très bons fusion de fichiers. Je l'ai fait, et maintenant, après des mois de faire, les conflits ne sont pas un bouleversant pour moi.

    InformationsquelleAutor Gary Fixler
  3. 8

    Il y a un seul moyen d'éviter les conflits: ne pas avoir des gens différents modifier le même fichier en même temps. Essentiellement, chaque fichier a un propriétaire qui est responsable de toutes les modifications et qui peuvent transmettre la propriété à l'autre. La propriété d'un fichier peut être passé autour basé sur une caractéristique particulière ou à la direction ou à la journée-à-jour, tant que la propriété est claire.

    Si vous trouvez que vous ne pouvez pas donner un seul propriétaire pour chaque fichier puis:

    • vous avez besoin de partager vos fichiers en fichiers plus petits, qui peuvent être assignés à un propriétaire
    • absolument exiger que GIT conflits résolus (avec tous les éditeurs à s'asseoir ensemble pour résoudre les conflits individuels).
    • D'utiliser un multi-outil de fusion de visualiser et de résoudre les conflits.
    InformationsquelleAutor GoZoner
  4. 3

    De la commande.

    Il ya quelques autres choses que vous pouvez faire qui peuvent aider trop.
    Il sera plus clair si je poste séparément.

    Où vous insérez de nouvelles choses vous aidera à déterminer si vous créer des conflits.

    Imaginez une liste de noms d'employés 

    Andy, 
Oliver, 
Ivan,

    Alors Brad et Patrick rejoindre et leurs noms sont ajoutés à la liste.
    Vous ajoutez Brad et j'ajoute Patrick. Nous avons à la fois ajouter les noms au bas de la liste, puis utilisez git pour la fusion de nos listes. Le résultat sera familier pour les utilisateurs de git :-

    Merge branch 'Patrick' into Brad

Conflicts:
    names.txt

@@@ -1,4 -1,4 +1,8 @@@
  Andy, 
  Oliver, 
  Ivan,
  <<<<<<< HEAD
 +Brad,
  =======
+ Patrick,
  >>>>>>> Patrick

    Supposons maintenant que nous avions fait la même chose, mais a imposé un simple ordre alphabétique de la règle sur notre liste. Maintenant, quand nous arrivons à la fusion des deux branches, les résultats sont un peu plus agréable :-

    Andy,
Ivan,
Oliver,

    Ajouter un nom de vous-même et puis de fusionner avec l'autre personne changer avec git, pour ajouter le nom d'autres.

    Auto-merging names.txt
Merge made by the 'recursive' strategy.
 names.txt | 1 +
 1 file changed, 1 insertion(+)

    Et nous obtenons

    Andy,
Brad,
Ivan,
Oliver,
Patrick,

    Puisque nous ne savons pas qui va se joindre à l'entreprise suivante, nous sommes en mesure d'ajouter à la liste au hasard, et par l'insertion dans des endroits aléatoires, les conflits de localisation dans les fichiers sont moins susceptibles.

    InformationsquelleAutor Ivan
  5. 3

    Utilisation figurant en annexe du bloc commence

    Dans un logiciel comme ça ...

    function chess() 
{
    while (!end_of_game)
    {
        make_move()

    les lignes de départ des blocs avec les accolades sont facilement va être confondue avec d'autres lignes dans le logiciel composé de l'ouverture des accolades.
    Si le même logiciel est écrit comme ceci, en y ajoutant le bloc commence à lignes précédentes ...

    function chess() {
    while (!end_of_game) {
        make_move()

    personnellement, je n'aime pas, mais Git n', il y a beaucoup moins de lignes qui ressemblent à Git et obtenir trompent les uns les autres, c'est à dire Git est plus susceptible de percevoir l'édition de la même façon, nous ne, rendant toute conflits beaucoup plus facile à résoudre.

    Et commentaires sur le bloc terminaisons

    D'utiliser des commentaires à faire de même, à la recherche des lignes distinctes.

    Si vous écrivez beaucoup de javascript et JSON, vous pouvez avoir beaucoup de lignes qui ressemblent un peu à ce.

                }
        }
    }
)

    Si vous commentez choses, alors ils peuvent devenir illisibles.

                }
        }
    }
) //end of weekdays()

    et

                }
        }
    }
) //end of weekend()

    n'est plus le même aspect à git. Cela peut aider à git pour comprendre vos modifications mieux. Si vous ajoutez quelque chose, comme 

    function a()
{
    ...
} //end of a()

    git est plus susceptible de voir que tant qu'unité de changement et ne pas penser que vous avez ajouté quelque chose comme

    }

function a()
{
    ...

    juste avant la fin d'une autre fonction. Même quand cela n'empêche pas les conflits, si git voit et présente vos modifications judicieusement (c'est à dire la façon dont nous nous somme vue mer), alors vous pouvez peut-être résoudre les conflits plus facilement. Descriptif de l'en-tête de commenter quelles fonctions, les paramètres qu'ils prennent, etc, aide à prévenir git d'écraser le contenu de voisins fonctions ensemble.

    InformationsquelleAutor Ivan
  6. 1

    Informer des collègues lorsque vous avez poussé vos modifications

    Une autre façon de réduire la douleur de conflits est simplement d'informer les collègues lorsque vous avez poussé vos modifications. Il leur permet de tirer vos modifications et de résoudre certains conflits, puis il. Tous les conflits sont susceptibles d'être entre votre changement récent, frais dans votre esprit et ce qu'ils sont à travailler sur, frais dans leur esprit.

    Si les gens ne tirez pas les modifications de la branche principale jusqu'à ce qu'ils aient terminé un grand développement et d'avoir des conflits avec les modifications apportées par un certain nombre de personnes, toutes dans le même domaine, il sera plus difficile à résoudre.

    Utiliser un mergetool

    Comment éviter git conflits dans une équipe?

    L'un de Git du but est le contrôle de version. D'autres programmes se spécialisent dans la fusion de fichiers et de résolution de conflits. Si vous configurez un mergetool à utiliser avec git, puis elle permet de résoudre de nombreux problèmes qui git considère comme un conflit, ou au moins de faire une très bonne estimation pour vous d'inspecter et de simplement laisser intact si il semble bon, ou vous faire confiance à l'outil.

    Qui laisse de moins en moins de véritables conflits qui ont besoin d'une décision intelligente pour la résolution.

    Utiliser de plus petits fichiers

    - Je ajouter un nouveau contrôleur au bas de mycontrollers.js et vous ajouter un nouveau contrôleur au bas de yourcontrollers.js: pas de problème.

    Nous à la fois ajouter un nouveau contrôleur au bas de allcontrollers.js: conflit.

    (Cependant, rappelez-vous les conseils sur les choses de commande par ordre alphabétique trop. myNewController() en commençant par M pourriez aller au moyen d'un fichier et yourNewController() en commençant par Y pourrait aller à la fin du même fichier, à nouveau avec pas de conflit.)

    InformationsquelleAutor Ivan
  7. 0

    De réduire le nombre de conflits dans le contrôle de version, sans se soucier de qui est l'édition de ce, il vous suffit de faire de petits changements et commit/push de façon incrémentielle. Diviser le problème en petits morceaux assez que vous pouvez rapidement modifier des fichiers et de les pousser dans le tronc. La plus courte durée de vos branches sont, le moins de chance il y aura des conflits de fusion.

    Même alors, à un certain moment, deux personnes vont modifier le même fichier en même temps, sans aucune faute de leur propre. La question évidente qui se passe quand est:

    "Comment puis-je prendre la douleur hors de la résolution de git conflits?"

    La réponse est, vous devez tirer le tronc et rebase votre branche sur elle souvent, et vous remarquerez que les conflits le plus tôt possible, alors qu'ils sont encore petits. À ce stade, les développeurs devraient s'asseoir ensemble et discuter calmement la meilleure façon de procéder, tandis que les changements sont frais dans leur esprit.

    Revanche, cette approche tente de résoudre les conflits sur d'énormes longue durée de vie des branches dans une panique juste avant une date de sortie, lorsque les développeurs du mal à vous souvenir de la pensée qui se cache derrière tous les changements qu'ils ont fait il y a quelques temps.

    InformationsquelleAutor Will Sheppard
  8. 0

    Utiliser l'UTF-8 ne sont pas en UTF-16 pour les fichiers texte.

    De nombreuses versions de Git (j'.e de toutes les versions que j'ai utilisé, pour autant que je sais) peut traiter UTF-16 fichiers comme des fichiers binaires en raison de la présence de beaucoup de zéro octets dans un typique UTF-16 fichier texte.

    Une fois Git pense qu'un fichier est un fichier binaire, il est susceptible de continuer à traiter le fichier comme un fichier binaire, même lorsqu'elle est modifiée. Cela signifie que le contrôle de version est réalisée par le stockage de l'intégralité du fichier plutôt que sur les différences entre eux et les quelques-uns des avantages d'un système de contrôle de version sont perdus. (Edit: Non. J'ai testé récemment par la modification d'un UTF-16 fichier en UTF-8 qui s'engage, en le modifiant et en s'engageant de nouveau - et il a commencé à traiter les changements que les modifications apportées au texte une fois l'original et modifié des fichiers ont été UTF-8.)

    La plupart des éditeurs modernes reconnaissent le codage de caractère et de style de fin de ligne d'un fichier et enregistrez le fichier dans le même format. Certains éditeurs (par exemple Babelpad) vous permettra de choisir si vous enregistrez votre fichier en UTF-8 ou UTF-16, et avec ou sans une marque d'ordre d'octet, etc.

    Si le fichier que vous souhaitez pour le contrôle de version est (i) au format UTF-16 et (ii) qui fonctionne aussi bien en UTF-8, par exemple une source de programme pour une vie décente moderne compilateur -- il convient de tenir compte de la conversion en UTF-8.

    Si Git pense que votre texte source est un fichier binaire avant sa première validation, de regarder et de voir si ça vaut la peine de le charger dans un éditeur de texte et l'enregistrer dans un autre format que Git reconnaît en tant que texte.

    (Note. Linux fichiers ont tendance à être en UTF-8 par défaut. Certains programmes Windows avait l'habitude de la création de l'UTF-16. C'est donc les utilisateurs de Windows qui sont les plus susceptibles d'avoir le problème. Notez également que vous souhaitez corriger cela avant la première livraison du fichier, avant de Git croit que c'est un fichier binaire!)

    Comment éviter git conflits dans une équipe?

    L'utilisation de Git rerere

    Réutilisation enregistré résolution!

    https://git-scm.com/book/en/v2/Git-Tools-Rerere

    InformationsquelleAutor Ivan