Name	Name	Last commit message	Last commit date
Latest commit History 22 Commits
README.md	README.md
github.jpeg	github.jpeg

Git & Github

Git is a software used as a distributed version control system (VCS). It is utilized to track changes in software projects, manage different versions, and collaborate effectively. Git operates swiftly, flexibly, and reliably.

GitHub is a cloud-based platform built upon Git. It allows you to host, share, and collaborate on projects.

💡Before diving into Git usage, let's take a look at some essential terminal commands.

Here are some basic terminal commands:

ls: It lists the files and folders in the current directory.
ls -la: It lists the files and folders in the current directory in detail, showing permissions, owners, and other attributes of the files.
cd [directory]: It changes the directory to the specified one.
cd ..: It allows the user to move up one directory level from the current directory, effectively navigating to the parent directory.
mkdir [folder name]: It creates a new folder.
rmdir: It is used to delete the specified folder (directory). However, the folder must be empty. If there are files or subfolders inside the folder, the rmdir command will not work. If files or subfolders need to be deleted as well, the rm -rf command should be used.
touch [file name]: It creates a new file.
rm [file name]: It deletes the specified file.
cp [source] [destination]: It copies the source file to the destination location.
mv [source] [destination]: It moves the source file to the destination location.
cat [file name]: It prints the content of the file to the terminal.
grep [word] [file name]: It finds the lines containing the specified word.
chmod [permissions] [file name]: It changes the permissions of the file.
pwd: It shows the current working directory. You can use this command to find out in which directory you are located.
echo 'message' > [file name]: Writes a "message" containing text or a string of characters to the specified file.
nano [file name]: Used to open and edit a file.

These commands will suffice for basic terminal usage.

👉 Now that we have covered the basic terminal commands, we can move on to Git commands.

Command	Description
`git config`	It is used to configure or view Git configuration settings.
`git init`	It is used to initialize an existing directory as an empty Git repository.
`git clone`	It is used to create a local copy from a remote Git repository.
`git add`	It prepares the changes in the working directory to be tracked by Git.
`git commit`	It saves the changes staged in the working directory to a local Git repository.
`git diff`	It shows the differences between the working directory and the index, or between the index and the last commit.
`git reset`	It is used to undo changes made in Git or to edit the index.
`git revert`	Instead of reverting the changes of the previous commit, it allows creating a new commit to undo those changes.
`git restore`	It is used to revert the contents of the working directory or specific files to their previous commit state or to change them.
`git status`	It shows which files have been modified in the working directory, which ones are staged in the index, and which ones are awaiting commit.
`git rm`	It is used to remove a file or directory from the Git repository.
`git log`	It is used to view the commit history in a Git repository.
`git show`	It is used to display the changes and commit details of a specific commit detail.
`git tag`	It is used to add changes in the working directory to the index for Git to track.
`git branch`	It is used to list the existing branches in the current Git repository or to create a new branch.
`git checkout`	It is used to switch between branches in a Git repository, navigate to a specific commit, or create a new branch.
`git switch`	It is a command used in Git version 2.23 and later. This command is used to switch between branches in Git repositories.
`git merge`	It is used to merge changes from different branches.
`git remote`	It is used to manage remote Git repositories and interact with them.
`git push`	It is used to push local commits to a remote Git repository.
`git fetch`	It is used to fetch new information from a remote Git repository to the local repository, but it does not make any changes to the current working directory.
`git pull`	It is used to pull the latest information from a remote Git repository and apply these updates to your local working directory and current branch.
`git stash`	It is used to temporarily store changes you are working on but haven't committed yet, and to clean your working directory.

👀 Now let's look at the commands in more detail.

(追記) 01 Git Configuration (追記ここまで)

git help

This command typically opens the help documentation related to Git commands. Additionally, you can use git help -a to display an alphabetical list of all Git commands. This provides a quick overview of all Git commands.

git config --global user.name "your name"

It is used to configure Git settings. This command is used to set the username and is typically defined as a global setting, meaning the username applies to all Git projects on the system.

This setting is important for specifying which user made the changes, especially during commit operations.

git config --global user.email "your-email@example.com"

It is used to configure Git settings. This command is used to set the user's email address and is typically defined as a global setting, meaning the email address applies to all Git projects on the system.

This setting is important for specifying which user made the changes, especially during commit operations.

git config --global core.editor "code -w"

This is used to set the user-defined text editor for Git. In this example, it specifies the use of Visual Studio Code (code), and the -w option ensures that Git waits for the editor to close before proceeding. This means you can continue with commit messages or other editing tasks without waiting for Visual Studio Code to close.

git config --list(-l)

Used to list Git configuration settings. This command displays the configuration settings and values used by Git.

For example, you can use this command to view the username, email address, color preferences, and other settings defined in the Git configuration. The output is typically in key=value format and includes the configured settings for Git.

(追記) 02 Starting a Project (追記ここまで)

git init [project name]

Used to initialize an existing directory as a Git repository. If [project name] is specified, a folder with this name is created, and the Git repository is initialized within this folder.

mkdir my_project
cd my_project

Now, let's initialize this directory as a Git repository using the git init command:

git init

This process turns the current directory into an empty Git repository. You can now track files in this directory, commit changes, and use Git's version control features. If you use git init my_project, a folder named my_project will be created, and the Git repository will be initialized inside that folder.
When the git init command is executed, Git initializes the current directory as a Git repository and adds a subdirectory named .git. This subdirectory contains all the information and configuration settings for the Git repository. Therefore, running the git init command creates a Git repository and generates the .git directory that holds all the related information.
However, if you want to undo this process and delete the Git repository, simply deleting the .git directory is enough. However, this action is irreversible, and you will lose all history, commit information, branch structures, and other related data. Therefore, you should proceed with caution when deleting the directory.
For example, after creating a Git repository, you can follow the steps below to delete the repository (use with caution):

rm -rf .git

This command completely deletes the .git directory in the current directory.
When the -r (recursive) and -f (force) options are included, it deletes the specified directory, along with all files and subdirectories within it, without prompting for confirmation.

git clone <project url>

Used to copy a project from a remote Git repository to a local machine. This command downloads the specified Git repository in its entirety and creates a local copy. The <project url> represents the URL of the Git repository to be cloned.

As an example, to clone a GitHub repo:

git clone https://github.com/user/repo-path.git

This command downloads the specified GitHub repository and creates a folder named repository-name in the current directory, copying the contents into it. This allows you to use the entire project on your local machine and make changes to it.

(追記) 03 Day-to-day Work (追記ここまで)

git status

Displays the status of files in the working directory and index of a Git repository. This command is used to see which files have been modified, which are staged in the index, and which are waiting to be committed. Here are some example usages of the git status command:

Create a new directory and switch to this directory:

mkdir my_project
cd my_project

Check the directory status using the git status command:

git status

The output will be like this:

fatal: Not a git repository (or any of the parent directories): .git

This output indicates that the directory is not yet a Git repository. Therefore, when the git status command is run, Git reports that no repository has been initialized in the directory and returns an error.
Now, let's create the Git repository:

git init

Check the directory status using the git status command again:

git status

The output will be like this:

On branch master
No commits yet
nothing to commit (create/copy files and use "git add" to track)

This output indicates that the Git repository has been created successfully, but no commits have been made yet and there are no files being tracked.

git add [file]

The git add command is used to add changes in the working directory to the staging area for Git to track. Here are some examples of using the git add command:

Staging a Single File:

# Create a new file
echo "This is an example file" > file.txt


# Add the file to the stage
git add file.txt

file.txt

git add

Staging Multiple Files:

# Create new files
echo "hello world 1" > file1.txt
echo "hello world 2" > file2.txt


# Add all files to stage
git add file1.txt file2.txt

Staging All Changes:

# Add all changes in the working directory to the staging area
git add .

.

git add .

Staging Files of a Specific Type:

# Only add files with .txt extension to stage
git add *.txt

.txt

Unstaging Changes:

# Unstage a file from the staging area
git reset file.txt

file.txt

git diff [file]

The git diff [file] command is used to show changes in a Git repository. This command is useful for comparing differences between commits, branches, or file versions. Here are the basic usages and examples of the git diff command:

Showing Differences Between the Working Directory and the Staging Area:

git diff

Showing Differences Between the Staging Area and the Last Commit:

git diff --cached

Showing Differences Between Two Specific Commits:

# git diff commit_id1 commit_id2
git diff abc def

abc

def

Showing Changes in a Specific File:

# git diff file_name
git diff app.js

Showing Differences Between a Specific Commit and the Current State:

# git diff commit_id
git dif abc

abc

Showing Differences Between a Different Branch and the Current State:

# git diff other_branch_name
git dif feature-branch

git checkout -- [file]

The git checkout command is used to switch between branches, view commits, create new branches, and revert files in the working directory within a Git repository. However, starting from Git 2.23, the git switch and git restore commands have taken over some of the responsibilities of git checkout. Here are the basic uses of the git checkout command:

Changing Branch:

# git checkout branch_name
git checkout main

main

Creating a New Branch and Changing:

# git checkout -b new_branch_name
git checkout -b feature-xyz

feature-xyz

Reverting Files to a Specific Commit or Branch State:

# git checkout -- file_name
git checkout -- index.html

index.html

Going to a Specific Commit:

# git checkout commit_id
git checkout abc123

abc123

Viewing the State of a Specific Commit on a Specific Branch:

# git checkout branch_name -- file_name
git checkout main -- index.html

index.html

main

git switch

The git switch command, introduced in Git version 2.23, is designed for switching between branches. This command allows you to move from the current branch to another branch. It replaces the git checkout command for branch switching, providing a safer and more explicit tool. Here are the basic usages and examples of the git switch command:

Switching to Branch:

# git switch branch_name
git switch feature-branch

feature-branch

Creating and Switching to a Branch:

# git switch -c new_branch_name
git switch -c new-feature

new-feature

Match and Switch to a Remote Branch with the Current Branch:

# git switch --track remote_repo_name/remote_branch_name
git switch --track origin/main

Saving Changes Before Switching Branches:

# git switch -c new_branch_name --discard-changes
git switch -c new-feature --discard-changes

new-feature

git commit

The git commit command is used to permanently save changes in your working directory. Here are the basic uses and some examples of the git commit command:

Basic Commit Process:

# git commit -m "Commit Description"
git commit -m "Update homepage design"

git commit

-m

Committing All Files in the Staging Area:

git commit -a -m "Update all files"

-a

Editing Changes:

git commit --amend -m "fix: Commit Description"

--amend

git rm [file]

The git rm command removes a file or directory from version control in a repository. The removed file or directory will no longer be tracked, and this change will take effect in the next commit. However, the file or directory is not physically deleted; it is only untracked.

Stop Tracking the File:

# git rm file_name
git rm myFile.txt

myfile.txt

Stop Tracking and Remove the File:

# git rm -f file_name
git rm -f myFile.txt

myfile.txt

-f

(追記) 04 Storing Your Work (追記ここまで)

git stash

The git stash command is used to temporarily save changes in the current branch. This is useful when you want to save your work without committing it, allowing you to switch branches or work on something else without losing progress. Here are the basics of git stash usage and examples:

Saving Changes:

git stash

git stash

Viewing the Stash List:

git stash list

Applying a Specific Stash:

# git stash apply stash_index_number
git stash apply 0

apply

git stash pop

Applies and deletes the stash:

# git stash pop stash_index_number
git stash pop 0

Inspecting a Specific Stash:

# git stash show stash_index_number
git stash show 0

Deleting All Stashes:

git stash clear

(追記) 05 Git Branching Model (追記ここまで)

git branch

The git branch command is used to list branches, create new branches, switch between branches, and delete branches in a Git repository. Here are the basic usages and some examples of the git branch command:

Listing Branches:

git branch

Creating a New Branch:

# git branch new_branch_name
git branch feature-xyz

feature-xyz

Change Branch (Checkout):

# git checkout target_branch_name
git checkout feature-xyz


# Alternatively, in Git 2.23 and later
# The following command can also be used:
# git switch target_branch_name
git switch feature-xyz

git checkout

git switch

Creating a New Branch and Switching:

# git checkout -b new_branch_name
git checkout -b feature-abc

feature-abc

Deleting Branch:

# git branch -d branch_name_to_delete
git branch -d feature-xyz

feature-xyz

git branch -D

git merge

git merge command is used to combine different branches. It is typically used when you want to add changes made on a feature branch to the master branch or merge changes from different branches. Here is the basic usage of the git merge command along with examples:

Merging a Specific Branch into the Current Branch:

git checkout master # switch to the branch to be merged
git merge feature-xyz # merge feature-xyz branch into master branch


# or use with switch command
git switch master
git merge feature-xyz

feature-xyz

Fast Forward Merge:

If the changes on a branch were made after the latest commit on the target branch (the branch to be merged), Git performs a 'Fast Forward' merge. In this case, no separate commit is created.

git checkout master
git merge feature-xyz

master

feature-xyz

master

feature-xyz

Non-Fast Forward Merge:

If there are changes made between the branch being merged and the target branch, and Fast Forward merge is not possible, Git will create a new commit to complete the merge.

git checkout master
git merge --no-ff feature-xyz

--no-ff

Handling Conflicting Changes:

If there are conflicting changes during the merge process, Git will not be able to complete the merge automatically. In this case, manual intervention may be required.

git checkout master
git merge feature-xyz

Merge with a Specific Commit:

# git merge commit_id
git merge abc123

(追記) 06 Inspect History (追記ここまで)

git log

git log command is used to view the commit history of a Git repository. This command provides a list containing details such as commit IDs, authors, dates, and commit messages. Here are the basic usages and some examples of the git log command:

Basic Usage:

git log

Shortening Commit Information:

git log --oneline

Graphical Representation:

git log --oneline --graph

Displaying Commit History for a Specific Directory or File:

# git log file_name
git log index.html

index.html

Displaying Commits Up to a Specific Date:

git log --until=2025年01月01日

Displaying the commits made by a specific author:

# git log --author="author_name"
git log --author="mces58"

git show

git show command provides detailed information about a specific commit, branch, or tag in Git. This command displays the changes made in a commit, the commit message, and details about modified files. Below are the basic uses and examples of the git show command:

Displaying a Specific Commit:

# git show commit_id
git show abc123

abc123

Display the Last Commit:

git show

Showing a Specific Branch or Tag:

# git show branch_name
git show main
# git show v1.0.0

Show changes for a specific file:

# git show commit_id file_name
git show abc123 index.html

index.html

Show changes in color:

git show --color commit_id

Line-by-Line Comparison of Changes:

git show -v commit_id

(追記) 07 Tagging Commits (追記ここまで)

git tag

The git tag command is used to add a tag to a specific commit or manage existing tags in a Git repository. Tags typically represent the name, version number, or description of a specific release or significant point in the repository's history. Here are the basic uses of the git tag command with examples:

Creating a Tag:

# git tag tag_name
git tag v1.0.0

v1.0.0

Adding a Tag to a Specific Commit:

# git tag tag_name commit_id
git tag v1.0.0 abc123

v1.0.0

abc123

Creating Annotated Tags:

# git tag -a tag_name -m "Tag Description"
git tag -a v1.0.0 -m "Stable version"

v1.0.0

Listing Tags:

git tag

Showing a Specific Label Version:

# git show tag_name
git show v1.0.0

v1.0.0

Deleting a Specific Tag:

# git tag -d tag_name
git tag -d v1.0.0

v1.0.0

Push Tag to Remote Repository:

# git push remote_repo tag_name
git push origin v1.0.0

Push All Tags to Remote Repository:

# git push remote_repo --tags
git git push origin --tags

(追記) 08 Reverting Changes (追記ここまで)

git reset [<path>...]

The git reset command is used to modify the commit history of a branch and revert files in the working directory. This command should be used carefully, as it changes history and is generally not recommended on shared branches. Here are the basic uses and examples of the git reset command:

Reverting Commits:

# git reset commit_id
git reset abc123

abc123

git reset

Reverting Files:

# git reset --hard commit_id
git reset --hard abc123

Reverting Commits with a Soft Reset:

# git reset --soft commit_id
git reset --soft abc123

Mixed Reset to Revert Commits and Staging Area (Default):

# git reset --mixed commit_id
git reset abc123

Reverting to the Previous Commit:

git reset --hard HEAD^

git revert

The git revert command allows you to undo changes from one or more commits by creating a new commit. This method undoes changes without altering the commit history, providing a reversible mechanism for reverting changes. Here are the basic uses and examples of the git revert command:

Reverting a Specific Commit:

# git revert commit_id
git revert abc123

abc123

Reverting Multiple Commits:

# git revert commit_id1 commit_id2
git revert abc123 def456

abc123

def456

Adding a description to the revert commit:

While performing a revert operation, you can add a description to the new commit using the -m or --mainline option. This specifies which parent branch to revert when dealing with a merge commit

# git revert -m 1 commit_id
git revert -m 1 abc123

git restore

The git restore command is used to restore files or changes in the working directory or revert them to a specific commit state. Introduced in Git version 2.23, it serves as a replacement for the git reset and git checkout commands. Here are the basic usages and examples of the git restore command:

Restoring Files in the Working Directory:

# git restore file_name
git restore index.html

index.html

Reverting to a Specific Commit State:

# git restore --source=commit_id --staged --worktree file_name
git restore --source=abc123 --staged --worktree index.html

Undo All Changes:

git restore --source=commit_id --staged --worktree --source=commit_id .

Cancel changes in the working directory:

# git restore --source=HEAD --worktree file_name
git restore --source=HEAD --worktree index.html

Reverting Files to a Specific Commit State:

git restore --source=commit_id --staged --worktree --source=commit_id file_name

Revert All Changes:

git restore --source=commit_id --staged --worktree --source=commit_id .

(追記) 09 Synchronizing Repositories (追記ここまで)

git remote

The git remote command is used to manage remote repositories, which are often centralized locations where the project is stored or shared. This command allows you to view, add, remove, and modify remote repositories. Below are the basic uses and examples of the git remote command:

Listing Remote Repositories:

git remote

Listing Remote Repositories in More Detail:

git remote -v

Adding a Remote Repository:

# git remote add remote_repo_name remote_repo_url
git remote add origin https://github.com/username/project.git

Updating a Remote Repository Name:

# git remote rename old_name new_name
git remote rename upstream origin

Removing a Remote Repository Name:

# git remote remove remote_repo_name
git remote remove origin

Displaying a Remote Repository Name or URL:

# git remote show remote_repo_name
git remote show origin

Updating the URL of a Remote Repository:

# git remote set-url remote_repo_name new_url
git remote set-url origin https://new-address.com/username/project.git

mc-es/GitTutorial

Folders and files

Latest commit

History

Repository files navigation

Git & Github

Here are some basic terminal commands:

These commands will suffice for basic terminal usage.

(追記) 01 Git Configuration (追記ここまで)

(追記) 02 Starting a Project (追記ここまで)

(追記) 03 Day-to-day Work (追記ここまで)

Staging a Single File:

Staging Multiple Files:

Staging All Changes:

Staging Files of a Specific Type:

Unstaging Changes:

Showing Differences Between the Working Directory and the Staging Area:

Showing Differences Between the Staging Area and the Last Commit:

Showing Differences Between Two Specific Commits:

Showing Changes in a Specific File:

Showing Differences Between a Specific Commit and the Current State:

Showing Differences Between a Different Branch and the Current State:

Changing Branch:

Creating a New Branch and Changing:

Reverting Files to a Specific Commit or Branch State:

Going to a Specific Commit:

Viewing the State of a Specific Commit on a Specific Branch:

Switching to Branch:

Creating and Switching to a Branch:

Match and Switch to a Remote Branch with the Current Branch:

Saving Changes Before Switching Branches:

Basic Commit Process:

Committing All Files in the Staging Area:

Editing Changes:

Stop Tracking the File:

Stop Tracking and Remove the File:

(追記) 04 Storing Your Work (追記ここまで)

Saving Changes:

Viewing the Stash List:

Applying a Specific Stash:

Applies and deletes the stash:

Inspecting a Specific Stash:

Deleting All Stashes:

(追記) 05 Git Branching Model (追記ここまで)

Listing Branches:

Creating a New Branch:

Change Branch (Checkout):

Creating a New Branch and Switching:

Deleting Branch:

Merging a Specific Branch into the Current Branch:

Fast Forward Merge:

Non-Fast Forward Merge:

Handling Conflicting Changes:

Merge with a Specific Commit:

(追記) 06 Inspect History (追記ここまで)

Basic Usage:

Shortening Commit Information:

Graphical Representation:

Displaying Commit History for a Specific Directory or File:

Displaying Commits Up to a Specific Date:

Displaying the commits made by a specific author:

Displaying a Specific Commit:

Display the Last Commit:

Showing a Specific Branch or Tag:

Show changes for a specific file:

Show changes in color:

Line-by-Line Comparison of Changes:

(追記) 07 Tagging Commits (追記ここまで)

Creating a Tag:

Adding a Tag to a Specific Commit:

Creating Annotated Tags:

Listing Tags:

Showing a Specific Label Version:

Deleting a Specific Tag:

Push Tag to Remote Repository:

Push All Tags to Remote Repository:

(追記) 08 Reverting Changes (追記ここまで)

Reverting Commits:

Reverting Files:

Reverting Commits with a Soft Reset:

Packages