谷歌技术讲座:Linus Torvalds谈git

http://www.youtube.com/watch?v=4XpnKHJAok8

Git Wiki的比较页面

http://git.or.cz/gitwiki/GitSvnComparsion

Git并不比Subversion好。但也不是更糟。这是不一样的。

关键的区别在于它是去中心化的。想象一下你是一个在路上的开发人员，你在你的笔记本电脑上开发，你想要有源代码控制，这样你就可以回到3小时前。

使用Subversion时，您会遇到一个问题:SVN存储库可能位于您无法到达的位置(在您的公司中，并且您目前没有互联网)，您无法提交。如果你想复制你的代码，你必须复制/粘贴它。

使用Git，您就不会遇到这个问题。您的本地副本是一个存储库，您可以提交它并获得源代码控制的所有好处。当您重新获得到主存储库的连接时，您可以针对它提交。

一开始看起来不错，但是要记住这种方法增加了复杂性。

Git似乎是“新的、闪亮的、酷的”东西。它绝对不坏(毕竟Linus为Linux内核开发写了它是有原因的)，但是我觉得很多人只是因为它是新的并且是由Linus Torvalds写的，就跳上了“分布式源代码控制”这列火车，而不知道为什么/它是否更好。

Subversion有问题，但是Git、Mercurial、CVS、TFS等等也有问题。

编辑:所以这个答案现在已经有一年了，仍然获得了很多赞，所以我想我会添加更多的解释。在写这篇文章后的去年，Git获得了很多动力和支持，特别是在像GitHub这样的网站真正起飞之后。我现在同时使用Git和Subversion，我想分享一些个人见解。

First of all, Git can be really confusing at first when working decentralized. What is a remote? and How to properly set up the initial repository? are two questions that come up at the beginning, especially compared to SVN's simple "svnadmin create", Git's "git init" can take the parameters --bare and --shared which seems to be the "proper" way to set up a centralized repository. There are reasons for this, but it adds complexity. The documentation of the "checkout" command is very confusing to people changing over - the "proper" way seems to be "git clone", while "git checkout" seems to switch branches.

当你去中心化的时候，Git真的会发光。我家里有一台服务器，路上有一台笔记本电脑，SVN在这里根本不能很好地工作。使用SVN，如果我没有连接到存储库，我就不能进行本地源代码控制(是的，我知道SVK或复制回购的方法)。对于Git，这是默认模式。这是一个额外的命令(git commit在本地提交，而git push origin master将主分支推到名为“origin”的远程)。

如上所述:Git增加了复杂性。创建存储库的两种模式，签出vs克隆，提交vs推…您必须知道哪些命令在本地工作，哪些命令在“服务器”上工作(我假设大多数人仍然喜欢中央的“主存储库”)。

而且，工具仍然不够，至少在Windows上是这样。是的，有一个Visual Studio插件，但我仍然使用git bash和msysgit。

SVN的优点是学习起来简单得多:有您的存储库，所有针对它的更改，如果您知道如何创建、提交和签出，您就可以准备好，并可以在以后提取分支、更新等内容。

Git的优势在于，如果一些开发人员不总是连接到主存储库，它会更适合。而且，它比SVN快得多。据我所知，分支和合并支持要好得多(这是意料之中的，因为这是编写它的核心原因)。

这也解释了为什么它在互联网上获得了如此多的关注，因为Git非常适合开源项目:只需Fork它，将您的更改提交到您自己的Fork，然后让原始项目维护者提取您的更改。使用Git，这就可以了。真的，在Github上试试吧，太神奇了。

我还看到了Git-SVN网桥:中央存储库是一个Subversion repo，但开发人员在本地使用Git，网桥将他们的更改推到SVN。

但是即使有了这么长的补充，我仍然坚持我的核心信息:Git并没有更好或更差，它只是不同而已。如果你需要“离线源代码控制”，并愿意花一些额外的时间学习它，那就太棒了。但是如果您有一个严格集中的源代码控制，并且/或者因为您的同事不感兴趣而在第一时间努力引入源代码控制，那么SVN的简单性和出色的工具(至少在Windows上)就会脱颖而出。

它是分布的。基准测试表明，它的速度要快得多(考虑到它的分布式性质，像diffs和log这样的操作都是本地的，所以在这种情况下，它当然要快得多)，而且工作文件夹也更小(这仍然让我大吃一惊)。

当您使用subversion或任何其他客户端/服务器版本控制系统时，您实际上是通过签出版本在您的机器上创建工作副本。这代表了存储库外观的时间快照。通过更新更新工作副本，通过提交更新存储库。

使用分布式版本控制，您没有快照，而是拥有整个代码库。想要一个3个月大的版本吗?没问题，3个月前的版本还在你的电脑上。这不仅意味着速度更快，而且如果您与中央服务器断开连接，您仍然可以执行许多您习惯的操作。换句话说，您不仅拥有给定修订的快照，而且拥有整个代码库。

您可能认为Git会占用大量硬盘空间，但从我看到的几个基准测试来看，它实际上占用的空间更少。不要问我怎么做。我的意思是，它是由莱纳斯构建的，我猜他对文件系统略知一二。

Git和DVCS通常都非常适合于独立编写大量代码的开发人员，因为每个人都有自己的分支。但是，如果您需要从其他人那里进行更改，她必须提交给她的本地回购，然后她必须将该更改集推给您，或者您必须从她那里获取更改集。

我自己的推理也让我认为，如果你做集中发布之类的事情，DVCS会让QA和发布管理变得更加困难。必须有人负责从其他人的存储库中进行推送/拉取，解决任何在最初提交时就可以解决的冲突，然后进行构建，然后让所有其他开发人员重新同步他们的回购。

当然，所有这些都可以通过人工流程来解决;DVCS只是破坏了一些由集中式版本控制修复的东西，以便提供一些新的便利。

这一切都是关于做某事所需的易用性/步骤。

如果我在我的PC/笔记本电脑上开发一个项目，git会更好，因为它的设置和使用要容易得多。 合并时不需要服务器，也不需要一直输入存储库URL's in。

如果只有两个人，我会说git也更简单，因为你可以互相推拉。

一旦你超越了这一点，我就会选择颠覆，因为在这一点上你需要设置一个“专用”服务器或位置。

使用git可以像使用SVN一样做到这一点，但是git的好处被需要执行额外步骤来与中央服务器同步所抵消。在SVN中，你只需要提交。在git中，你必须先执行git commit，然后再执行git push。额外的步骤很烦人，因为你最后做了太多。

SVN也有更好的GUI工具的好处，但是git生态系统似乎正在迅速追赶，所以从长远来看我并不担心这一点。

使用Git，您几乎可以脱机做任何事情，因为每个人都有自己的存储库。

创建分支和合并分支非常简单。

即使你没有项目的提交权限，你仍然可以拥有自己的在线存储库，并发布补丁的“推送请求”。每个喜欢你的补丁的人都可以把它们拉到他们的项目中，包括官方的维护者。

分叉一个项目，修改它，并仍然从HEAD分支中合并错误修复是很简单的。

Git适用于Linux内核开发人员。这意味着它非常快(必须如此)，并且可以扩展到数千个贡献者。Git使用的空间也更少(Mozilla存储库的空间最多减少30倍)。

Git非常灵活，非常TIMTOWTDI(有不止一种方法可以做到)。你可以使用任何你想要的工作流，Git会支持它。

最后，还有GitHub，一个托管Git存储库的好网站。

Git的缺点:

它更难学，因为Git有更多的概念和命令。 修订版不像subversion那样有版本号 许多Git命令是神秘的，错误消息对用户非常不友好 它缺少一个好的GUI(比如伟大的TortoiseSVN)

Git还使分支和合并变得非常容易。Subversion 1.5刚刚添加了合并跟踪，但是Git仍然更好。使用Git进行分支是非常快速和廉价的。它使得为每个新特性创建分支更加可行。哦，与Subversion相比，Git存储库的存储空间非常有效。

Easy Git有一个很好的页面，比较了Git和SVN的实际使用情况，这将让你了解Git可以做什么(或更容易做什么)。(从技术上讲，这是基于Easy Git的，它是Git之上的轻量级包装器。)

SubVersion最让我恼火的一点是它把自己的文件夹放在项目的每个目录中，而git只把一个文件夹放在根目录中。这不是什么大事，但这样的小事积少成多。

当然，SubVersion有Tortoise，它(通常)非常好。

由于它不需要不断地与中央服务器通信，几乎每个命令都在不到一秒的时间内运行(显然git的push/pull/fetch较慢，因为它们必须初始化SSH连接)。分支要容易得多(一个简单的命令就可以分支，一个简单的命令就可以合并)

我喜欢DVCS的主要原因是:

You can commit broken things. It doesn't matter because other peoples won't see them until you publish. Publish time is different of commit time. Because of this you can commit more often. You can merge complete functionnality. This functionnality will have its own branch. All commits of this branch will be related to this functionnality. You can do it with a CVCS however with DVCS its the default. You can search your history (find when a function changed ) You can undo a pull if someone screw up the main repository, you don't need to fix the errors. Just clear the merge. When you need a source control in any directory do : git init . and you can commit, undoing changes, etc... It's fast (even on Windows )

一个相对较大的项目的主要原因是由点3创建的改进的交流。其他的则是不错的奖金。

Subversion仍然是一种更常用的版本控制系统，这意味着它有更好的工具支持。您会发现几乎所有IDE都有成熟的SVN插件，并且有很好的资源管理器扩展可用(如TurtoiseSVN)。除此之外，我不得不同意Michael的观点:Git并不比Subversion更好或更差，它是不同的。

其他的回答很好地解释了Git的核心特性(这些特性非常棒)。但是还有很多小方法可以让Git表现得更好，并帮助我的生活更加理智。以下是一些小细节:

Git has a 'clean' command. SVN desperately needs this command, considering how frequently it will dump extra files on your disk. Git has the 'bisect' command. It's nice. SVN creates .svn directories in every single folder (Git only creates one .git directory). Every script you write, and every grep you do, will need to be written to ignore these .svn directories. You also need an entire command ("svn export") just to get a sane copy of your files. In SVN, each file & folder can come from a different revision or branch. At first, it sounds nice to have this freedom. But what this actually means is that there is a million different ways for your local checkout to be completely screwed up. (for example, if "svn switch" fails halfway through, or if you enter a command wrong). And the worst part is: if you ever get into a situation where some of your files are coming from one place, and some of them from another, the "svn status" will tell you that everything is normal. You'll need to do "svn info" on each file/directory to discover how weird things are. If "git status" tells you that things are normal, then you can trust that things really are normal. You have to tell SVN whenever you move or delete something. Git will just figure it out. Ignore semantics are easier in Git. If you ignore a pattern (such as *.pyc), it will be ignored for all subdirectories. (But if you really want to ignore something for just one directory, you can). With SVN, it seems that there is no easy way to ignore a pattern across all subdirectories. Another item involving ignore files. Git makes it possible to have "private" ignore settings (using the file .git/info/exclude), which won't affect anyone else.

有趣的是: 我在Subversion Repos中托管项目，但是通过Git Clone命令访问它们。

请阅读在谷歌代码项目中使用Git进行开发

虽然谷歌代码原生说话 Subversion，可以轻松使用Git 在开发过程中。搜索“git” Svn建议这种做法是正确的 广泛传播，我们也鼓励你 用它来做实验。

在Svn存储库上使用Git给我带来了好处:

我可以分配到几个 机器，承诺和从 对他们来说 我有一个中央备份/公共svn存储库供其他人检查 他们可以自由地使用Git

我喜欢Git，因为它实际上有助于在中大型团队中开发人员之间的沟通。作为一个分布式版本控制系统，通过它的推送/拉系统，它帮助开发人员创建一个源代码生态系统，这有助于管理在单个项目上工作的大量开发人员。

例如，假设你信任5个开发人员，并且只从他们的存储库中提取代码。每个开发人员都有自己的信任网络，从那里提取代码。因此，开发是基于开发人员之间的信任结构，其中代码责任由开发社区共享。

当然，在这里的其他答案中也提到了其他好处。

“为什么Git比X好”概述了Git相对于其他scm的各种优缺点。

简要:

Git tracks content rather than files Branches are lightweight and merging is easy, and I mean really easy. It's distributed, basically every repository is a branch. It's much easier to develop concurrently and collaboratively than with Subversion, in my opinion. It also makes offline development possible. It doesn't impose any workflow, as seen on the above linked website, there are many workflows possible with Git. A Subversion-style workflow is easily mimicked. Git repositories are much smaller in file size than Subversion repositories. There's only one ".git" directory, as opposed to dozens of ".svn" repositories (note Subversion 1.7 and higher now uses a single directory like Git.) The staging area is awesome, it allows you to see the changes you will commit, commit partial changes and do various other stuff. Stashing is invaluable when you do "chaotic" development, or simply want to fix a bug while you're still working on something else (on a different branch). You can rewrite history, which is great for preparing patch sets and fixing your mistakes (before you publish the commits) … and a lot more.

有一些缺点:

There aren't many good GUIs for it yet. It's new and Subversion has been around for a lot longer, so this is natural as there are a few interfaces in development. Some good ones include TortoiseGit and GitHub for Mac. Partial checkouts/clones of repositories are not possible at the moment (I read that it's in development). However, there is submodule support. Git 1.7+ supports sparse checkouts. It might be harder to learn, even though I did not find this to be the case (about a year ago). Git has recently improved its interface and is quite user friendly.

在最简单的用法中，Subversion和Git是差不多的。两者之间没有太大区别:

svn checkout svn://foo.com/bar bar
cd bar
# edit
svn commit -m "foo"

and

git clone git@github.com:foo/bar.git
cd bar
# edit
git commit -a -m "foo"
git push

Git真正的亮点在于分支和与其他人一起工作。

一些回答已经提到了这些问题，但我想明确说明两点:

1)有选择性提交的能力(例如，git add——patch)。如果您的工作目录包含多个不属于同一逻辑更改的更改，Git可以很容易地提交只包含部分更改的提交。对于Subversion，这是很困难的。

2)在不公开更改的情况下提交的能力。在Subversion中，任何提交都是立即公开的，因此是不可撤销的。这极大地限制了开发人员“尽早提交，经常提交”的能力。

Git不仅仅是一个VCS;它也是一个开发补丁的工具。Subversion只是一个VCS。

这里所有的答案都是意料之中的，以程序员为中心，但是如果你的公司在源代码之外使用修订控制会发生什么呢?有很多文档不是源代码，它们受益于版本控制，应该与代码接近，而不是在另一个CMS中。大多数程序员都不是孤立地工作——我们作为团队的一部分为公司工作。

考虑到这一点，比较Subversion和git在客户端工具和培训方面的易用性。我看不出有哪一种分布式修订控制系统会更容易使用或向非程序员解释。我很乐意被证明是错误的，因为这样我就可以评估git，并希望它能够被那些需要版本控制的人(而不是程序员)接受。

即便如此，如果管理层问我为什么我们应该从集中式版本控制系统转向分布式版本控制系统，我也很难给出一个诚实的答案，因为我们不需要它。

Disclaimer: I became interested in Subversion early on (around v0.29) so obviously I'm biased, but the companies I've worked for since that time are benefiting from my enthusiasm because I've encouraged and supported its use. I suspect this is how it happens with most software companies. With so many programmers jumping on the git bandwagon, I wonder how many companies are going to miss out on the benefits of using version control outside of source code? Even if you have separate systems for different teams, you're missing out on some of the benefits, such as (unified) issue tracking integration, whilst increasing maintenance, hardware and training requirements.

Subversion非常容易使用。在过去的几年里，我从来没有发现任何问题或事情没有像预期的那样工作。此外，还有许多优秀的GUI工具，对SVN集成的支持也很大。

With Git you get a more flexible VCS. You can use it the same way like SVN with a remote repository where you commit all changes. But you can also use it mostly offline and only push the changes from time to time to the remote repository. But Git is more complex and has a steeper learning curve. I found myself in the first time committing to wrong branches, creating branches indirectly or get error messages with not much informations about the mistake and where I must search with Google to get better informations. Some easy things like substitution of markers ($Id$) doesn't work but GIT has a very flexible filtering and hook mechanism to merge own scripts and so you get all things you need and more but it needs more time and reading of the documentation ;)

如果您主要脱机使用本地存储库，那么如果本地机器上丢失了某些东西，则没有备份。使用SVN，您主要使用远程存储库，同时您的备份也在另一个服务器上… Git也可以以同样的方式工作，但这并不是Linus的主要目标，要有类似SVN2的东西。它是为Linux内核开发人员和分布式版本控制系统的需要而设计的。

Git比SVN好吗?只需要一些版本历史记录和备份机制的开发人员可以轻松地使用SVN。经常使用分支、同时测试更多版本或主要离线工作的开发人员可以从Git的特性中受益。有一些非常有用的特性，比如SVN中没有的存储特性，可以使工作更轻松。但另一方面，并非所有人都需要所有功能。所以我看不到SVN的死角。

Git需要一些更好的文档，错误报告必须更有帮助。而且现有的有用的gui也很少。这次我只找到了一个支持大多数Git特性的Linux GUI (Git -cola)。Eclipse集成正在工作，但还没有正式发布，也没有官方更新站点(只有一些外部更新站点，从主干定期构建http://www.jgit.org/updates) 因此，现在使用Git的首选方式是命令行。

来自SourceGear的Eric Sink写了一系列关于分布式和非分布式版本控制系统之间区别的文章。他比较了最流行的版本控制系统的优缺点。非常有趣的读物。 文章可以在他的博客www.ericsink.com上找到:

阅读差异 Git是版本控制工具中的C Git缺乏对不变性和DVCS最佳实践的尊重 DVCS和dag，第1部分 DVCS和dag，第2部分 DVCS和Bug跟踪 合并历史，dag和Darcs Git为什么这么快? Mercurial, Subversion和Wesley Snipes

首先，并发版本控制似乎是一个很容易解决的问题。一点也不。无论如何……

SVN非常不直观。Git更糟糕。这可能是因为开发人员喜欢并发版本控制这样的难题，他们对制作一个好的UI没有多大兴趣。[/ sarcastic-speculation]

SVN supporters think they don't need a distributed version-control system. I thought that too. But now that we use Git exclusively, I'm a believer. Now version control works for me AND the team/project instead of just working for the project. When I need a branch, I branch. Sometimes it's a branch that has a corresponding branch on the server, and sometimes it does not. Not to mention all the other advantages that I'll have to go study up on (thanks in part to the arcane and absurd lack of UI that is a modern version control system).

Windows中的Git现在得到了很好的支持。

查看GitExtensions = http://code.google.com/p/gitextensions/

以及更好的Windows Git体验的手册。

http://subversion.wandisco.com/component/content/article/1/40.html

我认为可以很有把握地说，在开发人员中，SVN和Git的争论已经激烈了一段时间，每个人都有自己的观点，哪个更好。这甚至在我们2010年及以后关于颠覆的网络研讨会的问题中被提出。

我们的开源和Subversion公司总统总监Hyrum Wright谈到了Subversion和Git之间的区别，以及其他分布式版本控制系统(DVCS)。

他还谈到了Subversion中即将发生的变化，比如下一代工作拷贝(WC-NG)，他认为这会导致许多Git用户转换回Subversion。

请观看他的视频，并通过在这个博客上评论或在我们的论坛上发帖来告诉我们你的想法。注册很简单，只需要一点时间!

我非常喜欢能够在Git中管理源代码的本地分支，而不会混淆中央存储库的水。在许多情况下，我将从Subversion服务器签出代码并运行本地Git存储库，只是为了能够做到这一点。初始化Git存储库不会因为到处都是烦人的.svn文件夹而污染文件系统，这一点也很棒。

至于Windows工具的支持，TortoiseGit处理基本的很好，但我仍然喜欢命令行，除非我想查看日志。我真的很喜欢Tortoise{Git|SVN}在读取提交日志时的帮助方式。

我最近一直住在Git的土地上，我喜欢用它来做个人项目，但是我还不能把工作项目从Subversion转换到Git上，因为它改变了工作人员的想法，而且没有紧迫的好处。此外，我们内部运行的最大项目非常依赖于svn:externals，从我目前所看到的来看，它在Git中并不能很好地无缝工作。

我认为Subversion很好。直到你开始合并…或者做任何复杂的事情。或者做任何Subversion认为复杂的事情(比如查询哪些分支弄乱了特定的文件，更改实际上来自哪里，检测复制和粘贴，等等)…

我不同意获胜的答案，我认为GIT的主要好处是离线工作——它当然有用，但它更像是我的用例的额外功能。SVK也可以离线工作，对我来说，把我的学习时间投入到哪一个是没有问题的)。

只是它非常强大、快速，而且——在习惯了这些概念之后——非常有用(是的，在这个意义上:用户友好)。

有关合并故事的更多细节，请参见: 使用git-svn(或类似)*只是*帮助svn合并?

David Richards关于Subversion / GIT的WANdisco博客

The emergence of GIT has brought with it a breed of DVCS fundamentalists – the ‘Gitterons’ – that think anything other than GIT is crap. The Gitterons seem to think software engineering happens on their own island and often forget that most organizations don’t employ senior software engineers exclusively. That’s ok but it’s not how the rest of the market thinks, and I am happy to prove it: GIT, at the last look had less than three per cent of the market while Subversion has in the region of five million users and about half of the overall market. The problem we saw was that the Gitterons were firing (cheap) shots at Subversion. Tweets like “Subversion is so [slow/crappy/restrictive/doesn't smell good/looks at me in a funny way] and now I have GIT and [everything works in my life/my wife got pregnant/I got a girlfriend after 30 years of trying/I won six times running on the blackjack table]. You get the picture.

为什么我认为Subversion比Git好(至少对于我所从事的项目来说)，主要是因为它的可用性和更简单的工作流程:

http://www.databasesandlife.com/why-subversion-is-better-than-git/

对于那些正在寻找一个好的Git GUI的人来说，Syntevo SmartGit可能是一个很好的解决方案。它是私有的，但对非商业用途是免费的，可以在Windows/Mac/Linux上运行，我认为甚至可以使用某种git-svn网桥来支持SVN。

This is the wrong question to be asking. It's all too easy to focus on git's warts and formulate an argument about why subversion is ostensibly better, at least for some use cases. The fact that git was originally designed as a low-level version control construction set and has a baroque linux-developer-oriented interface makes it easier for the holy wars to gain traction and perceived legitimacy. Git proponents bang the drum with millions of workflow advantages, which svn guys proclaim unnecessary. Pretty soon the whole debate is framed as centralized vs distributed, which serves the interests of the enterprise svn tool community. These companies, which typically put out the most convincing articles about subversion's superiority in the enterprise, are dependent on the perceived insecurity of git and the enterprise-readiness of svn for the long-term success of their products.

但问题是:Subversion是架构的死胡同。

Whereas you can take git and build a centralized subversion replacement quite easily, despite being around for more than twice as long svn has never been able to get even basic merge-tracking working anywhere near as well as it does in git. One basic reason for this is the design decision to make branches the same as directories. I don't know why they went this way originally, it certainly makes partial checkouts very simple. Unfortunately it also makes it impossible to track history properly. Now obviously you are supposed to use subversion repository layout conventions to separate branches from regular directories, and svn uses some heuristics to make things work for the daily use cases. But all this is just papering over a very poor and limiting low-level design decision. Being able to a do a repository-wise diff (rather than directory-wise diff) is basic and critical functionality for a version control system, and greatly simplifies the internals, making it possible to build smarter and useful features on top of it. You can see in the amount of effort that has been put into extending subversion, and yet how far behind it is from the current crop of modern VCSes in terms of fundamental operations like merge resolution.

现在，对于那些仍然相信Subversion在可预见的未来足够优秀的人，我有一个发自内心的不可知论的建议:

Subversion永远不会赶上从RCS和CVS的错误中吸取教训的新型vcs;这在技术上是不可能的，除非他们从头开始重新配置存储库模型，但这样就不是真正的SVN了，不是吗?不管你认为自己有多不具备现代VCS的能力，你的无知也无法保护你远离Subversion的陷阱，其中许多情况在其他系统中是不可能或很容易解决的。

It is extremely rare that the technical inferiority of a solution is so clear-cut as it is with svn, certainly I would never state such an opinion about win-vs-linux or emacs-vs-vi, but in this case it is so clearcut, and source control is such a fundamental tool in the developer's arsenal, that I feel it must be stated unequivocally. Regardless of the requirement to use svn for organizational reasons, I implore all svn users not to let their logical mind construct a false belief that more modern VCSes are only useful for large open-source projects. Regardless of the nature of your development work, if you are a programmer, you will be a more effective programmer if you learn how to use better-designed VCSes, whether it be Git, Mercurial, Darcs, or many others.