Git merge - learn by example
Tags: git, programming, beginners, webdev
Published: 2022-12-19 07:02:42

Git merge is a powerful tool that allows developers to integrate changes from different branches into a single branch. In this article, I'll explain different ways to merge branches with Git, using a simple example to illustrate each method.

> *Before we move on, I suggest taking a look at* [https://github.com/dotenx/dotenx](https://github.com/dotenx/dotenx)*, an open-source tool to visually build websites, APIs and much more and publish them in no time.*

* * *

To get started, let's create a new Git repository and add a file to it:

```bash
$ git init
$ echo "Hello, world!" > greeting.txt
$ git add greeting.txt
$ git commit -m "Add greeting"
```

Next, let's create a new branch and make some changes to the file:

```bash
$ git branch new-feature
$ git checkout new-feature
$ echo "Bonjour, le monde!" >> greeting.txt
$ git commit -am "Add French greeting"
```

Now we have two branches in our repository: the `master` branch, which contains the original "Hello, world!" greeting, and the `new-feature` branch, which contains the additional "Bonjour, le monde!" greeting.

There are several ways to merge these changes back into the `master` branch. One way is to use the `git merge` command with the `--no-ff` option, which creates a new merge commit even if a fast-forward merge is possible. This is useful when you want to preserve the entire branch history, rather than just fast-forwarding the `master` branch to the latest commit in the `new-feature` branch.

```bash
$ git checkout master
$ git merge --no-ff new-feature
```

The output of this command will look something like this:

```bash
Merge made by the 'recursive' strategy.
 greeting.txt | 1 +
 1 file changed, 1 insertion(+)
```

If we run `git log`, we can see that a new merge commit has been created, which brings together the changes from both branches:

```bash
$ git log --oneline

e7f1234 (HEAD -> master, new-feature) Merge branch 'new-feature'
b5c9123 Add French greeting
3e2a111 Add greeting
```

Another way to merge the `new-feature` branch is to use the `git merge` command with the `--squash` option. This option combines all the commits in the `new-feature` branch into a single commit, which is then merged into the `master` branch. This is useful when you want to clean up the commit history, or when you want to merge a feature branch into a release branch and preserve a linear history.

```bash
$ git checkout master
$ git merge --squash new-feature
$ git commit -m "Merge new-feature"
```

The output of this command will look similar to the previous example, but if we run `git log`, we can see that there is only one commit for the merged changes:

```bash
$ git log --oneline

e7f1234 (HEAD -> master) Merge new-feature
3e2a111 Add greeting
```

One tricky situation that can arise when merging branches is a conflict. This occurs when the same lines of code have been modified in both branches, and Git is unable to automatically resolve the differences. In this case, Git will mark the conflicting lines in the file and ask you to resolve the conflict manually.

To demonstrate this, let's create another branch and make some changes to the same lines of code that we modified in the `new-feature` branch:

```bash
$ git branch conflict
$ git checkout conflict
$ sed -i 's/Hello, world!/Hola, mundo!/' greeting.txt
$ git commit -am "Add Spanish greeting"
```

Now let's try to merge the `conflict` branch into `master`:

```bash
$ git checkout master
$ git merge conflict
```

Git will display a message indicating that there is a conflict, and the `greeting.txt` file will contain markers showing the conflicting lines:

```bash
Copy codeAuto-merging greeting.txt
CONFLICT (content): Merge conflict in greeting.txt
Automatic merge failed; fix conflicts and then commit the result.
```

```bash
Copy code<<<<<<< HEAD
Bonjour, le monde!
=======
Hola, mundo!
>>>>>>> conflict
```

To resolve the conflict, we need to edit the file and remove the markers. For example, we could keep both greetings by adding a line break between them:

```bash
Bonjour, le monde!

Hola, mundo!
```

Then we can commit the resolved conflict:

```bash
$ git add greeting.txt
$ git commit -m "Resolve conflict"
```

### Bonus

One trick for avoiding conflicts when merging branches is to ensure that each branch focuses on a separate aspect of the codebase. For example, if one branch is working on the front-end interface and another branch is working on the back-end logic, there is less likelihood of conflicts occurring.

Another tricky situation can arise when merging a branch that contains a large number of commits. In this case, it may be difficult to review and understand the changes that are being merged. One way to simplify the process is to use the `git merge` command with the `--squash` option, as we saw earlier. This will combine all the commits into a single commit, which can be easier to review and understand.

* * *

Finally, I encourage you to join the open-source movement to make a long-lasting impact and contribute to the development of software that benefits society as a whole. Participating in open-source projects can also help boost your career progress by demonstrating your skills and expertise to potential employers and allowing you to collaborate with other experienced developers.

[https://blog.dotenx.com/how-to-contribute-to-open-source-with-any-skill-level](https://blog.dotenx.com/how-to-contribute-to-open-source-with-any-skill-level)