JIYIK CN >

Git is a tool used by developers on a daily basis, especially when working in a team; it plays a vital role in the software industry. This version control tool provides a plethora of commands to its developers through which they perform different types of tasks depending on the work assigned to them.

This article will teach us how to get the latest version of the code through various Git commands. In two different ways, we can update our latest version code from the repository in the local repository.

Get the latest version of the code when you don't care about local changes

If local changes are no problem for us, then we can update our code in three different ways:

Step 1

First, we will get the latest code using the Git command git fetch:

git fetch origin

This command will show you the updated branch. git fetchThe command enables us to access the complete branch structure of another repository.

Fetching is considered the safest way to review commits before combining them with our local repository.

After that we will git resetreset the code by command , continuing with the flag --hard origin:

git reset --hard origin/[tag/branch/commit-id usually: master]

This command is used to kick out all staged and unstaged changes. It also ignores everything on the current local branch and makes it origin/masterthe same as on the remote repository.

Step 2

In this process, we will delete the entire folder through the following command:

rm -rf [project_folder]

This command will recursively remove an entire folder from your Git repository for future reuse.

git cloneAfter that, we will clone the repository using the command mentioned below through command :

git clone [remote_repo]

When we run git clone, every version of every file in the project's history is cloned, even though everything is copied to the remote repository.

Step 3

The methods we're mentioning now are more destructive, so it's best to stick with steps 2 or 1, as described above.

git reset --hard HEAD

The above command will throw out all the uncommitted changes we have made and are still in the staging area of ​​our local changes. Now we will clean up our working tree with the following command:

git clean -xffd

The above command will clean up the working tree to the default state.

git pull

This command will fetch updates from a remote repository. It is a hybrid of git fetchand .git merge

It fetches updates from the remote repository, applies the latest changes locally as quickly as possible, and updates the local branch.

Get the latest version of the code when you care about local changes

Step 1

By executing the following command we will not face conflicts with the new online version because sometimes conflicts are very dangerous and take time to resolve.

git fetch origin
git status

The output of the above command will look something like this:

Your current branch is much behind 'origin/master' by only 1 commit and can be fast-forwarded.

Once we get the above output, we execute git pullthe command. Also, we will get the latest version of the repository.

git pull

Step 2

By executing these commands we will face a conflict with the new online version:

git fetch origin
git status

These commands will report something like:

error: Local changes to the files given must be overwritten with the help of merge:
    file_name
Changes should be committed or stashed before merging.
Aborting

Now, we will commit our local changes through the command mentioned below as follows:

git add .
git commit -m 'Commit msg'

After that, we will try to get the changes that don't work.

git pull

This git pullwill report something like:

Here pull can not be applied because you have unmerged files.
use 'git commit -a'.

Once this error occurs, we will open the conflicting file and attempt to fix the conflicts that have occurred by executing the following command:

git add .
git commit -m 'Fix conflicts'
git pull

The output of these commands is as follows:

Already up-to-date.