-
-
Save mohanmca/d405dd27fdfa92b51975 to your computer and use it in GitHub Desktop.
git-cheatsheet
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# Cloning a remote repository (SSH) | |
git clone <user@server:path/to/repo.git> | |
e.g. git clone [email protected]:TomyJaya/git-real.git | |
# Cloning a remote repository (https) | |
git clone <URL> | |
e.g. git clone https://github.com/TomyJaya/git-real.git | |
# Checking the Status of Your Files | |
git status | |
# add a file to staging/ index/ changeset | |
git add <file_name> | |
e.g. git add README.md | |
# Add all files to staging/ index/ changeset | |
git add . | |
# To see what youíve changed but not yet staged | |
git diff | |
# If you want to see what youíve staged that will go into your next commit. (cached and staged are synonymous) | |
git diff --cached | |
git diff --staged | |
# Commit your changes | |
git commit -m "<message>" | |
e.g. git commit -m "Initial Commit" | |
# Commit all modified files, by pass add to index or staging | |
git commit -a -m '<message>' | |
e.g. git commit -a -m 'added new benchmarks' | |
# Remove files | |
git rm <file> | |
e.g. git rm PROJECTS.md | |
# keep the file in your working tree but remove it from your staging area | |
git rm --cached <file> | |
e.g. git rm --cached README | |
# Renaming and Moving Files | |
git mv <file_from> <file_to> | |
e.g. git mv README.md README | |
# Retrieve logs (view commit history) | |
git log | |
git log --pretty=oneline | |
git log --pretty=format:"%h - %an, %ar : %s" | |
git log --pretty=format:"%h %s" --graph | |
git log --graph --oneline | |
git log --since=2.weeks | |
git log -Sfunction_name # Another really helpful filter is the -S option which takes a string and only shows the commits that introduced a change to the code that added or removed that string. | |
# Undoing Things (Changing the last Commit) | |
git commit -m 'initial commit' | |
git add forgotten_file | |
git commit --amend # You end up with a single commit ñ the second commit replaces the results of the first. | |
### donít amend your last commit if youíve already pushed it. | |
#Unstage staged files | |
git reset HEAD <file_name> | |
e.g. git reset HEAD CONTRIBUTING.md | |
# Undo commit/ local commit -- nuke last commit and never see it again. | |
git reset --hard HEAD~1 | |
# Undo commit/ local commit but keep your changes | |
git reset HEAD~1 | |
# Undo commit/ local but leave your files and your index: | |
git reset --soft HEAD~1 | |
# Revert changes (Unmodifying a Modified File) | |
"git checkout -- <file>..." to discard changes in working directory | |
e.g. git checkout -- CONTRIBUTING.md | |
WARNING: Itís important to understand that git checkout -- [file] is a dangerous command. Any changes you made to that file are gone ñ you just copied another file over it. Donít ever use this command unless you absolutely know that you donít want the file. | |
# Show all remotes ( remote repositories: versions of your project that are hosted on the Internet or network somewhere. ) | |
git remote | |
git remote -v # shows URL | |
# Adding remote repository | |
git remote add [shortname] [url] | |
e.g. git remote add pb https://github.com/paulboone/ticgit | |
IMPORTANT: | |
http://git-scm.com/book/en/v2/Git-Basics-Working-with-Remotes | |
- If you clone a repository, the command automatically adds that remote repository under the name ìoriginî. So, git fetch origin fetches any new work that has been pushed to that server since you cloned (or last fetched from) it. Itís important to note that the git fetch command pulls the data to your local repository ñ it doesnít automatically merge it with any of your work or modify what youíre currently working on. You have to merge it manually into your work when youíre ready. | |
- If you have a branch set up to track a remote branch, you can use the git pull command to automatically fetch and then merge a remote branch into your current branch. This may be an easier or more comfortable workflow for you; and by default, the git clone command automatically sets up your local master branch to track the remote master branch (or whatever the default branch is called) on the server you cloned from. Running git pull generally fetches data from the server you originally cloned from and automatically tries to merge it into the code youíre currently working on. | |
# Fetching and Pulling from Your Remotes | |
git fetch [remote-name] | |
e.g. git fetch origin | |
# Pushing to Your Remotes | |
git push origin master | |
# Inspecting a remote | |
git remote show origin | |
# Removing and Renaming Remotes | |
git remote rename pb paul | |
git remote rm paul | |
# Listing Your Tags | |
git tag | |
git tag -l 'v1.8.5*' # search with a particular pattern | |
# Tags (Lightweight and annotated) | |
# Annotated Tags | |
git tag -a <version_name> -m '<tag_message>' | |
e.g. git tag -a v1.0 -m 'my version 1.0' | |
# Show Tag information | |
git show v1.0 | |
# Lightweight tag | |
git tag v1.4-lw | |
# Tag a previous commit | |
git tag -a <version_name> <abbreviated_index_checksum> | |
e.g. git tag -a v1.2 9fceb02 | |
# Sharing Tags | |
git push origin [tagname] | |
e.g. git push origin v1.5 | |
git push origin --tags # transfer all of your tags to the remote server that are not already there | |
# Checking out Tags (can't really do that, instead, put a version of the repository in your working directory that looks like a specific tag): | |
git checkout -b version2 v2.0.0 # Create a new branch version2 which has contents as of tag v2.0.0 | |
#Set up Aliases: | |
git config --global alias.co checkout | |
git config --global alias.br branch | |
git config --global alias.ci commit | |
git config --global alias.st status | |
git config --global alias.unstage 'reset HEAD --' # Can do git unstage fileA instead of git reset HEAD fileA | |
git config --global alias.last 'log -1 HEAD' # see the last commit easily | |
# List all branches | |
git branch | |
git branch -v # with last commit on each branch | |
git branch --merged # only merged branch | |
git branch --nomerged # only unmerged branch | |
# Create a new Branch | |
git branch <new_branch_name> | |
# Switch to branch | |
git checkout <branch_name> | |
e.g. git checkout branch123 or git checkout master | |
# Shorthand to checkout and create a branch | |
git checkout -b <branch_name> | |
# Delete branch | |
git branch -d <branch_name> | |
# Force Delete branch (will delete even if there's unmerged changes) | |
git branch -D <branch_name> | |
# Git fetch and merge a branch (e.g. serverfix) | |
git fetch origin | |
git merge origin/serverfix | |
# If you want your own serverfix branch that you can work on, you can base it off your remote branch | |
git checkout -b serverfix origin/serverfix | |
# Tracking Branches | |
# Checking out a local branch from a remote branch automatically creates what is called a ìtracking branchî (or sometimes an ìupstream branchî). Tracking branches are local branches that have a direct relationship to a remote branch. If youíre on a tracking branch and type git pull, Git automatically knows which server to fetch from and branch to merge into. | |
git checkout --track origin/serverfix | |
# Add a tracking to an existing local branch | |
git branch -u origin/serverfix | |
# List tracking branches | |
git branch -vv | |
# Deleting Remote Branches | |
git push origin --delete serverfix | |
# Rebasing | |
# However, there is another way: you can take the patch of the change that was introduced in C4 and reapply it on top of C3. In Git, this is called rebasing. With the rebase command, you can take all the changes that were committed on one branch and replay them on another one. | |
git checkout experiment | |
git rebase master | |
git checkout master | |
git merge experiment | |
git rebase --onto master server client # Check out the client branch, figure out the patches from the common ancestor of the client and server branches, and then replay them onto master | |
git checkout master; git merge client # fast-forward your master branch | |
git rebase master server # You can rebase the server branch onto the master branch without having to check it out first by running git rebase [basebranch] [topicbranch] ñ which checks out the topic branch (in this case, server) for you and replays it onto the base branch (master): | |
git checkout master; git merge server # fast-forward the base branch (master): | |
### Do not rebase commits that exist outside your repository. | |
# Check for whitespace error | |
git diff --check | |
# Get abbreviated commit | |
git log --abbrev-commit --pretty=oneline | |
# get history of HEAD | |
git reflog | |
# get what was done in a branch yesterday | |
git show master@{yesterday} | |
# get all commits reachable by experiment that arenít reachable by master | |
git log master..experiment | |
# to see what youíre about to push to a remote: | |
git log origin/master..HEAD | |
# see all commits that are reachable from refA or refB but not from refC | |
git log refA refB ^refC | |
git log refA refB --not refC | |
# Triple Dot: all the commits that are reachable by either of two references but not by both of them. | |
git log --left-right master...experiment | |
# Saving changes before switching branch without commit (Stashing) | |
git stash | |
git stash save | |
git stash -u | |
git stash --include-untracked # Git will also stash any untracked files you have created | |
# see list of stash | |
git stash list | |
# apply latest stash | |
git stash apply | |
# apply a specific stash | |
git stash apply stash@{2} | |
# delete stash | |
git stash drop stash@{0} | |
# pop stash | |
git stash pop | |
# Cleaning working directory | |
git clean | |
git clean -d -n # -n option, which means ìdo a dry run and tell me what you would have removedî. | |
# Create a branch from a stash | |
git stash branch testchanges | |
# remove everything but save it in a stash. | |
git stash --all | |
# Git Grep (Search for occurences of string of chars) | |
git grep -n <phrase> #will show line number | |
git grep --count <phrase> # will show count | |
git grep -p <phrase> # will find method | |
git grep --break --heading -n <phrase> # more readable format |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment