Скачать или смотреть Understanding How git checkout Handles Untracked Files

Discover why `git checkout` transfers files between branches and how untracked files behave in Git. Learn how to manage your changes effectively.
---
This video is based on the question https://stackoverflow.com/q/64750753/ asked by the user 'Dato Nefaridze' ( https://stackoverflow.com/u/14575208/ ) and on the answer https://stackoverflow.com/a/64750902/ provided by the user 'Cyrille Pontvieux' ( https://stackoverflow.com/u/1988874/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Git checkout transfers files to another branch

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding How git checkout Handles Untracked Files

Are you confused about what happens to your files when you switch branches in Git, particularly when it seems like your changes from one branch appear on another? You’re not alone! Many Git users face challenges when it comes to understanding how the git checkout command interacts with untracked files. In this post, we’ll break down a common scenario to shed light on this behavior and help you understand what’s going on.

The Problem: Mysterious File Transfers

Let’s set the scene with a practical example. Imagine you’re diligently working on your master branch and create a file called dato.py. After making some changes to it, you decide to stash your work — but then you switch over to a new branch called feature_branch using the command:

[[See Video to Reveal this Text or Code Snippet]]

Upon checking the status with:

[[See Video to Reveal this Text or Code Snippet]]

You notice that dato.py has followed you to your new branch! This raises a couple of questions:

Why did that file appear on feature_branch?

Is this behavior normal for Git?

What exactly happened to your files during this process?

The Solution: Understanding Git’s Branch Mechanics

Let's dive into the underlying mechanics of Git to clarify the situation.

1. git checkout and Branch Changes

When you issue the command git checkout feature_branch, Git is working to change your current branch to feature_branch. Here’s a critical point:

Branch Syncing: git checkout syncs your working directory with the state of files in the target branch. If dato.py exists on feature_branch, it will show up in your working directory.

What Does this Mean?

If someone had already created and committed dato.py on feature_branch, Git will pull in that file when you switch branches. However, if the file was never added or committed on the master branch, it should ideally remain untracked and not move to feature_branch.

2. The Role of Stashing

Let’s talk about what happens when you stash your changes. If you run the git stash command, it saves the changes in your tracked files, but it’s essential to note that:

Untracked Files Are Different: If your file was never added or committed in the first place, it is considered untracked.

In your case, it seems that while you believed you had stashed dato.py, it remained untracked, meaning it was not affected by the stash command. This behavior is typical for files that Git has not started tracking.

3. Untracked Files Explained

Untracked files are those that Git has observed in your working directory but has not been instructed to include in version control. Here’s what to remember:

Stash Doesn’t Affect Untracked Files: Stashing only works on files that Git is tracking. As a result, if the file hasn’t been added or committed, it will remain even when you switch branches.

Example Scenario

To solidify this understanding, let’s illustrate a simple Git workflow:

[[See Video to Reveal this Text or Code Snippet]]

In the above example:

After stashing, only the tracked file titi was saved into the stash, while tata remained untracked.

Conclusion: Managing Your Changes Effectively

In summary, the behavior you experienced with git checkout and untracked files is completely normal within the Git framework. Understanding how git commands interact with tracked and untracked files can help you manage your workflow more effectively.

Next time you switch branches or use stash, keep in mind:

Tracked files will react to stashing and branch switching.

Untracked files stay in your working directory unless added and committed.

By getting a good grasp of these concepts, you’ll reduce confusion and improve your Git usage. Happy coding!