what are the ten local branches most recently committed to?

Branches are one of Git'south most important concepts. And to master Git, information technology'southward essential to have a thorough agreement of how branches work.

Nosotros just released a tutorial about Git branches on the freeCodeCamp.org YouTube aqueduct.

Y'all volition larn well-nigh the many deportment y'all tin can perform around branches - from creating and deleting them all the fashion to publishing, renaming, and comparing them. This tutorial focuses on using Git with the control line. You practise Non need any GUI software to follow along.

This tutorial was created by Tobias Günther from Tower. Tower creates a powerful Git desktop GUI for Mac and Windows.

Hither is what covered in the tutorial:

• Branches as a core concept in Git
• Core concepts: the Head co-operative
• Core concepts: local vs. remote branches
• Creating new branches
• Switching branches
• Renaming branches
• Publishing branches
• Tracking branches
• Pulling + pushing branches
• Deleting branches
• Merging branches
• Rebasing branches
• Comparing branches
• Working with Branches Cheat Sail

Watch the full course on the freeCodeCamp.org YouTube channel (33 minute watch).

Transcript

(auto-generated)

Branches are one of the nearly important concepts.

In this course, Tobias volition requite you a thorough understanding on how branches piece of work in Git.

And don't forget to hit that subscribe button so yous don't miss any of our cracking courses.

Hullo Costless Lawmaking Campsite friends.

My proper name is Tobias and I'thou going to explain how to work with branches in Git.

One of the cadre and well-nigh important topics in Git and version control is how yous tin can productively work with your branches and what you can do to commencement off.

Simply before we get, let me have a huge shout out to the people at Free Code Camp for teaching people how to code for free on the internet.

Thank you so much for beingness on that mission.

And thanks for letting me assistance a petty flake with that contribution.

A couple of words nearly my background, I'm role of the team backside belfry tower is a graphical user interface for Git on Mac and Windows.

And nosotros've been effectually for more than 10 years now.

And in those 10 years, we've helped around 100,000 people in companies big and small freelancers, every developer in every part of the earth, work more than easily with the good version command system, take the headache out of skilful and make it more more easy.

This workshop today will non exist almost tower, don't worry, you lot don't have to have belfry installed, we volition do everything on the command line.

Then yous can follow along, no thing what you're using.

So before we start, what'south this going to be about? branches are one of the cadre concepts in Git.

And there's really an countless amount of things you can do with them, y'all can create and delete them, y'all tin compare, yous can merge and rebase them you can publish and track them.

And then we're talking nearly all of those things that y'all can do with your branches.

Earlier nosotros dive into the specifics, let me just briefly talk almost two core concepts that are mentioned once more and again.

So one is the head branch.

If you don't know that term, that's pretty important.

It is the currently agile or the checked out branch, you lot can have many branches in your repository, but you can take only i.

And that is active at a unmarried time.

So if you hit get status on your command line or are in a graphical user interface, you lot will see you are on a certain co-operative in this example here on co-operative main.

So master is currently the head branch, the active co-operative.

And the other cadre concept is the stardom between local and remote branches.

So when we're working with branches, we are in 99% of the time or 95% of the time, nosotros're working with branches in our local Git repository, right? The remote branches in your GitHub, git lab, Bitbucket, as your DevOps, whatever you accept, that they're more than for synchronizing, right, the bulk of the actual work happens in your local branches on your local machine in your local Git repository.

Alright, permit's start by creating new branches.

Right.

So earlier you tin can piece of work with branches, yous will offset need to accept some in your repository.

And to create a new branch, you can merely employ the git branch, control and provide the name of your co-operative.

So my new co-operative is the proper noun of that new branch.

And when I do it like that, when providing just a proper noun to the git branch command, git will assume that I want to showtime my new co-operative based on the currently checked out revision.

So I'k going to create a new branch on the state of affairs that I was to this point.

And so if I'd like to create a new branch at a specific other revision, let's say, let'southward see what revisions nosotros have in this repository.

Past the way, so this is this belfry, the graphical user interface that we make.

So here is my new branch, I but created that.

So that worked skilful news.

If I want to create my branch on a dissimilar revision, let'southward say I desire to first here, I tin can only copy the revision hash of that commit here.

And then on the command line, I tin type git branch, other branch, that's the name and I wanted to commencement on that revision here.

Alright, let's come across what that did.

Alright, and new branch.

And so that worked.

And it started on that revision here, right? And then you're pretty flexible with how you want to start your branches.

And again, equally I mentioned briefly, in that cadre concept area just a few seconds ago, you can only create new branches in your local repository, right? Creating branches in a remote repository, happens by publishing an existing local branch so I can, I can upload these here, simply I can't Create a co-operative on a remote, nosotros'll talk about that after on.

Or write git co-operative, either without mentioning a specific revision, then it's going to be your electric current revision, or mentioning a specific one to started on a specific revision.

Alright, switching branches, of class, another very important action you're going to apply all of the time.

Then the electric current co-operative, the checked out branch, and so to say, the caput branch, defines the context your work is in at the moment.

And the electric current head branches where new commits will be created, they volition exist created in that context.

And to modify the branch you're currently working in.

This means to check out another branch or to switch a co-operative.

And let's see how we tin can do that.

All right, so at the moment, if I hit git status, I tin can run across I am on co-operative chief.

So main is currently checked out, this is my head branch.

And if I want this to be a different branch, I can type git checkout.

And while nosotros have so many cute new branches, become new branch.

And while I switched to co-operative, my new branch, so the git checkout command is pretty versatile.

It's information technology'due south used for so many things.

In recent years, there has been a new control added to the Git control palette, and I would suggest yous utilise Git switch in the future.

Because Git switch is only for this purpose.

It'due south only for switching branches.

So if we want to switch to we created other branch, I tin can blazon Git switch, other co-operative and get switch, equally I said, is a little flake more unambiguous.

Because it merely has this purpose.

git checkout is a command with lots and lots of meanings.

So I'm more comfortable using Git switch, git checkout and get switch again.

So you lot can see in a graphical user interface, this is where the head arrow now points to.

So other branches, currently the checked out the agile branch.

Okay, number three renaming branches, it'south pretty easy to miss type A branches name or to change your mind later the fact.

So don't worry, you can rename branches, of grade, and become makes information technology pretty piece of cake to rename your local head branch.

So allow's do that.

And then we are currently on.

Over again, let's type git condition to make sure we are on branch other branch.

And if I'm not happy with that naming, I can merely change it using git co-operative with the dash m parameter, and and then provide a new proper name.

Then meliorate branch, permit's call it like that.

And accept a look.

Okay, I'm now on branch, better branch.

And that was pretty like shooting fish in a barrel.

And so in case you lot desire to rename a different branch, not the caput branch, not the currently checked out branch, and then nosotros have to provide the name of the old branch to to brand this an cryptic and then at the moment, we have, let's see what branches nosotros take.

Nosotros're using git co-operative without any parameters.

All correct, so better branch main and my new branch.

So allow's say I desire to rename a not head branch, a branch that is non currently checked out.

Permit'due south say I want to rename my new branch hither.

So allow's make some room.

Alright, so permit'due south rename git co-operative, nuance one thousand, my new branch and call it my better branch.

Permit'southward run into if that work.

git co-operative without any parameters shows you what branches you currently accept.

And voila, we just changed the name of a not head branch like this.

So these commands are used to piece of work for changing local branch names.

If yous'd similar to rename a remote co-operative, things are a niggling chip more complicated because Git doesn't allow you lot to rename rogue remote branches actually.

And then in practice, renaming a remote branch can exist done by deleting the one-time i and then pushing up publishing the new one from your local repository.

So let's take another look at what nosotros have.

Then if I'chiliad not happy with origin, staging that naming hither, I can delete that and then re upload it and I'll show yous how to publish upload your brand For the showtime fourth dimension in a second, and then we tin see how that works.

All correct, renaming branches with the git co-operative dash M.

Command.

And if you have a not head branch that you want to rename, provide the old proper name, and and so the new proper noun.

This is for renaming remote branches.

And nosotros'll exercise that in a while we are creating a new branch and pushing that for the first time.

And then we can exercise two things in one.

All correct publishing branches.

As I already said, information technology's not really possible to create a new branch on a remote repository.

What we can do, however, is republish an existing local branch on a remote repository.

And then we can upload what we have locally to the remote server and thereby share it with our squad, right.

So let's run across what nosotros have and what we tin publish.

Okay, so at the moment, we accept this beautiful feature uploader branch here, and it's non present on the remote.

So let's say I want to publish that for the first time, I want to upload it to the remote server named origin.

And let's let's do that on the control line.

And then I can simply use git push button nuance u, I'll explain what the new flag is in a second.

On the Origin remote, and information technology's the feature, loader branch.

Right, looking proficient.

All right, here we get.

So we've just uploaded that to that branch here, that local branch to the remote repository.

Now, we'll be talking most this dash you flag here in great detail in a 2d.

But to requite yous the the the nutshell, right now, information technology tells Git to establish a tracking connection.

And this means pushing and pulling afterward will be much, much, much, much more piece of cake in the hereafter.

So allow'south talk about that in detail.

Because the whole topic of tracking branches is really important to understand.

By default, local and remote branches have zilch to practice with each other, they're stored and managed every bit independent objects in Git.

Only in real life, of course, local and remote branches frequently practise have a relationship with each other.

For instance, a remote branch is ofttimes something like a analogue of a local ane, right? Such a relationship can be established in Git.

Then one co-operative typically a remote one, or a local ones, sorry, contrac.

Some other one, typically a remote one.

So in this little diagram, here, you can see nosotros have a local branch, it'southward called develop, and we have a remote co-operative on the origin remote, that'due south too called develop, and of course, I want them to have a relationship with each other, they're the counterparts of each other.

And with that tracking relationship constitute, when I later pull, or push, when I button from my local branch or pull from my remote co-operative, I can simply use the vanilla Git commands, I tin can use git push button and get pulled without any farther flags or parameters, because the tracking connection already knows in the can fill in the blank.

And then which branch on which remote do I want to push to or pull from, for example, all of that is already saved in the tracking connection.

And we've already used such one way to plant that so tracking connection when nosotros use git push with the you selection to publish that local branch.

And after that, as I said, we tin guess just use git push without mentioning the remote or the target co-operative or the source co-operative, this all works out.

And this likewise works the other way around.

So what we did was publish a local branch to a remote repository.

Only we can also go ahead and runway or download a remote co-operative and bring it to the local repository right the other way around is likewise possible.

And we can too establish a tracking connexion like that.

And then let's run into what we have.

This would exist number five.

And we currently have, right, a characteristic login branch on the remote that is not present hither in my local branches.

So permit's say somebody else worked on that feature, log in branch and I want to join that work and work with that co-operative.

So let's get that branch to my local branches.

And the way to do that is either to apply git co-operative with the dash dash rail option.

And this will exist characteristic login.

And information technology'south coming from origin characteristic, login.

So by that I created a local co-operative called feature login, that is based on origin feature login.

And they know about each other, right? I established that tracking connexion, and voila, hither we go, we now have that locally.

And in a graphical user interface like tower, I can run into that yep, there is a tracking connection, right, this local branch tracks the remote one.

Another manner to do that, well, let'due south create some other branch characteristic, downloader, and then we accept another local branch that is non nowadays on the, on the remote.

And we'll publish that really quickly.

And then remove it from here from my local branches.

Right, so over again, nosotros take that situation, I want to have that feature downloader branch on my local branches.

And currently, it'south only nowadays on the remote.

So another way to exercise that, instead of git branch dash dash track is to use the git checkout control.

And again, with the track choice, so that's the same.

And I'm basing that on origin feature, downloader.

And by not naming a local co-operative and but specifying the base, remote branch, become uses that branch name for the local branches name, then I at present take feature downloader hither again, same affair as earlier, so it doesn't really affair if you lot're using git branch nuance nuance track or git checkout distressed rails, it'due south just another way of doing that.

Okay, tracking branches, very important, either with git branch, distressed rail, or with git checkout, dash dash rails, pulling and pushing branches.

So one time yous have your tracking connection set properly, pulling and pushing is really simple and almost ho-hum, actually.

So that's why I strongly propose to piece of work with the commands I showed you before either.

When publishing a local branch with git push dash, y'all are when tracking a remote branch from the other side with git checkout dash track command, because again, once this tracking connection is set up, all yous need to exercise is utilize Git pull, and git push to sync your branches, right become pulled to download new commits from the remote probably from your colleagues, and get push for uploading or publishing your own new work to the remote server.

You lot don't demand with the striking connexion setup, you didn't need whatever additional parameters, you lot don't need to specify the remote like origin and the base branch or the target co-operative and the source branch.

Simply get pulled and get push button is plenty.

So that's the existent advantage of using those tracking connections.

Let's take another look at what we have here.

and run into what's happening.

Okay, so currently we are on the characteristic login branch.

And the Some other advantage of having those tracking connections set upward is that Git tells me if my local branch and the tract remote branch diverge.

And that means that let'south accept some other look at tower and what what this looks like.

So this feature login branch here has little numbers here.

And this ways one commit hasn't been pushed yet.

And so the remote version of that co-operative doesn't accept 1 commit that I produced locally.

And the other manner around.

Two commits are present on the remote terminate to probably a co worker or a teammate fabricated some commits.

And I oasis't pulled those down.

I haven't downloaded those.

And so this is really interesting to stay on track and empathize how local and remote branches diverged if there'southward something that I forgot to push button or haven't pushed however.

Or if in that location'southward something that I need to pull I need to update.

And with the command line with the git branch, nuance v command, I can get the same information.

So I see characteristic logging is ahead ane behind two ahead means I have Local commit that is not pushed still behind means I am backside the remote.

So there are new commits on the remote that I haven't pulled.

Pretty interesting information to understand where you are, how you act, how current your data is, you could say how right deleting branches soap, most branches are not meant to live forever.

And I encourage you to do a piddling bit of housecleaning now and then.

And here's how to delete a local branch.

That'due south pretty piece of cake.

And so let'south motion to number 7.

And see what we accept.

Okay, feature uploader and primary are there.

The first thing yous know to know is you cannot delete the current head branch.

So if I were to type git branch, dash D and feature uploader, I would get an error message because I as I said, I can delete the branches currently agile that is currently head.

So first, I would accept to step abroad from that get switch main make main or another co-operative active.

And so I could utilize git branch nuance D, and feature uploader to practise that loader and deleted branch feature uploader.

So this is now gone, correct, I deleted that.

In some cases, you will once more, go an fault message.

Considering let's say y'all accept worked on a local feature branch for some time produced some commits, and and so understand, okay, this, this doesn't pb anywhere I need to delete that you lot've produced new commits that are present nowhere else.

And if y'all try to delete that branch, git will say, well, be conscientious, you lot are about to delete information that is present nowhere else these commits haven't been integrated into other branches.

And then are you really sure and that's when y'all need to use the nuance f option forcefulness to force the deletion.

Needless to say, I guess that this is quite a subversive action with dash F for forcefulness.

Then be careful you have a hard time getting those commits back.

You tin Don't worry, just it's information technology has its reasons why expert warns you Well, these commits are present, nowhere else are you sure you desire to delete that branch.

Another thing you might want to do is delete a remote branch.

And as you already know, working with branches on the local end is unlike than working on the remote.

Then it's a unlike command git branch.

Allow'southward see what we have first.

And so let'south say nosotros want to delete that origin feature downloader co-operative here on the remote.

And we tin do that using Git.

clear up a piffling fleck git push again, and I want to remove something from origin.

Delete flag is used hither for characteristic downwardly loader.

And let's meet, all correct, nail, at that place it is gone.

So maybe another important affair to remember is when deleting a branch doesn't affair if it's a remote one of our local 1, keep in heed to check if you should delete its counterpart branch to write the tracking co-operative.

And so for instance, if y'all've deleted a remote feature co-operative, it might make sense to too delete its local tracking branch.

That way yous make sure you aren't left with lots of obsolete branches and a messy Git repository, of course.

And so always keep in heed when I delete one branch, is at that place a counterpart co-operative on the other finish, either local or remote? And should I delete that too? Perhaps.

Okay, deleting on the remote with git push, and nuance, nuance, delete.

Merging branches are pretty interesting topic.

Merging is probably the almost common way to integrate changes.

And so substantially, you're bringing new commits from another branch into your electric current head branch.

That's always the direction, right? You're, you're integrating into your current local head branch from another branch.

And merging in most cases is very easy in in in Git and very simple, different to other version command systems.

So that's i reason why it'due south so popular.

And essentially, it just requires 2 steps.

And so first, you need to brand agile, the co-operative that you desire to accept the changes come up into that should receive the changes then execute, execute the merge command with the name of the branch that has the want changes on permit's see what we have hither in our example scenario.

Okay, and then at the moment Maine has a new commit that is this i here, title of mistake page corrected.

And uploader has also a unlike commit clarify CSS background rule.

So they diverged.

And let's say I want to integrate this commit hither or these changes the new commits on characteristic upload into main, correct, I want to bring the new changes into the chief co-operative, and then I can just switch to main, brand master active, and so just type Git merge characteristic, what was information technology uploader? And voila, I'thousand getting an editor with a why is that, because merging most often not always produces a merge commit, right? Retrieve of that similar a knot that combines or that connects two branches.

And this is a new commit.

So I can provide a new commit message.

And I'm going with what Git provides here as a standard merge branch feature uploader.

Just close that.

And let's see what happened.

on Master wall, I just combined these two branches and, and I take all of the changes here from both branches.

And then this is what the end effect looks like.

Equally I said, there is this merge commit here that combines the changes from both branches.

And there is another way of integrating changes, and that is rebasing, and then this is just an alternative way to integrate commits from one co-operative into another.

And it's very important to stress that this is not better or worse, this is not the the pro version and merges the beginner version, it's simply different.

If and when you're using rebase, mainly comes down to your personal preferences and conventions in your team and the state of affairs.

So some teams love rebase, some prefer merge, and some practice in some cases and not in other cases.

And then information technology's not a matter of amend or worse, that's important to understand.

Then let's compare merge and rebase.

So you lot empathize what'southward the difference.

So this is the the starting situation, we have two branches, nosotros have branch a and branch B, and both accept diverting changes are unlike changes.

So we've couple commits here and one commit here.

And they they were branched off on this signal hither.

Now with merge, you've already seen that we would receive this merge commit in the end this melting point or this not that combines these two commits, using rebase.

On the other hand, the end result will expect quite different.

So especially because there is no separate merge commit that will be created this big difference.

Using rebase.

Information technology appears as if development history had happened in a straight line.

At that place's not this, this branching out anymore, it happens, or information technology looks similar it was a straight line.

And this has its pros and its cons.

So simply that's the result and the large deviation.

And then starting the actual process is pretty simple.

But let'south do that in practice.

This is case number nine.

And let's meet what we take.

Alright, then pretty like situation like before, on feature uploader, I have two commits these hither that are present nowhere else.

And on Main I accept this year that is present nowhere else.

And let'due south say I would like to integrate the changes from Maine into my feature uploader branch, correct.

And then the first step would be to switch to feature uploader to make that the caput co-operative considering, as with merge, I am always integrating into my head branch.

Right, the head branch is the one that's beingness manipulated.

I am already on feature uploader.

And then nothing to do here.

Only the 2nd footstep is Git rebase.

And I want to rebase on Master.

And that was already it.

Let's see what happened.

Now you can come across this title of error page corrected commit that used to be on Main is now as well present here on uploader.

And as you tin see, there'south non this branching out this, this melting, not no merge commit.

This looks similar a direct line.

And that's the big difference between merge and rebase.

Over again, if yous're using a graphical user interface like tower, you tin can just elevate and drib to merge or if y'all keep the Alt key pressed it becomes rebase.

Then these actions are pretty straightforward in a graphical user interface.

Alright, and then this is rebasing again, and final case or final action, comparing branches, sometimes it'south pretty helpful to compare two branches.

So for example, earlier you determine to integrate or delete a branch, you desire to see how information technology differs from another branch.

Does it comprise whatever new commits? Or not? Do I nevertheless need those? What's the divergence? So permit's do this in practice.

And see what nosotros take.

So similar situation should only before feature uploader and primary they diverged, they have unlike commits.

And let'southward compare that and see what is actually different betwixt them.

So I tin type git log master double dot feature uploader.

And this shows me which commits are in our feature uploaded branch, simply not in our principal branch.

And thereby I can encounter, okay, these 2 commits are here, but not hither.

And this would as well of class, mean, if I integrated into main these two commits, would arrive into the integration.

So I tin empathise the difference between those two.

If I desire to see what's the difference betwixt a local and a remote branch, I can also practise that same affair, really.

So let'south compare my local Maine with the origin Maine.

And the process is pretty similar.

git log, Maine.

Permit's start with origin Maine, and Maine.

And I can see okay, I have one commit currently in my local main that is not present in my remote branch origin primary.

So I know.

Okay, if I pushed at present, I would upload this commit here because it isn't present at that place.

All correct.

I think this is it for today.

To help you remember what you learned, I prepared a trivial crook sheet about this topics about all of the different commands that you can use in regard to working with branches.

Just hop on Bitly and get co-operative's crook sheet and download that for gratis.

This comes in handy in your daily piece of work, I'm sure of information technology.

And you tin download the crook sheet for free as y'all like.

I hope there'south a niggling bit of new information for you hither in this workshop and in the cheat sheet.

Have fun creating deleting renaming, tracking, pushing, pulling, comparing branches and piece of work with Git.

Thanks for your attention.

---

---

Learn to code for gratis. freeCodeCamp's open source curriculum has helped more than twoscore,000 people get jobs as developers. Get started

nordmandound1984.blogspot.com

Source: https://www.freecodecamp.org/news/how-git-branches-work/

Share this post