Introduction to Git Merge

Heloisa Louzada B. Gomes — Fri, 20 Sep 2024 13:29:54 +0000

In this post, we will talk about an essential process in project development: the merge. Merge means "to combine," that is, the action of merging two lines of development in a project.

What is the "Head"?

Before explaining merge, it is important to understand the concept of the head. The head is a pointer that always points to the version of the code currently being worked on. When a merge is performed, the head moves to reflect the combined changes between the branches.

Merge Strategies

There are different merge strategies. Let's cover the main ones:

Fast-Forward: The simplest strategy. The system just moves the pointer forward without conflicts. This happens when, after creating a new branch, all commits and changes were made exclusively in it. Thus, when performing the merge, there are no divergences between the main branch (master) and the new branch.

Ort: This strategy is used when there are changes in both the main branch and the created branch, but in different files, without causing conflicts. Git detects that the files are in different stages but can merge the changes automatically without manual intervention.

Handling Conflicts
When a conflict occurs during the merge, the changes need to be handled manually. When using VSCode, for example, a new tab opens so you can intuitively choose how to resolve the conflicts and continue with the project.

Step by step
First, you need to be on the branch where you want to combine the changes. To do this, use the command:

git checkout [branch name]

Now, you can merge the auxiliary branch with the target branch. Use the command:

git merge [branch name]

Pratical Exemple: If you are on a branch called auxiliary_branch and you want to merge it with the master branch, execute:

git checkout master
git merge auxiliar_branch

Now the changes from auxiliary_branch are now integrated into master. Always check that you are on the correct branch before merging to avoid unwanted conflicts.

Introduction to "branch"

Heloisa Louzada B. Gomes — Thu, 19 Sep 2024 14:51:41 +0000

Today, we’re going to talk about an essential concept for using Git and GitHub: branches. For this post, we’ll assume you are already familiar with the concepts of remote repository, local repository, stage, and commit; that you have already installed Git on your machine and created an account on GitHub. If you're not familiar with these concepts, check out the introductory post about Git in the following link (https://dev.to/ledscolatina/initial-introduction-to-git-and-github-4apc).

What are Branches?

A branch is essentially an independent environment where your commits are organized. Simplified, you can think of branches as parallel timelines where changes are made without interfering with others. Imagine the "multiverse" concept from Spider-Man: each version of the hero has its own timeline, and their actions do not affect the others, but when merged, they can create conflicts. Similarly, branches are separate environments where you can work without affecting the main code.

How do Branches Work?

When a project is created, it typically starts with a branch called master (or main, in the case of a clone), which is where the main code is maintained. If you want to add new features without compromising the existing functional code, the best practice is to create a new branch. This way, you can make commits and tests without affecting the main branch until everything is ready to be integrated (or even discarded, if necessary).

Creating a Branch

Let's imagine that you are starting a project in your local repository and then plan to push it to a remote repository.

When you start the project with git init, Git automatically creates a main branch for you, called master (or main).

git init

From this point, you can add files and make commits as usual. They will be recorded on the master branch, as if they were steps in a continuous timeline.

When the project is ready to be pushed to the remote repository on GitHub, we will start the step of linking the local repository to the remote one. To do this, you need to have a GitHub account and use some specific commands:

Create a new repository on your GitHub account.

Select the "<> Code" button and copy the URL of your remote repository.

In the git terminal, use the command git remote add origin [remote repository URL] to link your local repository to the remote one.

git remote add origin https://github/user/repository_name.git

To push your files to the remote repository, use a variation of the git push command. Since the repository was not cloned and we need to connect it to the remote repository, you need to specify the name of the branch you want to push, as the newly created repository does not yet have any bran ches. The command is: git push origin [branch-name].

git push origin master

Navigating Between Branches

Next, let's start a new branch. This allows you to work on a separate branch where your changes won't affect what has already been done on the main branch.

To create a new branch, use the command git branch [branch-name].

git branch new_branch

If you want to create and immediately switch to the new branch, use git checkout -b [branch-name].

git checkout -b new_branch

In this way, the files and commits added to this new branch will not be visible on the master branch, and vice versa.

To switch between branches, simply use the command git checkout [branch-name]. This is useful when you need to quickly switch between different parts of the project.

Finalizing: Merge

Suppose your modifications were successful, and now you want to integrate the new features into the main branch. For this, a powerful concept called merge comes into play. Want to know how it works? Stay tuned for the next post!

Post about merge =D

DEV Community: Heloisa Louzada B. Gomes