
When developers, regardless of their experience level, are in the process of merging a branch with the source branch using git, they often encounter a situation known as a <span class="highlight-small">git merge conflict.</span> This occurs when the changes made in the source branch conflict with those in the target branch.

Despite being acquainted with git, many developers struggle to resolve these conflicts due to a lack of understanding of how to pull the conflict details into their local machines.

### Understand why the merge conflict has happened ?

Conflicts generally arise when two people have changed the same lines in a file, or if one developer deleted a file while another developer was modifying it. In these cases, Git cannot automatically determine what is correct.

![conflicts - devphobia.com](/assets/blog/helpers/conflict.png)

The following steps are helping to pull the merge conflicts to the VSCode/other IDE

_Consider you have a branch name feature/sampleTextChange and the source is main_

#### Step 1: Clone the repository or update your local repository with the latest changes.

```git
git pull origin main
```

#### Step 2: Switch to the head branch of the pull request.

```git
git checkout feature/sampleTextChange
```

#### Step 3: Merge the base branch into the head branch.

```git
git merge main
```

#### Step 4: Fix the conflicts and commit the result.

See Resolving a merge conflict using the command line for step-by-step instructions on resolving merge conflicts.

#### Step 5: Push the changes.

```git
git push -u origin feature/sampleTextChange
```


Despite being acquainted with git, many developers struggle to resolve these conflicts due to a lack of understanding of how to pull the conflict details into their local machines.

A Guide to Resolving Git Conflicts in Your Local Setup


GIT is an unavoidable thing for everyone who is working in IT. To keep the code safe and distributed between multiple resources that been achieved with the help of GIT.

<div class="highlight">

## What is GIT?

<a rel="nofollow" target="_blank" href="https://git-scm.com/">Git</a> is a distributed version control system that tracks changes in any set of computer files, usually used for coordinating work among programmers collaboratively developing source code during software development. Its goals include speed, data integrity, and support for distributed, non-linear workflows.

</div>

I know many of them are very professional at using the GIT commands and many of them are not. I thought to share a list of GIT commands for those who have just started to use the GIT and who are feeling very difficult to remember all those commands when it is required.

<div class="list-disc">

- ### `git init`

  Create a new local repo.

- ### `git clone`

  Cloning an existing repository and to create local working directory.

- ### `git diff`

  Git diff command will show the changes which are not yet staged.

- ### `git status`

  To view the list of modified and untracked files using this command.

- ### `git add.`

  Add the modified and untracked files into stage for commit.

- ### `git add<file-name>`

  Stage a particular file for committing.

- ### `git commit -m "<message>"`

  Committing the previously staged files with message.

- ### `git commit -a`

  Commit all local changes to tracked files, not the new files.

- ### `git commit --amend`

  convenient way to modify the most recent commit. It lets you combine staged changes with the previous commit instead of creating an entirely new commit. It can also be used to simply edit the previous commit message without changing its snapshot.

- ### `git log`

  Get all the change history of a branch.

- ### `git checkout <branch>`

  Switch to a branch update the working directory.

- ### `git branch <new-branch>`

  It is used to create new branch.

- ### `git branch -d <branch>`

  Delete a branch from local.

- ### `git fetch <remote>`

  This will fetch all the branches from remote repository. This Command brought other branches of the repository that were all created by other developers.

- ### `git pull <remote> <branch>`

  Fetch remote version of a branch that contains the latest changes.

- ### `git push <remote> <branch>`

  This will be sending the locally committed changes to the repository, after this any of your developers can have a look at your changes.

- ### `git merge <branch>`

  Merge the specified branch into the current branch.

- ### `git rebase <branch>`

  Rebase your current head onto the specified branch.

- ### `git revert <commit>`

  Create a new commit to revert to the specified commit.

- ### `git rev-list --count HEAD ^<branch-name>`

  Get number of commits have done against to the branch.

- ### `git reset`

  git reset is a powerful command that is used to undo local changes to the state of a Git repo.

  Check the one example of <a target="_blank" href="/posts/how-to-squash-the-number-of-commits-from-a-branch">squashing the commit using git reset</a>

</div>

If you feel this is really useful, please save this URL to your notepad or bookmark for future use. Also share across to your colleagues.


To keep the code is safe and distrubuted between multiple resources that been achieved with the help of GIT

Some useful GIT commands for beginners


Git commit is the safer side to protect our work from system crash so like everyone I am also doing git commits multiple times.
Then I have a question, here you doing lot of commit does it make any blocker ?

Answer is "No".

Then why are we required to squash ?

During development time we will do a lot of commits until the work is getting done. After completion of the work or review time you may experience the below.

<div class="list-number">

- You can see a lot of commits mixing the appearance of important and non-relevant commits. That may feel looks ugly.

- In some projects the commit message has validation to build the current branch.
For example, a commit message must include common syntax if didn't have then the build will be cancelled. In this situation we have to clear the previous history by doing the git squash.
</div>

Then git squash only the solution to resolve the situation, it has been done by executing the a command called `git reset`. Yes, this command will help us to squash git commits.

This operation is a bit tricky, so we should have more attention when doing this activity.

### **Can we squash the commits from a branch ?**

We have a situation to clear the unwanted commits details into the commit history, if we having lot of commits that look very ugly and will face lot of problems when doing other git operations such as <span class="highlight-small">git reset</span>.

<div class="highlight">
  
### What is git squash ?

Combine multiple commits into one commit.

</div>

There are other commands also available but I am using a different approach.

To do this operation follow the below git commands,

### **Get the number of commits to the git branch using the below command**

To achieve this operation, the most relevant detail is the number of commits you have made.So get the number of commit as given below.

```git
git rev-list --count HEAD ^<branch-name>

E.g:- git rev-list --count HEAD ^feature/update-heading-in-form
```

The above command will return the number of commits. Consider the number of commit is 7 (7 for DHONI :) ).

If you did not provide the `branch name`, then the command will return the number of commits to the repository.The upcoming steps are very important and we have to execute it carefully.

Okay ?,

Then, by using this number, we want to execute another git squash command.

Please checkout your branch and do the below git command

```git
git reset --soft HEAD~7
```

The above git command pulls all the commit history. Please fix it if any conflicts are there.
Finally, push the changes into force mode.

```git
git push --force
```

- ### **Git squash commit in short steps,**

<div class="highlight">
<span class="font-semibold">Step-1.</span> Get the number of commits 
        
git rev-list --count HEAD ^*< branch-name >*

<span class="font-semibold">Step-2.</span> If the commit count is 7 then,

git reset --soft HEAD~7

<span class="font-semibold">Step-3.</span> Fix the conflicts if any!

<span class="font-semibold">Step-4.</span> Push back to git in force mode

git push --force

</div>
I hope the explanation is helped you to conitnue your work.

<div class="learn-more-container">

**Learn more**

- <a href="/posts/javascript-interview-questions-and-answers">Javascript interview questions and answers</a>

- <a href="/posts/some-useful-techniques-for-array-operation-using-javascript">
  Some useful techniques for array operation using javascript</a>
  </div>


We can squash the number of commits from a git branch

More Stories related to 'git'

Also read the similar topics