git fetch fetches information on remote branches, but does not make any changes to your local master branch. Because of this, master and origin/master are still diverged. You'd have to merge them by using git pull.

When you make a commit, your local master branch is ahead of origin/master until you push those changes. This case is the opposite, where the origin/master branch is ahead of your local master branch. This is why you are getting different outcomes.

Read https://stackoverflow.com/a/7104747/2961170 for more information.

All parameters to 'git merge' in this case are branches that you're merging from, i.e. source branches. You're always merging to the current branch.

Because origin is a remote name, git automatically expands it to that remote's default branch, so it's actually equivalent to origin/master – the command is being told to merge the same branch twice.

(It is possible to merge more than one branch, known as "octopus merge", but this is rarely done – and when it is done, the branches of course are different.)

As it is, the command doesn't make much sense. Maybe it should have been either git merge origin/master (without the duplication) or git pull origin master.

git merge origin/master can do one of two things (or error).

In the first case, it creates a new commit that has two parents: the current HEAD, and the commit pointed to by the ref origin/master (unless you're doing something funny, this is likely to be (the local pointer to) the branch named master on a remote named origin, though this is completely conventional).

In the second case, where there is no tree-level merge necessary, rather than creating a new commit, it updates the currently checked-out ref to point to the same commit as is pointed to by origin/master. (This is called a fast-forward merge -- git can be directed to either always or never do this when you merge through command-line flags).

It does not call git commit directly, which is a higher-level (porcelain in the git-parlance) command intended for users.

Calling git merge master/original will try and resolve master/original to a commit, which will almost certainly (again, unless you've done something deliberate) not be the same as origin/master. If you happen to have a remote named master that has a branch named original, it will create a new commit which has that as the second parent.

You may find git help rev-parse to be helpful in deciphering how git attempts to resolve ref names or other notations into commits.

It is not the same at all. git merge origin/master will merge your remote-tracking branch master to your current head. git merge origin master will attempt to create an octopus merge with branches origin and master to the current head. It will probably fail, because most likely you do not have a branch named origin (which would be very confusing, since it is the default name for a remote repository).

Use git merge origin/master.

newbranch should be current branch, to make sure you can checkout it, then you get updated from you repo using fetch and then merge newbranch with master

About checkout: branch, with which you're currently working is already checkout. To switch to another branch you need checkout it. If already you're working with branch you don't need checkout.

git checkout newbranch
git fetch
git merge origin/master

instead merge you can use rebase, in this case last line should be replaced

git rebase origin/master

Merge and rebase just update you branch with information from other branch. Merge get commits from master and add them to your branch. Rebase did the same by a little different way. See Merging vs. Rebasing. For now just forget about rebase, just do merge.

git fetch && git merge origin/master 

is different from

git fetch && git merge origin master # Invalid

because git fetch updates .git/refs/remote/<remote server name>/<remote branch name>. And unless specified, you're always referring to your HEAD of the working directory, which is in .git/refs/heads/<branch name>

Note: git merge is a local operation. git merge origin master is an invalid operation. As discussed here SO question

Git fetch
git fetch fetches information on remote branches, but does not make any changes to your local master branch. Because of this, master and origin/master are still diverged. You'd have to merge them by using git pull
When you make a commit, your local master branch is ahead of origin/master until you push those changes. This case is the opposite, where the origin/master branch is ahead of your local master branch. This is why you are getting different outcomes

Source

Basically, you need to pull from origin onto your local repository, in order to update the files you already have.

Usually a git pull origin master should do the trick.

If it does not, you must do git remote add origin [email protected]:mobile-site.git and then follow this with git pull origin master.

git pull is essentially the equivalent of git fetch followed by git merge. Here are some links that might help you:

• Git Pull
• Git Fetch
• Git Merge