Need help with get-acquainted-with-git?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

202 Stars 69 Forks 44 Commits 0 Opened issues

Services available


Need anything else?

Contributors list

# 499,149
34 commits
# 786,730
1 commit
# 786,731
1 commit
# 413,544
1 commit

Get Acquainted With Git*

Basic Commands

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 
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 -- 
Show differences for specific file or directory

Managing Files and Directories

git rm 
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 

git rm -r 
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 

git mv  
Move a file that's been committed to the repo.

git mv  
Move a directory (and its files).

Creating and Using Branches

git checkout -b 
Create a branch and check it out in one step

git branch 
Create a branch, but stay in current branch.

git checkout 
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 
Remove branch locally, but only if you've merged branch.

git branch -D 
Remove branch even if you haven't merged changes.

git checkout master

git merge 
Return to master branch and merge changes from branch

Getting Out of Changes

File Fixes

git reset HEAD 
Unstage a file. (HEAD represents the current commit)

git reset HEAD
Unstage all staged files.

git checkout 
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^ 
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  
Revert to version of file from specific commit

Undo Commits

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 Precaution: always create a backup branch before doing any undo commits. git merge 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 
Returns files to state they were in after specificed commit

Finding Differences Between Versions

git diff
View differences between current working files and staging area (or if files aren't staged compare working with last commit).

git diff 
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.

A Simple Workflow

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)

  1. Make sure master is up-to-date. Add and commit files, if there are any.
  2. Create and checkout a new working branch:
    git checkout -b 
  3. Make changes to this branch. Make sure to add files and make commits along the way.
  4. When done with branch:
    git status
    Just to check and make sure that there are no outstanding changes that have yet to be committed. If there are, add and commit files.
  5. Switch back to master
    git checkout master
  6. Merge changes from working branch
    git merge 
  7. Remove branch
    git branch -d 
  8. Deploy master (push to web server for example).
  9. 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:

  1. git checkout master
  2. git branch -D 

Then just follow steps 1-7 again.

Useful Configuration Options

git config --global status
Lets you just type
git st
whenever you want to see the status of the repo

git config --global checkout
Lets you just type
git co
whenever you want to checkout a branch

git config --global commit
Lets you just type
git ci
whenever you want run a commit

*This just covers some basic Git commands. Doesn't cover remote repos,

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.