Guide to Git essential Commands and usage

CMS & Web development, Linux system administration

Git is a distributed version control system that allows teams of developers to efficiently collaborate on code. With Git, you can track changes to your project over time, easily collaborate with others, and merge code changes from multiple developers.

As a beginner, it’s important to learn some essential Git commands and workflows to start using version control effectively. This guide will walk through the basic Git commands and processes step-by-step to help you get started with Git and version control.

Setting Up Git

To start using Git, you need to install it on your computer first. Here’s how to get set up:

Install Git

On Linux/Unix: Git usually comes pre-installed with most Linux distributions. To confirm, open a terminal and type git --version to check if Git is installed. If not, use your distro’s package manager to install it (e.g. apt-get install git on Ubuntu/Debian).
On Mac: Install Git via Homebrew with brew install git, or download the installer from git-scm.com.
On Windows: Download and run the Git installer from git-scm.com. Select your options during the installation process.

Configure Git

Once Git is installed, you need to configure your name and email to identify your commits:

$ git config --global user.name "Your Name"
$ git config --global user.email "[email protected]"

This links your Git activity to your identity. The --global flag sets this username/email for all Git repositories on your system.

Generate SSH keys (optional)

If you plan to connect to remote Git repositories over SSH, you need to generate SSH keys. This allows you to push to repos without entering your password every time.

To generate keys:

$ ssh-keygen -t rsa -b 4096 -C "[email protected]"

This will create a public and private SSH key pair. You can then add your public key to services like GitHub to connect over SSH.

You’re now ready to start using Git! Let’s go over some core concepts and commands.

Git Concepts

Before learning Git commands, it’s important to understand some key concepts in Git:

Repository: A repository (or repo) contains the entire collection of files and folders associated with a project, along with each file’s revision history.
Commit: A commit is a snapshot of your repo at a particular point in time. Commits capture the changes you make to the code.
Branch: A branch represents an independent line of development. By default, every repo has a main branch (typically called master) that serves as the definitive branch.
Merge: A merge combines changes from one branch into another, e.g. merging feature branch changes into main.
Remote: A remote repo is one hosted on the internet or network. It allows collaborators to push and pull changes.
Clone: Cloning downloads a remote repo to your local machine so you can work on it.

These concepts enable powerful collaboration workflows in Git. Keep them in mind as we run through essential commands.

Git Commands

Now let’s dive into the basic Git commands and workflows you’ll use in daily development.

git init

Initializes a new Git repo in the current directory. This turns a regular directory into a Git project where you can start tracking changes.

$ git init

git status

Checks the status of the repo and displays files that are untracked, modified, staged, etc. Extremely useful command.

$ git status

git add

Adds files changes in your working directory to the staging area to be included in the next commit. Call git add on specific files or directories like:

$ git add file.txt
$ git add folder/

To add all changed files, use:

$ git add .

git commit

Commits the staged snapshot to the project history. Committed snapshots can be thought of as “save points” that you can revert to later.

Always write a descriptive commit message:

$ git commit -m "Your descriptive commit message"

git log

Shows the commit history with author name, date, and commit message. Useful for viewing project history and finding old commits:

$ git log

git checkout

Checkout switches between branches in a repo. To start working on a new branch:

$ git checkout -b branch-name

To switch to an existing branch:

$ git checkout branch-name

And to switch back to main:

$ git checkout main

git merge

Merges changes from one branch into your current branch (e.g. merging feature changes into main).

$ git merge branch-to-merge

This performs the merge. Git will auto-merge changes if there are no major conflicts between the branches.

git remote

Manages connections to remote repositories. You’ll need to add a remote to push your repo to a hosted service like GitHub:

$ git remote add origin https://github.com/user/repo.git

Verify your remote connections using:

$ git remote -v

git push

Pushes local repo commits to the remote repo specified. For example:

$ git push origin main

This pushes your local main branch to the origin remote’s main branch.

git pull

Pulls in changes from a remote repo to your local repo. Fetches changes from the remote first then merges them to your local branch:

$ git pull origin main

git clone

Clones a remote repo to create a local working copy. For example:

$ git clone https://github.com/user/repo.git

This downloads the remote repo to your machine so you can work locally.

Those are the key Git commands and workflows to get started with version control. Some other useful commands include:

git diff to view changes between commits, branches, working directory vs repo, etc.
git reset to undo local changes and revert repo state
git rebase to rebase your commits onto another branch

And many more! The Git documentation provides a detailed reference for additional commands.

Now let’s walk through a simple collaborative Git workflow…

Collaborative Git Workflow Example

Here’s an example workflow for collaboratively developing a project with a remote Git repository and multiple contributors:

Initialize Git in a new project folder:

$ git init

Create the remote repository on GitHub
Connect local repository to remote:

$ git remote add origin https://github.com/user/repo.git

Create a new feature branch locally:

$ git checkout -b new-feature

Make changes, stage, and commit locally:

$ git add .
$ git commit -m "Add new feature"

Fetch latest remote changes:

$ git fetch

Merge remote main branch into your feature branch:

$ git merge origin/main

Push feature branch to remote:

$ git push origin new-feature

On GitHub, create a pull request to merge new-feature into main
Review code, approve, and merge pull request on GitHub
Pull remote main into local repository:

$ git pull origin main

Checkout main branch locally:

$ git checkout main

Your colleague’s changes are now fetched into your local main branch.

This shows a complete collaborative workflow:

Forking a feature branch locally
Pushing to remote
Creating a PR to merge into main
Fetching latest main into local repo

By leveraging branches, commits, merges, and remotes, you can collaborate efficiently on code!

Conclusion

Those are the key Git commands and workflows to get you started with version control for your projects and code. Here are some additional tips:

Commit regularly with descriptive messages
Keep your main branch stable by doing feature work in branches
Sync your local repo often with remote to get latest changes
Leverage pull requests/merge requests for peer reviews
Use git log and git diff to inspect changes

Git enables powerful collaboration and version control for projects. Learning its basic commands gets you up and running managing code with Git. The Git documentation provides more details on advanced workflows.

With these essentials, you now have the key tools to start version controlling your code!