Get Acquainted With Git*
git init
Creates a new Git repository in the current directory. In addition, a directory named .git is added to the folder. This folder holds all the Git history and information for the repo. To get rid of the repo, just delete the .git folder
git status
Show me the current status of the repository. Shows
- Untracked files -- new files that have not be added to the staging or committed
- Files that are tracked, have been changed but have not been staged
- Staged files -- files that have been added but not commited
git add .
Adds all the files in the current directory to staging.
git add -A
Adds all files in the current repo (even new files that are not yet tracked)
git add -u
Add all files that are already being tracked (ignore new files)
git add -p
Add just parts of changes to a file. "p" stands for patch and lets you go through each section of a file that has changed and add (stage) just parts of the file
git add <path/to/file>
Adds specified file to staging
git commit -m "Add file to repo"
Commit staged files to the repo
git commit --amend -m "New Message"
Changes the commit message for the last commit
git commit -am "New Message"
Lets you add and commit all tracked, modified files in one step.
git commit --amend -m "New commit message" Replace last commit. Use this if you forgot something that you wanted to inlcude in the last commit. Creates a new Git SHA.
git log
Show a log of all commits.
git log --oneline
Show a log of all commits, one line per commit. Can make this the default by git config format.pretty oneline
git diff
Show differences between working tree and staging (or last commit)
git diff -- staged
Show differences between staged changes and repository
git diff -- <path to file/path to directory>
Show differences for specific file or directory
git rm <path/to/file> Remove a file that's being tracked in the repo. If you haven't yet added the file to staging, this will produce an error. You may need to force the removal if the file is staged but not committed: git rm -f <path/to/file>
git rm -r <path/to/directory> Remove a directory's worth of files. Also removes the directory. Directories themselves aren't tracked in Git. You may need to force the remove if a file in the directory is staged but not committed: git rm -rf <path/to/directory>
git mv <path/to/file> <path/to/new-file-name> Move a file that's been committed to the repo.
git mv <path/to/directory> <path/to/new-directory-name> Move a directory (and its files).
git checkout -b <name_of_branch>
Create a branch and check it out in one step
git branch <name_of_branch>
Create a branch, but stay in current branch.
git checkout <name_of_branch>
Check out an already created branch
git branch
See a list of all branchs, highlights the currently checked out branch
git checkout master
Checkout master branch
git branch -d <name_of_branch>
Remove branch locally, but only if you've merged branch.
git branch -D <name_of_branch>
Remove branch even if you haven't merged changes.
git checkout master
git merge <name_of_branch>
Return to master branch and merge changes from <name_of_branch> branch
git reset HEAD <path/to/file> Unstage a file. (HEAD represents the current commit)
git reset HEAD Unstage all staged files.
git checkout <path/to/file> To revert to the last committed version of a file but only if a) the file has been committed and b) is not currently in staging
git checkout HEAD^ <path/to/file> Revert to version of file from prior commit (HEAD^ represents the prior commit). Careful: this overwrites changes to files in your working branch.
git checkout <sha-of-commit> <path/to/file> Revert to version of file from specific commit
Be careful with these commands when working on a shared repository -- for example with Github. Resetting commits changes the "history" of the repo -- so only use it to back out of local commits that haven not been pushed to a shared repository.
git branch <name_of_backup_branch> Precaution: always create a backup branch before doing any undo commits. git merge <name_of_backup_branch> If anything goes wrong during undo commits, you can always roll back to normal using the backup branch.
git reset --soft HEAD^ Undo last commit of entire repo, but leave files staged.
git reset --hard HEAD^ Completely blow away last commit. Changes files to state of previous commit.
git reset --hard HEAD^^ Completely blow away last two commits. Changes files to state of previous commit.
git reset --hard HEAD^^^ Completely blow away last three commits. Changes files to state prior to last third commit.
git reset --hard <sha-of-commit> Returns files to state they were in after specificed commit
git diff View differences between current working files and staging area (or if files aren't staged compare working with last commit).
git diff <path/to/file> View differences between current working file and staging area (or if file isn't staged compare working with last commit).
git diff --staged View differences between staged files and last commit.
Don't work on the master branch.
Master branch should hold your working, production files. Don't mess with them. When you need to fix something, or add a new feature to your project, create a new working branch. Make changes to that branch, then merge them into the master branch when done. You can then deploy your master branch (push it up to a web server, for example)
- Make sure master is up-to-date. Add and commit files, if there are any.
- Create and checkout a new working branch:
git checkout -b <working_branch_name> - Make changes to this branch. Make sure to add files and make commits along the way.
- When done with branch:
git statusJust to check and make sure that there are no outstanding changes that have yet to be committed. If there are, add and commit files. - Switch back to master
git checkout master - Merge changes from working branch
git merge <working_branch_name> - Remove branch
git branch -d <working_branch_name> - Deploy master (push to web server for example).
- Repeat steps 1-8 for your next feature/set of changes.
If things gets TOTALLY messed up in your working branch, you can just switch back to the master branch and delete the working branch:
git checkout mastergit branch -D <working_branch_name>
Then just follow steps 1-7 again.
git config --global alias.st status Lets you just type git st whenever you want to see the status of the repo
git config --global alias.co checkout Lets you just type git co whenever you want to checkout a branch
git config --global alias.ci commit Lets you just type git ci whenever you want run a commit