Git

# open locally stored HTML man page in browser
$ git help <subcommand>			
$ git <subcommand> --help

# view help doc in terminal
$ git <subcommand> -h 				

$ git init

$ git status

# Staging (wildcards allowed)
$ git add <filenames/dirnames>

# Commiting
$ git commit -m "my first commit"

# combine add and commit; won't work if any new file was created and is still untracked
$ git commit -a -m "made changes to existing files only"

# Amending last commit (will overwrite a previous commit)
$ git commit --amend -m "forgot to add a file in repo"

# Amending last commit (but only change author info and not message)
$ git commit --amend --no-edit

# Pushing to remote (if remote is already set)
$ git push

# View Commit History of current branch
$ git log
# View Commit History of all branches
$ git log --all
# Show logs in an ASCII graph
$ git log --graph
# Show each logs in a single line
$ git log --oneline

HEAD 		latest commit in the current branch

HEAD^ 		parent of last commit in current branch
HEAD~ 		same as above
HEAD^^ 		parent of parent of last commit in current branch

HEAD~1 		parent of last commit in current branch
HEAD~2 		parent of parent of last commit in current branch
HEAD~n 	 	jump to nth commit from HEAD

# git commit --amend (see above section)

# Undoing before staging = make file as-in latest commit (can use "git reset --hard" too)
$ git checkout <file/dir>

# Undoing after staging but before commiting = unstage and make file as-in latest commit (can use "git reset --hard" too)
$ git reset <file/dir>
$ git checkout <file/dir>

# Undoing after committing
# remove commits but don't unstage files
$ git reset --soft <commit_hash>

# remove commits and unstages files; default
$ git reset --mixed <commit_hash>

# remove commits, unstage files, and undo any file modifications since!
$ git reset --hard <commit_hash>


# a newer "restore" command is also an alternative of reset but its dangerous (avoid it!)
# default command is equivalent to reset --hard!
$ git restore <file/dir> 

# unstaging
$ git restore --staged <file/dir>


# if the commits we deleted with reset were already pushed to remote, we can do a force push (very bad practice!)
$ git push -f

# Undoing Committed Changes = reverting
$ git revert HEAD
# or
$ git revert <hash> 

# add remote
$ git remote add foobar <URL>

# list all remotes
$ git remote -v

# renaming remotes (change remote name from "origin" to "foobar")
$ git remote rename origin foobar

# remove remote
$ git remote remove foobar

# set upstream branch for "bar" to "foo"
$ git branch --set-upstream-to=origin/foo bar

# set current tracking branch's upstream branch; req only on first push to remote
$ git push --set-upstream origin foobar
$ git push -u origin foobar  # same as above

# show upstream info of all branches
$ git branch -vv

# pulling from a remote branch (if upstream isn't set)
$ git pull origin master

# pushing to a remote branch (if upstream isn't set)
$ git push origin master

# if upstream has been set, use normal ones
$ git pull
$ git push

# view all
$ git tag

# view a specific tag ("v1.0.foo")
$ git show v1.0.foo

# create new lightweight tag (tags the latest commit)
$ git tag v2.0 -m "an optional message"

# create new annotated tag (better as it stores more info about creator)
$ git tag -a v2.0 -m "an optional message"

# create a tag for an existing commit (and not only for the latest commit)
$ git tag -a v2.0 -m "an optional message" <commit_hash>

# remove
$ git tag -d v2.0

# tags have to be explicitly pushed (they won't be pushed to remote with a normal push)
$ git push origin v2.0

# push all tags
$ git push --tags

# Create branch
$ git branch <branchname> 
# Checkout to that branch
$ git checkout <branchname>
# Combined
$ git checkout -b <brachname>

# Jump to another branch
$ git checkout foobar
# Goto previous branch
$ git checkout -

# View all local branches
$ git branch
# View all local and remote branches
$ git branch -a

# Delete branch (if no unmerged changes are there in it), we can't delete branch we're currently on (obviously, lol!)
$ git branch -d <branchname>
# Deleting using above won't delete branches from remote, use below to do so
$ git push -d <remotename> <branchname>

# create a new branch, and checkout to it
$ git switch -c foobar

# jump to another branch
$ git switch master

# create branch from an earlier commit
$ git branch foo <commit_hash>

# when we use branch command without the <commit_hash>, HEAD is passed as default

# Go to a previous commit (detached head state)
$ git checkout <hash>

# to get out of detached head state
$ git checkout -
# or
$ git checkout <branchname>

# goto foobar
$ git checkout foobar
# merge changes from master into foobar
$ git merge master

# alternatively, we can pull too 
$ git pull master

# resolve conflict manually and add, commit the files or abort the merge
$ git merge --abort

# merge strategy - biased merge with our/their changes only
$ git merge --strategy-option theirs
$ git merge --strategy-option ours

# use strategy on individual files/dirs
$ git checkout --theirs <file/dir>
$ git checkout --ours <file/dir>

# rebase "feature" branch onto "master" branch
$ git checkout feature
$ git rebase master

# Stashing changes
$ git stash
# View all stashes (latest is stash@{0}, then stash@{1} and so on...)
$ git stash list
# Apply stash (apply but don't remove stash from list)
$ git stash apply stash@{0}
# git stash pop (apply latest stash and then remove it, if merge conflict then don't remove)
$ git stash pop
# git stash pop (apply a stash and then remove it, if merge conflict then don't remove)
$ git stash pop stash@{2}
# remove all stashes
$ git stash clear

# default = all branches
$ git reflog 

# show ref logs related to specific branch only
$ git reflog <branch_name>

# can see ref log for stashes too
$ git reflog stash

# show reflog for all refs (all branches and stashes)
$ git reflog --all

# Clone - download remote repository to local filesystem
$ git clone <repo_url>

# SSH preferred for all communications with GitHub

# Fork
# PR (Pull Request)

# Aliases can be set via terminal (using alias command) or by editing ".git/config": 
[alias]
  	co = commit
  	st = status
  	br = branch
  	hist = log --pretty=format:'%h %ad | %s%d [%an]' --graph --date=short

# between working dir and the index (same as "git status -vv")
$ git diff

# between the index and the most recent commit
$ git diff --staged
# or
$ git diff --cached

# between working dir and the most recent commit (most useful!)
$ git diff HEAD

# between local and upstream branch
$ git diff origin/foo foo

# between local and upstream branch for a single file
$ git diff origin/foo foo file.txt

# between two commits
$ git diff <commit_hash1> <commit_hash2>