Chapter 1: Introduction to Git Commands

This guide serves as a practical reference for essential Git commands that beginners can utilize effectively.

Git repositories consist of various branches. To see all branches, use the command:

git branch

This command also highlights the current branch you are on. To switch between branches, you can employ:

git checkout <branch_name>

To view the status of your repository and gain insights into how to proceed with your operations, use:

git status

This command is particularly useful if you're unsure about the current state of your repository or the next steps you need to take.

For detailed command information, you can access the manual page with:

man git-<command>

For example, to view the manual for the status command, type:

man git-status

To list all commits, utilize:

git log

Each commit contains a unique hash, author information, subject line, commit message, and additional details. To view the content of the commits, use:

git log -p

If you prefer a concise overview, you can view just the hash and subject of each commit with:

git log --oneline

To check the logs for a specific range of commits, you can run:

git log <first_commit_hash>~..<last_commit_hash>

For examining a single commit's log, use:

git show <hash_commit>

If no commit hash is specified, git show will display the commit at the branch's head.

You can create tags for commits using the git tag command. To print all commits up to a specific tag, use:

git log <tag> [<file_pattern>]

For instance:

git log v5.4 block/bfq*

This command will log commits up to tag v5.4 for files in the block directory that start with bfq. To check logs from different branches, you can use:

git log <branch_name>

To determine the kernel versions associated with a specific commit, you can use:

git log --oneline | egrep "commit message"

After finding the commit hash, you can list all tags associated with it using:

git tag -l --contains <hash>

To clean up untracked files, the command is:

git clean -fd

Be cautious when using this, especially if there are extra files in your working directory. This command cleans from the current folder, so to clean the entire repository, ensure you start at the root.

To see the differences between your working tree and the current commit, use:

git diff

To reset your working directory to a specific commit, the command is:

git reset --hard <commit_hash>

For resetting to the most recent commit, you can use:

git reset --hard HEAD

To revert back to a previous commit, you can also specify the number of commits to go back:

git reset --hard HEAD~n

For checking remote repositories, use:

git remote

To view all details on remote repositories, type:

git remote -v

To add a remote repository, the syntax is:

git remote add <name> <repo_URL>

To synchronize with a remote branch, use:

git pull

In cases where the history has changed, you may need:

git fetch

git reset --hard <remote_name>/<branch>

To check out a remote branch, the command is:

git checkout <branch_name_in_remote_repo>

If multiple repositories contain branches with the same name, specify with:

git checkout --track <repo_name>/<branch_name>

To apply patches, the command is:

git am <patch1> <patch2> ...

In case of conflicts during the application of patches, you can abort the process with:

git am --abort

To resolve conflicts, edit the conflicting files manually, deciding which version to keep. After resolving, use:

git add <filename>

Then continue with:

git am --continue

To create a copy of your current branch, use:

git checkout -b <new_branch_name>

Before making commits, configure your user details:

git config --global user.email "[email protected]"

git config --global user.name "Your Name"

A common mistake is using "mail" instead of "email" which can lead to issues.

To create a commit with all changes, use:

git commit -a

For self-signed commits, use:

git commit -as -m "commit title"

To choose your default editor for commit messages:

git config --global core.editor /usr/bin/vim

To check for changes ready to commit, use:

git diff --cached

To put a file back to an unstaged state, use:

git reset <file_path>

For committing only certain changes, you can add parts of files with:

git add -p

To amend the last commit, the command is:

git commit --amend

To create patches from the last commit or a range of commits, use:

git format-patch HEAD~n

To delete a branch, use:

git branch -D <branch_name>

To push local commits to a remote branch, use:

git push <remote_repo_name> <top_sha_commit>:<remote_branch>

If you need to propose your commits without write access, consider creating a Pull Request.

To reset the history of a branch, you can create a new branch from a specific commit and push it to a remote repository:

git checkout -b new_branch <commit_hash>

git push --force --set-upstream <remote_repo> new_branch

For managing pending changes, you can use:

git stash

git stash list

git stash pop

To revert a commit, use:

git revert <commit_to_keep>

Remember that switching branches updates timestamps for all files, which may lead to unnecessary recompilation.

To avoid this, consider using make --dry-run before actual compilation to minimize unnecessary changes.

When merging branches, you might want to create a backup, then merge with:

git merge <branch_to_merge>

If conflicts arise, resolve them and finalize the merge with:

git commit

Merging retains conflict resolutions, but can create complex histories.

Alternatives to merging include git cherry-pick or git rebase, each with their own implications for commit histories.

To create a new repository from a folder, navigate to the folder and initialize:

cd <tree_root_folder>

git init

git add .

git commit -m "Initial commit"

For working between distinct branches, use:

git checkout <working_branch>

git log -p <other_branch>

git show <other_branch>:<file_path>

git diff <other_branch>

I hope this compilation serves as a valuable resource for your Git journey.

The Git Cheat Sheet - A Helpful Illustrated Guide - This video serves as a visual reference for essential Git commands, making it easier for beginners to understand and apply them effectively.

Git Crash Course - Part 2: Git Cheat Sheet: Quick Reference Guide for Beginners - This video provides a quick overview of Git commands, helping beginners grasp the basics of version control.