[svnbook commit] r1538 - trunk/src/zh/book

rocksun svnbook-dev at red-bean.com
Mon Jul 11 12:33:42 CDT 2005

Author: rocksun
Date: Mon Jul 11 12:33:40 2005
New Revision: 1538

* zh/book/ch03.xml: Add UTF BOM, finished, need more check up. 
* zh/book/glossary.xml: add some new word

Modified: trunk/src/zh/book/ch03.xml
--- trunk/src/zh/book/ch03.xml	(original)
+++ trunk/src/zh/book/ch03.xml	Mon Jul 11 12:33:40 2005
@@ -1,24 +1,11 @@
-<chapter id="svn-ch-3">
-  <title>Guided Tour</title>
+<chapter id="svn-ch-3">
+  <title>指导教程</title>
-    <para>Now we will go into the details of using Subversion.  By the
-      time you reach the end of this chapter, you will be able to
-      perform almost all the tasks you need to use Subversion in a
-      normal day's work.  You'll start with an initial checkout of
-      your code, and walk through making changes and examining those
-      changes. You'll also see how to bring changes made by others
-      into your working copy, examine them, and work through any
-      conflicts that might arise.</para>
-    <para>Note that this chapter is not meant to be an exhaustive list
-      of all Subversion's commands—rather, it's a conversational
-      introduction to the most common Subversion tasks you'll
-      encounter.  This chapter assumes that you've read and understood
-      <xref linkend="svn-ch-2"/> and are familiar with the general
-      model of Subversion.  For a complete reference of all commands,
-      see <xref linkend="svn-ch-9"/>.</para>
+    <para>我们要进入到Subversion使用的细节中去了,当你到达这一章的结束,你将学会日常应用中所有使用Subversion的命令,你将从一个初始化检出开始,作修改然后检测这些修改,然后看如何取得别人做的修改到工作目录,检查他们,解决所有可能发生的冲突。</para>
+    <para>这一章不会包括所有的Subversion命令—而是介绍你将会遇到的最常用任务的介绍,这一仗假定你已经读过并且理解<xref linkend="svn-ch-2"/>,而且熟悉Subversion的模型,想看所有命令的参考,见<xref linkend="svn-ch-9"/>。</para>
@@ -26,15 +13,11 @@
   <!-- ======================== SECTION 1 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-3-sect-1">
-    <title>Help!</title>
+    <title>帮助!</title>
-    <para>Before reading on, here is the most important command you'll
-      ever need when using Subversion: <command>svn help</command>.
-      The Subversion command-line client is
-      self-documenting—at any time, a quick <command>svn help
-      <subcommand></command> will describe the syntax, switches,
-      and behavior of the <command>subcommand</command>.</para>
+    <para>在继续读之前,这是 Subversion最重要的命令:<command>svn help</command>,Subversion命令行工具是一个自文档的工具—在任何时候你可以运行<command>svn help
+      <subcommand></command>来查看子命令的语法、参数以及<command>subcommand</command>的行为。</para>
@@ -44,12 +27,8 @@
   <sect1 id="svn-ch-3-sect-2">
-    <para>You use <command>svn import</command> to import a new
-      project into a Subversion repository.  While this is most likely
-      the very first thing you will do when you set up your Subversion
-      server, it's not something that happens very often.  For a
-      detailed description of import, see <xref
-      linkend="svn-ch-3-sect-7.3"/> later in this chapter.</para>
+    <para>使用<command>svn import</command>来导入一个新项目到Subversion的版本库,这恐怕是要使用Subversion必定要做的第一步操作,但不是经常发生的事情,想看详细的介绍,可以看本章后面的<xref
+      linkend="svn-ch-3-sect-7.3"/>。</para>
@@ -57,31 +36,16 @@
   <!-- ======================== SECTION 3 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-3-sect-3">
-    <title>Revisions: Numbers, Keywords, and Dates, Oh My!</title>
+    <title>修订版本: 号码、关键字和日期,噢,天呢!</title>
+    <para>在继续之前你一定要知道一些关于如何识别一个修订版本,像你在<xref linkend="svn-ch-2-sect-3.2"/>看到的,一个修订版本就是版本库的一个<quote>快照</quote>,当你继续提交并扩大你的版本库,你必须有手段来识别这些快照。</para>
-    <para>Before we go on, you should know a bit about how to identify
-      a particular revision in your repository.  As you learned in
-      <xref linkend="svn-ch-2-sect-3.2"/>, a revision is a
-      <quote>snapshot</quote> of the repository at a particular moment
-      in time.  As you continue to commit and grow your repository,
-      you need a mechanism for identifying these snapshots.</para>
-    <para>You specify these revisions by using the
-      <option>--revision</option> (<option>-r</option>) switch plus
-      the revision you want (<command>svn --revision REV</command>) or
-      you can specify a range by separating two revisions with a colon
-      (<command>svn --revision REV1:REV2</command>).  And Subversion
-      lets you refer to these revisions by number, keyword, or
-      date.</para>
+    <para>你可以使用<option>--revision</option>(<option>-r</option>)参数来选择特定修订版本(<command>svn --revision REV</command>),你也可以指定在两个修订版本之间的一个范围 (<command>svn --revision REV1:REV2</command>)。Subversion可以让你通过号码、关键字和日期访问。</para>
     <sect2 id="svn-ch-3-sect-3.1">
-      <title>Revision Numbers</title>
+      <title>修订版本号</title>
-      <para>When you create a new Subversion repository, it begins its
-        life at revision zero and each successive commit increases the
-        revision number by one.  After your commit completes, the
-        Subversion client informs you of the new revision
-        number:</para>
+      <para>当你新建了一个Subversion版本库,从修订版本号0开始,每一次成功的提交加1,当你提交成功,Subversion告诉客户端这个新版本号:</para>
 $ svn commit --message "Corrected number of cheese slices."
@@ -90,35 +54,17 @@
 Committed revision 3.
-      <para>If at any point in the future you want to refer to that
-        revision (we'll see how and why we might want to do that later
-        in this chapter), you can refer to it as
-        <quote>3</quote>.</para>
+      <para>如果你想在未来使用这个版本(我们将在此章的后面讲述我们这样做的方式和原因),你可以通过号码<quote>3</quote>。</para>
     <sect2 id="svn-ch-3-sect-3.2">
-      <title>Revision Keywords</title>
+      <title>修订版本关键字</title>
-      <para>The Subversion client understands a number of
-        <firstterm>revision keywords</firstterm>.  These keywords
-        can be used instead of integer arguments to the
-        <option>--revision</option> switch, and are resolved into
-        specific revision numbers by Subversion:</para>
+      <para>Subversion客户端可以理解一些<firstterm>修订版本关键字</firstterm>,这些关键字可以用来代替<option>--revision</option>的数字参数,这会被Subversion解释到特定版本:</para>
-        <para>Each directory in your working copy contains an
-          administrative subdirectory called
-          <filename>.svn</filename>.  For every file in a directory,
-          Subversion keeps a copy of each file in the administrative
-          area.  This copy is an unmodified (no keyword expansion, no
-          end-of-line translation, no nothing) copy of the file as it
-          existed in the last revision (called the <quote>BASE</quote>
-          revision) that you updated it to in your working copy.  We
-          refer to this file as the <firstterm>pristine
-          copy</firstterm> or <firstterm>text-base</firstterm> version
-          of your file, and it's always an exact byte-for-byte copy of
-          the file as it exists in the repository.</para> 
+        <para>工作拷贝中的每一个目录都有一个叫作<filename>.svn</filename>的管理目录,目录中的每一个文件,Subversion在管理区域为它保留了一个备份,这是上一个版本(叫做<quote>BASE</quote>版本)没有修改的(没有关键字扩展,没有行结束翻译,没有任何其他区别)拷贝,我们使用<firstterm>纯文件</firstterm>或者叫做<firstterm>文本方式</firstterm>保存这个文件,而且它是与版本库中的文件完全一样。</para> 
@@ -126,46 +72,38 @@
-            <para>The latest revision in the repository.</para>
+            <para>版本库中最新的版本。</para>
-            <para>The <quote>pristine</quote> revision of an item in a
-              working copy.</para>
+            <para>工作拷贝中的<quote>未修改</quote>版本。</para>
-            <para>The last revision in which an item changed before (or
-              at) <literal>BASE</literal>.</para>
+            <para><literal>BASE</literal>版本基础上修改过的版本。</para>
-            <para>The revision just <emphasis>before</emphasis> the last
-              revision in which an item changed.  (Technically,
-              <literal>COMMITTED</literal> - 1.)</para>
+            <para>修改过版本<emphasis>之前</emphasis>的那个版本(技术上为COMMITTED -1)。</para>
-        <para><literal>PREV</literal>, <literal>BASE</literal>, and
-          <literal>COMMITTED</literal> can be used to refer to local
-          paths, but not to URLs.</para>
+        <para><literal>PREV</literal>、<literal>BASE</literal>、和<literal>COMMITTED</literal>是用来表示本地路径而不是URL。</para>
-      <para>Here are some examples of revision keywords in action.
-        Don't worry if the commands don't make sense yet; we'll be
-        explaining these commands as we go through the chapter:</para>
+      <para>下面是一些关键字使用的例子,不要担心现在没有意义,我们将在本章的后面解释这些命令:</para>
 $ svn diff --revision PREV:COMMITTED foo.c
@@ -190,25 +128,16 @@
 # (foo.c's working revision is decreased.)
-      <para>These keywords allow you to perform many common (and
-        helpful) operations without having to look up specific
-        revision numbers or remember the exact revision of your
-        working copy.</para>
+      <para>这些关键字允许你执行许多常用(而且有用)的操作,而不必去查询特定的修订版本号,或者记住本地拷贝的修订版本号。</para>
     <sect2 id="svn-ch-3-sect-3.3">
-      <title>Revision Dates</title>
+      <title>修订版本日期</title>
+      <para>在任何你使用特定版本号和版本关键字的地方,你也可以在<quote>{}</quote>中使用日期,你也可通过日期或者版本号一起使用访问一段时间的修改!</para>
-      <para>Anywhere that you specify a revision number or revision
-        keyword, you can also specify a date
-        inside curly braces <quote>{}</quote>.  You can even access
-        a range of changes in the repository using both dates and
-        revisions together!</para>
-      <para>Here are examples of the date formats that Subversion
-        accepts.  Remember to use quotes around any date that contains
-        spaces.</para>
+      <para>如下是一些Subversion能够接受的日期格式,注意在日期中有空格时需要使用引号。</para>
 $ svn checkout --revision {2002-02-17}
@@ -225,9 +154,7 @@
-      <para>When you specify a date as a revision, Subversion finds
-        the most recent revision of the repository as of that
-        date:</para>
+      <para>当你指定一个日期,Subversion会在版本库找到接近这个日期的最新版本:</para>
 $ svn log --revision {2002-11-28}
@@ -237,50 +164,29 @@
-        <title>Is Subversion a Day Early?</title>
+        <title>Subversion会早一天吗?Is Subversion a Day Early?</title>
-        <para>If you specify a single date as a revision without
-          specifying a time of day (for example
-          <literal>2002-11-27</literal>), you may think that Subversion
-          should give you the last revision that took place on the
-          27th of November.  Instead, you'll get back a revision from
-          the 26th, or even earlier.  Remember that Subversion will
-          find the <emphasis>most recent revision of the
-          repository</emphasis> as of the date you give.  If you give
-          a date without a timestamp, like
-          <literal>2002-11-27</literal>, Subversion assumes a time of
-          00:00:00, so looking for the most recent revision won't
-          return anything on the day of the 27th.</para>
-        <para>If you want to include the 27th in your search, you can
-          either specify the 27th with the time (<literal>{"2002-11-27
-          23:59"}</literal>), or just specify the next day
-          (<literal>{2002-11-28}</literal>).</para>
+        <para>如果你只是指定了日期而没有时间(举个例子<literal>2002-11-27</literal>),你也许会以为Subversion会给你11-27号最后的版本,相反,你会得到一个26号版本,甚至更早。记住Subversion会根据你的日期找到<emphasis>最新的</emphasis>版本,如果你给一个日期,而没有给时间,像<literal>2002-11-27</literal>,Subversion会假定时间是00:00:00,所以在27号找不到任何版本。</para>
+        <para>如果你希望查询包括27号,你既可以使用(<literal>{"2002-11-27
+          23:59"}</literal>),或是直接使用(<literal>{2002-11-28}</literal>)。</para>
-      <para>You can also use a range of dates.  Subversion will find
-        all revisions between both dates, inclusive:</para>
+      <para>你可以使用个时间段,Subversion会找到这段时间的所有版本,包括:</para>
 $ svn log --revision {2002-11-20}:{2002-11-29}
-      <para>As we pointed out, you can also mix dates and revisions:</para>
+      <para>我们也曾经指出,你可以混合日期和修订版本号:</para>
 $ svn log --revision {2002-11-20}:4040
-      <para>Users should be aware of a subtlety that can become quite
-        a stumbling-block when dealing with dates in Subversion.  Since
-        the timestamp of a revision is stored as a property of the
-        revision—an unversioned, modifiable
-        property—revision timestamps can be changed to represent
-        complete falsifications of true chronology, or even removed
-        altogether.  This will wreak havoc on the internal
-        date-to-revision conversion that Subversion performs.</para>
+      <para>用户一定要认识到这种精巧会成为处理日期的绊脚石,因为一个版本的时间戳是作为一个属性存储的—不是版本化的,而是可以编辑的属性—版本号的时间戳可以被修改来建立一个虚假的年代表,也可以被完全删除。这将大大破坏Subversion的这种时间-版本转化功能的表现。</para>
@@ -290,14 +196,9 @@
   <!-- ======================== SECTION 4 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-3-sect-4">
-    <title>Initial Checkout</title>
+    <title>初始化的Checkout</title>
-    <para>Most of the time, you will start using a Subversion
-      repository by doing a <firstterm>checkout</firstterm> of your
-      project.  Checking out a repository creates a copy of it on your
-      local machine.  This copy contains the <literal>HEAD</literal>
-      (latest revision) of the Subversion repository that you specify
-      on the command line:</para>
+    <para>大多数时候,你从版本库使用<firstterm>checkout</firstterm>取出一个新拷贝开始使用Subversion,这个拷贝包扩版本库中的HEAD(最新的版本):</para>
@@ -312,19 +213,13 @@
-      <title>Repository Layout</title>
+      <title>版本库规划</title>
-      <para>If you're wondering what <literal>trunk</literal> is all
-        about in the above URL, it's part of the way we recommend
-        you lay out your Subversion repository which we'll talk a lot
-        more about in <xref linkend="svn-ch-4"/>.</para>
+      <para>你也许会为在每个URL上包括<literal>trunk</literal>感到好奇,这是我们将在<xref linkend="svn-ch-4"/>详细论述我们推荐的这种规划方式。</para>
-    <para>Although the above example checks out the trunk directory,
-      you can just as easily check out any deep subdirectory of a
-      repository by specifying the subdirectory in the checkout
-      URL:</para>
+    <para>尽管上面的例子取出了trunk目录,你可以通过输入URL取出任意深度的子目录:</para>
 $ svn checkout http://svn.collab.net/repos/svn/trunk/doc/book/tools
@@ -337,48 +232,25 @@
 Checked out revision 2499.
-    <para>Since Subversion uses a <quote>copy-modify-merge</quote>
-      model instead of <quote>lock-modify-unlock</quote> (see <xref
-      linkend="svn-ch-2"/>), you're already able to start making
-      changes to the files and directories in your working copy.  Your
-      working copy is just like any other collection of files and
-      directories on your system.  You can edit and change them, move
-      them around, you can even delete the entire working copy and
-      forget about it.</para>
+    <para>因为Subversion使用<quote>拷贝-修改-合并</quote>模型而不是<quote>锁定-修改-解锁</quote>模型(见<xref
+      linkend="svn-ch-2"/>),你可以开始修改工作拷贝中的目录和文件,你的工作拷贝和你的系统中的其他文件和目录完全一样,你可以编辑并改变他们,移动他们,你可以完全的删掉它把它忘了。</para>
-        <para>While your working copy is <quote>just like any other
-          collection of files and directories on your system</quote>,
-          you need to let Subversion know if you're going to be
-          rearranging anything inside of your working copy.  If you
-          want to copy or move an item in a working copy, you should
-          use <command>svn copy</command> or <command>svn
-          move</command> instead of the copy and move commands
-          provided by your operating system.  We'll talk more about
-          them later in this chapter.</para>
+        <para>因为你的工作拷贝<quote>同你的系统上的文件和目录没有什么区别</quote>,如果你希望重新规划工作拷贝,你必须要让如果你希望拷贝或者移动一个项目到工作拷贝,你应该使用<command>svn copy</command>或者 <command>svn
+          move</command>而不要使用操作系统的命令,我们会在以后的章节详细介绍。</para>
-    <para>Unless you're ready to commit a new file or directory, or
-      changes to existing ones, there's no need to further notify the
-      Subversion server that you've done anything.</para>
+    <para> 除非你准备好了提交一个新文件或目录,或改变了已存在的,没有必要通知Subversion你做了什么。</para>
-      <title>What's with the <filename>.svn</filename> directory?</title>
+      <title><filename>.svn</filename>目录包含什么?</title>
-      <para>Every directory in a working copy contains an
-        administrative area, a subdirectory named
-        <filename>.svn</filename>.  Usually, directory listing
-        commands won't show this subdirectory, but it is nevertheless
-        an important directory.  Whatever you do, don't delete or
-        change anything in the administrative area!  Subversion
-        depends on it to manage your working copy.</para>
+      <para>
+   任何一个在工作拷贝中的目录包括一个一个管理区域名为<filename>.svn</filename>,通常列表操作不显示这个目录,但它仍然是一个非常重要的目录,无论你做什么?不要删除或是更改这个区域的任何东西,Subversion使用它来管理工作拷贝。</para>
-    <para>While you can certainly check out a working copy with the
-      URL of the repository as the only argument, you can also specify
-      a directory after your repository URL.  This places your working
-      copy in the new directory that you name.  For example:</para>
+    <para>因为你可以使用版本库的URL作为唯一参数参数取出一个工作拷贝,你也可以在版本库URL之后指定一个目录,这样会将你的工作目录放到你的新目录,举个例子:</para>
 $ svn checkout http://svn.collab.net/repos/svn/trunk subv
@@ -391,9 +263,7 @@
 Checked out revision 2499.
-    <para>That will place your working copy in a directory named
-      <literal>subv</literal> instead of a directory named
-      <literal>trunk</literal> as we did previously.</para>
+    <para>这样将把你的工作拷贝放到<literal>subv</literal>而不是和前面那样放到<literal>trunk</literal>。</para>
@@ -401,18 +271,15 @@
   <!-- ======================== SECTION 5 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-3-sect-5">
-    <title>Basic Work Cycle</title>
+    <title>基本的工作周期</title>
-    <para>Subversion has numerous features, options, bells and whistles, but on
-      a day-to-day basis, odds are that you will only use a few of them. In
-      this section we'll run through the most common things that you might
-      find yourself doing with Subversion in the course of a day's work.</para>
+    <para>Subversion有许多特性、选项、铃声和口哨,但日常的工作中你只使用其中的一小部分,特殊情况下会用他们中的少数,在这一节里,我们会介绍许多你在日常工作中常见的命令。</para>
-    <para>The typical work cycle looks like this:</para>
+    <para>典型的工作周期是这样的:</para>
-        <para>Update your working copy</para>
+        <para>更新你的工作拷贝</para>
             <para><command>svn update</command></para>
@@ -422,7 +289,7 @@
-        <para>Make changes</para>
+        <para>做出修改</para>
             <para><command>svn add</command></para>
@@ -440,7 +307,7 @@
-        <para>Examine your changes</para>
+        <para>检验修改</para>
             <para><command>svn status</command></para>
@@ -455,7 +322,7 @@
-        <para>Merge others' changes into your working copy</para>
+        <para>合并别人的修改到工作拷贝</para>
             <para><command>svn update</command></para>
@@ -467,7 +334,7 @@
-        <para>Commit your changes</para>
+        <para>提交你的修改</para>
             <para><command>svn commit</command></para>
@@ -477,13 +344,10 @@
     <sect2 id="svn-ch-3-sect-5.1">
-      <title>Update Your Working Copy</title>
+      <title>更新你的工作拷贝</title>
-      <para>When working on a project with a team, you'll want to
-        update your working copy to receive any changes made since
-        your last update by other developers on the project.  Use
-        <command>svn update</command> to bring your working copy into
-        sync with the latest revision in the repository.</para>
+      <para>
+      当你在一个团队的项目里工作时,你希望更新你的工作拷贝得到所有其他人这段时间作出的修改,使用<command>svn update</command>让你的工作拷贝与最新的版本同步。</para>
 $ svn update
@@ -492,80 +356,51 @@
 Updated to revision 2.
-      <para>In this case, someone else checked in modifications to
-        both <filename>foo.c</filename> and <filename>bar.c</filename>
-        since the last time you updated, and Subversion has updated
-        your working copy to include those changes.</para>
-      <para>Let's examine the output of <command>svn update</command>
-        a bit more.  When the server sends changes to your working
-        copy, a letter code is displayed next to each item to let you
-        know what actions Subversion performed to bring your working
-        copy up-to-date:</para>
+      <para>这种情况下,其他人在你上次更新之后提交了对<filename>foo.c</filename>和<filename>bar.c</filename>的修改,因此Subversion更新你的工作拷贝来引入这些更改。</para>
+      <para>让我们认真检查<command>svn update</command>的输出,当服务器发送修改到你的工作拷贝,一个字母显示在每一个项目之前,来让你知道Subversion对你的工作拷贝做了什么操作:</para>
           <term><computeroutput>U      foo</computeroutput></term>
-            <para>File <filename>foo</filename> was
-              <computeroutput>U</computeroutput>pdated (received changes
-              from the server).</para>
+            <para>文件<filename>foo</filename>更新了(从服务器收到修改)。</para>
           <term><computeroutput>A      foo</computeroutput></term>
-            <para>File or directory <filename>foo</filename> was
-              <computeroutput>A</computeroutput>dded to your working
-              copy.</para>
+            <para>文件或目录<filename>foo</filename>被添加到工作拷贝。</para>
           <term><computeroutput>D      foo</computeroutput></term>
-            <para>File or directory <filename>foo</filename> was
-              <computeroutput>D</computeroutput>eleted from your working
-              copy.</para>
+            <para>文件或目录<filename>foo</filename>在工作拷贝被删除了。</para>
           <term><computeroutput>R      foo</computeroutput></term>
-            <para>File or directory <filename>foo</filename> was
-              <computeroutput>R</computeroutput>eplaced in your working
-              copy; that is, <filename>foo</filename> was deleted, and a
-              new item with the same name was added.  While they may have
-              the same name, the repository considers them to be distinct
-              objects with distinct histories.</para>
+            <para>文件或目录<filename>foo</filename>在工作拷贝已经被替换了,这是说,<filename>foo</filename>被删除,而一个新的同样名字的项目添加进来,他们具有同样的名字,但是版本库会把他们看作具备不同历史的不同对象。</para>
           <term><computeroutput>G      foo</computeroutput></term>
-            <para>File <filename>foo</filename> received new changes
-              from the repository, but your local copy of the file had
-              your modifications.  Either the changes did not intersect,
-              or the changes were exactly the same as your local
-              modifications, so Subversion has successfully
-              mer<computeroutput>G</computeroutput>ed the repository's
-              changes into the file without a problem.</para>
+            <para>文件<filename>foo</filename>接收到版本库的更改,你的本地版本也已经修改,但改变没有互相影响,Subversion成功的将版本库和本地文件合并,没有发生任何问题。</para>
           <term><computeroutput>C      foo</computeroutput></term>
-            <para>File <filename>foo</filename> received
-              <computeroutput>C</computeroutput>onflicting changes from
-              the server.  The changes from the server directly overlap
-              your own changes to the file.  No need to panic, though.
-              This overlap needs to be resolved by a human (you); we
-              discuss this situation later in this chapter.</para>
+            <para>文件<filename>foo</filename>的修改与服务器冲突,服务器的修改与你的修改交迭在一起,不要恐慌,这种冲突需要人(你)来解决,我们在后面的章节讨论这种情况。</para>
@@ -574,82 +409,43 @@
     <sect2 id="svn-ch-3-sect-5.2">
-      <title>Make Changes to Your Working Copy</title>
+      <title>修改你的工作拷贝上作</title>
-      <para>Now you can get to work and make changes in your
-        working copy. It's usually most convenient to decide on a
-        particular change (or set of changes) to make, such as writing
-        a new feature, fixing a bug, etc.  The Subversion commands
-        that you will use here are <command>svn add</command>,
-        <command>svn delete</command>, <command>svn copy</command>,
-        and <command>svn move</command>.  However, if you are merely
-        editing files that are already in Subversion, you may not need
-        to use any of these commands until you commit.  Changes you can
-        make to your working copy:</para>
+      <para>现在你可以开始工作,在你的工作拷贝进行工作,你很容易决定作出一个修改(或者是一组),像写一个新的特性,修正一个错误等等。这时可以使用的Subversion命令包括<command>svn add</command>、
+        <command>svn delete</command>、<command>svn copy</command>、和<command>svn move</command>。如果你只是修改版本库中已经存在的一个文件,在你提交之前,不必使用上面的任何一个命令。你可以对工作备份作的修改包括:</para>
-          <term>File changes</term>
+          <term>文件修改</term>
-            <para>This is the simplest sort of change.  You don't need
-              to tell Subversion that you intend to change a file;
-              just make your changes.  Subversion will be able to
-              automatically detect which files have been
-              changed.</para>
+            <para>这是最简单的一种修改,你不必告诉Subversion你想修改一个文件,只需要去修改,然后Subversion会自动地探测到那些文件已经更改了。</para>
-          <term>Tree changes</term>
+          <term>目录树改变</term>
-            <para>You can ask Subversion to <quote>mark</quote> files
-              and directories for scheduled removal, addition,
-              copying, or moving.  While these changes may take place
-              immediately in your working copy, no additions or
-              removals will happen in the repository until you commit
-              them.</para>
+            <para>你可以<quote>标记</quote>目录或者文件为预定要删除、增加、复制或者移动,也许这些改动在你的工作拷贝马上发生,而版本库只在你提交的时候才发生改变。</para>
-      <para>To make file changes, use your text editor, word
-        processor, graphics program, or whatever tool you would
-        normally use.  Subversion handles binary files just as easily
-        as it handles text files—and just as efficiently
-        too.</para>
-      <para>Here is an overview of the four Subversion subcommands
-        that you'll use most often to make tree changes (we'll cover
-        <command>svn import</command> and <command>svn mkdir</command>
-        later).</para>
+      <para>修改文件,可以使用文本编辑器、字处理软件、图形程序或任何你常用的工具,Subverion处理二进制文件像同文本文件一样—效率也一样。</para>
+      <para>这些是常用的可以修改目录树结构的子命令(我们会在后面包括<command>svn import</command>和<command>svn mkdir</command>)。</para>
-        <para>While you can edit your files with whatever tool you
-          like, you shouldn't change the structure of your working
-          copy without letting Subversion know what you're doing.  Use
-          the <command>svn copy</command>, <command>svn
-          delete</command>, and <command>svn move</command> commands
-          to change the structure of your working copy, and use the
-          <command>svn add</command> command to place new files and
-          directories under version control.</para> </warning>
+        <para>你可以使用任何你喜欢的工具编辑文件,但你不可以在修改目录结构时不通知Subversion,需要使用<command>svn copy</command>、<command>svn
+          delete</command>和<command>svn move</command>命令修改工作拷贝的结构,使用<command>svn add</command>增加版本控制的新文件或目录。</para> </warning>
           <term><command>svn add foo</command></term>
-            <para>Schedule file, directory, or symbolic link
-              <filename>foo</filename> to be added to the repository.
-              When you next commit, <filename>foo</filename> will
-              become a child of its parent directory.  Note that if
-              <filename>foo</filename> is a directory, everything
-              underneath <filename>foo</filename> will be scheduled
-              for addition.  If you only want to add
-              <filename>foo</filename> itself, pass the
-              <option>--non-recursive</option> (<option>-N</option>)
-              switch.</para>
+            <para>预定将文件、目录或者符号链<filename>foo</filename>添加到版本库,当你下次提交后,<filename>foo</filename>会成为其父目录的一个子对象。注意,如果<filename>foo</filename>是目录,所有foo中的内容也会预定添加进去,如果你只想添加<filename>foo</filename>本身,使用<option>--non-recursive</option>(<option>-N</option>)参数。</para>
@@ -657,54 +453,28 @@
           <term><command>svn delete foo</command></term>
-            <para>Schedule file, directory, or symbolic link
-              <filename>foo</filename> to be deleted from the
-              repository.  If <filename>foo</filename> is a file or
-              link, it is immediately deleted from your working copy.
-              If <filename>foo</filename> is a directory, it is not
-              deleted, but Subversion schedules it for deletion.  When
-              you commit your changes, <filename>foo</filename> will
-              be removed from your working copy and the repository.
-              <footnote><para>Of course, nothing is ever totally
-              deleted from the repository—just from the
-              <literal>HEAD</literal> of the repository.  You can get
-              back anything you delete by checking out (or updating
-              your working copy) a revision earlier than the one in
-              which you deleted it.</para></footnote></para>
+            <para>预定将文件、目录或者符号链<filename>foo</filename>从版本库中删除掉,如果foo是文件,它马上从工作拷贝中删除,如果是目录,不会被删除,但是Subversion准备好删除了,当你提交你的修改,<filename>foo</filename>就会在你的工作拷贝和版本库中被删除。<footnote><para>当然没有任何东西是在版本库里被删除了—只是在版本库的<literal>HEAD</literal>里消失了,你可以通过检出(或者更新你的工作拷贝)你做出删除操作的前一个修订版本来找回所有的东西。</para></footnote></para>
           <term><command>svn copy foo bar</command></term>
-            <para>Create a new item <filename>bar</filename> as a
-              duplicate of <filename>foo</filename>.
-              <filename>bar</filename> is automatically scheduled for
-              addition.  When <filename>bar</filename> is added to the
-              repository on the next commit, its copy history is
-              recorded (as having originally come from
-              <filename>foo</filename>).  <command>svn copy</command>
-              does not create intermediate directories.</para>
+            <para>建立一个新的项目<filename>bar</filename>作为<filename>foo</filename>的复制品,,当在下次提交时会将<filename>bar</filename>添加到版本库,这种拷贝历史会记录下来(按照来自<filename>foo</filename>的方式记录),<command>svn copy</command>并不建立中介目录。</para>
           <term><command>svn move foo bar</command></term>
-            <para>This command is exactly the same as running
-              <command>svn copy foo bar; svn delete foo</command>.
-              That is, <filename>bar</filename> is scheduled for
-              addition as a copy of <filename>foo</filename>, and
-              <filename>foo</filename> is scheduled for removal.
-              <command>svn move</command> does not create intermediate
-              directories.</para>
+            <para>这个命令与与运行<command>svn copy foo bar; svn delete foo</command>完全相同,<filename>bar</filename>作为<filename>foo</filename>的拷贝准备添加,<filename>foo</filename>已经预定要被删除,<command>svn move</command>不建立中介的目录。</para>
-        <title>Changing the Repository Without a Working Copy</title>
+        <title>不通过工作拷贝修改版本库</title>
         <!-- ### pll - Fri 07 Feb 2003 12:55:07                            -->
         <!-- I find this sidebar rather confusing here, since you really   -->
@@ -715,47 +485,22 @@
         <!-- probably be in chapter 2 (around the "Subversion in action"   -->
         <!-- though, so that this sidebar makes more sense.                -->
-        <para>Earlier in this chapter, we said that you have to commit
-          any changes that you make in order for the repository to
-          reflect these changes. That's not entirely true—there
-          <emphasis>are</emphasis> some use cases that immediately
-          commit tree changes to the repository.  This only happens
-          when a subcommand is operating directly on a URL, rather
-          than on a working-copy path. In particular, specific uses
-          of <command>svn mkdir</command>, <command>svn
-          copy</command>, <command>svn move</command>, and
-          <command>svn delete</command> can work with URLs.</para>
-        <para>URL operations behave in this manner because commands
-          that operate on a working copy can use the working copy as a
-          sort of <quote>staging area</quote> to set up your changes
-          before committing them to the repository.  Commands that
-          operate on URLs don't have this luxury, so when you operate
-          directly on a URL, any of the above actions represent an
-          immediate commit.</para>
+        <para>本章的前面曾经说过,为了使版本库反映你的改动,你应该提交所有改动。这并不完全正确—有一些方式<emphasis>是</emphasis>可以直接操作版本库的,当然只有子命令直接操作URL而不是本地拷贝路径时才可以实现,通常<command>svn mkdir</command>、<command>svn
+          copy</command>、<command>svn move</command>、和
+          <command>svn delete</command>可以使用URL工作。</para>
+        <para>URL操作的运作方式是因为在中使用工作拷贝的运作方式时,工作拷贝成为一个<quote>集结地</quote>,可以在提交之前整理组织,直接对URL操作就没有这种奢侈,所以当你直接操作URL的时候,所有以上的动作代表一个立即的提交。</para>
     <sect2 id="svn-ch-3-sect-5.3">
-      <title>Examine Your Changes</title>
+      <title>检查你的变化</title>
-      <para>Once you've finished making changes, you need to commit
-        them to the repository, but before you do so, it's usually a
-        good idea to take a look at exactly what you've changed.  By
-        examining your changes before you commit, you can make a
-        more accurate log message. You may also discover that
-        you've inadvertently changed a file, and this gives you a
-        chance to revert those changes before committing.
-        Additionally, this is a good opportunity to review and
-        scrutinize changes before publishing them.  You can see
-        exactly what changes you've made by using <command>svn
-        status</command>, <command>svn diff</command>, and
-        <command>svn revert</command>.  You will usually use the first
-        two commands to find out what files have changed in your
-        working copy, and then perhaps the third to revert some (or
-        all) of those changes.</para>
+      <para>当你完成修改,你需要提交他们到版本库,但是在此之前,检查一下做过什么修改是个好主意,通过提交前的检查,你可以做一个精确的log信息,你也可以发现你不小心修改的文件。此外,这是一个审查和仔细察看修改的好机会,你可通过命令<command>svn
+        status</command>、<command>svn diff</command>、and
+        <command>svn revert</command>精确地察看所做的修改。你可以使用前两个命令察看工作拷贝中的修改,使用第3个来撤销一些(或所有)的修改。</para>
       <!-- pll - Fri 07 Feb 2003 12:55:07                                   -->
       <!-- I find this following paragraph a little unclear.  Mostly for    -->
@@ -764,48 +509,24 @@
       <!-- therefore, nothing has been clearly stated wrt the fact that the -->
       <!-- repository may not be local.                                     -->
-      <para>Subversion has been optimized to help you with this task,
-        and is able to do many things without communicating with the
-        repository.  In particular, your working copy contains a
-        secret cached <quote>pristine</quote> copy of each version
-        controlled file within the <filename>.svn</filename> area.
-        Because of this, Subversion can quickly show you how your
-        working files have changed, or even allow you to undo your
-        changes without contacting the repository.</para>
+      <para>Subversion已经被优化来帮助你完成这个任务,可以在不与版本库通讯的情况下做许多事情,详细来说,对于每一个文件,你的的工作拷贝在<filename>.svn</filename>包含一个<quote>原始的</quote>拷贝,所以Subversion可以快速的告诉你那些文件修改了,甚至允许你在不与版本库通讯的情况下恢复修改。</para>
       <sect3 id="svn-ch-3-sect-5.3.1">
         <title><command>svn status</command></title>
-        <para>You'll probably use the <command>svn status</command>
-          command more than any other Subversion command.</para>
+        <para>相对于其他命令,你会更多地使用这个<command>svn status</command>命令。</para>
-          <title>CVS Users: Hold That Update!</title>
+          <title>CVS用户:保持更新! CVS Users: Hold That Update!</title>
-          <para>You're probably used to using <command>cvs
-            update</command> to see what changes you've made to your
-            working copy.  <command>svn status</command> will give you
-            all the information you need regarding what has changed in
-            your working copy—without accessing the repository
-            or potentially incorporating new changes published by
-            other users.</para>
-          <para>In Subversion, <command>update</command> does just
-            that—it updates your working copy with any changes
-            committed to the repository since the last time you've
-            updated your working copy.  You'll have to break the habit
-            of using the <command>update</command> command to see what
-            local modifications you've made.</para>
+          <para>你也许使用<command>cvs update</command>来看你做了哪些修改,<command>svn status</command>会给你所有你做的改变—而不需要访问版本库或在不知情的情况下与其他用户作的更改比较。</para>
+          <para>在Subversion,<command>update</command>只是做这件事—将工作拷贝更新到版本库的最新版本,你可以消除使用<command>update</command>察看本地修改的习惯。</para>
-        <para>If you run <command>svn status</command> at the top of
-          your working copy with no arguments, it will detect all file
-          and tree changes you've made.  Below are examples of
-          the different status codes that <command>svn
-          status</command> can return.  (Note that the text following
-          <literal>#</literal> is not
-          actually printed by <command>svn status</command>.)</para>
+        <para>如果你在工作拷贝的顶级目录运行不带参数的<command>svn status</command>命令,它会检测你做的所有的文件或目录的修改,以下的例子是来展示<command>svn
+          status</command>可能返回的状态码(注意,<literal>#</literal>之后的不是<command>svn status</command>打印的)。</para>
   L    abc.c               # svn has a lock in its .svn directory for abc.c
@@ -825,11 +546,7 @@
     S  stuff/squawk        # this file or dir has been switched to a branch
-        <para>In this output format <command>svn status</command>
-          prints five columns of characters, followed by several
-          whitespace characters, followed by a file or directory name.
-          The first column tells the status of a file or directory
-          and/or its contents.  The codes printed here are:</para>
+        <para>在这种格式下,<command>svn status</command>打印五列字符,紧跟一些空格,接着是文件或者目录名。第一列告诉一个文件的状态或它的内容,返回代码解释如下:</para>
@@ -837,76 +554,51 @@
             <term><computeroutput>A      item</computeroutput></term>
-              <para>The file, directory, or symbolic link
-                <filename>item</filename> has been scheduled for
-                addition into the repository.</para>
+              <para>文件、目录或是符号链<filename>item</filename>预定加入到版本库。</para>
             <term><computeroutput>C      item</computeroutput></term>
-              <para>The file <filename>item</filename> is in a state
-                of conflict.  That is, changes received from the
-                server during an update overlap with local changes
-                that you have in your working copy.  You must resolve
-                this conflict before committing your changes to the
-                repository.</para>
+              <para>文件<filename>item</filename>发生冲突,在从服务器更新时与本地版本交迭时发生,在提交到版本库前,必须手工的解决冲突。</para>
             <term><computeroutput>D      item</computeroutput></term>
-              <para>The file, directory, or symbolic link
-                <filename>item</filename> has been scheduled for
-                deletion from the repository.</para>
+              <para>文件、目录或是符号链<filename>item</filename>预定从版本库中删除。</para>
             <term><computeroutput>M      item</computeroutput></term>
-              <para>The contents of the file <filename>item</filename>
-                have been modified.</para>
+              <para>文件<filename>item</filename>的内容被修改了。</para>
             <term><computeroutput>R      item</computeroutput></term>
-              <para>The file, directory, or symbolic link
-                <filename>item</filename> has been scheduled to
-                replace <filename>item</filename> in the repository.
-                This means that the object is first deleted, then
-                another object of the same name is added, all within a
-                single revision.</para>
+              <para>文件、目录或是符号链<filename>item</filename>预定将要替换版本库中的<filename>item</filename>,这意味着这个对象首先要被删除,另外一个同名的对象将要被添加,所有的操作发生在一个修订版本。</para>
             <term><computeroutput>X      item</computeroutput></term>
-              <para>The directory <filename>item</filename> is
-                unversioned, but is related to a Subversion externals
-                definition.  To find out more about externals
-                definitions, see <xref
-                linkend="svn-ch-7-sect-3"/>.</para>
+              <para>目录没有版本化,但是与Subversion的外部定义关联,关于外部定义,可以看<xref
+                linkend="svn-ch-7-sect-3"/>。</para>
             <term><computeroutput>?      item</computeroutput></term>
-              <para>The file, directory, or symbolic link
-                <filename>item</filename> is not under version
-                control.  You can silence the question marks by either
-                passing the <option>--quiet</option>
-                (<option>-q</option>) switch to <command>svn
-                status</command>, or by setting the
-                <literal>svn:ignore</literal> property on the parent
-                directory.  For more information on ignored files, see
-                <xref linkend="svn-ch-7-sect-2.3.3" />.</para>
+              <para>文件、目录或是符号链<filename>item</filename>不在版本控制之下,你可以通过使用<command>svn
+                status</command>的<option>--quiet</option>(<option>-q</option>)参数或父目录的<literal>svn:ignore</literal>属性忽略这个问题,关于忽略文件的使用,见<xref linkend="svn-ch-7-sect-2.3.3" />。</para>
@@ -914,112 +606,49 @@
             <term><computeroutput>!      item</computeroutput></term>
-              <para>The file, directory, or symbolic link
-                <filename>item</filename> is under version control but
-                is missing or somehow incomplete.  The item can be
-                missing if it's removed using a non-Subversion
-                command.  In the case of a directory, it can be
-                incomplete if you happened to interrupt a checkout or
-                update.  A quick <command>svn update</command> will
-                refetch the file or directory from the repository, or
-                <command>svn revert file</command> will restore a
-                missing file.</para>
+              <para>文件、目录或是符号链<filename>item</filename>在版本控制之下,但是已经丢失或者不完整,这可能因为使用非Subversion命令删除造成的,如果是一个目录,有可能是检出或是更新时的中断造成的,使用<command>svn update</command>可以重新从版本库获得文件或者目录,也可以使用<command>svn revert file</command>恢复原来的文件。</para>
             <term><computeroutput>~      item</computeroutput></term>
-              <para>The file, directory, or symbolic link
-                <filename>item</filename> is in the repository as one
-                kind of object, but what's actually in your working
-                copy is some other kind.  For example, Subversion
-                might have a file in the repository, but you removed
-                the file and created a directory in its place, without
-                using the <command>svn delete</command> or
-                <command>svn add</command> command.</para>
+              <para>文件、目录或是符号链<filename>item</filename>在版本库已经存在,但你的工作拷贝中的是另一个。举一个例子,你删除了一个版本库的文件,新建了一个在原来的位置,而且没有使用<command>svn delete</command>或是<command>svn add</command>。</para>
             <term><computeroutput>I      item</computeroutput></term>
-              <para>The file, directory, or symbolic link
-                <filename>item</filename> is not under version control,
-                and Subversion is configured to ignore it during
-                <command>svn add</command>, <command>svn import</command>
-                and <command>svn status</command> operations.  For more
-                information on ignored files, see <xref
-                linkend="svn-ch-7-sect-2.3.3"/>.  Note that this
-                symbol only shows up if you pass the
-                <option>--no-ignore</option> option to <command>svn
-                status</command>—otherwise the file would be
-                ignored and not listed at all!</para>
+              <para>文件、目录或是符号链<filename>item</filename>不在版本控制下,Subversion已经配置好了会在<command>svn add</command>、<command>svn import</command>和<command>svn status</command>命令忽略这个文件,关于忽略文件,见<xref
+                linkend="svn-ch-7-sect-2.3.3"/>。注意,这个符号只会在使用<command>svn
+                status</command>的参数<option>--no-ignore</option>时才会出现—否则这个文件会被忽略且不会显示!</para>
-        <para>The second column tells the status of a file or
-          directory's properties (see <xref
-          linkend="svn-ch-7-sect-2"/> for more information on
-          properties).  If an <computeroutput>M</computeroutput>
-          appears in the second column, then the properties have been
-          modified, otherwise a whitespace will be printed.</para>
-        <para>The third column will only show whitespace or an
-          <computeroutput>L</computeroutput> which means that
-          Subversion has locked the item in
-          the <filename>.svn</filename> working area.  You will see an
-          <computeroutput>L</computeroutput> if you run <command>svn
-          status</command> in a directory where an <command>svn
-          commit</command> is in progress—perhaps when you are
-          editing the log message.  If Subversion is not running, then
-          presumably Subversion was interrupted and the lock needs to
-          be cleaned up by running <command>svn cleanup</command>
-          (more about that later in this chapter).</para>
-        <para>The fourth column will only show whitespace or a
-          <computeroutput>+</computeroutput> which means that the file
-          or directory is scheduled to be added or modified with
-          additional attached history.  This typically happens when you
-          <command>svn move</command> or <command>svn copy</command> a file
-          or directory.  If you see
-          <computeroutput>A  +</computeroutput>, this means
-          the item is scheduled for addition-with-history.  It could be
-          a file, or the root of a copied directory.
-          <computeroutput>+</computeroutput>
-          means the item is part of a subtree scheduled for
-          addition-with-history, i.e. some parent got copied, and it's
-          just coming along for the ride.
-          <computeroutput>M  +</computeroutput> means the item
-          is part of a subtree scheduled for addition-with-history,
-          <emphasis>and</emphasis> it has local modifications.  When you
-          commit, first the parent will be added-with-history (copied),
-          which means this file will automatically exist in the copy.
-          Then the local modifications will be uploaded into the
-          copy.</para>
-        <para>The fifth column will only show whitespace or an
-          <computeroutput>S</computeroutput>.  This signifies that the
-          file or directory has been switched from the path of the
-          rest of the working copy (using <command>svn
-          switch</command>) to a branch.</para>
-        <para>If you pass a specific path to <command>svn
-          status</command>, it gives you information about that item
-          alone:</para>
+        <para>第二列说明文件或目录的属性的状态(更多细节可以看<xref
+          linkend="svn-ch-7-sect-2"/>),如果一个<computeroutput>M</computeroutput>出现在第二列,说明属性被修改了,否则显示空白。</para>
+        <para>第三列只显示空白或者<computeroutput>L</computeroutput>,<computeroutput>L</computeroutput>表示Subversion已经在<filename>.svn</filename>工作区域锁定了这个项目,当你运行<command>svn
+          commit</command>正在运行的时候—也许正在输入log信息,运行<command>svn
+          status</command>你可以看到<computeroutput>L</computeroutput>标记,如果Subversion并没有运行,可以假定Subversion发生中断并且已经锁定,你必须运行<command>svn cleanup</command>来清除锁定(本节后面将有更多论述)。</para>
+        <para>第四列只会显示空白或<computeroutput>+</computeroutput>,<computeroutput>+</computeroutput>的意思是一个有附加历史信息的文件或目录预定添加或者修改到版本库,通常出现在<command>svn move</command>或是<command>svn copy</command>时,如果是看到<computeroutput>A  +</computeroutput>就是说要包含历史的增加,它可以是一个文件或是拷贝的根目录。<computeroutput>+</computeroutput>表示它是即将包含历史增加到版本库的目录的一部分,也就是说他的父目录要拷贝,它只是跟着一起的。 <computeroutput>M  +</computeroutput>表示他将要包含历史的增加,并且已经更改了,首先会随父目录进行包含历史的增加,然后本地的修改提交到更改后的版本。</para>
+        <para>第五列只显示空白或是<computeroutput>S</computeroutput>,表示这个目录或文件已经转到了一个分支下了(使用<command>svn
+          switch</command>)。</para>
+        <para>如果你传递一个路径给<command>svn
+          status</command>,它只给你这个项目的信息:</para>
 $ svn status stuff/fish.c
 D      stuff/fish.c
-        <para><command>svn status</command> also has a
-          <option>--verbose</option> (<option>-v</option>) switch,
-          which will show you the status of <emphasis>every</emphasis>
-          item in your working copy, even if it has not been
-          changed:</para>
+        <para><command>svn status</command>也有一个<option>--verbose</option>(<option>-v</option>)选项,它可以显示工作拷贝中的<emphasis>所有</emphasis>项目,即使没有改变过:</para>
 $ svn status --verbose
@@ -1034,20 +663,10 @@
                 44        36    harry     stuff/things/gloo.c
-        <para>This is the <quote>long form</quote> output of
-          <command>svn status</command>.  The first column remains
-          the same, but the second column shows the working-revision of
-          the item.  The third and fourth columns show the revision in
-          which the item last changed, and who changed it.</para>
-        <para>None of the above invocations to <command>svn
-          status</command> contact the repository, they work only
-          locally by comparing the metadata in the
-          <filename>.svn</filename> directory with the working copy.
-          Finally, there is the <option>--show-updates</option>
-          (<option>-u</option>) switch, which contacts the repository
-          and adds information about things that are
-          out-of-date:</para>
+        <para>这是<command>svn status</command>的<quote>加长形式</quote>,第一列保持相同,第二项显示一个工作版本号,第三和第四列显示最后一次修改的版本号和修改人。</para>
+        <para>上面所有的<command>svn
+          status</command>调用并没有联系版本库,只是与<filename>.svn</filename>中的元数据进行比较的结果,最后,是<option>--show-updates</option>(<option>-u</option>)参数,它将会联系版本库为已经过时的数据添加新信息:</para>
 $ svn status --show-updates --verbose
@@ -1059,36 +678,17 @@
 Status against revision:   46
-        <para>Notice the two asterisks: if you were to run
-          <command>svn update</command> at this point, you would
-          receive changes to <filename>README</filename>
-          and <filename>trout.c</filename>.  This tells you some very
-          useful information—you'll need to update and get the
-          server changes on <filename>README</filename> before you
-          commit, or the repository will reject your commit for being
-          out-of-date.  (More on this subject later.)</para>
+        <para>注意这两个星号:如果你现在执行<command>svn update</command>,你的<filename>README</filename>和<filename>trout.c</filename>会被更新,这告诉你许多有用的信息—你可以在提交之前,你需要使用更新操作得到文件<filename>README</filename>的更新,或者说文件已经过时,版本库拒绝了你的提交。(后面还有更多关于此主题)。</para>
       <sect3 id="svn-ch-3-sect-5.3.2">
         <title><command>svn diff</command></title>
-        <para>Another way to examine your changes is with the
-          <command>svn diff</command> command.  You can find out
-          <emphasis>exactly</emphasis> how you've modified things by
-          running <command>svn diff</command> with no arguments, which
-          prints out file changes in unified diff
-          format:<footnote><para>Subversion uses its internal diff
-          engine, which produces unified diff format, by default.  If
-          you want diff output in a different format, specify an
-          external diff program using <option>--diff-cmd</option> and
-          pass any flags you'd like to it using the
-          <option>--extensions</option> switch.  For example, to see
-          local differences in file <filename>foo.c</filename> in
-          context output format while ignoring whitespace changes, you
-          might run <command>svn diff --diff-cmd /usr/bin/diff
-          --extensions '-bc' foo.c</command>.</para>
-          </footnote></para>
+        <para>另一种检查修改的方式是<command>svn diff</command>命令,你可以通过不带参数的<command>svn diff</command><emphasis>精确的</emphasis>找出你所做的修改,这会输出统一区别格式:<footnote><para>Subversion使用内置区别引擎,缺省情况下产生统一区别格式。如果你期望不通的输出格式,你可以使用<option>--diff-cmd</option>指定外置的区别程序,并且通过<option>--extensions</option>传递其他参数,举个例子,察看本地文件<filename>foo.c</filename>的区别,同时忽略空格修改,你可以运行<command>svn diff --diff-cmd /usr/bin/diff
+          --extensions '-bc' foo.c</command>。</para>
+          </footnote>
+        </para>
 $ svn diff
@@ -1131,55 +731,33 @@
 +things about bloo.
-        <para>The <command>svn diff</command> command produces this
-          output by comparing your working files against the cached
-          <quote>pristine</quote> copies within the
-          <filename>.svn</filename> area.  Files scheduled for
-          addition are displayed as all added-text, and files
-          scheduled for deletion are displayed as all deleted
-          text.</para>
-        <para>Output is displayed in <firstterm>unified diff
-          format</firstterm>.  That is, removed lines are prefaced
-          with a <literal>-</literal> and added lines are prefaced
-          with a <literal>+</literal>.  <command>svn diff</command>
-          also prints filename and offset information useful to the
-          <command>patch</command> program, so you can generate
-          <quote>patches</quote> by redirecting the diff output to a
-          file:</para>
+        <para><command>svn diff</command>命令通过比较你的文件和<filename>.svn</filename>的<quote>原始</quote>文件来输出信息,预定要增加的文件会显示所有增加的文本,要删除的文件会显示所有要删除的文本。</para>
+        <para>输出的格式<firstterm>统一区别格式</firstterm>(unified diff format),删除的行前面加一个<literal>-</literal>,添加的行前面有一个<literal>+</literal>,<command>svn diff</command>命令也打印文件名和<command>打补丁</command>需要的信息,所以你可以同过重定向一个区别文件来生成<quote>补丁</quote>:</para>
 $ svn diff > patchfile
-        <para>You could, for example, email the patch file to another
-          developer for review or testing prior to commit.</para>
+        <para>举个例子,你可以把补丁文件发送邮件到其他开发者,在提交之前审核和测试。</para>
       <sect3 id="svn-ch-3-sect-5.3.3">
         <title><command>svn revert</command></title>
-        <para>Now suppose you see the above diff output, and realize
-          that your changes to <filename>README</filename> are a
-          mistake; perhaps you accidentally typed that text into the
-          wrong file in your editor.</para>
+        <para>假设你通过上面的diff输出知道你不小心用编辑器在<filename>README</filename>中输入了一些字符。
+    </para>
-        <para>This is a perfect opportunity to use <command>svn
-          revert</command>.</para>
+        <para>这是使用<command>svn
+          revert</command>的好机会。</para>
 $ svn revert README
 Reverted 'README'
-        <para>Subversion reverts the file to its pre-modified state by
-          overwriting it with the cached <quote>pristine</quote> copy
-          from the <filename>.svn</filename> area.  But also note that
-          <command>svn revert</command> can undo
-          <emphasis>any</emphasis> scheduled operations—for
-          example, you might decide that you don't want to add a new
-          file after all:</para>
+        <para>Subversion把文件恢复到未修改的状态,叫做<filename>.svn</filename>目录的<quote>原始</quote>拷贝,应该知道<command>svn revert</command>可以恢复任何预定要做的操作,举个例子,你不再想添加一个文件:</para>
 $ svn status foo
@@ -1197,18 +775,11 @@
           <para><command>svn revert</command>
-            <replaceable>ITEM</replaceable> has exactly the same
-            effect as deleting <replaceable>ITEM</replaceable> from
-            your working copy and then running <command>svn update -r
-            BASE</command> <replaceable>ITEM</replaceable>.  However,
-            if you're reverting a file, <command>svn revert</command>
-            has one very noticeable difference—it doesn't have
-            to communicate with the repository to restore your
-            file.</para>
+            <replaceable>ITEM</replaceable>的效果与删除<replaceable>ITEM</replaceable>然后执行<command>svn update -r
+            BASE</command> <replaceable>ITEM</replaceable>完全一样,但是,如果你使用<command>svn revert</command>它不必通知版本库来存储文件。</para>
-        <para>Or perhaps you mistakenly removed a file from version
-          control:</para>
+        <para>或许你不小心删除了一个文件:</para>
 $ svn status README 
@@ -1227,43 +798,23 @@
-          <title>Look Ma! No Network!</title>
+          <title>看!没有网络!</title>
+        <para>这三个命令(<command>svn
+          status</command>、<command>svn diff</command>和
+          <command>svn revert</command>)都可以在没有网络的情况下工作,这让你在没有网络连接时的管理修改过程更加简单,像在飞机上旅行,乘坐火车往返或是在海滩上奋力工作时。</para>
-        <para>All three of these commands (<command>svn
-          status</command>, <command>svn diff</command>, and
-          <command>svn revert</command>) can be used without any
-          network access.  This makes it easy to manage your
-          changes-in-progress when you are somewhere without a network
-          connection, such as traveling on an airplane, riding a
-          commuter train or hacking on the beach.</para>
-        <para>Subversion does this by keeping private caches of
-          pristine versions of each versioned file inside of the
-          <filename>.svn</filename> administrative areas.  This allows
-          Subversion to report—and revert—local
-          modifications to those files <emphasis>without network
-          access</emphasis>.  This cache (called the
-          <quote>text-base</quote>) also allows Subversion to send the
-          user's local modifications during a commit to the server as
-          a compressed <firstterm>delta</firstterm> (or
-          <quote>difference</quote>) against the pristine version.
-          Having this cache is a tremendous benefit—even if you
-          have a fast net connection, it's much faster to send only a
-          file's changes rather than the whole file to the server.  At
-          first glance, this might not seem that important, but
-          imagine the repercussions if you try to commit a one line
-          change to a 400MB file and have to send the whole file to
-          the server!</para>
+        <para>Subversion通过在<filename>.svn</filename>管理区域使用原始的版本缓存来做到这一点,这使得恢复本地版本而<emphasis>不必访问网络</emphasis>,这个缓存(叫做<quote>text-base</quote>)也允许Subversion可以根据原始版本生成一个压缩的增量(<quote>区别</quote>)
     <sect2 id="svn-ch-3-sect-5.4">
-      <title>Resolve Conflicts (Merging Others' Changes)</title>
+      <title>解决冲突(合并别人的修改)</title>
-      <para>We've already seen how <command>svn status -u</command>
-        can predict conflicts.  Suppose you run <command>svn
-        update</command> and some interesting things occur:</para>
+      <para>我们可以使用<command>svn status -u</command>来预测冲突,当你运行<command>svn
+        update</command>一些有趣的事情发生了:</para>
 $ svn update
@@ -1273,103 +824,56 @@
 Updated to revision 46.
-      <para>The <computeroutput>U</computeroutput> and
-        <computeroutput>G</computeroutput> codes are no cause for
-        concern; those files cleanly absorbed changes from the
-        repository.  The files marked with
-        <computeroutput>U</computeroutput> contained no local changes
-        but were <computeroutput>U</computeroutput>pdated with changes
-        from the repository.  The <computeroutput>G</computeroutput>
-        stands for mer<computeroutput>G</computeroutput>ed, which
-        means that the file had local changes to begin with, but the
-        changes coming from the repository didn't overlap with the local
-        changes.</para>
-      <para>But the <computeroutput>C</computeroutput> stands for
-        conflict.  This means that the changes from the server overlapped
-        with your own, and now you have to manually choose between
-        them.</para>
+      <para><computeroutput>U</computeroutput>和<computeroutput>G</computeroutput>没必要关心,文件干净的接受了版本库的变化,文件标示为<computeroutput>U</computeroutput>表明本地没有修改,文件已经根据版本库更新。<computeroutput>G</computeroutput>标示合并,标示本地已经修改过,与版本库没有重迭的地方,已经合并。</para>
-      <para>Whenever a conflict occurs, three things typically occur
-        to assist you in noticing and resolving that conflict:</para>
+      <para>但是C<computeroutput>C</computeroutput>表示冲突,说明服务器上的改动同你的改动冲突了,你需要自己手工去解决。</para>
+      <para>当冲突发生了,有三件事可以帮助你注意到和解决问题:</para>
-          <para>Subversion prints a <computeroutput>C</computeroutput>
-            during the update, and remembers that the file is in a
-            state of conflict.</para>
+          <para>Subversion打印<computeroutput>C</computeroutput>标记,并且标记这个文件已冲突。</para>
-          <para>If Subversion considers the file to be of a mergable
-            type, it places <firstterm>conflict
-            markers</firstterm>—special strings of text which
-            delimit the <quote>sides</quote> of the
-            conflict—into the file to visibly demonstrate the
-            overlapping areas.  (Subversion uses the
-            <literal>svn:mime-type</literal> property to decide if a
-            file is capable of contextual, line-based merging.  See
-            <xref linkend="svn-ch-7-sect-2.3.2"/> to learn more.)</para>
+          <para>如果Subversion认为这个文件是可合并的,它会置入<firstterm>冲突标记</firstterm>—特殊的横线分开冲突的<quote>两面</quote>—在文件里可视化的描述重叠的部分(Subversion使用<literal>svn:mime-type</literal>属性来决定一个文件是否可以使用上下文的,以行为基础合并,更多信息可以看<xref linkend="svn-ch-7-sect-2.3.2"/>)。</para>
-          <para>For every conflicted file, Subversion places up to
-            three extra unversioned files in your working copy:</para>
+          <para>对于每一个冲突的文件,subversion放置三个额外的未版本化文件到你的工作拷贝:</para>
-                <para>This is your file as it existed in your working
-                  copy before you updated your working copy—that
-                  is, without conflict markers.  This file has your
-                  latest changes in it and nothing else.  (If
-                  Subversion considers the file to be unmergeable,
-                  then the <filename>.mine</filename> file isn't
-                  created, since it would be identical to the working
-                  file.)</para>
+                <para>你更新前的文件,没有冲突标志,只是你最新更改的内容。(如果Subversion认为这个文件不可以合并,<filename>.mine</filename>文件不会创建,因为它和工作文件相同。)</para>
-                <para>This is the file that was the
-                  <literal>BASE</literal> revision before you updated
-                  your working copy.  That is, the file that you
-                  checked out before you made your latest
-                  edits.</para>
+                <para>这是你的做更新操作以前的<literal>BASE</literal>版本文件,就是你在上次更新之后未作更改的版本。</para>
-                <para>This is the file that your Subversion client
-                  just received from the server when you updated your
-                  working copy.  This file corresponds to the
-                  <literal>HEAD</literal> revision of the
-                  repository.</para>
+                <para>这是你的Subversion客户端从服务器刚刚收到的版本,这个文件对应版本库的<literal>HEAD</literal>版本。</para>
-          <para>Here <literal>OLDREV</literal> is the revision number
-            of the file in your <filename>.svn</filename> directory
-            and <literal>NEWREV</literal> is the revision number of
-            the repository <literal>HEAD</literal>.</para>
+          <para>这里<literal>OLDREV</literal>是你的<filename>.svn</filename>目录中的修订版本号,<literal>NEWREV</literal>是版本库中<literal>HEAD</literal>的版本号。</para>
-      <para>For example, Sally makes changes to the file
-        <filename>sandwich.txt</filename> in the repository.  Harry has
-        just changed the file in his working copy and checked it in.
-        Sally updates her working copy before checking in and she gets
-        a conflict:</para>
+      <para>举一个例子,Sally在改变了<filename>sandwich.txt</filename>,Harry刚刚改变了本地拷贝中的这个文件并且提交到服务器,Sally在提交之前更新它的工作拷贝得到了冲突:</para>
 $ svn update
@@ -1382,9 +886,7 @@
-      <para>At this point, Subversion will <emphasis>not</emphasis>
-        allow you to commit the file <filename>sandwich.txt</filename>
-        until the three temporary files are removed.</para>
+      <para>在这种情况下,Subversion<emphasis>不</emphasis>会允许你提交<filename>sandwich.txt</filename>,直到你的三个临时文件被删掉。</para>
 $ svn commit --message "Add a few more things"
@@ -1392,36 +894,25 @@
 svn: Aborting commit: '/home/sally/svn-work/sandwich.txt' remains in conflict
-      <para>If you get a conflict, you need to do one of three
-        things:</para>
+      <para>如果你遇到冲突,三件事你可以选择:</para>
-            <para>Merge the conflicted text <quote>by hand</quote> (by
-              examining and editing the conflict markers within the
-              file).</para>
+            <para><quote>手动</quote>合并冲突文本(检查和修改文件中的冲突标志)。</para>
-            <para>Copy one of the temporary files on top of your
-              working file.</para>
+            <para>拷贝覆盖某一个临时文件你的工作文件。</para>
-            <para>Run <command>svn revert <filename></command>
-              to throw away all of your local changes.</para>
+            <para>运行<command>svn revert <filename></command>来放弃所有的修改。</para>
-      <para>Once you've resolved the conflict, you need to let
-        Subversion know by running <command>svn resolved</command>.
-        This removes the three temporary files and Subversion no
-        longer considers the file to be in a state of
-        conflict.<footnote><para>You can always remove the temporary
-        files yourself, but would you really want to do that when
-        Subversion can do it for you?  We didn't think so.</para>
+      <para>一旦你解决了冲突,你需要通过命令<command>svn resolved</command>让Subversion知道,这样就会删除三个临时文件,subversion不会认为这个文件是在冲突状态了。<footnote><para>你也可以手工的删除这三个临时文件,但是当Subversion会给你做时你会自己去做吗?我们是这样想的。</para>
@@ -1430,19 +921,11 @@
       <sect3 id="svn-ch-3-sect-5.4.1">
-        <title>Merging Conflicts by Hand</title>
+        <title>手工合并冲突</title>
+        <para>第一次尝试解决冲突让人感觉很害怕,但经过一点训练,它简单的像是骑着车子下坡。</para>
-        <para>Merging conflicts by hand can be quite intimidating the
-          first time you attempt it, but with a little practice, it
-          can become as easy as falling off a bike.</para>
-        <para>Here's an example.  Due to a miscommunication, you and
-          Sally, your collaborator, both edit the file
-          <filename>sandwich.txt</filename> at the same time.  Sally
-          commits her changes, and when you go to update your working
-          copy, you get a conflict and we're going to have to edit
-          <filename>sandwich.txt</filename> to resolve the conflicts.
-          First, let's take a look at the file:</para>
+        <para>这里一个简单的例子,由于不良的交流,你和同事Sally,与你同时编辑了<filename>sandwich.txt</filename>。Sally提交了修改,当你准备更新你的版本,冲突发生了,我们不得不去修改<filename>sandwich.txt</filename>来解决这个问题。首先,看一下这个文件:</para>
 $ cat sandwich.txt
@@ -1463,13 +946,7 @@
 Bottom piece of bread
-        <para>The strings of less-than signs, equal signs, and
-          greater-than signs are conflict markers, and are not part of
-          the actual data in conflict.  You generally want to ensure
-          that those are removed from the file before your next
-          commit.  The text between the first two sets of markers is
-          composed of the changes you made in the conflicting
-          area:</para>
+        <para>小于号、等于号和大于号串是冲突标记,并不是冲突的数据,你一定要确定这些内容在下次提交之前得到删除,前两组标志中间的内容是你在冲突区所做的修改:</para>
 <<<<<<< .mine
@@ -1479,8 +956,7 @@
-        <para>The text between the second and third sets of conflict
-          markers is the text from Sally's commit:</para>
+        <para>后两组之间的是Sally提交的修改冲突:</para>
@@ -1489,16 +965,7 @@
 >>>>>>> .r2
-        <para>Usually you won't want to just delete the conflict
-          markers and Sally's changes—she's going to be awfully
-          surprised when the sandwich arrives and it's not what she
-          wanted.  So this is where you pick up the phone or walk
-          across the office and explain to Sally that you can't get
-          sauerkraut from an Italian deli.<footnote><para>And if you
-          ask them for it, they may very well ride you out of town on
-          a rail.</para></footnote> Once you've agreed on the changes
-          you will check in, edit your file and remove the conflict
-          markers.</para>
+        <para>通常你并不希望只是删除冲突标志和Sally的修改—当她收到三明治时,会非常的吃惊。所以你应该走到她的办公室或是拿起电话告诉Sally,你没办法从从意大利熟食店得到想要的泡菜。<footnote><para>如果你向他们询问,他们会把你带到城外的车轨上。</para></footnote>一旦你们确认了提交内容后,修改文件并且删除冲突标志。</para>
 Top piece of bread
@@ -1513,30 +980,21 @@
 Bottom piece of bread
-        <para>Now run <command>svn resolved</command>, and you're
-          ready to commit your changes:</para>
+        <para>现在运行<command>svn resolved</command>,你已经准备好提交了:</para>
 $ svn resolved sandwich.txt
 $ svn commit -m "Go ahead and use my sandwich, discarding Sally's edits."
-        <para>Remember, if you ever get confused while editing the
-          conflicted file, you can always consult the three files that
-          Subversion creates for you in your working
-          copy—including your file as it was before you updated.
-          You can even use a third-party interactive merging tool to
-          examine those three files.</para>
+        <para>记住,如果你修改冲突时感到混乱,你可以参考subversion生成的三个文件—包括你未作更新的文件。你也可以使用第三方的合并工具检验这三个文件。</para>
       <sect3 id="svn-ch-3-sect-5.4.2">
-        <title>Copying a File Onto Your Working File</title>
+        <title>拷贝覆盖你的工作文件</title>
-        <para>If you get a conflict and decide that you want to throw
-          out your changes, you can merely copy one of the temporary
-          files created by Subversion over the file in your working
-          copy:</para>
+        <para>如果你只是希望取消你的修改,你可以仅仅拷贝Subversion为你生成的文件替换你的工作拷贝:</para>
 $ svn update
@@ -1551,11 +1009,9 @@
       <sect3 id="svn-ch-3-sect-5.4.3">
-        <title>Punting: Using <command>svn revert</command></title>
+        <title>踢悬空球:使用<command>svn revert</command></title>
-        <para>If you get a conflict, and upon examination decide that
-          you want to throw out your changes and start your edits
-          again, just revert your changes:</para>
+        <para>如果你得到冲突,经过检查你决定取消自己的修改并且重新编辑,你可以恢复你的修改:</para>
 $ svn revert sandwich.txt
@@ -1564,37 +1020,20 @@
-        <para>Note that when you revert a conflicted file, you don't
-          have to run <command>svn resolved</command>.</para>
+        <para>注意,当你恢复冲突文件时,不需要运行<command>svn resolved</command>。</para>
-      <para>Now you're ready to check in your changes.  Note that
-        <command>svn resolved</command>, unlike most of the other
-        commands we've dealt with in this chapter, requires an
-        argument.  In any case, you want to be careful and only run
-        <command>svn resolved</command> when you're certain that you've
-        fixed the conflict in your file—once the temporary files
-        are removed, Subversion will let you commit the file even if
-        it still contains conflict markers.</para>
+      <para>现在我们准备好提交修改了,注意<command>svn resolved</command>不像我们本章学过的其他命令一样需要参数,在任何你认为解决了冲突,就运行<command>svn resolved</command>,—一旦删除了临时文件,Subversion会让你提交这文件,即使存在冲突标记。</para>
     <sect2 id="svn-ch-3-sect-5.5">
-      <title>Commit Your Changes</title>
+      <title>提交你得修改</title>
+      <para>最后!你得修改结束了,你合并了所有修改,你准备好提交到版本库。</para>
-      <para>Finally!  Your edits are finished, you've merged all
-        changes from the server, and you're ready to commit your
-        changes to the repository.</para>
-      <para>The <command>svn commit</command> command sends all of
-        your changes to the repository.  When you commit a change, you
-        need to supply a <firstterm>log message</firstterm>,
-        describing your change.  Your log message will be attached to
-        the new revision you create.  If your log message is brief,
-        you may wish to supply it on the command line using the
-        <option>--message</option> (or <option>-m</option>)
-        option:</para>
+      <para><command>svn commit</command>命令发送所有的修改到版本库,当你提交修改时,你需要提供一些描述修改的<firstterm>log信息</firstterm>,你得信息会附到这个修订版本上,如果信息很简短,你可以在命令行中使用<option>--message</option>(<option>-m</option>)选项:</para>
 $ svn commit --message "Corrected number of cheese slices."
@@ -1603,10 +1042,7 @@
 Committed revision 3.
-      <para>However, if you've been composing your log message as you
-        work, you may want to tell Subversion to get the message from
-        a file by passing the filename with the
-        <option>--file</option> switch:</para>
+      <para>然而,如果你在工作中写日志信息时,你也许会希望通过告诉Subversion一个文件名得到日志信息,使用<option>--file</option>选项:</para>
 $ svn commit --file logmsg 
@@ -1615,20 +1051,11 @@
 Committed revision 4.
-      <para>If you fail to specify either the
-        <option>--message</option> or <option>--file</option> switch,
-        then Subversion will automatically launch your favorite editor
-        (see the <literal>editor-cmd</literal> section in
-        <xref linkend="svn-ch-7-sect-1.3.2"/>) for composing a log
-        message.</para>
+      <para>如果你没有指定<option>--message</option>或者<option>--file</option>选项,subversion会自动地启动你最喜欢的编辑器(见<xref linkend="svn-ch-7-sect-1.3.2"/>的<literal>editor-cmd</literal>部分)来编辑日志信息。</para>
-        <para>If you're in your editor writing a commit message and
-          decide that you want to cancel your commit, you can just
-          quit your editor without saving changes.  If you've already
-          saved your commit message, simply delete the text and save
-          again.</para>
+        <para>如果你使用编辑器撰写日志信息时希望取消提交,你可以直接关掉编辑器,不要保存,如果你已经做过保存,只要简单的删掉所有的文本并再次保存。</para>
 $ svn commit
@@ -1641,12 +1068,7 @@
-      <para>The repository doesn't know or care if your changes make
-        any sense as a whole; it only checks to make sure that nobody
-        else has changed any of the same files that you did when you
-        weren't looking.  If somebody <emphasis>has</emphasis> done
-        that, the entire commit will fail with a message informing you
-        that one or more of your files is out-of-date:</para>
+      <para>版本库不知道也不关心你的修改作为一个整体是否有意义,它只检查没有别人修改了同一个文件,如果别人<emphasis>已经</emphasis>修改这样做了,你的整个提交会失败,并且提示你一个或多个文件已经过时了:</para>
 $ svn commit --message "Add another rule"
@@ -1655,16 +1077,11 @@
 svn: Out of date: 'rules.txt' in transaction 'g'
-      <para>At this point, you need to run <command>svn
-        update</command>, deal with any merges or conflicts that
-        result, and attempt your commit again.</para>
+      <para>此刻,你需要运行<command>svn
+        update</command>来处理所有的合并和冲突,然后再尝试提交。</para>
-      <para>That covers the basic work cycle for using Subversion.
-        There are many other features in Subversion that you can use
-        to manage your repository and working copy, but you can get by
-        quite easily using only the commands that we've discussed so
-        far in this chapter.</para>
+      <para>我们已经覆盖了subversion基本的工作周期,还有许多其他特性可以管理你得版本库和工作拷贝,但是只使用前面介绍的命令你就可以很轻松的工作了。</para>
@@ -1674,55 +1091,39 @@
   <!-- ======================== SECTION 6 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-3-sect-6">
-    <title>Examining History</title>
+    <title>检验历史</title>
-    <para>As we mentioned earlier, the repository is like a time
-      machine.  It keeps a record of every change ever committed,
-      and allows you to explore this history by examining previous
-      versions of files and directories as well as the metadata that
-      accompanies them.  With a single Subversion command, you can
-      check out the repository (or restore an existing working copy)
-      exactly as it was at any date or revision number in the past.
-      However, sometimes you just want to <emphasis>peer
-      into</emphasis> the past instead of <emphasis>going
-      into</emphasis> the past.</para>
+    <para>我们曾经说过,版本库就像是一台时间机器,它记录了所有提交的所有修改,允许你检查文件或目录以及相关的元数据的历史。通过一个subversion命令你可以根据时间或修订号取出一个过去的版本(或者恢复现在的工作拷贝),然而,有时候我们只是想<emphasis>看看</emphasis>历史而不想<emphasis>回到</emphasis>历史。</para>
-    <para>There are several commands that can provide you with
-      historical data from the repository:</para>
+    <para>有许多命令可以为你提供版本库历史:</para>
           <term><command>svn log</command></term>
-            <para>Shows you broad information: log messages attached
-              to revisions, and which paths changed in each
-              revision.</para>
+            <para>展示给你主要信息:附加在版本上的日志信息和所有版本的路径修改。</para>
           <term><command>svn diff</command></term>
-            <para>Shows you the specific details of how a file changed
-              over time.</para>
+            <para>展示一个文件改变的详细情况。</para>
           <term><command>svn cat</command></term>
-            <para>This is used to retrieve any file as it existed in a
-              particular revision number and display it on your
-              screen.</para>
+            <para>取得在特定版本的某一个文件显示在当前屏幕。</para>
           <term><command>svn list</command></term>
-            <para>Displays the files in a directory for any given
-              revision.</para>
+            <para>显示一个目录在某一版本存在的文件。</para>
@@ -1732,13 +1133,7 @@
     <sect2 id="svn-ch-3-sect-6.1">
       <title><command>svn log</command></title>
-      <para>To find information about the history of a file or
-        directory, use the <command>svn log</command>
-        command. <command>svn log</command> will provide you with a
-        record of who made changes to a file or directory, at what
-        revision it changed, the time and date of that revision, and,
-        if it was provided, the log message that accompanied the
-        commit.</para>
+      <para>找出一个文件或目录的历史信息,使用<command>svn log</command>命令,<command>svn log</command>将会提供你一条记录,包括:谁做对文件或目录作了修改、那个修订版本作了修改、修订版本的日期和时间、还有如果你提供了日志信息,也会显示。</para>
 $ svn log
@@ -1757,12 +1152,7 @@
-      <para>Note that the log messages are printed in
-        <emphasis>reverse chronological order</emphasis> by default.
-        If you wish to see a different range of revisions in a
-        particular order, or just a single revision, pass the
-        <option>--revision</option> (<option>-r</option>)
-        switch:</para>
+      <para>注意日志信息缺省根据<emphasis>时间逆序排列</emphasis>,如果希望察看特定顺序的一段修订版本或者单一版本,使用<option>--revision</option> (<option>-r</option>)选项:</para>
 $ svn log --revision 5:19    # shows logs 5 through 19 in chronological order
@@ -1772,8 +1162,7 @@
 $ svn log -r 8               # shows log for revision 8
-      <para>You can also examine the log history of a single file or
-        directory.  For example:</para>
+      <para>你也可以检查单个文件或目录的日志历史,举个例子:</para>
 $ svn log foo.c
@@ -1782,18 +1171,10 @@
-      <para>These will display log messages <emphasis>only</emphasis>
-        for those revisions in which the working file (or URL)
-        changed.</para>
-      <para>If you want even more information about a file or
-        directory, <command>svn log</command> also takes a
-        <option>--verbose</option> (<option>-v</option>) switch.
-        Because Subversion allows you to move and copy files and
-        directories, it is important to be able to track path changes
-        in the filesystem, so in verbose mode, <command>svn
-        log</command> will include a list of changed paths in a
-        revision in its output:</para>
+      <para>这样<emphasis>只会</emphasis>显示这个工作文件(或者URL)做过修订的版本的日志信息。</para>
+      <para>如果你希望得到目录和文件更多的信息,你可以对<command>svn log</command>命令使用<option>--verbose</option> (<option>-v</option>)参数,因为Subversion允许移动和复制文件和目录,所以跟踪路径修改非常重要,在详细模式下,<command>svn
+        log</command> 输出中会包括一个路径修改的历史:</para>
 $ svn log -r 8 -v
@@ -1810,11 +1191,9 @@
-        <title>Why Does <command>svn log</command> Give Me an Empty
-          Response?</title>
+        <title>为什么<command>svn log</command>给我一个空的回应?</title>
-        <para>After working with Subversion for a bit, most users will
-          come across something like this:</para>
+        <para>当使用Subversion一些时间后,许多用户会遇到这种情况:</para>
 $ svn log -r 2
@@ -1822,18 +1201,8 @@
-        <para>At first glance, this seems like an error.  But recall
-          that while revisions are repository-wide, <command>svn
-          log</command> operates on a path in the repository.  If you
-          supply no path, Subversion uses the current working
-          directory as the default target.  As a result, if you're
-          operating in a subdirectory of your working copy and attempt
-          to see the log of a revision in which neither that directory
-          nor any of its children was changed, Subversion will show you
-          an empty log.  If you want to see what changed in that
-          revision, try pointing <command>svn log</command> directly at
-          the top-most URL of your repository, as in <command>svn log -r 2
-          http://svn.collab.net/repos/svn</command>.</para>
+        <para>乍一看,好像是一个错误,但是想一下修订版本号是作用在版本库整体之上的,如果你没有提供路径,<command>svn log</command>会使用当前目录作为默认的目标,所以,作为结果,如果你对一个本身和子目录在指定版本到现在没有做过修改的目录运行这个命令,你会得到空的日志。如果你希望察看某个版本做的修改的日志,只需要直接告诉<command>svn log</command>使用版本库顶级的目录,例如<command>svn log -r 2
+          http://svn.collab.net/repos/svn</command>。</para>
@@ -1842,38 +1211,30 @@
     <sect2 id="svn-ch-3-sect-6.2">
       <title>svn diff</title>
-      <para>We've already seen <command>svn diff</command>
-        before—it displays file differences in unified diff
-        format; it was used to show the local modifications made to
-        our working copy before committing to the repository.</para>
-      <para>In fact, it turns out that there are
-        <emphasis>three</emphasis> distinct uses of <command>svn
-        diff</command>:</para>
+      <para>我们已经看过<command>svn diff</command>—使用标准区别文件格式显示区别,它在提交前用来显示本地工作拷贝与版本库的区别。</para>
+      <para>事实上,<command>svn diff</command>有<emphasis>三</emphasis>种不同的用法:</para>
-          <para>Examine local changes</para>
+          <para>检查本地修改</para>
-          <para>Compare your working copy to the repository</para>
+          <para>比较工作拷贝与版本库</para>
-          <para>Compare repository to repository</para>
+          <para>比较版本库和版本库</para>
       <sect3 id="svn-ch-3-sect-6.2.1">
-        <title>Examining Local Changes</title>
+        <title>比较本地修改</title>
-        <para>As we've seen, invoking <command>svn diff</command> with
-          no switches will compare your working files to the cached
-          <quote>pristine</quote> copies in
-          the <filename>.svn</filename> area:</para>
+        <para>像我们看到的,不使用任何参数调用时,<command>svn diff</command>将会比较你的工作文件与缓存在<filename>.svn</filename>的<quote>原始</quote>拷贝:</para>
 $ svn diff
@@ -1894,12 +1255,9 @@
       <sect3 id="svn-ch-3-sect-6.2.2">
-        <title>Comparing Working Copy to Repository</title>
+        <title>比较工作拷贝和版本库</title>
-        <para>If a single <option>--revision</option>
-          (<option>-r</option>) number is passed, then your
-          working copy is compared to the specified revision in the
-          repository.</para>
+        <para>如果传递一个<option>--revision</option>(<option>-r</option>)参数,你得工作拷贝会与指定的版本比较。</para>
 $ svn diff --revision 3 rules.txt 
@@ -1920,12 +1278,10 @@
       <sect3 id="svn-ch-3-sect-6.2.3">
-        <title>Comparing Repository to Repository</title>
+        <title>比较版本库与版本库</title>
-        <para>If two revision numbers, separated by a colon, are
-          passed via <option>--revision</option>
-          (<option>-r</option>), then the two revisions are directly
-          compared.</para>
+        <para>如果通过<option>--revision</option>
+          (<option>-r</option>)传递两个版本号,通过冒号分开,这两个版本会进行比较。</para>
 $ svn diff --revision 2:3 rules.txt 
@@ -1942,13 +1298,7 @@
-        <para>Not only can you use <command>svn diff</command> to
-          compare files in your working copy to the repository, but if
-          you supply a URL argument, you can examine the differences
-          between items in the repository without even having a
-          working copy.  This is especially useful if you wish to
-          inspect changes in a file when you don't have a working copy
-          on your local machine:</para>
+        <para>你不仅可以用<command>svn diff</command>比较你工作拷贝中的文件,你甚至可以通过提供一个URL参数来比较版本库中两个文件的的区别,通常在本地机器没有工作拷贝时非常有用:</para>
 $ svn diff --revision 4:5 http://svn.red-bean.com/repos/example/trunk/text/rules.txt
@@ -1963,9 +1313,7 @@
     <sect2 id="svn-ch-3-sect-6.3">
       <title><command>svn cat</command></title>
-      <para>If you want to examine an earlier version of a file and
-        not necessarily the differences between two files, you can use
-        <command>svn cat</command>:</para>
+      <para>如果你只是希望检查一个过去的版本而不希望察看它们的区别,使用<command>svn cat</command>:</para>
 $ svn cat --revision 2 rules.txt 
@@ -1976,39 +1324,25 @@
-      <para>You can also redirect the output directly into a
-        file:</para>
+      <para>你可以重定向输出到一个文件:</para>
 $ svn cat --revision 2 rules.txt > rules.txt.v2
-      <para>You're probably wondering why we don't just use
-        <command>svn update --revision</command> to update the file to
-        the older revision.  There are a few reasons why we might
-        prefer to use <command>svn cat</command>.</para>
-      <para>First, you may want to see the differences between two
-        revisions of a file using an external diff program (perhaps a
-        graphical one, or perhaps your file is in such a format that
-        the output of unified diff is nonsensical).  In this case,
-        you'll need to grab a copy of the old revision, redirect it to
-        a file, and pass both that and the file in your working copy
-        to your external diff program.</para>
-      <para>Sometimes it's easier to look at an older version of a
-        file in its entirety as opposed to just the differences
-        between it and another revision.</para>
+      <para>你一定疑惑为什么不只是使用<command>svn update --revision</command> ,将文件更新到旧的文件,我们有一些使用<command>svn cat</command>原因。</para>
+      <para>首先,你或许希望使用外置的比较工具(或许是一个图形化的工具,或者你的格式无法用标准区别格式察看)察看这两个版本的区别,这种情况下,你需要得到一个旧的版本的拷贝,所以重定向到一个文件,并且在你的比较工具中指定这两个版本来察看区别。</para>
+      <para>有时候察看整个文件比只看区别要容易。</para>
     <sect2 id="svn-ch-3-sect-6.4">
       <title><command>svn list</command></title>
-      <para>The <command>svn list</command> command shows you what
-        files are in a repository directory without actually
-        downloading the files to your local machine:</para>
+      <para><command>svn list</command>可以不下载文件到本地目录来察看目录中的文件:</para>
 $ svn list http://svn.collab.net/repos/svn
@@ -2019,9 +1353,7 @@
-      <para>If you want a more detailed listing, pass the
-        <option>--verbose</option> (<option>-v</option>) flag to get
-        output like this:</para>
+      <para>如果你希望察看详细信息,你可以使用<option>--verbose</option> (<option>-v</option>)参数:</para>
 $ svn list --verbose http://svn.collab.net/repos/svn
@@ -2032,22 +1364,15 @@
    2785 sally               Jul 29 19:07 trunk/
-      <para>The columns tell you the revision at which the file or
-        directory was last modified, the user who modified it, the size
-        if it is a file, the date it was last modified, and the item's
-        name.</para>
+      <para>这些列告诉你文件和目录最后修改的版本、做出修改的用户、如果是文件,文件的大小和最后的修改日期、还有项目的名字。</para>
     <sect2 id="svn-ch-3-sect-6.5">
-      <title>A Final Word on History</title>
+      <title>于历史的最后一个词</title>
-      <para>In addition to all of the above commands, you can use
-        <command>svn update</command> and <command>svn
-        checkout</command> with the <option>--revision</option> switch
-        to take an entire working copy <quote>back in time</quote>
-        <footnote><para>See?  We told you that Subversion was a time
-        machine.</para></footnote>:</para>
+      <para>除了以上的命令,你可以使用带参数<option>--revision</option>的<command>svn update</command>和<command>svn
+        checkout</command>来使整个工作拷贝<quote>回到过去</quote><footnote><para>看到了吧?我们说过Subversion是一个时间机器。</para></footnote>:</para>
 $ svn checkout --revision 1729 # Checks out a new working copy at r1729
@@ -2065,35 +1390,16 @@
   <!-- ======================== SECTION 7 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-3-sect-7">
-    <title>Other Useful Commands</title>
+    <title>其他有用的命令</title>
-      <para>While not as frequently used as the commands previously
-        discussed in this chapter, you will occasionally need these
-        commands.</para>
+      <para>不如本章前面的命令常用,你偶尔会需要这些命令。</para>
     <sect2 id="svn-ch-3-sect-7.1">
       <title><command>svn cleanup</command></title>
-      <para>When Subversion modifies your working copy (or any
-        information within <filename>.svn</filename>), it tries to do
-        so as safely as possible.  Before changing the working copy,
-        Subversion writes its intentions to a log file. Next it executes
-        the commands in the log file to apply the requested change.
-        Finally, Subversion removes the log file. Architecturally, this
-        is similar to a journaled filesystem.  If a Subversion operation is
-        interrupted (if the process is killed, or if the machine
-        crashes, for example), the log files remain on disk.  By
-        re-executing the log files, Subversion can complete the
-        previously started operation, and your working copy can get
-        itself back into a consistent state.</para>
-      <para>And this is exactly what <command>svn cleanup</command>
-        does: it searches your working copy and runs any leftover
-        logs, removing locks in the process.  If Subversion ever tells
-        you that some part of your working copy is
-        <quote>locked</quote>, then this is the command that you
-        should run.  Also, <command>svn status</command> will display
-        an <literal>L</literal> next to locked items:</para>
+      <para>当Subversion改变你的工作拷贝(或是<filename>.svn</filename>中的任何信息),他会尽可能的小心,在修改任何事情之前,它把意图写到日志文件中去,然后执行log文件中的命令,然后删掉日志文件,这与分类帐的文件系统架构类似。如果subversion的操作中断了(举个例子:进程被杀死了,机器死掉了),日志文件会保存在硬盘上,通过重新执行日志文件,subversion可以完成上一次开始的操作,你的工作靠别可以回到一致的状态。</para>
+      <para>这就是<command>svn cleanup</command>所作的:它查找工作拷贝中的所有遗留的日志文件,删除进程中的锁。如果subversion告诉你工作拷贝中的一些部分已经<quote>锁定</quote>了,你就需要运行这个命令了。同样,<command>svn status</command>将会使用<literal>L</literal> 显示锁定的项目:</para>
 $ svn status
@@ -2111,9 +1417,7 @@
     <sect2 id="svn-ch-3-sect-7.3">
       <title><command>svn import</command></title>
-      <para>The <command>svn import</command> command is a quick way
-        to copy an unversioned tree of files into a repository,
-        creating intermediate directories as necessary.</para>
+      <para><command>svn import</command>命令是拷贝用户的一个未被版本化的目录树到版本库最快的方法,如果需要,它也要建立一些中介文件。</para>
 $ svnadmin create /usr/local/svn/newrepos
@@ -2126,9 +1430,7 @@
 Committed revision 1.
-      <para>The previous example copied the contents of directory
-        <filename>mytree</filename> under the directory
-        <filename>some/project</filename> in the repository:</para>
+      <para>在上一个例子里,将会拷贝目录<filename>mytree</filename>到版本库的<filename>some/project</filename>下:</para>
 $ svn list file:///usr/local/svn/newrepos/some/project
@@ -2137,10 +1439,8 @@
-      <para>Note that after the import is finished, the original tree
-        is <emphasis>not</emphasis> converted into a working copy.  To
-        start working, you still need to <command>svn
-        checkout</command> a fresh working copy of the tree.</para>
+      <para>注意,在导入之后,原来的目录树并<emphasis>没有</emphasis>转化成工作拷贝,为了开始工作,你还是需要运行<command>svn
+        checkout</command>导出一个工作拷贝。</para>
@@ -2150,16 +1450,9 @@
   <!-- ======================== SECTION 8 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-3-sect-8">
-    <title>Summary</title>
+    <title>摘要</title>
-      <para>Now we've covered most of the Subversion client commands.
-        Notable exceptions are those dealing with branching and
-        merging (see <xref linkend="svn-ch-4"/>) and properties (see
-        <xref linkend="svn-ch-7-sect-2"/>). However, you may want to
-        take a moment to skim through <xref linkend="svn-ch-9"/> to
-        get an idea of all the many different commands that Subversion
-        has—and how you can use them to make your work
-        easier.</para>
+      <para>我们已经覆盖了大多数subversion的客户端命令,引人注目的例外是分支与合并以及属性(见<xref linkend="svn-ch-4"/>),然而你也许会希望跳到<xref linkend="svn-ch-9"/>来察看所有不同的命令—怎样使你的工作更容易。</para>

Modified: trunk/src/zh/book/glossary.xml
--- trunk/src/zh/book/glossary.xml	(original)
+++ trunk/src/zh/book/glossary.xml	Mon Jul 11 12:33:40 2005
@@ -67,6 +67,14 @@
+      <glossentry>
+        <glossterm>delta(增量)</glossterm>
+        <glossdef>
+          <para>提交时只提交区别,也就是增量的模式</para>
+        </glossdef>
+      </glossentry>
@@ -91,6 +99,19 @@
+      <title>U</title>
+      <glossentry>
+        <glossterm>unified diff
+          format(统一区别格式)</glossterm>
+        <glossdef>
+          <para>标示文件区别的一种格式。</para>
+        </glossdef>
+      </glossentry>
+    </glossdiv>
+    <glossdiv>

More information about the svnbook-dev mailing list