JIYIK CN >

Most of the time, when we apply merge git pushor git mergemerge_s, we end up with some conflicts. In some cases, the resolution of a merge conflict is as simple as discarding local changes or changes from a remote or other branch.

When Git can't figure out how to merge two conflicting changes, it creates a conflict request. A conflict request is a special patch that describes the problem, contains both sides of the conflicting changes (ours and theirs), and the results of the merge attempt.

When two team members work on the same file and a conflict occurs in that file, Git applies the conflict to our working file. We can then edit the resulting file and Git will record our changes. If conflicting changes do occur, Git will mark the file as being in a conflicted state. There are several commands that can resolve conflicts in that particular branch.

Conflicts are most common when two or more people are working on the same file in the same repository. However, when conflicts are found in a file, Git is very smart and clever to resolve the conflict in a very awesome way. Git uses conflict markers to show which parts of a file are in conflict. Conflict markers are small hashes placed on both sides of the conflicting parts of the file.

Pull is not used alone. It is used with the help of fetching data from the remote server and then applying merge with the changes in the local repository. We can perform both the operations mentioned below if we want.

git fetch
git merge origin/$CURRENT_BRANCH

The meanings of mentioned above origin/$CURRENT_BRANCHare as follows.

• Git will apply the merge options and apply the changes from the remote repository, ie origin.
• This was added to$CURRENT_BRANCH
• It does not currently exist in our locally checked out branch

git pullNot only is it recommended, it's just running git fetchfollowed by git mergeWe're going to have three merges, and through those merges, Git will do three fetches, one of which is what we need.

git fetch origin   # it will update all our origin/* remote-tracking branches
git checkout new branch        
git merge origin/new branch     
git checkout master
git merge origin/master
git merge -X theirs new branch  
git push origin master   

The command mentioned above will effectively ignore any divergent changes on the branch we are merging into and develop a new commit on the branch we are merging into with all the commits merged on that branch.

We can also use in a normal merge --oursto merge all the changes in the branch we're merging into, and then skip any files that exist in the branch we're merging into, effectively doing a three-way merge between the two branches, and then only using the files from the branch we're merging into.

We found it much easier git merge --oursto merge the files using and then git rebase -imanually reapply the changes from the branch I wanted to merge using .

The above command did not work for files with conflicts, but we found the following command to resolve the conflicts.

git checkout file_with_conflict
git merge --ours --no-commit file_from_branch_with_conflict
git reset --hard git add file_with_conflict git commit -m