在SVN中，标记和分支非常相似。

标签=在时间上定义的片段，通常用于发布

分支=在开发过程中定义的片段，通常用于1.0、1.5、2.0等主要版本，然后在发布时标记分支。这允许您继续支持产品版本，同时在主干中进行突破性的更改

Trunk =开发工作空间，这是所有开发应该发生的地方，然后从分支发布合并回来的更改。

它们没有任何正式的含义。文件夹就是文件夹 SVN。它们是组织项目的一种普遍接受的方式。

The trunk is where you keep your main line of developmemt. The branch folder is where you might create, well, branches, which are hard to explain in a short post. A branch is a copy of a subset of your project that you work on separately from the trunk. Maybe it's for experiments that might not go anywhere, or maybe it's for the next release, which you will later merge back into the trunk when it becomes stable. And the tags folder is for creating tagged copies of your repository, usually at release checkpoints.

但正如我所说，对于SVN，文件夹就是文件夹。分支、主干和标签只是一种约定。

我随意使用“复制”这个词。SVN实际上并不完全复制存储库中的内容。

中继目录可能是您最熟悉的目录，因为它用于保存最新的更改。你的主要代码库应该在trunk中。

分支目录用于保存分支，无论它们是什么。

标签目录主要用于标记一组特定的文件。您可以对发布版本这样做，其中您希望“1.0”是这些修订版本的这些文件，“1.1”是这些修订版本的这些文件。通常，标签制作完成后就不需要修改了。有关标签的更多信息，请参见第4章。分支和合并(在Subversion版本控制中)。

我不太确定“标签”是什么，但分支是一个相当常见的源代码控制概念。

基本上，分支是在不影响主干的情况下对代码进行更改的一种方式。假设您想要添加一个相当复杂的新功能。您希望能够在进行更改时检入更改，但在完成该特性之前不希望它影响trunk。

首先创建一个分支。这基本上是创建分支时的主干副本。然后在分支中完成所有工作。在分支中所做的任何更改都不会影响trunk，因此trunk仍然可用，允许其他人继续在那里工作(比如做错误修复或小的增强)。一旦你的特性完成了，你就可以把分支集成回主干中。这将把所有的更改从分支移动到主干。

人们为分支使用了许多模式。如果您有一个同时支持多个主要版本的产品，通常每个版本都是一个分支。在我工作的地方，我们有一个QA分支和一个生产分支。在向QA发布代码之前，我们将变更集成到QA分支，然后从那里进行部署。当发布到产品时，我们从QA分支集成到生产分支，所以我们知道在生产中运行的代码与QA测试的代码是相同的。

这里是维基百科上关于分支的条目，因为它们可能比我能更好地解释事情。：）

嗯，我不确定我同意尼克重新标签类似于一个分支。标签只是一个标记

Trunk would be the main body of development, originating from the start of the project until the present. Branch will be a copy of code derived from a certain point in the trunk that is used for applying major changes to the code while preserving the integrity of the code in the trunk. If the major changes work according to plan, they are usually merged back into the trunk. Tag will be a point in time on the trunk or a branch that you wish to preserve. The two main reasons for preservation would be that either this is a major release of the software, whether alpha, beta, RC or RTM, or this is the most stable point of the software before major revisions on the trunk were applied.

在开源项目中，不被项目涉众接受的主要分支可以成为分叉的基础——例如，与其他源代码共享共同起源的完全独立的项目。

分支和标记子树与主干的区别如下:

Subversion allows sysadmins to create hook scripts which are triggered for execution when certain events occur; for instance, committing a change to the repository. It is very common for a typical Subversion repository implementation to treat any path containing "/tag/" to be write-protected after creation; the net result is that tags, once created, are immutable (at least to "ordinary" users). This is done via the hook scripts, which enforce the immutability by preventing further changes if tag is a parent node of the changed object.

Subversion从1.5版开始还增加了与“分支合并跟踪”相关的特性，这样提交到分支的更改就可以合并回支持增量式“智能”合并的主干中。

主干是保存最新源代码和特性的开发线路。它应该包含最新的错误修复以及添加到项目中的最新功能。

分支通常用于做一些远离主干(或其他开发线)的事情，否则会破坏构建。新特性通常构建在分支中，然后合并回主干中。分支通常包含一些代码，这些代码不一定被分支的开发线所批准。例如，程序员可以尝试对分支中的某些内容进行优化，只有在优化令人满意时才会合并回开发线上。

标记是存储库在特定时间的快照。不应该在这些基础上进行任何开发。它们最常用于获取发布给客户端的内容的副本，以便您可以轻松地访问客户正在使用的内容。

这里有一个链接到一个非常好的知识库指南:

源码控制

维基百科上的文章也值得一读。

除了Nick所说的，您还可以在流式线:并行软件开发的分支模式中找到更多信息

在这个图中，main是主干，rel1- maintenance是分支，1.0是标记。

我认为一些混淆来自标记概念和SVN中的实现之间的差异。对于SVN来说，标签是一个分支，它是一个副本。修改标签被认为是错误的，事实上，像TortoiseSVN这样的工具会警告你，如果你试图用../tags/..在路上。

标签=在时间上定义的片段，通常用于发布

我认为这就是人们通常所说的“标签”。但是在Subversion中:

它们没有任何正式的含义。文件夹对于SVN来说就是一个文件夹。

我觉得很困惑:一个对分支或标签一无所知的修订控制系统。从实现的角度来看，我认为创建“副本”的Subversion方式非常聪明，但我必须了解它，这就是我所说的有漏洞的抽象。

或者我使用CVS的时间太长了。

首先，正如@AndrewFinnell和@KenLiu指出的，在SVN中，目录名称本身没有任何意义——“主干、分支和标记”只是大多数存储库使用的一种常见约定。并不是所有的项目都使用所有的目录(根本不使用“标签”是很常见的)，事实上，没有什么可以阻止您调用任何您想要的名称，尽管打破常规经常会令人困惑。

我将描述分支和标记最常见的使用场景，并给出如何使用它们的示例场景。

Trunk: The main development area. This is where your next major release of the code lives, and generally has all the newest features. Branches: Every time you release a major version, it gets a branch created. This allows you to do bug fixes and make a new release without having to release the newest - possibly unfinished or untested - features. Tags: Every time you release a version (final release, release candidates (RC), and betas) you make a tag for it. This gives you a point-in-time copy of the code as it was at that state, allowing you to go back and reproduce any bugs if necessary in a past version, or re-release a past version exactly as it was. Branches and tags in SVN are lightweight - on the server, it does not make a full copy of the files, just a marker saying "these files were copied at this revision" that only takes up a few bytes. With this in mind, you should never be concerned about creating a tag for any released code. As I said earlier, tags are often omitted and instead, a changelog or other document clarifies the revision number when a release is made.

例如，假设你开始一个新项目。你开始在“主干”中工作，最终将以1.0版本发布。

Trunk / -开发版本，即将发布1.0 分支/ -空

一旦1.0.0完成，你将分支trunk到一个新的“1.0”分支，并创建一个“1.0.0”标记。现在，关于最终1.1版本的工作继续在主干中进行。

Trunk / -开发版本，即将发布1.1 分支/1.0 - 1.0.0发布版本 Tags /1.0.0 - 1.0.0发布版本

You come across some bugs in the code, and fix them in trunk, and then merge the fixes over to the 1.0 branch. You can also do the opposite, and fix the bugs in the 1.0 branch and then merge them back to trunk, but commonly projects stick with merging one-way only to lessen the chance of missing something. Sometimes a bug can only be fixed in 1.0 because it is obsolete in 1.1. It doesn't really matter: you only want to make sure that you don't release 1.1 with the same bugs that have been fixed in 1.0.

Trunk / -开发版本，即将发布1.1 分支/1.0——即将发布的1.0.1版本 Tags /1.0.0 - 1.0.0发布版本

一旦发现了足够多的错误(或者可能是一个严重的错误)，就决定发布1.0.1版本。因此，您从1.0分支创建了一个标记“1.0.1”，并发布了代码。此时，主干将包含1.1，而“1.0”分支包含1.0.1代码。下次你发布1.0版本的更新时，它将是1.0.2。

Trunk / -开发版本，即将发布1.1 分支/1.0——即将发布的1.0.2版 Tags /1.0.0 - 1.0.0发布版本 Tags /1.0.1 - 1.0.1发布版本

最终，你几乎准备好发布1.1，但你想先做一个测试版。在本例中，您可能会执行“1.1”分支和“1.1beta1”标记。现在，关于1.2(或者2.0)的工作在主干中继续进行，而1.1的工作则在“1.1”分支中继续进行。

Trunk / -开发版本，即将发布1.2 分支/1.0——即将发布的1.0.2版 分支/1.1——即将发布的1.1.0版本 Tags /1.0.0 - 1.0.0发布版本 Tags /1.0.1 - 1.0.1发布版本 Tags /1.1beta a1 - 1.1beta1发布版本

一旦发布了1.1 final版本，就可以从“1.1”分支执行“1.1”标记。

如果您愿意，还可以继续维护1.0，在所有三个分支(1.0、1.1和主干)之间移植错误修复。重要的一点是，对于您所维护的软件的每个主版本，都有一个包含该版本的最新代码版本的分支。

分支的另一个用途是用于特性。这是你分支主干(或你的发布分支之一)并独立开发新特性的地方。一旦特性完成，您将其合并并删除分支。

Trunk / -开发版本，即将发布1.2 分支/1.1——即将发布的1.1.0版本 分支/ui-rewrite -实验特性分支

The idea of this is when you're working on something disruptive (that would hold up or interfere with other people from doing their work), something experimental (that may not even make it in), or possibly just something that takes a long time (and you're afraid if it holding up a 1.2 release when you're ready to branch 1.2 from trunk), you can do it in isolation in branch. Generally you keep it up to date with trunk by merging changes into it all the time, which makes it easier to re-integrate (merge back to trunk) when you're finished.

还要注意，我在这里使用的版本控制方案只是众多方案之一。一些团队会将错误修复/维护版本作为1.1、1.2等，并将主要更改作为1。x, 2。x,等等。这里的用法是相同的，但是您可以将分支命名为“1”或“1”。而不是“1.0”或“1.0. X”。(除此之外，语义版本控制是如何进行版本号的一个很好的指南)。

一般来说(工具不可知的观点)，分支是用于并行开发的机制。一个SCM可以有0到n个分支。Subversion是0。

Trunk is a main branch recommended by Subversion, but you are in no way forced to create it. You could call it 'main' or 'releases', or not have one at all! Branch represents a development effort. It should never be named after a resource (like 'vonc_branch') but after: a purpose 'myProject_dev' or 'myProject_Merge' a release perimeter 'myProjetc1.0_dev'or myProject2.3_Merge' or 'myProject6..2_Patch1'... Tag is a snapshot of files in order to easily get back to that state. The problem is that tag and branch is the same in Subversion. And I would definitely recommend the paranoid approach: you can use one of the access control scripts provided with Subversion to prevent anyone from doing anything but creating new copies in the tags area.

标签是最终的。其内容不应改变。从来没有。永远。你忘了发行通知里的一行字?创建一个新标记。淘汰或删除旧的。

现在，我读了很多关于“在某某分支中合并某某，然后最终在主干分支中合并”的内容。 这就是所谓的合并工作流，这里没有强制性的内容。这并不是因为你有一个主干分支，你必须合并回任何东西。

按照惯例，主干分支可以代表您的开发的当前状态，但这是一个简单的顺序项目，该项目具有:

没有“预先”开发(用于准备下一个下一个版本，这意味着这些更改与当前的“主干”开发不兼容) 没有大规模的重构(用于测试新的技术选择) 没有以前版本的长期维护

因为对于这些场景中的一个(或所有)，你会得到四个“主干”，四个“当前开发”，而不是你在这些并行开发中所做的所有事情都必须合并回“主干”中。

这就是关于软件开发的事情，没有一致的知识，每个人似乎都有自己的方式，但这是因为它是一个相对年轻的学科。

这是我简单的方法，

trunk - trunk目录包含最新的、已批准的和合并的工作主体。与许多人所承认的相反，我的箱子只用于干净、整洁、合格的工作，而不是一个开发区域，而是一个释放区域。

在某个给定的时间点上，当主干似乎已经准备好释放时，它就会被标记并释放。

分支——分支目录包含实验和正在进行的工作。分支下的工作一直停留在那里，直到被批准合并到主干中。对我来说，这是所有工作完成的区域。

例如:我可以有一个迭代-5分支用于产品的第5轮开发，可能有一个原型-9分支用于第9轮实验，等等。

tags—标签目录包含已批准的分支和中继发布的快照。每当一个分支被批准合并到主干中，或者一个发布是由主干组成的，一个被批准的分支或主干发布的快照就会在标记下生成。

我想有了标签，我可以很容易地在时间里来回跳转到感兴趣的点。

One of the reasons why everyone has a slightly different definition is because Subversion implements zero support for branches and tags. Subversion basically says: We looked at full-featured branches and tags in other systems and did not found them useful, so we did not implement anything. Just make a copy into a new directory with a name convention instead. Then of course everyone is free to have slightly different conventions. To understand the difference between a real tag and a mere copy + naming convention see the Wikipedia entry Subversion tags & branches.

当我在OpenCV 2计算机视觉应用编程烹饪书的作者的网站上查找时，我发现了这个关于SVN的很棒的教程，我想我应该分享一下。

他有一个关于如何使用SVN的教程，以及短语“trunk”、“tag”和“branch”的含义。

直接引用自他的教程:

The current version of your software project, on which your team is currently working is usually located under a directory called trunk. As the project evolves, the developer updates that version fix bugs, add new features) and submit his changes under that directory. At any given point in time, you may want to freeze a version and capture a snapshot of the software as it is at this stage of the development. This generally corresponds to the official versions of your software, for example, the ones you will deliver to your clients. These snapshots are located under the tags directory of your project. Finally, it is often useful to create, at some point, a new line of development for your software. This happens, for example, when you wish to test an alternative implementation in which you have to modify your software but you do not want to submit these changes to the main project until you decide if you adopt the new solution. The main team can then continue to work on the project while other developer work on the prototype. You would put these new lines of development of the project under a directory called branches.

主干:在敏捷的每一个冲刺阶段结束后，我们会推出一个部分可交付的产品。这些释放物被保存在后备箱里。

分支:每个正在进行的冲刺的所有并行开发代码都保存在分支中。

标签:每次我们发布一个部分可发货的产品的测试版，我们都会为它做一个标签。这为我们提供了在那个时间点可用的代码，允许我们在开发过程中的某个时间点需要时回到那个状态。

对于熟悉GIT的人来说，GIT中的master相当于SVN中的trunk。

分支和标记在GIT和SVN中有相同的术语。