Once a project is initialized in Git, the files in the working directory can exist in one of two states: tracked or untracked. Tracked files are those that Git is aware of and can be further categorized as modified, unmodified, or staged for committing. These files are actively being version-controlled by Git, and any changes made to them can be tracked and managed effectively.

In contrast, untracked files are those that Git is not yet aware of or hasn't been instructed to track. These files reside in the project directory but have not been added to the version control system, which means Git won't monitor their changes unless they are explicitly added.

In this section, we will explore a set of valuable commands that enable us to interact with the tracked files in different stages. From examining modifications and staging changes to crafting well-structured commits, these commands will empower us to maintain a well-organized version control workflow.

By understanding and effectively using these commands, you'll be able to harness the full potential of Git's tracking capabilities, ensuring a seamless collaboration process, and a more efficient development experience. So, let's dive in and discover how to make the most of Git's tracked and staged file management!💪

Changes in the working directory:

$ git status

git status is a command that shows the current status of your Git repository. It informs you of any modified, untracked, or staged files, allowing you to keep track of changes and decide which files to include in the next commit. Regularly using git status helps maintain a well-organized version control workflow.

Changes to tracked files:

$ git diff

git diff is a command that shows the differences between the current working directory and the last committed version of the files in your Git repository. It highlights the changes line-by-line, helping you understand what modifications have been made but not yet staged for commit. This command is useful for reviewing and understanding the extent of changes before deciding which files to stage for the next commit.

See changes/differences of a specific file:

$ git diff <file>

This command accomplishes the same as $ git diff but shows the differences between the specified <file>

Add all current changes to the next commit:

$ git add .

The command git add . is used to stage all the changes made to tracked files in the current directory and its subdirectories. By executing this command, you tell Git to include all the modifications in the staging area, preparing them to be included in the next commit. It's a convenient way to add all changes at once before creating a commit to record the changes in the repository's history.

Add some changes in <file> to the next commit:

$ git add -p <file>

The command git add -p <file> allows you to interactively stage changes within the specified <file>.

Commit all local changes in tracked files:

$ git commit -a

The command git commit -a allows you to create a new commit that includes all changes to tracked files in the working directory, without explicitly staging them using git add. It automatically stages all modifications and removes any deletions in tracked files, effectively adding them to the staging area and then committing them in one step. However, this command does not include untracked files in the commit.

Commit previously staged changes:

$ git commit

git commit opens the default text editor for you to enter a commit message. After saving, Git creates a new commit with staged changes, recording them in the repository's history. Meaningful commit messages are crucial for tracking project development.

Commit with the message:

$ git commit -m 'message here'

The command git commit -m 'message here' allows you to create a new commit with a brief commit message provided directly in the command. It skips opening a text editor and commits the changes that are currently staged in the staging area, adding the message you specified. This is a convenient way to quickly commit changes with a concise description of the modifications.

Commit to skipping the staging area and adding a message:

$ git commit -am 'message here'

The command git commit -am 'message here' allows you to create a new commit with a commit message provided directly in the command and automatically stages all modified tracked files (excluding new untracked files). This option combines the git add . and git commit -m 'message' commands into one, making it a time-saving shortcut for committing changes. Remember to use this with caution, as it won't include newly added untracked files in the commit.

Commit to some previous date:

$ git commit --date="`date --date='n day ago'`" -am "<Commit Message Here>"

The command git commit --date="date --date='n day ago'" -am "<Commit Message Here>" allows you to create a new commit with a specific date set for the commit timestamp and a commit message provided directly in the command. The --date flag with the date command sets the commit date to "n" days ago, providing a way to backdate the commit if necessary. This option also automatically stages all modified tracked files (excluding new untracked files) and combines the git add . and git commit -m 'message' commands into one. As with the previous command, remember that it won't include newly added untracked files in the commit.

Change last commit:

$ git commit -a --amend

The command git commit -a --amend is used to amend the last commit in your Git history. It allows you to make additional changes to the staged files and include them in the previous commit, essentially modifying the commit with the new changes. This can be helpful for correcting mistakes or adding missed changes to the most recent commit. Remember that amending a commit rewrites history and should be used with caution, especially if the commit has already been pushed to a shared repository.

Amend with the last commit but use the previous commit log message

$ git commit --amend --no-edit

Change the committer date of the last commit:

GIT_COMMITTER_DATE="date" git commit --amend

Change Author date of the last commit:

$ git commit --amend --date="date"

Move uncommitted changes from the current branch to some other branch:

$ git stash
$ git checkout branch2
$ git stash pop

The commands git stash, git checkout branch2, and git stash pop are often used together to switch to a different branch temporarily while saving your current changes.

Using these commands together enables you to switch branches without committing incomplete work, giving you the flexibility to come back and continue working on your changes later. Remember to use git stash pop with care, as it applies the stashed changes and may cause conflicts or unexpected outcomes if not handled properly.

Restore stashed changes back to the current branch:

$ git stash apply

Resources📚🔖

• Git - Recording Changes to the Repository 🚀

• Basic Git commands 🚀

• What does 'stage' mean in git? 🚀

• Staging the changes 🚀

Happy exploring! :)