A git tutorial listed the much-used commands for most of git users

1. Git for absolutely
beginners
Dong-Yi Wu
2016

2. First of all, VCS
• VCS: Version Control System
• Keep tracking modifications over files
• Centralized Version Control Systems
• CVS, Subversion, Perforce
• Distributed Version Control Systems
• Git, Mercurial, Bazaar, Darcs

3. Major differences
• Centralized v.s. distributed
• everything is local
• Diff v.s. snapshot

4. Installation
• Mac - homebrew
• brew install git
• Windows
• Download git installer from git’s website
• Linux - package managers
• apt-get / aptitude / yum / rpm

5. Start working with git
• You usually start with:
• Make your own: git init
• Contains only master branch
• Work with existing project: git clone <url>

6. Terminology
• Working tree: the physical
working directory managed
by git
• Index: holds a snapshot of
the content of the working
tree, and it is this snapshot
that is taken as the
contents of the next
commit. Thus after making
any changes to the working
tree, and before running the
commit command, you
must use the add
command to add any new
or modified files to the
index.
• Repository: where git stores
files. All commits are
recorded by repository
https://dotblogs.com.tw/wasichris/2016/04/29/225157

7. Branches
• stable
• master
• stable master approach (commonly with develop branches)
• unstable master approach (accepts merges from feature/
issue and hotfix, with a stable branch)
• feature/issue
• hotfix
• wip (work in progress)

8. Setup identification info
• git config —global user.name “Tony Stark”
• git config —global user.email
“shh_not_ironman@stark.com”
• To configure different info for different projects, run the
previous command in the project without option —global
• To check config
• git config —list —global
• git config —list

9. .gitignore
• It indicates “what” shall not be tracked
• Directories
• build intermediates
• Build/Output
• build/
• Pods/
• Certain type of files
• .DS_Store, Gemfile.lock, Podfile.lock
• Comments start with pound sign(#)

10. add
• Add file contents to the index
• git add <paths> …
• git add .
• You may add files by regex
• git add *.sh
• -i: interactive
• Unless you have nicely composed .gitignore, using command
git add . might add files that are not suppose to be tracked

11. add - interactive

12. rm
• Remove files from the working tree and from the index
• git rm [—cached | -f] <paths>….
• git rm [—cached | -f] -r .
• —cached
• Unstages and keeps file
• -f
• Unstages and removes files
• -r
• recursive, along with .

13. diff
• Show changes between commits, commit and working tree, etc
• git diff
• git diff <base> <target>
• a base or a target can be a hash of a commit, a branch or a reference to a commit.
• Examples of a reference to a commit
• HEAD, HEAD~1, HEAD@{1}
• stash, stash@{1}
• master~1, master~5
• 044517c6faf3757f1f2ea4844d824bd397d488c9~1
• the commit prior the hash

14. diff and patch
• You may also generate patch file by:
• git diff <base> <target> > <patch_file>
• If the change involves binary files: git diff —
binary <base> <target>
• To apply the patch git apply <patch_file>, or
git apply —binary <patch_file> if the patch
contains binary diff

15. status
• Show the working tree status
• git status

16. reset
• Reset current HEAD to the specified state
• git reset [—soft | — mixed | —hard] <hash / ref>
• —soft
• reset only the repository to the specified state, preserving the content of
working tree and index/cache
• —mixed
• reset the repository and the index/cache, while preserving the content of
working tree
• —hard
• Do not preserve the information of the original commit. It resets working tree,
index/cache and the repository

17. revert
• Revert some existing commits
• git revert <commit/ref>
• revert a single commit
• git revert —continue
• Resolve conflicts and continue
• git revert —abort
• Abort revert
• git revert -n master~4…master~2
• Reverting from the forth latest commit of master(included) to the second
latest commit of master(included) without committing the revert(flag -n).

18. Resolving conflicts
• From time to time, you encounter conflicts to be
solved
• Check the blocks surrounded by conflict markers
and revise them properly

19. Resolving conflicts

20. cherry-pick
• Apply the changes introduced by some existing commits
• git cherry-pick <ref/commit>
• git cherry-pick brach~2
• git cherry-pick
00492d0a930cfc3e9a891151b62ea0d5629fc5f5
• git cherry-pick —continue
• git cherry-pick—abort

21. stash
• Stash the changes in a dirty working directory away
• git stash
• stash the changes
• git stash list
• show the stash list
• git stash drop [<stash>]
• Remove a single stashed state from the stash list
• stash ref is in form stash@{<revision>}
• If no <stash> is given, it removes the latest one.
• git stash clear
• Remove all stashed changes. Use with caution.

22. stash - cont.
• git stash pop [<stash>]
• Remove a single stashed state and apply it to the top of current working
tree state
• git stash apply [<stash>]
• Like pop, but do not remove the stash from the stash list
• git branch <branch name> [<stash>]
• Creates and checks out a new branch named <branchname> starting from
the commit at which the <stash> was originally created, applies the
changes recorded in <stash> to the new working tree and index. Then, the
stage is dropped
• If no <stash> given, the latest is applied.

23. commit
• Record changes to the repository
• git commit -m <your message>
• git commit —interactive
• git commit -a | —all
• automatically stage files that have been modified and
deleted, but new files you have not told Git about are not
affected.
• git commit —amend
• Amend new changes to previous commit

24. commit -a, —all

25. branch
• List, create, or delete branches
• git branch <branch name>
• Create a branch
• git branch [-r]
• list branches, with -r shows remote ones
• git [—set-upstream-to=<upstream> | -u <upstream> | unset-upstream] <branch name>
• set/remove the upstream of the branch
• git branch [-d | -D] <branch name>
• delete a branch. -D is a shortcut for ‘-d -f’
• git -m <old branch name> <new branch name>
• Rename/move a branch

26. checkout
• Switch branches or restore working tree files
• git checkout <branch>
• Switch to the specified branch
• git checkout — .
• Restore working tree state
• git checkout -b <branch> —track <remote>/<branch>
• Create, checkout and track a remote branch with a local branch
• git checkout [—ours | theirs] — <paths>
• —ours: apply working tree with your change
• —theirs: apply working tree with the change made by others

27. tag
• Create, list, delete or verify a tag object signed with GPG
• git tag -a <tag name> [-m <message>]
• light-weight tag: no -m option
• annotated tag: with -m option
• git tag -s <tag name> [-m <message>]
• similar with -a, it signs GPG signature to the tag
• git tag -l <pattern>
• list tags that matches the pattern
• e.g, git tag -l ‘v1.*’
• git tag -d <tag name>
• Delete tag with the tag name
• NOTE
• Tags are usually used to tag official release versions or milestone versions

28. push
• Update remote refs along with associated objects
• git push origin <local branch>
• You may need to setup upstream

29. pull
• Fetch from and integrate with another repository or
a local branch
• git pull

30. merge
• Join two or more development histories together
• git merge <branch>
• Merge <branch> into current branch
• git merge —abort
• Abort merging when you did a mess
• Merging ends with commit command

31. rebase
• Reapply commits on top of another base tip
• git rebase <branch>
• Rebase current branch with <branch>
• git rebase —continue
• Continue rebasing after solving conflicts
• git rebase —skip
• When rebasing encounters no changes, use this option to skip the commit
and continue rebasing
• git rebase —abort
• Abort rebasing when you messed up

32. Rebase or merge?
• “If you would prefer a clean, linear history free of
unnecessary merge commits, you should reach
for git rebase instead of git merge when
integrating changes from another branch.” —
Atlassian
• https://www.atlassian.com/git/tutorials/merging-vs-
rebasing/conceptual-overview

33. Rebase or merge?
• Rebasing tremendous amount of changes may be
difficult. Merging would be easier in this case

34. reflog
• Manage reflog information
• A mechanism to record when the tip of branches are updated
• You may have a chance of getting lost commits back (such as losing DETACHED
branch). It will give you the commit hashes of the mis-placed commit
• Once you got the commit hash or ref:
• git checkout <hash/ref>
• Example:
• git checkout refs/heads/master@{10}
• git checkout HEAD@{3}
• git checkout d7a4926

35. reflow - cont.
• git reflog
• Show reflogs
• git reflow —all
• Process the reflogs of all references

36. git blame
• Show what revision and author last modified each line
of a file
• git blame <path>
• Blame a single file
• git blame -L <start>, <end> <path>
• Blame a single file with a range. The simplest is
number, such as -L 1,10 (blame from line 1 to line
10)

37. log
• Show commit logs
• git log
• Show commit logs of current branch
• git log -S <pattern>
• you may use it to find commits of a deleted line with certain keyword
or pattern
• e.g. git log -S ‘to be deleted’
• git log —graph
• Show a text-based graphical representation of the commit history

38. git fetch
• Download objects and refs from another repository
• git fetch
• When you have problems of refs with your local git
repo, usually you may fix them by this command

39. Appendix: Rebasing a
branch pushed to remote
• git checkout <the branch>
• git pull
• get the latest changes
• git rebase <another branch>
• Resolve conflicts if any, until all changes applied
• git rebase —continue
• When you’re done with rebase, you may find you cannot push the branch. DON’T PANIC!
• git pull
• if you didn’t set upstream, set it first
• git commit