Git: The Tool, GitHub: The Service

Git and GitHub are different tools: Git is a distributed version control system, and GitHub is an online collaboration platform based on Git. Git manages code through workspaces, temporary storage areas and local warehouses, and uses common commands such as git init, git clone, etc. GitHub provides functions such as code hosting, Pull Request, Issue Tracking, etc. The basic process includes creating repositories, pushing code, and collaborating with Pull Request.

introduction

When we talk about version control and collaborative development, the names Git and GitHub are always in the shadow of each other. However, many people often confuse them without knowing that they are actually two completely different tools. Git is a distributed version control system, while GitHub is an online platform built on Git, providing code hosting and collaboration capabilities. Today we will explore the differences and connections between the two, helping you better understand how to use them to improve your development efficiency.

In this article, you will learn the core concepts and basic operations of Git, as well as the various features and usage tips provided by GitHub. We will also share some experiences and pitfalls with Git and GitHub in actual projects to help you avoid common pitfalls.

Git: A powerful tool for version control

Git was developed by Linus Torvalds in 2005 to solve version control issues in large software projects. It is a distributed version control system that allows developers to manage code versions locally and collaborate with team members.

How Git works

The working principle of Git can be simplified into three main concepts: Working Directory, Staging Area, and Local Repository. When you make code modifications, these changes first appear in the workspace. With the git add command, you can add these changes to the temporary storage area. Finally, through the git commit command, you submit the contents of the temporary storage area to the local repository.

 # Add file to the temporary storage area git add file.txt

# Submit to local repository git commit -m "Add file.txt"

Git's distributed nature allows every developer to have a complete repository of code, which not only improves collaboration efficiency, but also enhances project security.

Common Git commands

When using Git, here are some commonly used commands:

 # Initialize a Git repository git init

#Clone a remote repository git clone <url>

# Check the current status git status

# View submission history git log

# Switch branch git checkout <branch>

# Create and switch to a new branch git checkout -b <new-branch>

# Merge branch git merge <branch>

# Submit git commit after conflict resolution -m "Merge branch <branch>"

These commands form the basis of Git's daily operations, and mastering them will greatly improve your development efficiency.

GitHub: A platform for collaborative development

GitHub is an online platform built on Git. It not only provides code hosting services, but also provides rich collaboration tools and social functions. GitHub was launched in 2008 and quickly became the preferred platform for open source communities and enterprise development teams.

Key features of GitHub

Features provided by GitHub include but are not limited to:

• Code Hosting : You can push your Git repository to GitHub for remote backup and collaboration.
• Pull Request : This is a collaborative way for developers to submit code changes and request team members to review and merge.
• Issue Tracking : used to track problems and tasks in projects, so that team members can collaborate and resolve them.
• Wiki : Provides document space for projects to help team members share knowledge and information.
• Actions : Automated workflows, can be used for CI/CD, testing, etc.

Basic Process for Using GitHub

Assuming you have managed a project locally using Git and now you want to push it to GitHub, here is the basic process:

 # Create a new repository on GitHub, assuming the repository is called myproject

# Associate the local repository to the GitHub repository git remote add origin <GitHub repository URL>

# Push the main branch to GitHub
git push -u origin master

Next, you can use GitHub's Pull Request feature to collaborate on development:

 # Create a new branch locally git checkout -b feature/new-feature

# Make code modifications and submit git add.
git commit -m "Add new feature"

# Push new branch to GitHub
git push -u origin feature/new-feature

Then, create a Pull Request on GitHub, waiting for team members to review and merge.

Experience sharing and pitfalls

In the process of using Git and GitHub, I have accumulated some experience and stepped on pits. I will share it with you here:

Avoid large file submissions

When using Git, avoid submitting large files (such as video, audio, etc.), as this will significantly increase the size of the repository and affect the speed of cloning and pulling. If you have to submit large files, you can consider using Git LFS (Large File Storage) for management.

Use branches reasonably

Branching is a powerful feature of Git, but if used improperly, it can cause the code base to become messy. It is recommended to create a new branch when starting a new feature or fixing a bug, and then merge it into the main branch after completion. This keeps the stability of the master branch while making it easier to track and rollback.

Pull Request Review

When using Pull Request on GitHub, it is recommended that team members carefully review code changes to ensure code quality and consistency. A code review process can be set up to ensure that each Pull Request is reviewed by at least two people and all comments and issues are resolved before merger.

Backup and restore

While Git itself provides powerful version control, it is recommended to back up your repository regularly just in case. GitHub provides warehouse backup function, which can export warehouse data regularly. In addition, it is also very important to understand Git recovery commands (such as git reset and git revert ) to ensure that you can recover quickly when misoperating.

Performance optimization and best practices

Here are some recommendations for performance optimization and best practices when using Git and GitHub:

Optimize Git repository

As the project develops, Git repositories may become larger and larger, affecting the speed of cloning and pulling. You can use the git gc command to optimize the repository and delete unnecessary objects and files.

 # Optimize Git repository git gc --aggressive

Using Git Submodules

For large projects, consider using Git Submodules to manage dependency libraries. This allows you to manage dependent libraries as a standalone Git repository, avoiding committing them directly to the main repository.

 # Add a submodule git submodule add <submodule-url> <path>

# Update submodule git submodule update --init --recursive

Use GitHub Actions reasonably

GitHub Actions is a powerful automation tool that can be used for CI/CD, testing, etc. However, overuse may lead to excessive build time and affect the team's development efficiency. It is recommended to plan the Actions workflow rationally to ensure that each step is necessary and efficient.

 name: CI

on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  build:
    runs-on: ubuntu-latest

    Steps:
    - uses: actions/checkout@v2

    - name: Run a one-line script
      run: echo Hello, world!

    - name: Run a multi-line script
      run: |
        echo Add other actions to build,
        echo test, and deploy your project.

Best Practices for Code Review

When performing code reviews on GitHub, it is recommended to follow these best practices:

• Timely review : Try to conduct review within 24 hours after the submission of Pull Request to avoid delaying project progress.
• Detailed comments : Not only do you point out problems, but you also need to provide solutions and suggestions to help developers improve the quality of their code.
• Respect and courtesy : Be respectful and courteous in your comments, even if you point out the problem, do it in a constructive way.

Conclusion

Git and GitHub are indispensable tools in modern software development. They not only improve development efficiency, but also promote the development of team collaboration and the development of open source communities. Through the introduction and sharing of experience in this article, I hope you can better understand and use these two tools and improve your development skills. If you have any questions or suggestions, please leave a message in the comment section to discuss.

The above is the detailed content of Git: The Tool, GitHub: The Service. For more information, please follow other related articles on the PHP Chinese website!