Nick Cook

It is very easy to create and manage branches on Git for developers. As a matter of fact, the flexibility and power of its branching model is the major advantage of git. In Git, branches are a part of your everyday development process. Git branches are effectively a pointer to a snapshot of your modifications.

When you want to add a new feature or fix a bug, you need to create a new branch to encapsulate your changes. In this tutorial, you can get a deeper knowledge of Git branches and easily can understand why they chose to express this behavior in such a non-obvious manner. Also, take a look at the main concept of today’s guide ie., How to create a Git Branch along with Git Commands.

• What is a branch?
• What is Git Branching?
• What does the “git branch” command do?
• How do I create a new branch based on the current HEAD?
• Creating a Git branch using checkout
• Create Git Branch without switching
• Create Git Branch from Commit
• Create Git Branch from Tag
• How to create a new branch from a remote branch?
• How to create a new branch in a remote repository?
• Note on Ambiguous Names

What is a branch?

A branch in Git is simply a lightweight movable pointer to [a commit]. The default branch name in Git is master.

What is Git Branching?

Git branching allows developers to diverge from the production version of code to fix a bug or add a feature. However, developers create branches to work with a copy of the code without changing the current version.

What does the “git branch” command do?

There are a variety of tasks that can perform by using the “git branch” command. They are as follows:

• creating new local branches
• deleting existing local or remote branches
• listing local and/or remote branches
• listing branches that e.g. haven’t been merged yet

How do I create a new branch based on the current HEAD?

If you want to create a new branch as per your currently checked out (HEAD) branch, just use “git branch” with the name of the new branch as the only parameter shown below:

$ git branch <new-branch>

• How To Switch Branch on Git | What is Git Switch? | Git Switch vs Checkout
• How To Set Upstream Branch on Git | What is a Git Upstream Branch? | Git Set Upstream Branch without Push
• How To Create and Apply Git Patch Files | Creating & Applying Git Patch Files with Different Git Commands

Creating a Git branch using checkout

The easiest way to create a Git branch is to use the “git checkout” command with the “-b” option for a new branch. Next, you just have to specify the name of the branch you want to create.

$ git checkout -b <branch-name>

As an example, let’s say that you want to create a new Git branch from the master branch named “feature”

To achieve that, you will run the “git checkout” command with the “-b” option and add “feature” as the branch name.

$ git checkout -b feature
Switched to new branch 'feature'

As you can see, by using the “git checkout” command, you are creating a new branch and you are switching to this new branch automatically.

But what if you wanted to create a Git branch without switching to the new branch automatically?

Create Git Branch without switching

In order to create a new Git branch, without switching to this new branch, you have to use the “git branch” command and specify the name of the Git branch to be created.

$ git branch <branch_name>

Later on, you can switch to your new Git branch by using the “git checkout” function.

$ git checkout <branch_name>

Going back to our previous example, let’s say that you want to create a branch named “feature”.

$ git branch feature

You can inspect existing branches by running the “git branch” command with the “-a” option for all branches.

$ git branch -a

Awesome, you have successfully created a new Git branch and you switched to it using the checkout command.

Create Git Branch from Commit

In the last sections, we have seen how you can create a new Git branch from the HEAD commit of the current branch.

In some cases, you want to create a Git branch from a specific commit in your Git history.

To create a Git branch from a commit, use the “git checkout” command with the “-b” option and specify the branch name as well as the commit to creating your branch from.

$ git checkout -b <branch_name> <commit_sha>

Alternatively, you can use the “git branch” command with the branch name and the commit SHA for the new branch.

$ git branch <branch_name> <commit_sha>

Going back to our previous example, let’s say that you want to create a Git branch from a specific commit in your Git history.

To get commits SHA from your history, you have to use the “git log” with the “–oneline” option.

$ git log --oneline --graph

* 9127753 (HEAD -> master) Commit 3
* f2fcb99 Commit 2
* cab6e1b (origin/master) master : initial commit

To create a new Git branch from the second commit (f2fcb99), you would run the following command

$ git checkout -b feature f2fcb99
Switched to a new branch named 'feature'

Using the “git log” command, you can verify that your branch was created from the second commit of your history.

$ git log --oneline --graph

* f2fcb99 (HEAD -> feature) Commit 2
* cab6e1b (origin/master) master : initial commit

Awesome, you have successfully created a new Git branch from a specific commit!

Create Git Branch from Tag

In previous tutorials, we have seen that Git tags are pretty useful: they can be used as reference points in your development.

As a consequence, it can be quite useful to create Git branches from existing tags.

In order to create a new Git branch from a tag, use the “git checkout” command with the “-b” option and specify the branch name as well the tag name for your new branch.

$ git checkout -b <branch_name> <tag_name>

Alternatively, if you don’t want to switch to your new branch, you can use the “git branch” with the branch name and the tag name.

$ git branch <branch_name> <tag_name>

Back to our previous example, let’s say that you want to create a new Git branch from a tag named “v1.0” in your history.

In order to list your existing tags, you can use the “git tag” command. Alternatively, you can use the “git log” command to identify a tag associated with a commit.

$ git tag
v1.0

Now that you have identified your tag, you can create a new branch from it using the “git checkout” command.

$ git checkout -b feature v1.0

Next, you can inspect your Git history in order to make sure that your new branch was indeed created from the tag.

Alternatively, you could have used the “git branch” in order to create this branch.

$ git branch feature v1.0

How to create a new branch from a remote branch?

If you require to take a remote branch based on your new local branch, you can utilize the “–track” option:

$ git branch --track <new-branch> origin/<base-branch>

On the other hand, you can also use the “checkout” command to perform this. If you want to name the local branch like the remote one, you only have to define the remote branch’s name:

$ git checkout --track origin/<base-branch>

How to create a new branch in a remote repository?

Once you are done with working on a new local branch for some time, you may require to publish it in your remote repository, in order to share it with your team:

$ git push -u origin <local-branch>

The “-u” flag tells Git to establish a “tracking connection”, which will make pushing and pulling much easier in the future.

Note on Ambiguous Names

When you are creating new Git objects (whether they are branches, tags, or commits), you might run into this error

fatal: Ambiguous object name: <object>

So why does this error happens?

This exception occurs whenever two objects are named in the exact same way: a branch and a tag for example.

Whenever you are running a command involving one of those objects, Git can not tell the difference between the two and it returns this exception.

You might run into this error when running the “checkout” command.

If you are creating a new branch from a tag named “v1.0”, but one of your branches is already named “v1.0”, you will be presented with this error

$ git checkout -b feature v1.0
warning: refname 'v1.0' is ambiguous.
warning: refname 'v1.0' is ambiguous.
fatal: Ambiguous object name: 'v1.0'.

In order to solve this issue, you have to specify that your last argument is a tag and not the branch name.

To solve ambiguous notation, simply append the refs notation to the object that is ambiguous

$ git checkout -b feature refs/tags/v1.0
Switched to a new branch 'feature'

Conclusion

In this tutorial, you learned how you can easily create Git branches using the “git checkout” command.

You also learned that you can the “git branch” command if you don’t want to switch automatically to your new branch.

Finally, you have seen more advanced use-cases: creating branches from specific commits or from specific tags in your Git history.

Curious about Git, you can check our latest tutorials:

• Create and Apply Git Patches
• Add and Update Git Submodules
• Undo Last Git Commit

If you are interested in Git or in software engineering, we have a complete section dedicated to it on the website, so make sure to check it out!

Patches are a substitute way to exchange code changes and exchanging code via patches is rare. Also, it is a valuable tool in specific circumstances. With creating a patch, you can basically export one or more commits into plain text files, that you can quickly share with someone else for integration.

Traditionally, Git Patch is linked to the Unix Patch command that was utilized in old Unix versions to store differences between files or binaries. In this ultimate tutorial, we are going to talk completely about how to create and apply git patch files and what are the commands used to make it happen. Also, check our Git Commands Tutorial to find all commands in one place.

• Create Git Patch Files using git format-patch
• Creating a Git patch with git diff
• Creating Git Patch Files in a Directory
• Create Git Patch for Specific Commit
• Apply Git Patch Files
• Using git am to Apply a Patch
• Git Patch Troubleshooting
• Git Apply Patch failed: file already exists in Index
• Git Apply Patch failed: error in file

Create Git Patch Files using git format-patch

To create a Git patch file, you have to use the “git format-patch” command, specify the branch and the target directory where you want your patches to be stored.

$ git format-patch <branch> &lt;options>

So will the format-patch command do when executed?

The “git format-patch” command will check for commits that are in the branch specified but not in the current checked-out branch.

As a consequence, running a “git format-patch” command on your current checkout branch won’t output anything at all.

Also Read: How To Generate Git SSH Keys

Creating a Git patch with git diff

If you want to see commits differences between the target branch and the current checked-out branch, use the “git diff” command and specify the target and the destination branch.

$ git diff --oneline --graph <branch>..<current_branch>

* 391172d (HEAD -> <current_branch>) Commit 2
* 87c800f Commit 1

If you create patches for the destination branch, you will be provided with two separate patch files, one for the first commit and one for the second commit.

For example, let’s say that you have your “master” branch and a “feature” branch that is two commits ahead of your master branch.

When running the “git diff” command, you will be presented with the two commits added to your feature branch.

$ git diff --oneline --graph master..feature

* 391172d (HEAD -> feature) My feature commit 2
* 87c800f My feature commit 1

• How To Create Git Tags | Types of Tags in Git | Creating Git Tags with Examples
• How To Create a Git Branch | Learn Git Create New Branch from Current Branch
• How To Add and Update Git Submodules | Definition of Submodule

Now, let’s try creating patch files from commits coming from the master branch.

$ git format-patch master

0001-My-feature-commit-1.patch
0002-My-feature-commit-2.patch

You successfully created two patch files using the “git format-patch” command.

Creating Git Patch Files in a Directory

As you probably noticed from the previous section, patch files were created directory in the directory where the command was run.

This might not be the best thing because the patch files will be seen as untracked files by Git.

$ git status

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        0001-My-feature-commit-1.patch
        0002-My-feature-commit-2.patch

In order to create Git patch files in a given directory, use the “git format-patch” command and provide the “-o” option and the target directory.

$ git format-patch <branch> -o <directory>

Back to our previous example, let’s create Git patch files in a directory named “patches”.

This would give us the following command

$ git format-patch master -o patches

patches/0001-My-feature-commit-1.patch
patches/0002-My-feature-commit-2.patch

In this case, we provided the “git format-patch” will a local directory but you can provide any directory on the filesystem out of your Git repository.

Create Git Patch for Specific Commit

In some cases, you are not interested in all the existing differences between the two branches.

You are interested in one or two commits maximum.

You could obviously cherry-pick your Git commits, but we are going to perform the same action using Git patches.

In order to create a Git patch file for a specific commit, use the “git format-patch” command with the “-1” option and the commit SHA.

$ git format-patch -1 <commit_sha>

In order to get the commit SHA, you have to use the “git log” command and look for the corresponding commit SHA.

For example, given the example we just used, let’s inspect the differences between master and feature using the “git log” command.

$ git log master..feature

commit 391172da58dbfa27bc995eda538012ae1fbc5383 (HEAD -> feature)
Author: Bob <test@gmail.com>
Date:   Wed Dec 11 16:24:46 2019 -0500

    My feature commit 2

commit 87c800f87c09c395237afdb45c98c20259c20152
Author: Bob <test@gmail.com>
Date:   Wed Dec 11 16:03:15 2019 -0500

    My feature commit 1

In this case, we are not interested in the second commit (with SHA 391172..) but in the first commit (with SHA 87c800..)

Copy the commit SHA and run the “git format-patch” command again.

You can optionally provide the output directory similarly to the example we provided in the previous section.

$ git format-patch -1 87c800f87c09c395237afdb45c98c20259c20152 -o patches

patches/0001-My-feature-commit-1.patch

Awesome! You successfully created a Git patch file for one single commit on your repository.

Apply Git Patch Files

Now that you have created a patch file from your branch, it is time for you to apply your patch file.

Using git am to Apply a Patch

In order to apply a Git patch file, use the “git am” command and specify the Git patch file to be used.

$ git am <patch_file>

Referring to our previous example, make sure to check out the branch where you want your patch file to be applied.

$ git checkout feature

Switched to branch 'feature'
Your branch is up to date with 'origin/feature'.

Now that you are on your branch, apply your Git patch file with the “git am” command.

$ git am patches/0001-My-feature-commit-1.patch

Applying: My feature commit 1

Now, taking a look at your Git log history, you should see a brand new commit created for your patch operation.

$ git log --oneline --graph

* b1c4c91 (HEAD -> feature) My feature commit 1

When applying a Git patch, Git creates a new commit and starts recording changes from this new commit.

Awesome! You have successfully applied your Git patch file using “git am”.

Git Patch Troubleshooting

In some cases, you might run into errors when trying to apply Git patch files.

Let’s say for example that you have checked out a new branch on your Git repository and tried to apply a Git patch file to this branch.

When applying the Git patch, you are running into those errors.

Git Apply Patch failed: file already exists in Index

This case is easy to solve. You tried to apply a Git patch file that contained file creations (say you created two new files in this patch) but the files are already added into your new branch.

In order to see files already stored in your index, use the “git ls-files” command with the “–stage” option.

$ git ls-files --stage <directory>

100644 eaa5fa8755fc20f08d0b3da347a5d1868404e462 0       file.txt
100644 61780798228d17af2d34fce4cfbdf35556832472 0       file2.txt

If your patch was trying to add the “file” and “file2” files into your index, then it will result in the “file already exists in index” error.

To solve this issue, you can simply ignore the error and skip the patch operation.

To skip a Git patch apply operation and ignore conflicts, use “git am” with the “–skip” option.

$ git am --skip

Git Apply Patch failed: error in file

In some cases, you might run into some “merging” errors that may happen when applying a patch.

This is exactly the same error as when trying to merge one branch with another, Git will essentially fail to automatically merge the two branches.

To solve Git apply merging errors, identify the files that are causing problems, edit them, and run the “git am” command with the “–continue” option.

$ git am --continue

Conclusion

In this tutorial, you learned how you can create Git patch files using the “git format-patch” command. Also, you have understood that it is possible to create Git patch files for single commits and to apply them to the target branch easily using the “git am” command.

Are you using GitHub without setting up SSH Keys? Then, you’re actually missing out on more security and convenience. SSH Keys are the best two authentication methods used on GitHub for secure log-in and address modifications to repositories. Well, this tutorial will help you Setup SSH keys on GitHub easily and in a simpler way for administration.

If you want to check whether you have installed and configured Git on your Windows or Linux OS then make use of this Git Commands tutorial & dig deep into your main requirement.

• Why use an SSH key?
• How to Create SSH keys for Github
• Create SSH keys on Linux using ssh-keygen
• Create SSH keys on Windows using ssh-keygen
• Add SSH key to your GitHub Account
• Test GitHub SSH keys
• Troubleshooting

Why use an SSH Key?

If you want to access your account in a convenient and secured way then it can be possible by using an SSH Key. It’s helpful because you don’t need to memorize a long password. Also, you can get your actual password so brutally long and secure that no human or bot could guess it. The SSH key works as an actual key that only you control.

• How To Generate Git SSH Keys | Process of Git Generate SSH Key on Windows, Linux, Mac
• Issues with logging into EX Virtual Chassis via SSH and HTTP
• How To Clone a Git Repository | Clone a Git Repository with Command Line & Sourcetree

How to Create SSH keys for Github

Depending on the operating system you are using, there are two ways of creating SSH keys for GitHub.

Do Check: How To Generate Git SSH Keys

Create SSH keys on Linux using ssh-keygen

First of all, let’s have a look at creating SSH keys on Linux operating systems.

To create SSH keys on Linux, use the ssh-keygen command with an RSA algorithm (using the “-t” option)

$ cd ~/.ssh/ && ssh-keygen -t rsa -b 4096 -C "email@example.com"

Note: It is recommended to setup your SSH keys into the .ssh directory of your home directory. Storing them there is more convenient if multiple developers are working on the same repository.

You will be prompted with multiple questions.

You can choose to store your key in a custom file by typing a custom filename.

You can also choose to leave it blank in order for it to be added to the “id_rsa” existing file.

Generating public/private rsa key pair.
Enter file in which to save the key (/home/schkn/.ssh/id_rsa): custom_id_rsa
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in custom_id_rsa.
Your public key has been saved in custom_id_rsa.pub.
The key fingerprint is:
SHA256:6yBEAZCCAZCAfdeokgo256452574ffaaz+F6dedefr23222CUXTQc email@example.com
The key's randomart image is:
+---[RSA 4096]----+
|@*o+=+.   E..    |
|*+.+o    o .     |
|... =.  ....     |
| . + =. ..o      |
|  . *.o.S  .     |
|   . o.= =  .    |
|    . o o.+.     |
|     . o.oo      |
|        =*o      |
+----[SHA256]-----+

Similarly, you can leave the passphrase blank, otherwise, you will be asked for it as a password when performing operations on your repositories.

The ssh-keygen utility created two files for you :

• file_id_rsa: the private key used in the SSH authentication process. You should not share this private key by any means.
• file_id_rsa.pub: the extension gives the hint that this is the public key of your SSH authentication process. This is the key you are going to copy to Github in order to perform operations on your repos.

Configure your SSH keys

If you chose to create the GitHub public key in a separate file, named “custom_id_rsa” for example, you need to configure your SSH client in order to take into account this separate file.

Create a new file named “config” in your .ssh directory and paste the following content into it.

$ sudo nano ~/.ssh/config

Host *
    Hostname github.com
    User git
    IdentityFile ~/.ssh/custom_id_rsa

If you chose a different name, make sure to change the file name in the IdentifyFile line.

Save your file – you should not have to restart your SSH client for the changes to be applied.

Now that your files are ready, you can skip the next section dedicated to Windows hosts and start importing your keys to GitHub.

Create SSH keys on Windows using ssh-keygen

In order to use ssh-keygen on Windows, you need to have the OpenSSH client enabled.

Enabling OpenSSH client on Windows 10

In order to enable the OpenSSH client, you essentially have two options: by using Powershell or by using the graphical interface.

To enable the OpenSSH client via Powershell, use the “Add-WindowsCapability” option and specify the OpenSSH Client.

$ Add-WindowsCapability -Online -Name OpenSSH.Client*

Path          :
Online        : True
RestartNeeded : False

Note : you need to be administrator in order to enable OpenSSH on your computer.

You can also enable the OpenSSH client via the graphical interface :

• Click on “Start” and search for “Manage Optional Features“
• Click on “Add a Feature“
• Search for OpenSSH and install the OpenSSH client

Installing the OpenSSH client on Windows 10 will allow you to perform multiple commands via the Powershell: ssh-add, ssh-keygen (the one we are interested in), ssh-agent, ssh-keyscan, and the ssh executable.

On Windows, for versions greater than Windows 7, you can use ssh-keygen in order to connect to your remote Git repositories.

Open Powershell and type the following commands

$ ssh-keygen

Enter file in which to save the key (C:\Users\schkn/.ssh/id_rsa): C:\Users\schkn/.ssh/custom_id_rsa
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in custom_id_rsa.
Your public key has been saved in custom_id_rsa.pub.
The key fingerprint is:
SHA256:WTQ schkn@DESKTOP-PH31996
The key's randomart image is:
+---[RSA 2048]----+
|          o...   |
|         . ...   |
|      . + . .    |
|     E + * =     |
|    .   S B o.   |
|     ..= * .. . .|
|    ..=o* . .o.o.|
|     +oo+*  ..ooo|
|     .=B+.oo..oo |
+----[SHA256]-----+

In the first prompt, you can choose to save your public key in a separate file, but you will need to specify the entire path to the file.

If you chose to create your keys in a separate file, you will need to create a file named “config” into your .ssh directory

Note: The “config” file needs to have no extension at all, it cannot be named “config.txt” for example.

Configure your SSH keys

In order to configure your SSH keys, run the “New-Item” command to create a new file using Powershell.

$ New-Item -Path 'C:/Users/user/.ssh/config' -ItemType File

Note: You have to replace “user” with the actual user using the account

In the configuration file, paste the following content in order to select the correct key when performing Git commands.

Host *
    Hostname github.com
    User git
    IdentityFile ~/.ssh/custom_id_rsa

Save your file, and you should be good to go.

Add SSH key to your GitHub Account

In order to add an SSH key to your GitHub account, head over to the settings of your account and select the “SSH and GPG keys” option in the left menu.

On the right panel, click on the “New SSH key” button in order to create a new SSH key for Github.

When clicking on “New SSH key“, you will be asked to choose a name for your key and to paste the public key you saved before.

To get the content of your public key on Linux, use the cat command on your public key file.

$ cat ~/.ssh/custom_id_rsa.pub

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQC+HvRnxwPJyUiUO/UCPKrW6mFPgJF8LxsC2lbBePtn+UDv4Xy+eMJRgG5fbaqy2i0tvP+7T7bjVWtO9AAIlclkIVeu5LmV7RaE8H78VXxGVQLcWXvlS0SGlwIxXXd9hBeGh6qPmrya63Ezrt/J1fNy6Ro9s5+ndLogBG2G0JKdAoytbCIBgPmm6sK9nvv3kHrjSK4S0rRz0nb9oaxCQF6V+T75hPgYp+JMOl8yZZMGLN3GPadE2ye2/lskJXzYjlHyjAE6a0g+vrHmMjOULPUrO+aHEA84f   email@example.com

Note: You can also use the “cat” command in Powershell

Paste the content of your public key to the dedicated key text area on GitHub.

Click on “Add SSH key” in order to complete the process.

A new entry should be added to your SSH keys with the key fingerprint as well as the permissions given by the key (read and write by default)

Congratulations, you have successfully added your SSH keys to GitHub.

In order to validate the entire process, we are going to clone a Git repository to our local system.

This is where you might have authentication failures but multiple solutions will be provided in order to solve those issues.

Test GitHub SSH keys

In order to test our GitHub SSH keys, let’s try to clone one of our repositories on our local server.

In order to find the SSH URL, you have to use, head over to your repository and click on the “Clone or download” green button.

Make sure that you are using the SSH method by clicking on “Use SSH” if not already selected.

To clone the Github repository, use the “git clone” command with the URL provided in the previous box.

$ git clone git@github.com:SCHKN/private-repo.git

Cloning into 'private-repo'...
remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Receiving objects: 100% (3/3), done.

Awesome!

The repository was correctly fetched from GitHub and you can start working on the codebase.

Troubleshooting

In some cases, you may not be able to fetch your repositories from GitHub when setting up SSH authentication.

You will probably get the following error when performing simple git commands on your client

git@github.com: Permission denied (publickey)

This may be happening because of multiple reasons :

• Your public key is not correctly set on GitHub

Make sure in your account settings that your public key is set and that the permissions are also set properly.

• You are using a different file from the “id_rsa” default file to store your keys and you did not create the “config” file into your .ssh directory.

Refer to the previous sections to set your “config” file properly.

• You are not using the correct URL in order to fetch your repositories.

Make sure that you are executing your commands as the “git” user and not with the GitHub username you are using on the website.

$ git clone git@github.com:SCHKN/private-repo.git   <--- Correct

$ git clone user@github.com:SCHKN/private-repo.git  <--- Incorrect

Conclusion

In this tutorial, you learned how you can set up SSH keys for Github accounts and how you will have to configure them to use custom keys.

If you are curious about Git or about software engineering in general, we have a complete section dedicated to it on the website, so make sure to read our latest guides.

In Git History, tags are ref’s that point to specific points. Generally, Tagging is done to capture a point in history that is utilized for a marked version release (i.e. v1.0.1). A tag is like a branch that doesn’t change. If your want to have a reference to a given release of your software should create a new tag.

Are you new to Git and not familiar with the Git tags & Git Commands? Check out this entire tutorial and learn How to Create Git Tags easily along with naming the Git tags following the best practices of “Semantic Versioning”.

• How do you Create Git Tag?
• Create Tag with Message
• Git Tag Types
• Lightweight Tags
• Annotation Tags
• Naming tags with Semantic Versioning
• Push your created tags
• Create Git Tag for Commit
• Create Tag For Last Commit

How do you Create Git Tag?

In order to create a new tag, you have to use the “git tag” command and specify the tag name that you want to create.

$ git tag <tag_name>

As an example, let’s say that you want to create a new tag on the latest commit of your master branch.

To achieve that, execute the “git tag” command and specify the tag name.

$ git tag v2.0

Usually, you want to name your tag following the successive versions of your software.

Using this command, the latest commit (also called HEAD) of your current branch will be tagged.

To verify that your Git tag was successfully created, you can run the “git tag” command to list your existing tags.

$ git tag

v1.0
v2.0

Good job!

You have successfully created a tag on Git.

• How To List Git Tags | How to Check List of Tags in Git? | Process to List Local & Remote Tags in Git
• How To Create a Git Branch | Learn Git Create New Branch from Current Branch
• How To Delete Local and Remote Tags on Git | Git Delete Tag for local & remote

Create Tag with Message

Creating tags is great but you will need to add a description to your tag in order for other contributors to understand why you created it.

You would not create a commit without a commit message, you would not create a Git tag without a message.

To create a Git tag with a message, use the “git tag” command with the “-a” option for “annotated” and the “-m” option for message.

$ git tag -a <tag_name> -m "message"

Note: If you don’t provide the “-m” option, your default text editor will open in order for you to type the tag message.

As an example, let’s say that you want to create a new annotated tag on your master branch with the message “New release for v3.0”

To achieve that, you would run the following command

$ git tag -a v3.0 -m "New release for v3.0"

You can verify that your Git tag was successfully created by running the “git tag” command with the “-n” option.

$ git tag -n

Git Tag Types

As of now we know we have learned about git tag and how to create easily, let’s discuss the type of tags that supported by git. You can have two types of Git tags, one is Lightweight Tags and another is Annotated Tags.

Lightweight Tags

As the name suggests Lightweight Tags is the simpler and trimmed down version of creating a tag without any meta-information about the tag. Here is the syntax of the Git Lightweight tags.

$ git tag <tag_name>

Annotation Tags

Annotation Tags is a process of creating a Git tag with some extra meta information. To create an annotation tag you just need to add “-a” with the git tag command and “-m” to specify the message.

$ git tag -a v1.0 -m “Release v1.0 create.”

Now, you can apply the “git show” command to view all the data attached with the tag we simply created with annotation.

Naming tags with Semantic Versioning

When naming tags, the Git CLI does not put any constraints on the name of your Git tag.

However, there are some best practices when it comes to naming Git tags: using semantic versioning.

Semantic versioning is quite easy to understand: you want to name tags as versions of your software in the form of

v<major>.<minor>.<patch>

Where

• major: is a version number where you introduced breaking modifications (modifications of your new version are NOT compatible with previous versions);
• minor: is a version number that is compatible with previous versions;
• patch: is an increment for a bug fix or a patch fix done on your software.

For example, let’s say that you are currently working on version 1.0.0 of your software.

In your latest commit, you introduced a code-breaking change, as a consequence you are going to increment the major version number.

$ git tag v2.0.0

Push your created tags

By default, the “git push” command does not automatically push your tags to your remote repository.

To push your newly created tags, use the “git push” command and specify the “–tags” to explicitly push tags to your remote Git repository.

$ git push --tags

For example, given the tags that you created in the previous section, you would get the following output

$ git push --tags

To <user>/<repository>.git
* [new tag]         v1.0 -> v1.0
* [new tag]         v2.0 -> v2.0

Great, now your tags are pushed to your remote repository and your colleagues can start fetching it.

Create Git Tag for Commit

In some cases, you may want to create a Git tag for a specific commit of your Git history.

In order to create a Git tag for a specific commit, use the “git tag” command with the tag name and the commit SHA for the tag to be created.

$ git tag <tag_name> <commit_sha>

If you want to create an annotated tag for a specific commit, you can use the “-a” and “-m” options we described in the previous section.

$ git tag -a <tag_name> <commit_sha> -m "message"

As an example, let’s say that you want to create an annotated commit for the first commit of your Git history.

First, list the commits SHA by using the “git log” command with the “–oneline” option to get short commits SHA.

$ git log --oneline

9127753 (HEAD -> master) Commit 3
f2fcb99 (feature) Commit 2
cab6e1b (origin/master) master : initial commit

In order to create an annotated tag for the first commit in your Git history, you would execute the following command

$ git tag -a v1.0 cab6e1b -m "Tagged the first commit with v1.0"

Next, run the “git log” command again to make sure that your commit was correctly tagged.

$ git log --oneline

9127753 (HEAD -> master) Commit 3
f2fcb99 (feature) Commit 2
cab6e1b (tag: v1.0, origin/master) master : initial commit

Awesome, you have successfully created a tag for a specific commit in your Git history.

Create Tag For Last Commit

If you want to create a Git tag from the last commit, there is a shorter syntax that you can use: the HEAD syntax.

In order to create a Git tag for the last commit of your current checked-out branch, use the “git tag” command with the tag name and specify “HEAD” as the commit to create the tag from.

$ git tag <tag_name> HEAD   (for the last commit)

$ git tag <tag_name> HEAD~1  (for the commit before HEAD)

$ git tag <tag_name> HEAD~1  (for two commits before HEAD)

Similarly, if you want your tag to be annotated, you can still use the “-a” and “-m” options to annotate your tag.

$ git tag -a <tag_name> HEAD -m "message"

Like in the previous sections, you can verify that your tag was successfully created by running the “git tag” command with the “-n” option.

$ git tag -n

v1.0
v2.0
v3.0

Congratulations, you have successfully created a new tag for the last commit of your repository.

Conclusion

In this tutorial, you learned how you can easily create Git tags for your projects.

You also discovered advanced usages of tags with annotated messages but also about naming your git tags correctly using semantic versioning.

If you are interested in Git, you should have a look at our previous tutorials :

• How To Create a Git Branch
• How To Checkout Git Tags
• How To Delete Git Tags

Also, if you are passionate about software engineering, we have a complete section dedicated to it on the website, so make sure to check it out!

Guys who are new to Git should aware of the git stash command as it is the most important command in Git. It is performed to protect all the changes made with the current working directory and to go back to the last commit done on the branch (also known as HEAD).

In this tutorial, we guys will definitely come to know about git stash commands and how to do git stash changes in practical cases. Just make use of the available links and jump into the exact stuff you required to learn about Git stashing.

• Introduction to Git Stash
• What is Stashing?
• Create a Git stash
  • Create a Git stash with a name
• Stashing your work
• Stash a specific file
• Stash untracked files
• Specific Git Stash Branch
• Git Stash Changes
  • Tracking Git Stash Changes
• Git stash list
• Git stash apply
• Git stash pop
• Git stash show differences
• Git stash drop
• Git stash clear
• Conclusion

Introduction to Git Stash

In some cases, you need to change the branches however you are operating an unfinished part of your current project. In that situation, you don’t want to do a commit to half-done work. Here, Git stashing permits you to do so. The git stash command allows you to change branches without committing the current branch.

Also Check: Git Commands

The following image shows the properties and role of stashing concerning the repository and working directory.

Usually, the meaning of stash is “store something safely in a hidden place.” The sense in Git is also the same for stash; Git temporarily saves your data safely without committing.

• How To Delete Local and Remote Tags on Git | Git Delete Tag for local & remote
• How To Switch Branch on Git | What is Git Switch? | Git Switch vs Checkout
• How To Create Git Tags | Types of Tags in Git | Creating Git Tags with Examples

What is Stashing?

Stashing takes the messy state of your working directory, and temporarily saves it for further use. Several options are available with git stash. Some of the helpful options are provided here:

• Git stash
• Git stash save
• Git stash list
• Git stash apply
• Git stash changes
• Git stash pop
• Git stash drop
• Git stash clear
• Git stash branch

Stashing changes come with a special set of Git commands intended to create, delete and apply stashes at will.

Do Check: How To Set Upstream Branch on Git

Create a Git stash

The easiest way to create a git stash is to simply run the “git stash” command without any parameters.

$ git stash

As a consequence, all the changes staged for commit in your current working directory will be saved on the side for later use.

$ git stash
Saved working directory and index state WIP on branch1: 808b598 Initial commit

As you can see, my working directory as well as my index was saved for the “branch1” which is the current name of my branch.

After the colons, you can see the hash of the HEAD commit as well as the commit message: this is the name of your stash.

In this case, no names were assigned to our stash which might not be very handy if you want to pop your stash later on.

Create a Git stash with a name

In order to create a git stash with a name, use the “save” command and specify the name of your stash.

$ git stash save "my_stash_name"

Back to the example, we gave before on the branch named “branch1”, we would run

$ git stash save "modified README.md"
Saved working directory and index state On branch1: modified README.md

Now, Git did not provide a default name (made by the last HEAD commit message) but it assigned a custom name to it.

Alternatively, you can use the “git stash push” command in order to create a stash with a name.

$ git stash push -m "modified the README.md" again
Saved working directory and index state On branch1: modified again the READ.me

Stashing your work

The git stash command takes your uncommitted changes (both staged and unstaged), saves them away for later use, and then reverts them from your working copy. For instance:

$ git status
On branch main
Changes to be committed:
   new file: style.css
Changes not staged for commit:
   modified: index.html

$ git stash
Saved working directory and index state WIP on main: 5002d47 our new homepage
HEAD is now at 5002d47 our new homepage

$ git status
On branch main
nothing to commit, working tree clean

Currently, you’re free to make changes, create new commits, switch branches, and perform any other Git operations; then come back and re-apply your stash when you’re ready.

Remark that the stash is local to your Git repository; stashes are not given to the server when you push.

Stash a specific file

Using the previous commands, you have stashed all the tracked files in your current working directory.

In some cases, you may want to stash a specific file in order to retrieve it later on.

To stash a specific file, use the “git stash push” command and specify the file you want to stash.

$ git stash push -m "message" <file>

For example, in order to stash the “README.md” file in our current working directory but keep changes done to the other files, we would run

$ git stash push -m "modified the README.md" README.md
Saved working directory and index state On branch1: modified README.md

However, the other tracked files that may be modified in your current working directory are untouched.

Stash untracked files

As you probably noticed before when creating stashes, stash only saves tracked files of your working directory by default.

But what if you wanted to stash untracked files of your current working directory?

In order to stash untracked files, add the “–include-untracked” option to your “git stash” initial command.

Alternatively, you can simply use the “-u” which is equivalent to the untracked longer version.

$ git stash --include-untracked
Saved working directory and index state WIP on branch1: 808b598 Initial commit

$ git stash -u

Specific Git Stash Branch

In some cases, you may want to stash your current changes into a specific branch.

Let’s say for example that you worked on the “master” branch for modifications, but you decide that your work may need a specific branch for integration.

This can be done with the “git stash branch” command.

$ git stash branch <branch_name>

$ git stash branch <branch_name> stash@{stash_index}

Let’s say for example that you want to stash your current changes in a branch named “branch1”, you would execute.

$ git stash branch branch1 stash@{0}

Switched to a new branch 'branch1'
On branch branch5
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

        modified:   README.md

no changes added to commit (use "git add" and/or "git commit -a")
Dropped stash@{0} (8bf64dd0e0045069bf3b3e7d9e34f5e5227aefa7)

As you can see, the stash is dropped at the end of the process, essentially removing it completely from the stash stack.

Git Stash Changes

We can trace the stashes and their changes. To view & understand the changes in the file before stash and after stash operation, execute the below command:

Syntax:

$ git stash show

This command will help you display the file that is stashed and changes made on them. Take a look at the following output:

This result explains that there are two files that are stashed, and performed two insertions on them.

Tracking Git Stash Changes

Also, we can precisely track what changes are performed on the file. To show the changed content of the file, execute the below command:

Syntax:

$ git stash show -p

Here, -p stands for the partial stash. The given syntax will display the edited files and content, view the below output:

The above output is bestowing the file name with changed content. It runs as same as the git diff command and also gives the exact output.

Also, look at the below video tutorial to gain more knowledge on how to git stash changes:

List Git stashes

Now that you have created some stashes, it is time for you to list the stashes that you just created.

In order to list Git stashes, use the “git stash list” command.

$ git stash list

stash@{0}: WIP on branch1: 808b598 Initial commit
stash@{1}: On branch1: modified README.md
stash@{2}: On branch1: modified again the READ.me

As you can see, stashes are given an index starting at zero.

When creating new stashes, items are added to the stack meaning that the most recent stash has the index 0 while the oldest stash is at the bottom of the stack.

This is closely related to the concept of a stack in software engineering. A link to an in-depth article is included if you are curious about stacks.

Apply Git stashes

Now that you have saved your Git stashes on the side, you might want to “take them out from the stack” and apply them to your current working directory.

In order to apply your Git stash to your current working directory, use the “git stash apply” command and specify the stash you want to apply.

If you don’t specify any arguments to the apply command, the top of the stack will be applied.

$ git stash apply stash@{stash_index}

$ git stash apply (shortcut for git stash apply stash@{0})

For example, in order to apply the changes done in the stash with index 1, we would run

$ git stash apply stash@{1}

Already up to date!
On branch branch1
Your branch is up to date with 'origin/branch1'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

        modified:   README.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        file

By default, the stash applies command will list your current working directory after applying the corresponding stashes.

Now if you were to list your stashes, you would notice that applying your stash did not delete or remove the stash from the list.

$ git stash list

stash@{0}: WIP on branch1: 808b598 Initial commit
stash@{1}: On branch1: modified README.md
stash@{2}: On branch1: modified again the READ.me

If you want your stashes to be removed after applying them, you need to use the “git stash pop” command.

Pop Git stashes

So what is the difference between git stash pop and git stash apply?

The main difference is in the fact that the “git stash pop” applies your changes to your current working directory but it also deletes the stash from the stash stack.

To pop Git stashes, simply use the “git stash pop” command and specify the stash index you want to pop.

$ git stash pop stash@{stash_index}

Back to our previous stash example, this would give us

$ git stash pop stash@{1}

Already up to date!
On branch branch1
Your branch is up to date with 'origin/branch1'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

        modified:   README.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        file

Dropped stash@{1} (1adaf79224dca78aa6568b1e8154cbc4f747042f)

See the difference in the last line of the example?

The stash was dropped and removed from the stack.

Show Git stash differences

When you create a stash, it is most likely to perform some commits before going back to your stashed content.

As a consequence, you may want to see the differences between your stash and the most recent commit of your branch (also called HEAD)

To show the differences between a stash and the most recent commit, use the “git stash show” command.

$ git stash show stash@{stash_index}

README.md | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)

As a consequence, you will be listed with the differences between files, the insertions, and the deletions done.

To see all the differences including content, add the “-p” option.

$ git stash show -p stash@{stash_index}

diff --git a/README.md b/README.md
index f25b874..1088f9a 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,3 @@
-# private-repo
\ No newline at end of file
+The file was modified!

Drop Git stashes

In some cases, you may want to delete a Git stash entry from your stack.

In order to drop stashes, you have two options: with a drop or clear.

If you want to drop a specific stash from your stack, use the drop option and specify the stash index.

$ git stash drop stash@{stash_index}

For example, in order to delete stash with an index 1 from the previous example, you would run

$ git stash drop stash@{1}
Dropped stash@{1} (c11c6ae6c347d23dff8fbbf79d54a9e6e2e79b1c)

Drop all stashes using clear

If you want to delete all the Git stashes in your stack, you have to use the clear command.

$ git stash clear

Make sure that all your stashes were deleted with the list command.

$ git stash list

Conclusion

In this tutorial, you acquired basic knowledge about git stash such as how you can create stashes, delete stashes, and pop them in order to recover your work.

Git stash is pretty useful, but there are many other commands that you may find useful when using Git :

• You can learn how to set the upstream branch on Git;
• If you are just starting out, you can start by cloning repositories into your system.

If you are interested in software engineering, we have a complete section dedicated to it on the website, so make sure to check it out!

As developers, using & working with Git is mandatory. Git Users every time deals with many files in the local repository. If any user accidentally added any file to your Git then you can remove it from your index by performing the unstage files on Git. Unstaging file is very beneficial, it can be used to separate files in different commits or to do work on some other modifications.

If you are a beginner, then take help from the Junos Notes provided Git Commands Tutorial. However, this tutorial is completely on How to unstage files on Git and it addresses various methods to unstage all files or particular files or committed files elaborately in the below modules.

• Prerequisites
• Unstage a File in Git
• 1. Unstage Files using git `rm` command
  • Case 1: rm –cached on new file which is not committed.
  • Case 2: rm –cached on existing file.
• 2. Unstage Files using git reset
  • What does the git reset command do?
• Unstage all files on Git
• Remove unstaged changes on Git
• Unstage Committed Files on Git
  • Unstage Commits Soft
  • Unstage Commits Hard

Prerequisites

• Firstly, Installation of Git is the required
• A Git project
• Create a local and remote repository
• A terminal window/command line
  • Linux: Activities > Search > Terminal
  • Windows: right-click Start > Command prompt (or Windows PowerShell)

Unstage a File in Git

In Git, unstaging a file can be done in two ways.

1) git rm –cached <file-name>
2) git reset Head <file-name>

1. Unstage Files using git `rm` command

One of the methods to unstage git files is using the ‘rm’ command. It can be used in two ways:

1) On the brand new file which is not on Github.
2) On the existing file which exists on Github.

Let’s check the process of using the git rm command in both scenarios.

Case 1: rm –cached on new file which is not committed.

rm –cached <brand-new-file-name> is useful to remove only the file(s) from the staging area where this file is not available on GitHub ever. After executing this command, the file rests in the local machine, it just unstaged from the staging area.

Example:

$ git add filetwo.txt
$ git status

On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: filetwo.txt

$ git rm --cached filetwo.txt
$ git status

On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
filetwo.txt
nothing added to commit but untracked files present (use "git add" to track)

Case 2: rm –cached on existing file.

• How to Remove Files from Git Commit | Git Remove File from Commit Stage
• How To Clear Git Cache | Learn Git Clear Cache in Different Ways
• How To Git Reset to HEAD | What is Git HEAD? | How to Reset Git Head to Latest Commit

If ‘rm –cached <existing-file-name>.’command is utilized on the existing file on git then this file will be considered for delete and endures as untracked on the machine. If we make a commit after this command then the file on Github will be deleted forever. We should be very careful while using this command. So, this case is not advised for unstaging a file.

Do Refer: How To Clean Up Git Branches

2. Unstage Files using git reset

The most effortless way to unstage files on Git is by using the “git reset” command and specify the file you want to unstage.

git reset <commit> -- <path>

By default, the commit parameter is optional: if you don’t specify it, it will be referring to HEAD.

What does the git reset command do?

This command will reset the index entries (the ones you added to your staging area) to their state at the specified commit (or HEAD if you didn’t specify any commits).

Also, we use the double dashes as argument disambiguation meaning that the argument that you are specifying may be related to two distinct objects: branches and directories for example.

As a quick example, let’s pretend that you added a file named “README” to your staging area, but now you want to unstage this file.

$ git status

On branch master
Your branch is up to date with 'origin/master'.

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

        new file:   README

In order to unstage the README file, you would execute the following command

$ git reset -- README

You can now check the status of your working directory again with “git status”

$ git status

On branch master
Your branch is up to date with 'origin/master'.

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        README

nothing added to commit but untracked files present (use "git add" to track)

As you probably understood by now, the “git reset” command is doing the exact opposite of the “git add” command: it removes files from the index.

Unstage all files on Git

Previously, we have seen how you can unstage a file by specifying a path or a file to be reset.

In some cases, you may want to unstage all your files from your index.

To unstage all files also you can use the “git reset” command without specifying any files or paths.

$ git reset

Again, let’s pretend that you have created two files and one directory and that you added them to your staging area.

$ git status

On branch master
Your branch is up to date with 'origin/master'.

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

        new file:   README
        new file:   directory/file

In order to unstage all files and directories, execute “git reset” and they will be removed from the staging area back to your working directory.

$ git reset 

$ git status

On branch master
Your branch is up to date with 'origin/master'.

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        README
        directory/

nothing added to commit but untracked files present (use "git add" to track)

Remove unstaged changes on Git

In some cases, after unstaging files from your staging area, you may want to remove them completely.

In order to remove unstaged changes, use the “git checkout” command and specify the paths to be removed.

$ git checkout -- <path>

Again, let’s say that you have one file that is currently unstaged in your working directory.

$ git status

On branch master
Your branch is up to date with 'origin/master'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

        modified:   README

no changes added to commit (use "git add" and/or "git commit -a")

In order to discard changes done to this unstaged file, execute the “git checkout” command and specify the filename.

$ git checkout -- README

$ git status

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

Alternatively, if you want to discard your entire working directory, head back to the root of your project and execute the following command.

$ git checkout -- .

$ git status

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

Unstage Committed Files on Git

In some cases, you actually committed files to your git directory (or repository) but you want to unstage them in order to make some modifications to your commit.

Luckily for you, there’s also a command for that.

Unstage Commits Soft

To unstage commits on Git, use the “git reset” command with the “–soft” option and specify the commit hash.

$ git reset --soft <commit>

Alternatively, if you want to unstage your last commit, you can the “HEAD” notation in order to revert it easily.

$ git reset --soft HEAD~1

Using the “–soft” argument, changes are kept in your working directory and index.

As a consequence, your modifications are kept, they are just not in the Git repository anymore.

Inspecting your repository after a soft reset would give you the following output, given that you unstaged the last commit.

$ git status

On branch master
Your branch is up to date with 'origin/master'.

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

        modified:   README

What happens if you were to hard reset your commit?

In this case, all changes would be discarded and you would lose your changes.

Unstage Commits Hard

To unstage commits on Git and discard all changes, use the “git reset” command with the “–hard” argument.

$ git reset --hard <commit>

Note: Be careful when using the reset hard command, you will lose all your changes when hard resetting.

Conclusion

In this tutorial, you learned how you can unstage files easily on Git using the “git reset” command.

You learned that you can either specify a path or a single file to unstage files and keep on working on your files until you commit them to your repository.

If you are curious about Git, we have a whole section dedicated to it on the website, make sure to have a look!