Basic Git Commands: A Comprehensive Cheat Sheet
Git is hands down the most popular open-source version control system available for developers and project managers to date, making it essential to learn and understand the basics for managing your projects.
In this comprehensive guide, we'll cover all of the basic Git commands so you can get a jump-start on your projects quickly and with ease.
When moving around in your repositories, you'll need to tell Git who you are, something especially useful when collaborating with other developers. They need to know who you are, how to contact you, and who made the changes. These two commands tell Git your name and email address:
git config --global user.name "Josh Rowe"
git config --global user.email firstname.lastname@example.org
--global flag instructs Git to set these parameters for all your repositories so you don't have to in future projects.
Keep in mind that Git will strip some characters from the values you pass in.
Create A New Local Repository
To create a new repository on your local machine, use the following command:
Running this command will generate a
.git subdirectory in your current working directory, containing all of the necessary Git metadata for your new repository.
Check Out an Existing Repository
The following command will clone an existing repository to your local machine, providing a direct copy from the source location that you can then make updates to and commit to, provided you have the necessary permissions:
git clone /path/to/repository
If you're cloning from a remote server, the command will look something like this:
git clone username@hostname:/path/to/repository
You'll need to ensure you have at least read-only access to the remote repository before cloning it.
Pull Changes from a Remote Repository
Fetch and merge changes from a remote repository to your local working directory:
This command will overwrite any changes you've made or alert you of any potential merging issues, so make sure you have everything saved and look out for warning messages after running this command.
Add Files to Staging
You can add individual files to your local index:
git add [filename]
You can add files from an entire directory to your local index:
git add /directory/path
Or, you can add all files within your working directory instead of listing them out manually one by one, which is useful when creating a new project with a lot of files:
git add *
To commit changes made to existing files to head, use the following command:
git commit -m "List changes"
To commit any files you've added with
git add and commit changes made to existing files, run this command:
git commit -a
You can also combine the
-m flags into a single command:
git commit -am "List changes"
Pro Tip: Keep your commit messages short and to the point, so you can easily find past commits later if you need to go back.
git commitcommand only commits changes to your local index, not to the remote repository. You'll also need to run a
git pushcommand, which we'll cover shortly.
Connect to a Remote Repository
If you need to connect your local working directory to a remote server, add the server with this command so you can push changes to the connected repository:
git remote add origin [server]
Push Changes to a Remote Repository
Once you've committed your changes to head on your local machine, you'll need to push them out to the remote repository. The following command will upload your changes to your currently checked-out branch.
If you need to upload your changes to a branch that doesn't currently exist in your remote repository, you can specify the branch name from your local working directory so that it gets created:
git push origin [branch-name]
Create a new branch in your local working directory and switch to it automatically once created:
git checkout -b [branch-name]
Switch to an existing branch:
git checkout [branch-name]
List all available branches in your local working directory and display the name of the branch you're currently working in:
Delete a branch from your local working directory:
git branch -d [branch-name]
Push all branches to your remote repository:
git push --all origin
List Files Added or Changed
To list the files you've added or changed since your last commit, use the following command:
Review Files, Branch Changes & Conflicts
You can review any additions, changes, or deletions of file contents between your current working file versions and the committed versions in your local index. View all changes made:
Review changes or conflicts within a single file:
git diff --base [filename]
Preview changes between two branches before merging them:
git diff [source-branch-name] [target-branch-name]
[source-branch-name] is the name of the branch you've made changes to and
[target-branch-name] is the name of the branch you'll be merging into.
Now that you've reviewed your changes, you can merge changes from an existing branch into your active branch:
git merge [branch-name]
If you make a mistake or need to drop all of your local changes that haven't been committed yet, you can fetch the latest history from the remote server, replacing your local files with the latest from the remote repository:
git fetch origin
git reset --hard origin/master
Note: Running these commands will overwrite any unsaved and uncommitted changes and changes that have not yet been pushed to the remote repository. Make sure you double-check your work to prevent unwanted loss of work.
Search for Text
You can search for a string throughout your entire working directory. The following command will search for the string "foobar":
git grep "foobar"
This tutorial covered the basic Git commands needed to successfully manage a project. Try creating a test project on your local machine and run through each command individually.
I'd also advise you to set up a free GitHub account to test remote repository management.
There are no comments yet. Start the conversation!