Tool

Git

Basic usage of git.

Move tmp content from one computer to another

On Machine A

First, create a branch named tmp and commit your tmp work there.

1
2
3
git checkout -b tmp
git add .
git commit -m "tmp"

Then, push local tmp branch to remote tmp branch.

1
git push origin tmp

You can restore the state of your local workspace by:

1
2
3
4
5
6
7
git checkout master

git merge tmp
git reset --soft HEAD~1
git restore --staged .

git branch -D tmp

On Machine B

Fetch the tmp remote branch locally:

1
git fetch origin tmp:tmp

Merge content of tmp branch into your main branch:

1
git merge tmp

Reset soft and restore so that the last commit is reverted:

1
2
git reset --soft HEAD~1
git restore --staged .

Delete the local and remote tmp branch:

1
2
3
git branch -D tmp

git push origin --delete tmp

Sync with Remote

Stash your unstaged work to make your working dir clean:

1
git stash

Fetch remote branch and merge:

1
git pull origin main

Git stash pop:

1
git stash pop

Alternatively, you can use the --autostash flag to handle this entire workflow in a single command:

1
git pull origin main --autostash

Squashing Git Commits

https://gist.github.com/patik/b8a9dc5cd356f9f6f980

1
2
git reset --soft HEAD~3
git commit -m "Squashing Git Commits"
1
git push origin +master
1
2
3
4
5
6
7
git log --author=songzy
git reset f7f4aec68
git log -2
git reset 7e26106
git log -2
git clean -df
git checkout -- .

git reset

1
git reset <file>

Remove the specified file from the staging area, but leave the working directory unchanged.

1
git reset

Reset the staging area to match the most recent commit, but leave the working directory unchanged.

1
git reset --hard

Reset the staging area and the working directory to match the most recent commit.

1
git reset <commit>

Move the current branch tip backward to , reset the staging area to match, but leave the working directory alone. 

1
2
git reset --hard <commit>

Move the current branch tip backward to and reset both the staging area and the working directory to match.

Whereas reverting is designed to safely undo a public commit, git reset is designed to undo local changes.

1
2
3
4
5
git add foo.py
git commit -m "Start developing a crazy feature"
git commit -a -m "Continue my crazy feature"
git reset --hard HEAD~2

The git reset HEAD~2 command moves the current branch backward by two commits.

git rebase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Add the remote, call it "upstream":

git remote add upstream https://github.com/whoever/whatever.git

# Fetch all the branches of that remote into remote-tracking branches,
# such as upstream/master:

git fetch upstream

# Make sure that you're on your master branch:

git checkout master

# Rewrite your master branch so that any commits of yours that
# aren't already in upstream/master are replayed on top of that
# other branch:

git rebase upstream/master

git push -f origin master

git branch

1
git show-branch -a

Show branches and their commits

1
git branch <branch>

Create a new branch called . This does not check out the new branch.

1
git branch -d <branch>

Delete the specified branch.

1
git branch -D <branch>

Force delete the specified branch, even if it has unmerged changes. 

1
git branch -m <branch>

Rename the current branch to <branch>.

1
2
git checkout $branch2
git merge $branch1

Merge branch1 into branch2.

1
warning: refname 'HEAD' is ambiguous.
1
2
git branch -m HEAD temp
git branch -d temp

git checkout

Give up the current modification and go back to the last commit

1
git checkout -- .
1
2
3
4
5
6
7
git log --oneline

b7119f2 Continue doing crazy things
872fa7e Try something crazy
a1e8fb5 Make some important changes to hello.py
435b61d Create hello.py
9773e52 Initial import

You can find the ID of the revision you want to see.

1
2
git checkout a1e8fb5
git checkout master

Nothing you do in here will be saved in your repository. 

1
2
git checkout a1e8fb5 hello.py
git checkout HEAD hello.py

Unlike checking out a commit, this does affect the current state of your project. 

1
2
git status
HEAD detached From 91ea20b
1
2
3
4
5
git checkout source
error: Your local changes to the following files would be overwritten by checkout:
        source/_posts/2016-02-25-github.markdown
Please, commit your changes or stash them before you can switch branches.
Aborting
1
2
git stash
git checkout source

git clean

1
git clean -n

This will show you which files are going to be removed without actually doing it.

1
git clean -f

Remove untracked files from the current directory.

1
git clean -f <path>

Remove untracked files, but limit the operation to the specified path.

1
git clean -df

Remove untracked files and untracked directories from the current directory.

1
git clean -xf

Remove untracked files from the current directory as well as any files that Git usually ignores.

git clone

If you clone a repository, the default branch you have is whatever the remote’s HEAD points to (HEAD is actually a symbolic ref that points to a branch name).

A symbolic ref is a regular file that stores a string that begins with ref: refs/. For example, your .git/HEAD is a regular file whose contents is ref: refs/heads/master.

HEAD@{1} is always last value of HEAD, ORIG_HEAD is last value of HEAD before dangerous operation.

git commit

1
git commit --amend

Combine the staged changes with the previous commit and replace the previous commit with the resulting snapshot.

1
git commit -a

Commit all your local changes. (like git add . followed by git commit)

git config

1
vi ~/.gitconfig
1
2
git config --global user.email "your_email@example.com"
git config --global user.email

git diff

1
git diff filename

git fetch

1
git fetch

Fetch all of the branches from the repository. This also downloads all of the required commits and files from the other repository.

1
2
3
git checkout master
git log origin/master
git merge origin/master
1
error: RPC failed; result=18, HTTP code = 0
1
2
git fetch origin master
git merge origin/master

git format-patch

1
2
3
$ git format-patch -o ./patches -2
0001-C.patch
0002-D.patch
1
git am ./patches/*

git log

Check all the change paths to file Predictor.java.

1
2
git log --follow -p Predictor.java
git log -p -1

git merge

1
git merge --squash <branch_name>

將另一個 branch 的 commit 合併為一筆，特別適合需要做實驗的 fixes bug 或 new feature，最後只留結果。合併完不會幫你先 commit。

git pull

1
git pull <远程主机名> <远程分支名>:<本地分支名>

如果远程分支是与当前分支合并，则冒号后面的部分可以省略。

Here.

1
ssh: connect to host github.com port 22: Connection refused
1
2
3
4
5
vi ~/.ssh/config

Host github.com
  Hostname ssh.github.com
  Port 443

git push

1
git push <远程主机名> <本地分支名>:<远程分支名>
1
git push origin HEAD:master

See the commits tab(rather than project tab). It is all there.

1
ssh -v -T songzy12@git.tsinghuax.org

IP filtered, move to your lab.

1
fatal: Could not read from remote repository.

Server down.

git remote

1
git remote set-url origin git@github.com:songzy12/certificate_predictor.git

git revert

1
git revert <commit>

Generate a new commit that undoes all of the changes introduced in <commit>, then apply it to the current branch.

  • it doesn’t change the project history
  • it is able to target an individual commit at an arbitrary point in the history
1
2
git commit -m "Make some changes that will be undone"
git revert HEAD

git rm

1
git rm -r --cached ".\source\_posts\Git Shell.lnk"

The git rm command will allows you to remote a file from git control. The –cached option to git remove allows you to leave it on your hard drive.

git stash

1
2
3
4
5
git stash
git stash list
git stash pop
git stash clear
git stash drop

fileMode

  • 100644: normal file
  • 100755: executable file
  • 120000: symbolic link

The mode is taken from normal UNIX modes but is much less flexible – these three modes are the only ones that are valid for files (blobs) in Git (although other modes are used for directories and submodules).

The 6 digits show the file mode using the classical UNIX notations. First two digits show file type, the third one is about set-uid/set-gid/sticky bits, and you know the last three. 4\2\1 is just r\w\x.

1
man 2 stat
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
S_IFLNK    0120000   symbolic link
S_IFREG    0100000   regular file

S_IRWXU    00700     mask for file owner permissions
S_IRUSR    00400     owner has read permission
S_IWUSR    00200     owner has write permission
S_IXUSR    00100     owner has execute permission
S_IRWXG    00070     mask for group permissions
S_IRGRP    00040     group has read permission
S_IWGRP    00020     group has write permission
S_IXGRP    00010     group has execute permission
S_IRWXO    00007     mask for permissions for others (not in group)
S_IROTH    00004     others have read permission           
S_IWOTH    00002     others have write permission
S_IXOTH    00001     others have execute permission

To ignore file mode changes:

1
repo forall -c git config core.fileMode false