Git Basics: clone, add, commit, push, and pull

In the field of version control, Git has become the standard tool for software developers due to its efficiency, distributed architecture, and powerful branch management capabilities. For beginners, mastering the basic operations of Git forms the foundation of building collaborative development workflows. This article systematically introduces the five most core Git commands: clone, add, commit, push, and pull, accompanied by specific examples to help readers get started quickly.

The Git workflow typically involves data interaction between a local repository and a remote repository. Understanding the logical relationships between these commands helps developers manage code change history clearly, ensuring smooth team collaboration. Whether maintaining personal projects or coordinating team development, proficiency in using these basic commands is an essential skill.
Before starting any operation, it is necessary to clarify the status of the local repository. If a local repository has not been created yet, use the git init command to initialize the current directory as a Git repository. If you already have a remote code repository or wish to develop based on someone else's code, use the clone command.

The clone command copies a complete replica of the remote repository to the local machine. This command not only downloads all files but also synchronizes all branch and tag information from the remote repository, providing a complete context environment for subsequent operations. When executing this command, you must specify the address of the remote repository, typically in the format git clone <remote repository URL>.

For example, assuming we need to clone an open-source project hosted on GitHub with the address https://github.com/example/my-project.git, you can directly input the following in the terminal:

git clone https://github.com/example/my-project.git my-local-repo

Upon completion, the current directory will change to a new subdirectory named my-local-repo, containing all project files and the .git hidden directory. The .git directory is the core of the Git repository, storing all historical snapshots, configuration information, and branch metadata; users should generally not manually modify the contents of this directory.

Tracking Changes and Committing Code

After cloning a project, developers typically modify code or add new files. At this point, use the add command to add specific files or directories to the staging area (Staging Area). The staging area acts as a buffer between the Git working directory and the repository, used to prepare the set of code for the next commit.

The git add command can specify a single file, multiple filenames, or use wildcards to batch add files. For example, to add all modified files in the current directory, use git add .; if you wish to add only a specific configuration file, use git add config.json.

After staging the files, use the commit command to formally record the changes in the staging area into the local repository's history log. The commit command generates a unique commit hash (Commit Hash) and includes a commit message as the description. Commit messages should follow principles of clarity and conciseness; it is generally recommended to include a brief summary and a detailed explanation section.

Example operations are as follows:

# After modifying files, stage the changes
git add src/main.py

# Create a commit, recording it in local history
git commit -m "Fixed routing error in login module"

After executing commit, the history of the local repository will be updated, but the remote repository has not yet perceived this change. If you directly push to the remote at this stage, it may fail due to conflicts or permission issues; therefore, it should be used in conjunction with the subsequent push command.

Synchronizing Remote Repository and Pulling Code

When team members develop together, it is crucial to ensure that everyone's local repository remains synchronized with the remote repository. This relies primarily on the pull and push commands.

The pull command is the core tool for synchronizing remote code; it essentially executes fetch (retrieve remote updates) followed by merge (merge into the current branch). This command pulls the latest code from the remote repository to the local machine and attempts to automatically merge it into the current branch. If a conflict occurs during the merge process, Git will prompt the user to resolve the conflict manually before re-committing.

# Pull the latest code from the remote repository and merge
git pull origin main

In this command, origin is the default remote repository name recognized by Git, and main is the name of the current branch (different projects may use master or other names).

In contrast, the push command is used to push local commits to the remote repository. Before executing push, ensure that your local code is synchronized with the remote to avoid unnecessary conflicts or overwriting others' work. The push command can also specify the target branch, for example:

# Push changes from the current branch to the remote main branch
git push origin main

Through these two operations, developers can establish a closed-loop code flow mechanism: Local Modifications -> Commit -> Push -> Pull -> Merge.

Best Practices and Precautions

To efficiently utilize Git, it is recommended to follow the best practices listed below:

  1. Commit Frequently: Do not wait until all features are complete to commit once; instead, perform add and commit as soon as a logical unit is completed to enable quick rollback or history review.
  2. Standardize Commit Messages: Follow the Conventional Commits format with prefixes such as feat:, fix:, docs:, etc., to facilitate the generation of automated reports later.
  3. Pull Regularly: Before starting a new task, ensure you execute git pull to avoid conflicts with others' code.
  4. Push Carefully: Before pushing to the remote, it is recommended to first check via git push --dry-run (if supported by your version) or manually review the commit messages to ensure correctness before formally pushing.

After mastering these basic operations, developers are capable of participating in mainstream Git workflows. With accumulated experience, you can further learn advanced features such as branch management, redirections, and rebasing to handle more complex development scenarios.