You could also just create a pull request.

If there are no merge conflicts its easier.

If there are merge conflicts:

git fetch origin
git checkout {branch}
git merge master

Afterwards you have the merge conflict on your branch and you can resolve it.

git add .
git commit -m "{commit message}"
git push

And you have resolved the merge conflict and can merge the pull request onto the master.

Hint: With squash and merge the whole branch is committed as one commit onto master.

This is a very practical question, but all the answers above are not practical.

Like

git checkout master
git pull origin master
git merge test
git push origin master

This approach has two issues:

1. It's unsafe, because we don't know if there are any conflicts between test branch and master branch.

2. It would "squeeze" all test commits into one merge commit on master; that is to say on master branch, we can't see the all change logs of test branch.

So, when we suspect there would some conflicts, we can have following git operations:

git checkout test
git pull 
git checkout master
git pull
git merge --no-ff --no-commit test

Test merge before commit, avoid a fast-forward commit by --no-ff,

If conflict is encountered, we can run git status to check details about the conflicts and try to solve

git status

Once we solve the conflicts, or if there is no conflict, we commit and push them

git commit -m 'merge test branch'
git push

But this way will lose the changes history logged in test branch, and it would make master branch to be hard for other developers to understand the history of the project.

So the best method is we have to use rebase instead of merge (suppose, when in this time, we have solved the branch conflicts).

Following is one simple sample, for advanced operations, please refer to http://git-scm.com/book/en/v2/Git-Branching-Rebasing

git checkout master
git pull
git checkout test
git pull
git rebase -i master
git checkout master
git merge test

Yep, when you have uppers done, all the Test branch's commits will be moved onto the head of Master branch. The major benefit of rebasing is that you get a linear and much cleaner project history.

The only thing you need to avoid is: never use rebase on public branch, like master branch.

Never do operations like the following:

git checkout master
git rebase -i test

Details for https://www.atlassian.com/git/tutorials/merging-vs-rebasing/the-golden-rule-of-rebasing

appendix:

• if you are not sure about rebasing operations, please refer to: https://git-scm.com/book/en/v2/Git-Branching-Rebasing

Create a pull request.

In this order using Terminal or Command Prompt,

git checkout main switch to main branch

git pull origin main grab latest updates from main branch

git merge master merge master branch to your main branch

git push origin main push your changes to main

For easier route, you can download Github Desktop app, add your repo into the app and do all the fetch, commit, push and even PULL REQUEST to merge the branch to the main brach.

FYI, naming your other branch master is not recommended and it will making it difficult to distinguish your main (your main branch) and master (other branch). Github has changed its naming from master to main instead to avoid unpleasant term.

I had the same issue, I used git pull origin master --allow-unrelated-histories from main branch and then commit + push which solved the problem in my case. Found the solution in this article

Personally, my approach is similar to yours, with a few more branches and some squashing of commits when they go back to master.

One of my co-workers doesn't like having to switch branches so much and stays on the development branch with something similar to the following all executed from the development branch.

git fetch origin master    
git merge master    
git push origin development:master

The first line makes sure he has any upstream commits that have been made to master since the last time updated his local repository.

The second pulls those changes (if any) from master into development

The third pushes the development branch (now fully merged with master) up to origin/master.

I may have his basic workflow a little wrong, but that is the main gist of it.

To merge branch with master,there are two ways you can proceed

• By Git commands
• By Github Dashboard

Git Commands

Here also you can go with two different commands,first is

• checkout to your master branch using git checkout master
• pull your latest code from the branch you want to merge,use git pull --rebase origin branch_name. It may give you some conflicts which you can resolve by using git status,after resolving you can check if any conflict is more there or not by using git rebase --continue.

Second way

• To master you can cherrypick the commits from the branch you want to merge git cherry-pick <commit id>.If you are getting conflict use git cherry-pick --continue.

Actually this is the more suggested way you can proceed.

Merge branch using GitHub Dashboard

This is most easiest way to merge. Create new pull request, select the branch you want to merge and resolve the conflicts.