Edit grandmaster.txt

[gitmagic/gitmagic.git] / vi / grandmaster.txt

== Git Grandmastery ==

Bây giờ, bạn có thể thông qua lệnh *git help* để bật trang trợ giúp lên và có thể hiểu
gần như tất cả mọi thứ. Tuy nhiên, việc xác định chính xác lệnh cần sử dụng để giải quyết
các vấn đề đặt ra có lẽ chẳng dễ dàng gì. Có lẽ tôi có thể giúp bạn tiết kiệm được thời gian: bên dưới là một vài
chiêu mà tôi đã từng sử dụng trong quá khứ.

=== Phát hành Mã Nguồn ===

For my projects, Git tracks exactly the files I'd like to archive and release
to users. Để tạo gói tarball cho mã nguồn, Tôi chạy:

 $ git archive --format=tar --prefix=proj-1.2.3/ HEAD

=== Commit What Changed ===

Việc phải thông báo với Git khi bạn thêm, xóa hay đổi tên các tệp tin là việc rầy rà với
các dự án nào đó. Thay vào đó, bạn có thể gõ:

 $ git add .
 $ git add -u

Git sẽ xem tất cả các tệp tin trong thư mục hiện tại and work out the details by
itself. Thay vì chạy lệnh add thứ hai, hãy chạy  `git commit -a` nếu bạn cũng có
ý định commit vào lúc này. Xem *git help ignore* để biết làm cách nào để chỉ ra
các tệp tin bỏ qua.

Bạn có thể thi hành những điều trên chỉ cần một dòng lệnh:

 $ git ls-files -d -m -o -z | xargs -0 git update-index --add --remove

Tùy chọn *-z* và *-0*  prevent ill side-effects from filenames containing
strange characters. As this command adds ignored files, bạn có thể muốn sử dụng
tùy chọn `-x` hay `-X`.

=== Lần commit này Nhiều Quá! ===

Bạn quên việc commit quá lâu? Been coding furiously and forgotten
about source control until now? Bạn muốn những thay đổi liên quan đến nhau phải được commit riêng từng lần và nối tiếp nhau, bởi vì
đây là phong cách của bạn?

Đừng lo lắng. Chạy:

 $ git add -p

Với mỗi lần thay đổi mà bạn tạo ra, Git sẽ hiện cho bạn biết từng đoạn mã đã bị thay đổi,
và hỏi nó có phải là một bộ phận của lần commit tiếp theo. Trả lời là  "y" hay "n". Bạn
có các sự lựa chọn khác, như là hoãn lại; gõ "?" để biết thêm chi tiết.

Khi nào bạn thỏa mãn thì gõ

 $ git commit

to commit precisely the changes you selected (the 'staged' changes). Make sure
you omit the *-a* option, otherwise Git will commit all the edits.

What if you've edited many files in many places? Reviewing each change one by
one becomes frustratingly mind-numbing. In this case, use *git add -i*, whose
interface is less straightforward, but more flexible. With a few keystrokes,
you can stage or unstage several files at a time, or review and select changes
in particular files only. Alternatively, run *git commit \--interactive* which
automatically commits after you're done.

=== The Index: Git's Staging Area ===

So far we have avoided Git's famous 'index', but we must now confront it to
explain the above. The index is a temporary staging area. Git seldom shuttles
data directly between your project and its history. Rather, Git first writes
data to the index, and then copies the data in the index to its final
destination.

For example, *commit -a* is really a two-step process. The first step places a
snapshot of the current state of every tracked file into the index. The second
step permanently records the snapshot now in the index. Committing without the
*-a* option only performs the second step, and only makes sense after running
commands that somehow change the index, such as *git add*.

Usually we can ignore the index and pretend we are reading straight from and writing straight to the history. On this occasion, we want finer control, so we manipulate the index. We place a snapshot of some, but not all, of our changes into the index, and then permanently record this carefully rigged snapshot.

=== Đừng Quên HEAD của Mình ===

Thẻ HEAD giống như một con trỏ, nó trỏ đến lần commit cuối cùng, advancing with each new commit. Some Git commands let you move it. Ví dụ như:

 $ git reset HEAD~3

sẽ chuyển HEAD lên vị trí lần commit cách đây ba lần. Thus all Git commands now act as if you hadn't made those last three commits, while your files remain in the present. See the help page for some applications.

But how can you go back to the future? The past commits know nothing of the future.

Nếu bạn có giá trị băm SHA1 của HEAD gốc thì:

 $ git reset 1b6d

But suppose you never took it down? Đừng lo: for commands like these, Git ghi lại HEAD gốc với thẻ có tên là ORIG_HEAD, và bạn có thể trở về ngon lành và an toàn với lệnh:

 $ git reset ORIG_HEAD

=== HEAD-hunting ===

Có thể ORIG_HEAD là chưa đủ. Perhaps you've just realized you made a monumental mistake and you need to go back to an ancient commit in a long-forgotten branch.

By default, Git keeps a commit for at least two weeks, even if you ordered
Git to destroy the branch containing it. The trouble is finding the appropriate
hash. You could look at all the hash values in `.git/objects` and use trial
and error to find the one you want. But there's a much easier way.

Git records every hash of a commit it computes in `.git/logs`. The subdirectory `refs` contains the history of all activity on all branches, while the file `HEAD` shows every hash value it has ever taken. The latter can be used to find hashes of commits on branches that have been accidentally lopped off.

Lệnh reflog cung cấp cho chúng ta một giao diện thân thiện dành cho các tệp tin log. Hãy thử bằng lệnh:

  $ git reflog

Thay vì phải cắt và dán giá trị băm từ reflog, hãy thử:

 $ git checkout "@{10 minutes ago}"

Hay checkout lần thứ 5th-last visited commit via:

 $ git checkout "@{5}"

Xem chương ``Specifying Revisions'' từ lệnh *git help rev-parse* để biết thêm chi tiết.

You may wish to configure a longer grace period for doomed commits. For
example:

  $ git config gc.pruneexpire "30 days"

means a deleted commit will only be permanently lost once 30 days have passed
and *git gc* is run.

You may also wish to disable automatic invocations of *git gc*:

  $ git config gc.auto 0

in which case commits will only be deleted when you run *git gc* manually.

=== Building On Git ===

In true UNIX fashion, Git's design allows it to be easily used as a low-level component of other programs, như là giao diện đồ họa GUI và giao diện Web, thay thế cho giao diện dòng lệnh, patch managements tools, các công cụ nhập và chuyển đổi, và những thứ tương tự như thế. Trên thực tế, một số lệnh Git bản chất nó cũng là các kịch bản (scripts) standing on the shoulders of giants. With a little tinkering, you can customize Git to suit your preferences.

One easy trick is to use built-in Git aliases to shorten your most frequently
used commands:

  $ git config --global alias.co checkout
  $ git config --global --get-regexp alias  # display current aliases
  alias.co checkout
  $ git co foo                              # same as 'git checkout foo'

Another is to print the current branch in the prompt, or window title.
Invoking

  $ git symbolic-ref HEAD

shows the current branch name. In practice, you most likely want to remove
the "refs/heads/" and ignore errors:

  $ git symbolic-ref HEAD 2> /dev/null | cut -b 12-

The +contrib+ subdirectory is a treasure trove of tools built on Git.
In time, some of them may be promoted to official commands. On Debian and
Ubuntu, this directory lives at +/usr/share/doc/git-core/contrib+.

One popular resident is +workdir/git-new-workdir+. Via clever symlinking, this script creates a new working directory whose history is shared with the original repository:

  $ git-new-workdir an/existing/repo new/directory

The new directory and the files within can be thought of as a clone, except since the history is shared, the two trees automatically stay in sync. There's no need to merge, push, or pull.

=== Daring Stunts ===

These days, Git makes it difficult for the user to accidentally destroy data.
But if you know what you are doing, you can override safeguards for common
commands.

*Checkout*: Uncommitted changes cause checkout to fail. To destroy your changes, and checkout a given commit anyway, use the force flag:

  $ git checkout -f HEAD^

On the other hand, if you specify particular paths for checkout, then there are no safety checks. The supplied paths are quietly overwritten. Take care if you use checkout in this manner.

*Reset*: Reset also fails in the presence of uncommitted changes. To force it through, run:

  $ git reset --hard 1b6d

*Branch*: Deleting branches fails if this causes changes to be lost. Để ép buộc việc xóa, hãy gõ:

  $ git branch -D dead_branch  # instead of -d

Cũng tương tự như thế, attempting to overwrite a branch via a move fails if data loss would ensue. To force a branch move, type:

  $ git branch -M source target  # instead of -m

Không giống như checkout và reset, these two commands defer data destruction. The
changes are still stored trong thư mục con .git, and can be retrieved by
recovering the appropriate giá trị băm `.git/logs` (xem "HEAD-hunting" ở phía trên).
By default, they will be kept for at least two weeks.

*Clean*: Some git commands refuse to proceed because they're worried about
clobbering untracked files. If you're certain that all untracked files and
directories are expendable, then delete them mercilessly with:

  $ git clean -f -d

Next time, that pesky command will work!

=== Preventing Bad Commits ===

Stupid mistakes pollute my repositories. Most frightening are missing files due
to a forgotten *git add*. Lesser transgressions are trailing whitespace and
unresolved merge conflicts: though harmless, I wish these never appeared on the
public record.

If only I had bought idiot insurance by using a _hook_ to alert me about these problems:

 $ cd .git/hooks
 $ cp pre-commit.sample pre-commit  # Older Git versions: chmod +x pre-commit

Now Git aborts a commit if useless whitespace or unresolved merge conflicts are
detected.

Với bản hướng dẫn này, I eventually added the following to the beginning of the
*pre-commit* hook to guard against absent-mindedness:

 if git ls-files -o | grep '\.txt$'; then
   echo FAIL! Untracked .txt files.
   exit 1
 fi

Nhiều hoạt động của Git hỗ trợ hooks; hãy xem *git help hooks*. We activated the
sample *post-update* hook earlier when discussing Git over HTTP. This runs
whenever the head moves. Đoạn script ví dụ post-update cập nhật các tệp tin Git cần
for communication over Git-agnostic transports giống như là HTTP.