Git

How to Create a new GIT Branch from a Tag?

noviceadmin — Sun, 18 Sep 2022 15:10:55 +0000

How to Create a new GIT Branch from a Tag?

noviceadmin Sun, 09/18/2022 - 15:10

A new GIT branch can be created from a tag through the “git checkout” command with the “-b” option followed by a new branch name and tag name.

$ git checkout -b <new-branch> <tag-name>

Why Create Git Branch from a Tag

GIT tags are created to mark a specific point in git history and then deployed. But sometimes you might want to debug the deployed code and the best way is to create a new GIT branch from that tag.

How to Create Git Branch from a Tag

Let’s say you have deployed tag v2.0 on production and now you have some issues after the deployment.

Now creating a debug branch from the tag v2.0 will be the best way to make sure you have the exact code which is deployed on production.

Now let's go through each step one by one to create a new branch from the correct tag.

1. Get the tag

Make sure you fetch all the tags from your remote repository with the "git fetch" command

$ git fetch --all --tags

2. Confirm the tag

Now confirm that you have fetched the required tag v2.0 from which you want to create the branch.

$ git tag -l
v2.0
v1.0

3. Create a new branch from the tag

After confirming that tag v2.0 fetch properly, we can now run the "git checkout" command to create the new branch from that tag.

$ git checkout -b debug-tag-2-0 v2.0

Now we have a new branch "debug-tag-2-0" ready for debugging on local.

Conclusion

In this tutorial, we learned why we might need to create a new git branch from a tag for debugging and how this can be achieved with the "git checkout" command.

Comments

Hello novicedev.com…

Christine Fuller Sat, 03/11/2023 - 04:38

Hello novicedev.com webmaster, Well done!

Add new comment

How to Create a GIT Branch from a Commit?

noviceadmin — Mon, 12 Sep 2022 11:14:00 +0000

How to Create a GIT Branch from a Commit?

noviceadmin Mon, 09/12/2022 - 11:14

Usually, a branch is created from another branch which is the latest HEAD commit of the branch. But what if you want to create a branch from a previous commit HEAD?

GIT branch can be created with a commit hash using the ‘git checkout’ command with ‘-b’ option and then pass a new branch name with the commit SHA.

$ git checkout -b <new-branch> <commit-sha>

Or, you can also use the 'git branch' command to create the branch without switching to the new branch.

$ git branch <new-branch> <commit-sha>

Here are the detailed steps to create a GIT branch from a commit hash with the git checkout command:

1. Find commit SHA with git log

The first step is to find the commit SHA from which you want to create the branch.

Use ‘git log’ command with ‘--online’ and ‘--graph’ options to get the commit SHA.

$ git log --oneline --graph
* 39710b8 (HEAD -> feature-2) Feature 2 added.
* ecddf76 Feature 1 added.
* 34cd5ff (new-branch, develop) Test commit.

Now you can see 3 commits in the git history.

2. Create new branch from commit SHA

Now let's assume you want to create a branch from the second commit with commit hash value 'ecddf76'.

$ git checkout -b feature-102 ecddf76

3. Confirm new branch head

Use 'git log' command again to make sure that the new branch is created from the correct commit SHA

$ git log --oneline --graph
* ecddf76 (HEAD -> feature-104) Feature 1 added.
* 34cd5ff (new-branch, develop) Test commit.

Now you have successfully created a new branch from a commit in the commit history.

Further reading: https://www.atlassian.com/git/tutorials/using-branches/git-checkout

Add new comment

How to Create a Git Branch (WITH EXAMPLE)

noviceadmin — Mon, 12 Sep 2022 03:33:51 +0000

How to Create a Git Branch (WITH EXAMPLE)

noviceadmin Mon, 09/12/2022 - 03:33

Whenever you start developing a new feature you must start with creating a new branch git. This way you separate your feature changes from other branches.

A new branch can be created with the ‘git checkout’ command with the ‘-b’ option and a new branch name as arguments. This will create a new branch from your current branch and also switch the branch to the new branch.

$ git checkout -b <new-branch>

But if you don't want to create a new branch from the current branch then you can also pass the base branch as an argument.

$ git checkout -b <new-branch> <base-branch>

Once the feature is completed, this new branch can be merged back into the other branch.

Example of creating a GIT branch

Let's take an example, you want to create a new feature branch 'feature-2' from the master branch.

1. Checkout master branch (source branch)

First, make sure your current git branch is the master branch. You can check this by running "git branch" or "git branch --show-current" commands

$ git branch
feature-1
* master

If not, then make sure to checkout the master branch.

$ git checkout master

2. Run the "git checkout" command with "-b" and feature the branch name

Now you can run the GIT checkout command to create a new feature branch "feature-2"

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

Once run successfully, the new branch will be created and your current branch will be switched to this new branch.

3. Confirm the new branch

You can verify your new branch by running the ‘git branch’ command.

$ git branch
feature-1
* feature-2
master

Conclusion

In this tutorial, we learned to create a new branch in GIT with the "git checkout" command. This can also be achieved with the "git branch" command.

A GIT branch is not the only source for creating a new feature branch. A New GIT branch can also be created from commit SHA, a tag, or a remote branch.

Add new comment

GIT STASH: Save uncommitted changes (WITH EXAMPLES)

noviceadmin — Thu, 07 Apr 2022 06:25:36 +0000

GIT STASH: Save uncommitted changes (WITH EXAMPLES) noviceadmin Thu, 04/07/2022 - 06:25

Want to switch the git branch for some other quick fix but don’t want to commit changes in the current branch then the “git stash” command is here for your rescue.

What is Git stash?

Git stash command is used to store changes that you don’t want to commit now and take you to the last commit of the branch. And later when you are ready you can reapply the stashed changes.

Now let's see in more detail with examples of how to use “git stash”.

How to use Git stash command?

The simplest git stash workflow is to stash the changes with the git stash command, work on some other functionality and later apply the stashed changes back to get the modified files.

Here is a step-by-step example of how to use git stash.

1. Check uncommitted changes

Run “git status” to check for uncommitted changes which you want to save.

$ git status
On branch develop
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: index.php
no changes added to commit (use "git add" and/or "git commit -a")

2. Run "git stash" command

If you find any changes which you don't want to commit and work on something else, then run "git stash". Git stash will store changes and will give you a clean branch.

$ git stash
Saved working directory and index state WIP on develop: 34cd5ff Test commit.

3. Work on something else

Now you are free to switch to other branches or work on something else without any modified changes in the working directory.

4. Get a clean working directory

Once you are done with other work you need to make sure you have a clean working directory by running "git status".

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

5. Run "git stash pop"

Now run the "git stash pop" command to get back your stashed changes. This command reapplies the last stashed change to the working directory and deletes it from the stash.

$ git stash pop
On branch develop
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: index.php
no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (d75596436aa3c3e926061d2213e3f2959bc2b16b)

6. Check modified changes

You can run git status again to make sure everything is okay and you have your modified changes back.

$ git status
On branch develop
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: index.php
no changes added to commit (use "git add" and/or "git commit -a")

Advanced Git stash commands

Git stash also comes with many useful advanced commands which will help you in specific scenarios.

git stash
git stash apply
git stash list
git stash drop
git stash clear
git stash pop
git stash branch
git stash file
git stash show

More resources

Add new comment

How to Rename GIT Branch?

noviceadmin — Thu, 27 Jan 2022 16:32:49 +0000

How to Rename GIT Branch?

noviceadmin Thu, 01/27/2022 - 16:32

Made a small mistake while naming your git branch, don't panic this blog post will go through all the possibilities for renaming the git branch on local and remote.

Git branch can be renamed with a simple command "git branch -m <new-name>", this will rename your current git branch name. Once the branch is renamed on local you can push the new branch to remote and delete the old git branch on the remote.

Now let's go through some detail on why and how to rename a git branch on local and remote.

Why you might want to rename the git branch name?

Before going into details of how to rename local and remote git branches, let's see the reason why you might want to do it:

You might want to rename your git branch if the branch name does not match your project branch naming standards.
You might have the wrong branch name or a wrong ticket number in your branch name.
Sometimes you might make a typo mistake while naming your branch and want to make it perfect by renaming it.

How to rename the local git branch?

Now let's see how to rename a git branch on local with these steps:

The first step to rename a branch is to checkout the branch you might want to rename.
```
$ git checkout <old-name>
```
Now you can run the "git branch" command with -m and the new branch name
```
$ git branch -m <new-name>
```
To check if the branch is renamed correctly you can run the "git branch" or "git status" command to check your current branch
```
$ git branch
```
```
$ git status
On branch new-name
nothing to commit, working tree clean
```

If your old git branch was only on your local and not pushed to remote then you can stop here.

But if you have the wrong branch name on remote as well then continue reading.

How to rename remote git branch?

In the previous stage, we rename the git branch on local and now we will follow these steps to update the branch name on remote as well.

Once the branch is renamed on local, run the below command to push the renamed branch to remote
```
$ git push origin -u <new-name>
```
Pushing the branch to remote with the new name will now delete the old branch on the remote. You need to run the below command to delete the remote branch with the old name.
```
$ git push origin --delete <old-name>
```

Conclusion

Okay, now we know that there is no need to panic if you made a mistake while naming your git branch.

We have seen why might need to rename your git branch, how to rename a branch on local, and then how to push it to the remote repository if required.

And always remember to remove the old git branch from the remote to make sure no one uses it.

Leave a comment if you need to know more about renaming your git branch and do check out our blog post on basic git commands you should know.

Add new comment

16 Basic Git Commands with EXAMPLES

noviceadmin — Mon, 03 Jan 2022 14:35:41 +0000

16 Basic Git Commands with EXAMPLES

noviceadmin Mon, 01/03/2022 - 14:35

As a beginner knowing all the git commands could be overwhelming, but you can get away with some basic git commands at the start.

In this article, we will go through these 16 basic git commands that you should know as a new developer.

git clone
git init
git checkout
git branch
git config
git status
git diff
git add
git commit
git push
git remote
git pull
git log
git rm
git stash
git fetch

Now let's go through them in little detail...

1. Git clone

Git clone git command is used when you are trying to download a project from a remote repository.

Syntax:

$ git clone <repository>

Example:

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

2. Git init

Git init command is used to convert a directory into a git repository. This command is useful when you are starting a new project or want to initialize git in an existing project.

Syntax:

$ git init

3. Git checkout

Git checkout command is used to switch your current branch to another one.

Syntax:

$ git checkout <branch_name>

With -b option Git checkout branch can also create a new branch from the current branch.

Syntax:

$ git checkout -b <new_branch>

4. Git branch

Git branch command is used to list all the branches on your local repository. And the output will highlight the current branch you are in.

Syntax:

$ git branch

Git branch command can also be used to create a new branch by adding the name of the new branch at end of the command.

Syntax:

$ git branch <new_branch>

5. Git config

Git config command is used to set the git user config for the project or globally. At the start of your project make sure you set the correct user.name and user.email for your project.

Syntax:

$ git config <setting> <command>

Example:

git config user.email [email protected]
git config user.name “John Corner”

Git config command can also be used to set this config globally. You can find more information about the git config command here.

6. Git status

Git status command returns the current status of your working directory. This is the best way to know what is modified, added or deleted in your repository.

Syntax:

$ git status

7. Git diff

Git diff command can be used in many different ways and initially, you can use it to check what is modified in a file or directory.

$ git diff <file_name or directory_name>

8. Git add

Git add command is used to move new or modified files to the staging area. After this changes can be committed.

Syntax:

$ git add <file_name or directory_name>

If you want to add all files then use the git add command with “.”.

Syntax:

$ git add .

9. Git commit

Once you are done with your changes, the git commit command is used to save your change in the git branch.

Syntax:

$ git commit -m “Your commit message.”

10. Git push

To more your local committed changes to remote use git push command. With this command, you push your local branch to the remote repository.

Syntax:

$ git push <remote> <branch>

11. Git remote

Git remote command with different options helps to sync the local repository with the remote repository. You can view, create/add, delete, rename remote to other repositories.

Git remote command is used to show the remote repository name and URL to which your local repository is connected.

Syntax:

# View remote
$ git remote -v
# Add remote
$ git remote add <remote_name> <remote_path>
# Delete remote
$ git remote rm <remote_name>
# Rename remote
$ git remote rename <old_remote_name> <new_remote_name>

12. Git pull

As the name suggests, the git pull command will fetch all the changes from the remote repository and merge them into your local repository.

$ git pull

13. Git log

Git log command is used to show commit history in the current branch on your local repository. Commit history will be in chronological order with unique commit hash, commit author and date.

$ git log

You can use the git log command with other options to filter the logs.

14. Git rm

Git rm command is used to remove files or directories from the git index. Different options can be used with the git rm command to get the desired result.

And keep in mind the git rm command will also remove files from the working directory.

Syntax:

$ git rm <file_name>

15. Git stash

Git stash command is used to save current changes of modified files and get a clean branch.

You will need git stash when you want to move to a different branch but can't because you have modified changes in your current branch.

$ git stash

You can always come back to your original branch and do the "git stash pop" command to get back your stashed changes.

16. Git fetch

Git fetch is used when you want to get updates from a remote repository.

It works the same as git pull doesn't merge the changes into your local repository.

Syntax:

$ git fetch <remote_name>

Conclusion

These are only the basic git command that every beginner should start with. All these git commands can be used in many different ways by adding arguments with them.

And you can always test these git commands and get familiar with them by creating a free git repository on Github or Gitlab.

Add new comment

How To Clone A GIT Repository

noviceadmin — Sat, 25 Dec 2021 15:47:28 +0000

How To Clone A GIT Repository

noviceadmin Sat, 12/25/2021 - 15:47

Git clone command is used when you are trying to download a project from an existing remote repository. Once the git clone command is successfully executed you will have a copy of the repo in your machine.

Git repository can be downloaded or cloned with the "git clone" command with the path of the repository as an argument. This will clone the specified git repository folder in your current directory. A repository can also be cloned in a specific folder using the directory argument after the repository path.

Now let's see in more detail with examples on how to clone or download a git repository.

Clone Git repository

The below command will clone the remote git repository and the name of the directory will be the same as the repository name.

Syntax:

$ git clone <repository>

Example:

$ git clone https://github.com/username/myproject.git

Git clone to the specific directory

With the git clone command, you can add a directory name in front of the repository option to clone the repository in a particular directory.

Syntax:

$ git clone <repository> <directory>

Example:

$ git clone https://github.com/username/myproject.git my_project

Conclusion

Now we know how simple it is to get started with getting code from a remote repository to your local machine with the Git Clone command. And make sure to go into the cloned directory to start working with the project.

If you need to explore more about the Git clone command or different configuration options available with the head to this document.

Add new comment

How to checkout a git tag

noviceadmin — Sun, 29 Aug 2021 15:23:47 +0000

How to checkout a git tag

noviceadmin Sun, 08/29/2021 - 15:23

Git tags are created to mark a release candidate. Because it points directly to a commit in the git history and will not change.

But sometimes we need to checkout a remote tag to our local. You can achieve this by fetching it from remote and checkout it as a branch on local.

Here is how we can achieve this.

Fetch git tags

The first thing you need is to fetch the git tag to your local. You can do this by using the git fetch command with --all and --tags arguments.

$ git fetch --all --tags

Checkout tag as a branch

The next step is to checkout a specific tag as a branch with git checkout command with the tag name and new branch name.

$ git checkout tags/<tag_name> -b <branch_name>

Now you can test the code from a tag on your local branch and make updates as well.

Add new comment

How to delete local and remote git tags (WITH EXAMPLES)

noviceadmin — Tue, 27 Oct 2020 06:05:19 +0000

How to delete local and remote git tags (WITH EXAMPLES) noviceadmin Tue, 10/27/2020 - 06:05

Once you have created a git tag, you might realize that the git tag name is wrong and does not match the release pattern. In this scenario, you might want to delete the git tag.

It might be possible you have already pushed the wrong git tag to the remote. So in this tutorial, we will see how to delete a git tag from local as well as from remote.

How to delete local git tag

To delete a local git tag simply run the "git tag" command with the -d option and tag name. To know the tag name you can run the "git tag" command with the -l option to list all tags, identify the tag you want to delete.

Here is an example of how to delete a local tag in git.

$ git tag -l
v1.0
v2.0
v2.5
v3.0
$ git tag -d v2.5
Deleted tag 'v2.5' (was aea93f1727)
$ git tag -l
v1.0
v2.0
v3.0

You can run the "git tag" with the -l option to verify that the tag is deleted.

How to delete remote git tag

There are two ways to delete the remote git tag.

One is to delete the tag from local first (as shown above) and then push it to the remote. Another option is to delete the tag from the remote.

Let check both methods of deleting a tag from remote.

Once the tag is removed from local, the next step would be to remove the remote git tag using the command below.

$ git push origin :refs/tags/v2.5
To [email protected]:username/project.git
- [deleted] v2.5

For directly deleting the remote git tag, use the "git push origin" command with --delete option and tag name.

$ git push origin --delete v2.5
To [email protected]:username/project.git
- [deleted] v2.5

Recap

So in this blog post, we learned about how to delete the local git tag and then push that deletion to the remote. And another option is to directly delete the remote git tag.

You can read further about git tags in the following articles:

Add new comment

How to create git tags (With Examples)

noviceadmin — Fri, 23 Oct 2020 07:23:02 +0000

How to create git tags (With Examples) noviceadmin Fri, 10/23/2020 - 07:23

Git tag is used to mark a specific point in the git history. And are mostly used for creating project releases.

Git tags are similar to git branches but no change can be made once a tag is created.

In this tutorial, you will learn about how to create new git tags for your project.

Create a new git tag

The simplest and most straightforward way to create a new tag is by running the “git tag” command with the tag name.

$ git tag <tag_name>

The above syntax can be used to create a tag by replacing <tagname> with the actual tag name.

Here is an example of how someone might use this git command in real life to create a tag.

$ git tag v1.0

In the above example “v1.0” is the name of your new git tag.

Create a git tag from a commit

Git tag can also be created from a particular commit SHA from git history. You can use the “git tag” command with the tag name and commit SHA for which tag need is created.

Syntax to create git tag from a commit:

$ git tag <tag_name> <commit_sha>

Example to create a git tag from a commit:

$ git tag v1.0 c69d03e

If you want to create a tag from the last commit then you can simply use a HEAD option as shown below.

$ git tag v1.0 HEAD

Git tag can also be created from the commit SHA with an annotation tag by adding “-a” and “-m” options.

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

View available git tags

Once the tag is created you can just run the “git tag” command to confirm the tag and get all the tag you have available.

$ git tag
v1.0
v2.0
v3.0

-l option can be added to "git tag" command to further refine the result if you have a big list of tags. For example, if you only want to see tags for v2.0 and sub-releases.

$ git tag -l "v2.*"
v2.0
v2.5

Type of git tags

As now we know what are git tags and why we need them, let’s talk about the type of tags git supports. You can have two types of tags in git, 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. The example you have seen above is the example of Lightweight Tags, and here is the syntax again.

$ git tag <tag_name>

Annotation Tags

Annotation Tags are a method 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.”

And now you can use the “git show” command to see all the data attached with the tag we just created with annotation.

$ git show v1.0
tag v1.0
Tagger: John Corner <[email protected]>
Date:   Sun Oct 25 16:41:00 2020 +0800
Release v1.0 created.
commit c69d03eaf212510534a3d79f98ff36bb4b018a81
(HEAD -> master, tag: v1.0, origin/master)
Merge: 83633c99e 0714ce67b
Author: John Corner <[email protected]>
Date:   Sun Oct 18 04:42:24 2020 +0000

Conclusion

So in this blog post, we learned about how to create a git tag for your project release with examples.

We also covered how to create a git tag from a commit SHA and how to view the created git tags. Later we cover Lightweight tags and Annotation tags with examples.

You can read further about git tags in the following articles:

Git
Git Tag