SoFunction
Updated on 2025-05-06

Detailed explanation of git advanced hooks hook script

Overview

Git Hooks is an important feature of Git. It allows users to define some automated scripts in the Git repository, which can be triggered to execute when specific Git events (such as committing code, receiving code, etc.) occur.

Here is a detailed explanation of Git Hooks:

1. Definition and location of Git Hooks

Git Hooks are essentially a group of Git repository directories.git/hooks/executable file under .

Every Git repository has a hidden one.gitdirectory containing all data and configuration information related to version control, andhooksThe folder stores the template for the Git hook script.

These scripts can be written in any scripting language you like (such as Bash, Python, etc.), as long as the language is executable in the system environment.

2. How Git Hooks Work

When the user executes a Git command (such asgit commitorgit push) Git will check first.git/hooks/Whether the corresponding hook script exists in the directory.

If it exists and the script is executable, Git will run the script before (or after, depending on the type of hook) that Git command. The execution result of the script will determine whether to continue executing the Git command.

For certain hooks (e.g.pre-commit、pre-receiveetc.), if the script fails to execute (return status code is not 0), the Git command will be interrupted; for other hooks (e.g.post-commit、post-receiveetc.), the Git command will continue to be executed even if the script fails.

3. Types of Git Hooks and trigger timing

Git Hooks can be divided into two categories: client hooks and server hooks. Client hooks are executed mainly locally, while server hooks are executed on Git servers.

Here are the common Git Hooks types and corresponding trigger times:

Client hook：

  • pre-commit: In executiongit commitThe command is triggered before the commit object is generated. It is often used to check for upcoming snapshots, such as running the lint tool to check the code format.
  • post-commit: Triggered after successful submission. It can be used to send email notifications, update version numbers, etc.
  • pre-push:existgit pushThe command is triggered before sending data to the remote repository. Can be used to automatically run test cases to ensure code quality.

Service terminal hook：

  • pre-receive: Triggered before the remote repository receives data. It can be used to check whether the pushed branches, labels, etc. comply with the specifications.
  • post-receive: Triggered after receiving and processing data in the remote warehouse. Can be used to trigger the deployment process, update the cache, etc.

4. The practical application of Git Hooks

Git Hooks are widely used, and the following are some common application scenarios:

  1. Code Style Check:existpre-commitRun the lint tool in the Hook to check the code format to ensure that the submitted code complies with the code specifications.
  2. Automated testing:existpre-pushThe test cases are automatically run in the Hook. If the test fails, the push operation is blocked and the code quality is ensured.
  3. Email Notification:existpost-commitorpost-receiveSend email notifications in the Hook to inform other developers that new changes have been submitted.
  4. Automatically generate documents:existpost-mergeRun scripts in a Hook to automatically generate API documents from the latest source code.

5. How to enable and configure Git Hooks

To enable Git Hooks, users need to remove the corresponding script file suffix name.sample(if it exists), then add your own code and give the script file executable permissions. When configuring Git Hooks, users can choose the appropriate hook type according to their needs and write corresponding script code.

Overall, Git Hooks is a powerful tool that helps users automate and customize Git workflows, improve code quality and team collaboration efficiency.

Add hook script

Adding hook scripts (hooks) in Git can follow these steps:

1. Enter the project directory

  • Open a terminal or command line tool.
  • usecdCommands enter your Git project directory. For example:cd /path/to/your/project。

2. Find the .git/hooks directory

  • In the project directory, find the hidden one.gitFolder. This folder contains all configuration and metadata of the Git repository.
  • Enter.gitAfter the folder, findhooksSubfolder. This folder stores all Git hook scripts.

3. Select or create hook script file

  • hooksThe folder may contain some.sampleThe ending sample script file. These files are examples provided by Git, and you can select or copy one as you like.
  • If you want to create a new hook file, you can copy a sample file (remove it).samplesuffix) and name the name of the hook you want. For example, if you want to create apre-commitHook, can be copiedRename the file topre-commit。

4. Write hook scripts

  • Use a text editor to open the hook file of your choice.
  • Write scripts according to your needs. A hook script can be any executable script file, such as Bash scripts, Python scripts, etc.
  • The content of the script depends on what you want to perform when a specific event occurs. For example,pre-commitHooks can be used to perform code checking and testing before submitting code.

5. Set script executable permissions

  • On Unix/Linux systems, you need to set executable permissions for the hook script.
  • Availablechmod +x <script name>Command to add execution permissions.
  • For example:chmod +x .git/hooks/pre-commit。

6. Test hook script

  1. To ensure that the hook script can execute normally, you can manually trigger the corresponding event (such as submitting code) to test whether the hook script works as expected.
  2. If there is a problem with the script, you can debug based on the prompts provided in the terminal or command line tool.

Things to note

  1. Hook scripts run locally, not remote repositories or other users' machines.
  2. Each clone will contain the same default hook script (if any), but each clone can modify the hook script according to its own needs.
  3. Git hooks cannot be skipped in hook scripts. If you want to use Git commands in your script, make sure that the script does not loop infinitely.
  4. Hook scripts can be written in any programming language, just make sure the script file can be interpreted and executed correctly.

Through the above steps, you can add hook scripts to Git to automate and customize your Git workflow.

Open source hook script

Regarding open source Git hook scripts, there are several well-known projects and tools that provide easy management and use of Git hooks.

Here are some common open source Git hook script management tools and their features:

Husky

  • Husky is a popular Git hook management tool that simplifies the configuration and use of hooks.
  • It allows you to easily add, modify and delete Git hooks in your project.
  • Husky is usually used in conjunction with Lint-Staged to check and repair code formats of files in the temporary storage area.

Git Hooks(maintained by Vercel)

  • This is an open source Git hook management project maintained by Vercel, designed to help developers manage and use Git hooks more efficiently.
  • With this project, developers can easily set up and manage Git hooks, thereby improving code quality and development efficiency.

Pre-commit

  • Although Pre-commit is not a Git hook management tool itself, it is a tool for performing various checks before submitting code.
  • You can use Pre-commit with Git hooks to automatically run checks before each commit.

Commitlint

  • Commitlint is used to check whether the submitted information complies with the specification and is often used with Husky.
  • By configuring Commitlint, you can ensure that team members’ submissions follow a consistent format and style.

Lint-Staged

  • Lint-Staged is a tool for running lint and tests on Git staging files.
  • It is used in conjunction with Git hook management tools such as Husky, and can run lints and tests only on those files that have been modified or added, thus improving efficiency.

These open source projects and tools provide rich functionality and flexibility, allowing developers to customize Git hook scripts to their needs. By using these tools, developers can automate and customize Git workflows, improve code quality and team collaboration efficiency.

Please note that the specific tool you use depends on your project requirements and team preferences. Before using it, it is recommended to read the relevant documentation and guides carefully to ensure proper configuration and use of Git hook scripts.

Summarize

The above is personal experience. I hope you can give you a reference and I hope you can support me more.