2. Features of Git
The following image shows the git workflow diagram:
In Git, the workflow is mainly divided into three areas -
$ git config --global user.name "username"
$ git config --global user.email "user_emails@atechseva.com"
This configures Git on your PC with your username and email.
$ sudo apt-get update
$ sudo apt-get install git
$ git config --global user.name "user_name"
$ git config --global user.email "user_email@atechseva.com"
$ git config --global user.name "user_name"
$ git config --global user.email "user_email@atechseva.com"
git clone is a command which is used to clone or copy a target repository.
The following image shows an illustration of the git clone command. Using the command, a copy of the original repository is created.
How to clone a repository?
In this way, a clone of the target repository can be made.
Clone a specific branch from the repository.
A very useful feature of the git clone is that it allows cloning a specific branch of the target repository without having to clone the entire repository.
To clone a specific branch, you need to use the command -b to specify the branch. The following command is used:
git clone -b <Branch_name> <Repo_URL>
For creating a new branch, the following command is used :
git branch <branch_name>
For example -
git branch demo
This command creates a new branch named demo from the Main branch:
Using the git checkout command, we can switch from one branch to another.
Command :
git checkout <branch_name>
Git doesn’t allow creating a new and isolated branch on a remote repository. But, you to make a branch remote, we can push an existing local branch.
The steps to create a remote branch is as follows:
git checkout -b <branch_name>
git push -u origin <branch_name>
Note: origin is the default name of remote
Now, if someone wants to fetch some information, one can simply run:
git fetch
git checkout <branch_name>
Once the work is done on a branch and merged with the Main branch, one can delete the branch.
The following command is used to delete branches:
git delete -d <branch_name>
Note: This command deletes a copy of the branch, but the original branch can still exist in remote repositories.
To delete remote branches, use the following command:
git push origin --delete <branch_name>
The Git checkout is used to command Git on which branch changes have to be made. Checkout is simply used to change branches in repositories. It can also be used to restore files.
The following image describes the scenario of creating different branches and switching to a brach when needed, i.e. we can switch from the main brach to a different branch and vice versa.
To checkout or create a branch, the following command can be used:
git checkout -b <branch_name>
This will simply switch to the new branch branch_name.
While working on a large codebase, it because easy to have some reference point. That is where the checkout tag is used.
The following command is used to specify the tagname as well as the branch that will be checked out.
git checkout tag</tag> <branch_name>
git status is mainly used to display the state of the staging area and the repository. It helps us to track all the changes made, point out untracked files.
Command:
git status
git status after a file is added
touch file.txt
git status after a file is deleted after commit
git rm file.txt
Git commit is used to record all the changes in the repository. The git commit will commit all the changes and make a commit-id for the same for tracking down the changes made as shown in the image below.
As shown in the image, the command git commit creates a commit-id to track down changes and commits all the changes to the git repository.
Command:
git commit
The -m along with the command lets us write the commit message on the command line.
Command:
git commit -m "Commit message"
The -am along with the command is to write the commit message on the command line for already staged files.
Command:
git commit -am "Commit message"
The amend is used to edit the last commit. In case we need to change the last committed message, this command can be used.
Command:
git commit -amend
rm stands for remove. It is used to remove a collection of files. The git rm command is used to remove or delete files from the working tree and index.
Command:
git rm <file_name>
Now, if you use the command git status, it would show, that the file has been deleted.
Git merge is a command that allows you to merge branches from Git. It preserves the complete history and chronological order and maintains the context of the branch.
The following image demonstrates how we can create different features by branching from the main branch and how we can merge the newly created features after the final review to the main branch.
The command git merge is used to merge the branches.
Command :
git merge <branch_name>
Git Rebase is a process of combining a sequence of commits to a new base commit.
The following rebase command is used for rebasing the commits:
git rebase <branch_name>
Git Fetch only downloads the latest changes into the local repository. It downloads fresh changes that other developers have pushed to the remote repository since the last fetch and allows you to review and merge manually at a later time using Git Merge. As it doesn’t change the working directory or the staging area, it is safe to use.
The below illustration shows the working of the command git fetch. It fetches all the latest changes that have been made in the remote repository and lets us make changes accordingly.
The command used is :
git fetch <branch_name>
You can pull in any changes that have been made from your forked remote repository to the local repository.
As shown in the below image, using the git pull command, all the changes and content can be fetched from the remote repository and can be immediately updated in the local repository to match the content.
We can simply pull a remote repository by using the git pull command. The syntax is as follows:
git pull
This command is equivalent to
git fetch origin head
Use the following command to check if there has been any change:
git pull <RemoteName> <BranchName>
If there is no change, it will show “Already up to date”. Else, it will simply merge those changes in the local repository.
Sometimes in large codebases, there might be some cases when we do not want to commit our code, but at the same time don’t want to lose the unfinished code. This is where git stash comes into play. The git stash command is used to record the current state of the working directory and index in a stash.
It stores the unfinished code in a stash and cleans the current branch from any uncommitted changes. Now, we can work on a clean working directory.
If in the future, we again need to visit that code, we can simply use the stash and apply those changes back to the working repository.
As shown below, using the command git stash, we can temporarily stash the changes we have made on the working copy and can work on something else. Later, when needed, we can git stash pop and again start working on it.
The syntax for stashing is as follows:
git stash
Suppose, you are working on a website and the code is stored in a repository.
Now let's say, you have some files named design.css and design.js. Now you want to stash these files so that you can again use them later, while you work on something else.
Therefore, later you can use the git stash list command to view all the changes.
Drop Stash
In case, you no longer require a stash, you can delete it with the following command:
git stash drop <stash_id>
If you want to delete all the stashes, simply use:
git stash clear
At times, there are some files that we might want Git to ignore while commiting. For example, private files or folders containing passwords, APIs etc. These files are user-specific and hence, we can ignore these using the .gitignore.
.gitignore is generated automatically inside the project directory and ignores the files to get committed to the repositories.
How to use the .gitignore?
Follow the below steps to use add the files you want Git to ignore.
Now, if you check the status of your repo, you will see, all the files which were written in the .gitignore file have been ignored.
Git rebase is used to rewrite commits from one branch to another branch. In order to combine unpublished local changes with the published remote changes, git pull is performed.
With git pull --rebase, the unpublished changes will be again applied on the published changes and no new commit will be added to history.
The squash along with git merge produces the working tree. It indexes in the same way as that of the real merge but discards the merge history.
Command:
git merge --squash origin/main
When to use git merge --squash?
The reflog records every change that is made in the repository. Apart from this, if some branch is lost from the repo, the recovery can be done using this command.
Command:
git reflog
Revert simply means to undo the changes. Therefore, it is an undo command in Git. Unlike traditional undo operation, the revert command does not delete any data. git revert is a commit operation, as it undo the specified commit.
Command:
git revert
Options:
This option is used to revert back a commit.
Command:
git revert <commit_id>
In case, we want to edit the commit message before reverting, -e is used for the same.
Command:
git revert -e <commit_id>
Git bisect is a git tool used for debugging. Suppose, you have a large codebase and some commit causes a bug, but you are not sure of which commit causes it.
Git bisect goes through all the previous commits and uses binary search to find the bugged commit.
The git bisect command is used to find the bisect position as shown. It bisects (divides) your history between the good and the bad commit range. It then moves through every commit id between this range and at each snapshot it allows you to test the code.
It is applied as follows:
It will return the commit which causes the bug and one can debug the issue efficiently.
git blame is used to know who/which commit is responsible for the latest changes in the repository. The author/commit of each line is visible through this.
Command:
git blame <file_name>
This command shows the commits which are responsible for changes of all lines of code.
Choosing a commit from one branch and applying it to another is known as cherry picking in Git. Following are the steps to cherry pick a commit:
git switch master
git cherry-pick <commit_id
Git Submodules
Submodules are a tool that allows attaching an external repository inside another repository at a specific path. It allows us to keep a git repository as a subdirectory of another git repository.
Commands:
git submodule add <URL_link>
git submodule init is to copy the mapping from .gitmodules file into ./.git/config file. git submodule init has extend behavior in which it accepts a list of explicit module names.
This enables a workflow of activating only specific submodules that are needed for work on the repository.
Command:
git submodule init
Git Subtrees
Commands:
git subtree add --prefix=git-subtree --squash \<Git_repo_link>
git subtree pull --prefix <URL_link>
The following table shows the most commonly used Git Commands:
S. No |
Command Name |
Use |
1 |
|
Initialise a local Git Repository |
2 |
|
Add one or more files to the staging area |
3 |
|
Commit changes to the head but not to the remote repository. |
4 |
|
Check the status of your current repository and list the files you have changed. |
5 |
|
Provides a list of all commits made on a branch |
6 |
|
View the changes you have made to the file |
7 |
|
Push the branch to the remote repository so that others can use it. |
8 |
|
Tell Git who you are by configuring the author name |
9 |
|
Tell Git who you are by configuring the author email id. |
10 |
|
Creates a Git repository copy from a remote source |
11 |
|
Connect your local repository to the remote server and add the server to be able to push it. |
12 |
|
Create a new branch |
13 |
|
Switch from one branch to another |
14 |
|
Merge the branch into the active branch |
15 |
|
Reapply commits on top of another base tip |
16 |
|
Creates a new branch and switch to it |
17 |
|
Stash changes into a dirty working directory |
18 |
|
Update local repository to the newest commit |
19 |
|
Revert commit changes |
20 |
|
Shows which files would be removed from working directory. Use the -f flag in place of the -n flag to execute the clean. |
21 |
|
View changes (detailed) |
22 |
|
Show difference between working directory and last commit. |
23 |
|
View changes (briefly) |
24 |
|
Show a log of changes to the local repository’s HEAD. Add --relative-date flag to show date info or --all to show all refs. |
25 |
|
Interactively rebase current branch onto <base>. Launches editor to enter commands for how each commit will be transferred to the new base. |
26 |
|
Resetting a staged file |
27 |
|
Remove a file (or folder) |
28 |
|
List all variables set in config file, along with their values |
29 |
|
Delete local branch in Git |
30 |
|
Delete remote branch in Git |
31 |
|
Unstash the changes |
32 |
|
The -am along with the command is to write the commit message on the command line for already staged files. |
33 |
|
The amend is used to edit the last commit. Incase we need to change the last committed message, this command can be used. |
34 |
|
The git rm command is used to remove or delete files from working tree and index. |
35 |
|
Git rebase is used to rewrite commits from one branch to another branch. |
36 |
|
The squash along with git merge produces the working tree. It indexes in the same way as that of the real merge, but discards the merge history. |
37 |
|
edit the commit mesage before reverting, -e is used for the same. |
38 |
|
Git bisect goes through all the previous commit and uses binary search to find the bugged commit. |
39 |
|
git blame is used to know who/which commit is responsible for the lastest changes in the repository. |
40 |
|
Choosing a commit from one branch and applying it to another is known as cherry picking in Git. |
Conclusion
So, we learnt how Git makes managing large software codebases easier, how you can commit changes, clone the repository, how branches work and many git commands that reduce the burden from the lives of developers.
Happy Coding
There are 0 Comments on this post