How to preserve local changes during Git Pull

During the development process, we often need to pull code updates from the remote warehouse. The Git Pull command is a command used to pull code updates from a remote repository and automatically merge them into the local repository. However, sometimes we modify the code locally, and performing a Git Pull operation will overwrite the local modifications, causing the risk of code loss. Therefore, this article will introduce how to retain local modifications during Git Pull to avoid code loss.

1. Use Git Stash to save local modifications

Git Stash is a very useful command that can store all uncommitted modifications in the current working directory in a stack , and restore the working directory to the state before the Git Pull command was executed. After we execute the Git Pull command, we can use the Git Stash Pop command to apply the previously saved modifications to the current working directory, thus retaining the local modifications.

The following is an example that demonstrates how to use Git Stash to save local changes:

$ git stash save "save my local changes"
$ git pull
$ git stash pop

2. Use Git Commit to save local modifications

Git Commit is the command to record the modifications in the Git warehouse into the history. If we have made changes to the code, we can commit the changes through Git Commit to retain the local changes when executing the Git Pull command. This method requires modifications to be pushed to the remote repository, so the change request needs to be merged into the main branch before executing Git Pull.

The following is an example that demonstrates how to use Git Commit to save local changes:

$ git add .
$ git commit -m "save my local changes"
$ git pull

3. Use Git Patch to save local modifications

Git Patch is a command that can package local modifications into a patch file and apply it to other Git repositories. If we modify a file locally but do not want to perform Git Commit or Git Stash, we can use Git Patch to save the local modifications and apply the patch file when executing the Git Pull command. The advantage of this method is that it can only submit the modified part and avoid unnecessary submission.

The following is an example that demonstrates how to use Git Patch to save local changes:

$ git diff > my.patch
$ git pull
$ git apply my.patch

Summary:

The above are three ways to retain local modifications: using Git Stash, using Git Commit and using Git Patch. No matter which method is used, local modifications can be preserved and the risk of code loss can be avoided. In actual development, it is recommended to choose an appropriate method based on the actual situation.

The above is the detailed content of How to preserve local changes during Git Pull. For more information, please follow other related articles on the PHP Chinese website!