Quelle est la différence entre Mercurial et Git?

je travaille sur Mercurial, mais fondamentalement je crois que les deux systèmes sont équivalents. Ils travaillent tous les deux avec le même abstractions: une série de clichés (révisions) qui composent l'histoire. Chaque jeu de modifications sait d'où il vient (le jeu de modifications parent) et peut avoir de nombreux jeux de modifications enfant. La récente extension hg-git fournit un pont bidirectionnel entre Mercurial et Git et montre en quelque sorte ce point.

Git a un fort accent sur la mutation de ce alors que Mercurial n'encourage pas la réécriture de l'histoire, mais il est facile de faire quoi qu'il en soit et les conséquences de le faire sont exactement ce que vous devriez attendre d'eux (c'est-à-dire, si je modifie un ensemble de changements que vous avez déjà, votre client le verra comme nouveau si vous tirez de moi). Donc Mercurial a un bias vers des commandes non destructives.

comme pour les branches légères, alors Mercurial a pris en charge les dépôts avec branches multiples depuis..., toujours, je pense. Les dépôts Git avec plusieurs branches sont exactement cela: plusieurs fils divergés de développement dans un dépôt unique. Git ajoute ensuite des noms à ces brins et vous permet d'interroger ces noms à distance. L'extension Bookmarks pour Mercurial ajoute des noms locaux, et avec Mercurial 1.6, Vous pouvez déplacer ces bookmarks lorsque vous poussez/tirez..

J'utilise Linux, mais apparemment TortoiseHg est plus rapide et meilleur que L'équivalent Git sur Windows (en raison d'une meilleure utilisation du mauvais système de fichiers Windows). Tous les deux http://github.com et http://bitbucket.org fournir l'hébergement en ligne, le service à Bitbucket est grande et réactive (je n'ai pas essayé github).

J'ai choisi Mercurial car il me semble propre et élégant -- j'ai été rebuté par les scripts shell/Perl/Ruby que j'ai reçus avec Git. Essayez de jeter un oeil à la git-instaweb.sh fichier si vous voulez savoir ce que je veux dire: c'est un shell script qui génère un Ruby script, qui je pense exécute un serveur web. Le script shell génère un autre script shell pour lancer le premier script Ruby. Il y a aussi un peu de Perl , pour bonne mesure.

j'aime blog post qui compare Mercurial et Git avec James Bond et MacGyver ... le Mercurial est plus discret que Git. Il me semble que les gens qui utilisent Mercurial ne sont pas facilement impressionné. Cela se reflète dans la façon dont chaque système fait ce que Linus a décrit comme " la fusion la plus cool jamais!" . Dans Git, vous pouvez fusionner avec un dépôt indépendant en faisant:

git fetch <project-to-union-merge>
GIT_INDEX_FILE=.git/tmp-index git-read-tree FETCH_HEAD
GIT_INDEX_FILE=.git/tmp-index git-checkout-cache -a -u
git-update-cache --add -- (GIT_INDEX_FILE=.git/tmp-index git-ls-files)
cp .git/FETCH_HEAD .git/MERGE_HEAD
git commit

ces commandes me semblent assez obscures à l'oeil. Dans Mercurial-nous faire:

hg pull --force <project-to-union-merge>
hg merge
hg commit

Remarquez comment les commandes Mercuriales sont simples et pas spéciales du tout -- la seule chose inhabituelle est le drapeau --force à hg pull , qui est nécessaire puisque Mercurial va avorter autrement quand vous tirez à partir d'un dépôt sans rapport. Ce sont des différences comme celles-ci qui font que le Mercurial me semble plus élégant.

Git est une plate-forme, Mercurial est "juste" une application. Git est une plate-forme de système de fichiers en version versionnée qui est livrée avec une application DVCS dans la boîte, mais comme d'habitude pour les applications plate-forme, elle est plus complexe et a des contours plus rugueux que les applications ciblées. Mais cela signifie aussi que le VCS de git est immensément flexible, et il y a une énorme profondeur de choses non-source-contrôle que vous pouvez faire avec git.

C'est l'essence de la différence.

Git est mieux compris de la base vers le haut – du dépôt vers le haut. Scott Chacon Git du Parler est une excellente introduction pour cette. Si vous essayez d'utiliser git sans savoir ce qui se passe sous le capot, vous finirez par être confus à un moment donné (à moins que vous ne vous en teniez à une fonctionnalité très basique). Cela peut sembler stupide quand tout ce que vous voulez est un DVCS pour votre routine quotidienne de programmation, mais le génie de git est que le format de dépôt est en fait très simple et vous can comprendre toute l'opération de git assez facilement.

pour des comparaisons plus techniques, les meilleurs articles que j'ai personnellement Vus sont ceux de Dustin Sallings:

• Les Différences Entre Mercurial et Git
• thread Reddit où git expérimentés Dustin réponses à ses propres git néophyte questions

il a effectivement utilisé les deux DVCSs largement et les comprend à la fois bien – et a fini par préférer git.

la grande différence est sur les fenêtres. Mercurial est supporté nativement, Git ne l'est pas. Vous pouvez obtenir un hébergement très similaire à github.com avec bitbucket.org (en fait encore mieux que vous obtenez un dépôt privé gratuit). J'ai utilisé msysGit pendant un certain temps, mais j'ai déménagé à Mercurial et j'en ai été très heureux.

si vous êtes un développeur Windows à la recherche d'un contrôle basique de révision déconnecté, utilisez Hg. J'ai trouvé que Git était incompréhensible alors que Hg était simple et bien intégré avec le shell Windows. J'ai téléchargé Hg et suivi ce tutoriel (hginit.com) - dix minutes plus tard, j'ai eu un repo local et j'étais de retour pour travailler sur mon projet.

je pense que la meilleure description de "Mercurial vs. Git" est:

"Git est Wesley Snipes. Mercurial is Denzel Washington "

Ils sont presque identiques. La différence la plus importante, de mon point de vue (je veux dire, la raison pour laquelle j'ai choisi un CVN plutôt que l'autre) est la façon dont les deux programmes gèrent les directions générales.

pour démarrer une nouvelle branche, avec Mercurial, il suffit de cloner le dépôt dans un autre répertoire et de commencer à développer. Ensuite, vous tirez et fusionner. Avec git, vous devez explicitement donner un nom à la nouvelle rubrique de la branche que vous souhaitez utiliser, puis vous commencez codage utilisant le même répertoire .

en bref, chaque branche dans Mercurial a besoin de son propre répertoire; dans git vous travaillez habituellement sur un répertoire unique. Changer de branche dans Mercurial signifie changer de répertoire; dans git, cela signifie demander à git de changer le contenu du répertoire avec git checkout.

je suis honnête: je ne sais pas s'il est possible de faire la même chose avec Mercurial, mais puisque je travaille habituellement sur des projets web, en utilisant toujours le même répertoire avec git me semble très confortable, puisque je n'ai pas à reconfigurer Apache et le redémarrer et que je ne perturbe pas mon système de fichiers à chaque fois que je branche.

modifier: comme deestan a noté, Hg a branches nommées , qui peuvent être stockées dans un dépôt unique et permettre au développeur de changer de branches dans la même copie de travail. les branches git ne sont pas exactement les mêmes que les branches Mercurielles nommées, de toute façon: elles sont permanentes et ne pas jeter les branches, comme dans git. Cela signifie que si vous utilisez une branche nommée pour des tâches expérimentales, même si vous décidez de ne jamais la fusionner, elle sera stockée dans le dépôt. C'est la raison pour laquelle Hg encourage l'utilisation de clones pour des tâches expérimentales de courte durée et des branches nommées pour des tâches de longue durée, comme pour les branches de libération.

la raison pour laquelle beaucoup d'utilisateurs de Hg préfèrent les clones sur les branches nommées est beaucoup plus sociale ou culturelle que technique. Par exemple, avec les dernières versions de Hg, c'est même possible de fermer une branche nommée et récursive de supprimer les métadonnées de révisions.

de l'autre côté, git invite à utiliser" named branches " qui ne sont pas permanentes et ne sont pas stockées sous forme de métadonnées sur chaque ensemble de modifications.

de mon point de vue personnel, donc, le modèle de git est profondément lié au concept de branches nommées et basculer entre une branche et une autre avec le même répertoire; hg peut faire la même chose avec les branches nommées, mais pourtant il encourage l'utilisation de clones, personnellement, je n'aime pas trop.

Il y a un énorme différence entre git et mercurial ; la manière de le représenter à chaque commit. git représente s'engage comme des instantanés, tandis que mercurial les représente comme des diffs.

Que cela signifie dans la pratique? De nombreuses opérations sont plus rapides en git, comme passer à une autre propagation, comparer les propagations, etc. Spécialement si ces les commits sont loin.

AFAIK l'approche de mercurial ne présente aucun avantage.

rien. Ils font tous les deux la même chose, les deux performent à peu près également. La seule raison pour laquelle vous devez choisir l'un sur l'autre est si vous aider avec un projet qui utilise déjà un..

l'autre raison possible d'en choisir une est une application ou un service qui ne prend en charge qu'un seul système.. Par exemple, j'ai à peu près choisi d'apprendre le git à cause de github ..

aussi la comparaison de google (bien qu'il soit un peu vieux, Fait en 2008)

http://code.google.com/p/support/wiki/DVCSAnalysis

si je les comprends correctement (et je suis loin d'être un expert sur chacun), ils ont fondamentalement chacun une philosophie différente. J'ai utilisé mercurial pour la première fois pendant 9 mois. J'ai utilisé git pendant 6 ans.

hg est un logiciel de contrôle de version. Son but principal est de suivre les versions d'un logiciel.

git est un système de fichiers basé sur le temps. Le but est d'ajouter une autre dimension à un système de fichiers. La plupart ont des fichiers et des dossiers, git ajoute du temps. Que ça se passe travailler génial comme un VCS est un sous-produit de sa conception.

dans hg, il y a une histoire de l'ensemble du projet qu'il essaie toujours de maintenir. Par défaut, je crois que hg veut toutes les modifications à tous les objets par tous les utilisateurs en poussant et en tirant.

dans git il y a juste un pool d'objets et ces fichiers de suivi (branches/têtes) qui déterminent quel ensemble de ces objets représente l'arbre des fichiers dans un état particulier. En poussant ou en tirant uniquement git envoie les objets nécessaires pour les branches particulières que vous poussez ou tirez, qui est un petit sous-ensemble de tous les objets.

en ce qui concerne git, il n'y a pas de "1 projet". Vous pourriez avoir 50 projets dans le même repo et git s'en fiche. Chacun pourrait être géré séparément dans le même repo et vivre amende.

Hg concept de branches, branches de l'artère principale du projet ou de branches, branches etc. Git n'a pas un tel concept. Direction dans git est simplement un état de l'arbre, tout est une branche git. Quelle branche est officielle, actuelle, ou la plus récente n'a pas de sens dans git.

ça n'a pas de sens. Si je pouvais dessiner hg pourrait ressembler à ceci où chaque commit est un o

             o---o---o
            /        
o---o---o---o---o---o---o---o
         \         /
          o---o---o

un arbre avec une seule racine et des branches qui en sortent. Alors que git peut faire cela et souvent les gens l'utilisent de cette façon qui n'est pas appliquée. Une image de git, s'il y a une telle chose, pourrait facilement ressembler à cela

o---o---o---o---o

o---o---o---o
         \
          o---o

o---o---o---o

en fait, d'une certaine façon, cela n'a même pas de sens de montrer des branches en gitan.

une chose qui est très déroutante pour la discussion, git et mercurial ont tous deux quelque chose appelé une "branche", mais ils ne sont pas du tout les mêmes choses. Une branche dans le mercurial se produit quand il y a des conflits entre les différentes repos. Une branche git est apparemment similaire à un clone de hg. Mais un clone, alors qu'il peut donner un comportement similaire est absolument pas la même. J'essaierai de les tester en git vs hg en utilisant le chrome repo qui est assez grand.

$ time git checkout -b some-new-branch
Switched to new branch 'some-new-branch'

real   0m1.759s
user   0m1.596s
sys    0m0.144s

et maintenant en hg en utilisant le clone

$ time hg clone project/ some-clone/

updating to branch default
29387 files updated, 0 files merged, 0 files removed, 0 files unresolved.
real   0m58.196s
user   0m19.901s
sys    0m8.957

ce sont tous les deux des courses à chaud. C'est à dire, j'ai couru deux fois et c'est la deuxième manche. hg clone est en fait le même que git-nouvelle-workdir. Les deux font un dir de travail entièrement nouveau presque comme si vous aviez tapé cp -r project project-clone . Ce n'est pas le même de faire une nouvelle branche dans git. Il est beaucoup plus de poids lourds. S'il y a un vrai équivalent de la ramification de git dans hg, Je ne sais pas ce que c'est.

je comprends à un certain niveau hg et git pourrait être en mesure de faire des choses similaires. Si oui, alors il y a une énorme différence dans le flux de travail qu'ils mènent. Dans git, le flux de travail typique est de créer une branche pour chaque fonctionnalité.

git checkout master
git checkout -b add-2nd-joypad-support
git checkout master
git checkout -b fix-game-save-bug
git checkout master
git checkout -b add-a-star-support

qui vient de créer 3 branches, chaque basés sur une branche appelée maître. (Je suis sûr qu'il y a un moyen en git de faire ces 1 ligne chacun au lieu de 2)

Maintenant le travail, sur celui que je viens de faire

git checkout fix-game-save-bug

et commencer à travailler. Commettre des choses, etc. Passer d'une branche à l'autre, même dans un projet aussi grand que chrome, est presque instantané. En fait, je ne sais pas comment faire ça à hg. Ça ne fait partie d'aucun tutoriel que j'ai lu.

une autre grosse différence. La scène de Git.

Git a cette idée d'une scène. Vous pouvez penser que c'est un dossier caché. Quand vous vous engagez, vous ne commettez que ce qui est sur la scène, pas les changements dans votre arbre de travail. Ça peut sembler étrange. Si vous voulez propager toutes les modifications dans votre arborescence de travail, vous devez faire git commit -a qui ajoute tous les fichiers modifiés à l'étape et les propage ensuite.

Quel est l'intérêt de la scène alors? Vous pouvez facilement séparer vos commits. Imaginez que vous avez édité joypad.rpc et de la sauvegarde.rpc et que vous souhaitez engager séparément

git add joypad.cpp  // copies to stage
git commit -m "added 2nd joypad support"
git add gamesave.cpp  // copies to stage
git commit -m "fixed game save bug"

Git a même des commandes pour décider quelles lignes particulières dans le même fichier que vous voulez copier à l'étape de sorte que vous pouvez diviser ces propagations séparément aussi bien. Pourquoi voudriez-vous faire cela? Parce que comme les commits séparés d'autres peuvent tirer seulement ceux qu'ils veulent ou s'il y avait un problème ils peuvent revenir juste le commit qui avait le problème.

il y a un tableau de comparaison dynamique à la versioncontrolblog où vous pouvez comparer plusieurs systèmes de contrôle de version différents.

voici un tableau de comparaison entre git, hg et bzr.

il y a des différences assez significatives quand il s'agit de travailler avec des branches (surtout à court terme).

Il est expliqué dans le cet article (BranchingExplained) qui compare Mercurial avec Git.

y a-t-il des collaborateurs Windows pour votre projet?

parce que s'il y en a, L'interface graphique de Git-for-Windows semble maladroite, difficile, peu amicale.

Mercurial-on-Windows, par contraste, est un no-brainer.

une chose à remarquer entre le mercurial de bitbucket.org et git de github est, mercurial peut avoir autant de dépôts privés que vous voulez, mais github vous devez mettre à niveau à un compte payant. Donc, c'est pour ça que je préfère bitbucket qui utilise du mercuriel.

L'an dernier, j'ai évalué le git et le hg pour mon propre usage, et j'ai décidé d'utiliser le hg. J'ai senti que cela ressemblait à une solution plus propre, et fonctionnait mieux sur plus de plateformes à l'époque. C'était surtout un tirage au sort, si.

plus récemment, j'ai commencé à utiliser git à cause de git-svn et de la possibilité d'agir en tant que client Subversion. Cela m'a convaincu et je suis maintenant complètement passé à git. Je pense qu'il a une courbe d'apprentissage légèrement plus élevé (surtout si vous avez besoin de poke autour de l'intérieur), mais c'est vraiment un grand système. Je vais aller lire ces deux articles de comparaison que John a postés.

je suis actuellement en train de migrer de SVN vers un DVCS (tout en bloguant sur mes résultats, mon premier véritable effort de blogging...), et j'ai fait un peu de recherche (=googler). D'après ce que je vois, vous pouvez faire la plupart des choses avec les deux paquets. Il semble que git a un peu plus ou mieux mis en œuvre des fonctionnalités avancées, Je pense que l'intégration avec windows est un peu mieux pour mercurial, avec TortoiseHg. Je sais qu'il y a Git Guépard (j'ai essayé les deux), mais les mercurial la solution se sent juste plus robuste.

voir comment ils sont tous les deux open-source (droite? Je ne pense pas que non plus manquera de fonctionnalités importantes. Si quelque chose est important, les gens vont demander, les gens de code.

je pense que pour les pratiques courantes, Git et Mercurial sont plus que suffisants. Ils ont tous les deux de grands projets qui les utilisent (git -> Linux kernel, Mercurial - > Mozilla foundation projects, entre autres bien sûr), donc je ne pense pas les deux manquent vraiment de quelque chose.

cela dit, je suis intéressé par ce que les autres disent à ce sujet, car il ferait une grande source pour mes efforts de blogging; -)

il y a une grande et exhaustive comparaison des tableaux et des graphiques sur git, Mercurial et Bazaar au Infoq's guide about DVCS .

je me rends compte que cela ne fait pas partie de la réponse, mais sur cette note, je pense également que la disponibilité de plugins stables pour les plateformes comme NetBeans et Eclipse jouent un rôle dans lequel outil est un meilleur ajustement pour la tâche, ou plutôt, quel outil est le meilleur ajustement pour"vous". C'est, à moins que vous vraiment voulez le faire de la CLI.

Eclipse (et tout ce qui est basé sur elle) et NetBeans ont parfois des problèmes avec les systèmes de fichiers distants (comme SSH) et mises à jour externes de fichiers; ce qui est encore une autre raison pour laquelle vous voulez que ce que vous choisissez de travailler "sans couture".

j'essaie de répondre à cette question pour moi maintenant .. et j'ai fait bouillir les candidats à Git ou Mercurial .. merci à tous d'avoir fourni des contributions utiles sur ce sujet sans devenir religieux.

Encore une autre comparaison intéressante de mercurial et git: Mercurial vs Git . L'accent est mis sur les internes et leur influence sur le processus de ramification.

si vous êtes intéressé par une comparaison de la performance de Mercurial et Git jeter un oeil à cet article . La conclusion est:

Git et Mercurial tournent en grand nombre, mais font un compromis intéressant entre la vitesse et la taille du dépôt. Mercurial est rapide avec les ajouts et les modifications, et maintient la croissance du dépôt sous contrôle en même temps. Git est également rapide, mais son dépôt se développe très rapidement avec des modifications les dossiers jusqu'à ce que vous Remballez - et ces remballages peuvent être très lents. Mais le dépôt est beaucoup plus petit que celui de Mercurial.

le site mercurial a une grande description des similitudes et des différences entre les deux systèmes, expliquant les différences de vocabulaire et les concepts sous-jacents. En tant qu'utilisateur de longue date de git, il m'a vraiment aidé à comprendre l'état D'esprit mercuriel.

si vous migrez à partir de SVN, utilisez Mercurial car sa syntaxe est beaucoup plus compréhensible pour les utilisateurs de SVN. À part ça, tu ne peux pas te tromper non plus. Mais cochez tutoriel GIT et HGinit avant de sélectionner l'un d'eux.

Ce lien peut vous aider à comprendre la différence http://www.techtatva.com/2010/09/git-mercurial-and-bazaar-a-comparison/

certains pensent que les systèmes VCS doivent être compliqués. Ils encouragent l'invention de termes et de concepts sur le terrain. Ils penseraient probablement que de nombreux doctorats sur le sujet serait intéressant. Parmi ceux-là, il y a probablement ceux qui ont conçu Git.

Mercurial est conçu avec une mentalité différente. Les développeurs ne devraient pas trop se soucier de la VCS, et ils devraient plutôt passer leur temps sur leur fonction principale: l'ingénierie logicielle. Mercurial permet aux utilisateurs de utilisez et abusez du système sans les laisser faire des erreurs non-récupérables.

tout outil professionnel doit venir avec un CLI clairement conçu et intuitif. Les utilisateurs de Mercurial peuvent faire la plupart du travail en émettant des commandes simples sans aucune option étrange. En git double dash, les options folles sont la norme. Mercurial a un avantage substantiel si vous êtes un CLI personne (et pour être honnête, tout auto-respect ingénieur logiciel devrait être).

à donner un exemple, supposons que vous validez par erreur. Vous avez oublié de modifier certains fichiers. Pour annuler votre action dans Mercurial, tapez simplement:

$ hg rollback

vous recevez alors un message que le système annule votre dernière transaction.

dans Git, vous devez taper:

$ git reset --soft HEAD^

donc OK supposons que vous ayez une idée de ce qu'est la réinitialisation. Mais en plus vous devez savoir ce que "-- doux" et "--hard" réinitialise sont (tout intuitif suppositions?). OH et bien sûr n'oubliez pas le caractère " ^ " à la fin! (au nom de Ritchie, c'est quoi ça?..)

L'intégration de Mercurial avec des outils tiers comme kdiff3 et meld est bien meilleure aussi. Générez vos patches fusionnent vos branches sans trop de tracas. Mercurial inclut également un serveur http simple que vous activez en tapant

hg serve

et laissez les autres parcourir votre référentiel.

le résultat est, Git fait ce que Mercurial fait, d'une manière beaucoup plus compliquée et avec un CLI bien inférieur. Utilisez Git si vous voulez transformer le CV de votre projet en un domaine de recherche scientifique. Utilisez Mercurial si vous voulez obtenir le travail VCS fait sans se soucier beaucoup à ce sujet, et de se concentrer sur vos tâches réelles.