Combining Multiple Commits Into One Prior To Push

Solution 1:

For your first question, no, there's nothing wrong with pushing multiple commits at once. Many times, you may want to break your work down into a few small, logical commits, but only push them up once you feel like the whole series is ready. Or you might be making several commits locally while disconnected, and you push them all once you're connected again. There's no reason to limit yourself to one commit per push.

I generally find that it's a good idea to keep each commit a single, logical, coherent change, that includes everything it needs to work (so, it does not leave your code in a broken state). If you have a two commits, but they would cause the code to be broken if you only applied the first one, it might be a good idea to squash the second commit into the first. But if you have two commits where each one makes a reasonable change, pushing them as separate commits is fine.

If you do want to squash several commits together, you can use git rebase -i. If you're on branch topical_xFeature, you would run git rebase -i master. This will open an editor window, with a bunch of commits listed prefixed by pick. You can change all but the first to squash, which will tell Git to keep all of those changes, but squash them into the first commit. After you've done that, check out master and merge in your feature branch:

git checkout topical_xFeature
git rebase -i master
git checkout master
git merge topical_xFeature

Alternatively, if you just want to squash everything in topical_xFeature into master, you could just do the following:

git checkout master
git merge --squash topical_xFeature
git commit

Which one you choose is up to you. Generally, I wouldn't worry about having multiple smaller commits, but sometimes you don't want to bother with extra minor commits, so you just squash them into one.

Solution 2:

This is the way I generally follow to combine multiple Commits into a single commit before I push the code.

To achieve this, I suggest you use 'squash' concept provided by GIT.

Follow the below steps.

1) git rebase -i master (instead of master you can also use a specific commit)

open the rebase interactive editor, where it will show all your commits. Basically where you need to identify the commits which you want to merge into a single commit.

Imagine these are your commits and shown something like this in the editor.

pick f7f3f6d changed my name a bit    
pick 310154e updated README formatting and added blame   
pick a5f4a0d added cat-file  

It's important to note that these commits are listed in the opposite order than you normally see them using the log command. Means, the older commit will be shown first.

2) Change 'pick' to 'squash' for last committed changes. something like shown below. Doing that so, your last 2 commits will be merged with the first one.

pick f7f3f6d changed my name a bit         
squash 310154e updated README formatting and added blame   
squash a5f4a0d added cat-file

You can also use short form if you have lot of commits to combine:

p f7f3f6d changed my name a bit         
s 310154e updated README formatting and added blame   
s a5f4a0d added cat-file

for editing use 'i', it will enable the editor for insertion. Keep in mind top most(oldest) commit cannot be squashed as there is no previous commit to combine with. So it has to be picked or 'p'. Use 'Esc' to exit insert mode.

3) Now, save the editor with the following command. :wq

When you save that, you have a single commit that introduces the changes of all three previous commits.

Hope this will help you.