Do a checkout from your current branch and pull from another branch. This pulls all the commits from the other branch into the current branch. You can work on all the changes without changes being committed to actual branch. Optionally you can commit and push if these changes needs to be tracked.
After running the stash command for a branch, if the git user wants to pull the branch's changes to another branch, it can be done easily by using the `git stash pop` command that works like the `git merge` command.
Before following these instructions keep in mind that featurex
is the branch where changes are being merged and pushed
go to your branch featurex
git checkout featurex
merge the changes of our-team
branch into featurex
branch
git merge our-team
or
git cherry-pick {commit-hash}
if you want to merge specific commits.
Note: probably you will have to fix conflicts after merging our-team
branch into featurex
branch before pushing.
You can use rebase, for instance, git rebase our-team
when you are on your branch featurex
.
It will move the start point of the branch at the end of your our-team
branch, merging all changes in your featurex
branch.
git fetch origin our-team
or
git pull origin our-team
but first you should make sure that you already on the branch you want to update to (featurex).
For other people coming upon this post on google. There are 2 options, either merging or rebasing your branch. Both works differently, but have similar outcomes.
The accepted answer is a rebase. This will take all the commits done to our-team
and then apply the commits done to featurex
, prompting you to merge them as needed.
One bit caveat of rebasing is that you lose/rewrite your branch history, essentially telling git that your branch did not began at commit 123abc but at commit 456cde. This will cause problems for other people working on the branch, and some remote tools will complain about it. If you are sure about what you are doing though, that's what the --force
flag is for.
What other posters are suggesting is a merge. This will take the featurex
branch, with whatever state it has and try to merge it with the current state of our-team
, prompting you to do one, big, merge commit and fix all the merge errors before pushing to our-team
. The difference is that you are applying your featurex
commits before the our-team
new commits and then fixing the differences. You also do not rewrite history, instead adding one commit to it instead of rewriting those that came before.
Both options are valid and can work in tandem. What is usually (by that I mean, if you are using widespread tools and methodology such as git-flow) done for a feature branch is to merge it into the main branch, often going through a merge-request, and solve all the conflicts that arise into one (or multiple) merge commits.
Rebasing is an interesting option, that may help you fix your branch before eventually going through a merge, and ease the pain of having to do one big merge commit.
You are almost there :)
All that is left is to
git checkout featurex
git merge our-team
This will merge our-team into featurex.
The above assumes you have already committed/stashed your changes in featurex, if that is not the case you will need to do this first.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With