-
- Joined
- Mar 22, 2026
-
- Messages
- 272
-
- Reaction score
- 0
-
- Points
- 0
Git hooks are powerful, customizable scripts that Git executes automatically before or after events like committing, pushing, or receiving. They are a fundamental way to enforce policies, automate tasks, and ensure code quality within your development workflow. Understanding and leveraging them can significantly streamline your team's processes and prevent common errors.
What are Git Hooks?
At their core, Git hooks are simply executable scripts (e.g., shell scripts, Python, Ruby) placed in the
Client-Side vs. Server-Side Hooks
Git hooks are categorized into two main types:
1. Client-Side Hooks: These run on the developer's local machine. They are useful for personal automation, enforcing local coding standards, or running tests before pushing. Examples include
2. Server-Side Hooks: These run on the server that hosts your Git repository (e.g., GitHub, GitLab, your own Git server). They are primarily used to enforce repository-wide policies, control access, or integrate with CI/CD systems. Examples include
This article will focus primarily on client-side hooks, as they are more commonly customized by individual developers and teams.
The
Every Git repository initializes with a
Common Client-Side Hooks and Their Uses
Writing a Simple
Let's create a
1. Navigate to your repository's
2. Create a file named
3. Add the following content:
4. Make the script executable:
Now, if you try to commit a Python file that contains the string "DEBUG", the commit will be aborted with the error message.
Managing and Sharing Hooks
One challenge with Git hooks is that the
Bypassing Hooks
Occasionally, you might need to bypass a hook (e.g., during an emergency fix or if a hook is temporarily broken). You can do this by adding the
Conclusion
Git hooks are a powerful, often underutilized feature that can significantly improve code quality, enforce consistency, and automate repetitive tasks in your development workflow. By integrating them into your team's practices, you can catch issues earlier, reduce manual review effort, and maintain a cleaner, more reliable codebase. Explore the different hook types and consider using a hook management tool to make their adoption seamless for your entire team.
What are Git Hooks?
At their core, Git hooks are simply executable scripts (e.g., shell scripts, Python, Ruby) placed in the
.git/hooks directory of any Git repository. When a specific Git event occurs, Git checks this directory for a script matching the event's name and, if found, executes it. If the script exits with a non-zero status, the Git operation (like a commit or push) can be aborted.Client-Side vs. Server-Side Hooks
Git hooks are categorized into two main types:
1. Client-Side Hooks: These run on the developer's local machine. They are useful for personal automation, enforcing local coding standards, or running tests before pushing. Examples include
pre-commit, prepare-commit-msg, commit-msg, and pre-push.2. Server-Side Hooks: These run on the server that hosts your Git repository (e.g., GitHub, GitLab, your own Git server). They are primarily used to enforce repository-wide policies, control access, or integrate with CI/CD systems. Examples include
pre-receive, update, and post-receive.This article will focus primarily on client-side hooks, as they are more commonly customized by individual developers and teams.
The
.git/hooks DirectoryEvery Git repository initializes with a
.git/hooks directory containing example hook scripts (often ending with .sample). To activate a hook, you simply rename the .sample file to remove the extension (e.g., pre-commit.sample becomes pre-commit) and make it executable.
Bash:
cd your_repo/.git/hooks
mv pre-commit.sample pre-commit
chmod +x pre-commitCommon Client-Side Hooks and Their Uses
pre-commit: This is one of the most widely used hooks. It runs *before* a commit is finalized.
prepare-commit-msg: Runs *before the commit message editor is launched but after* the default message is created.
[JIRA-123] ) based on the branch name.commit-msg: Runs *after* the developer has entered a commit message.
post-commit: Runs *after* a commit is successfully made.
pre-commit, this hook cannot abort the commit.pre-push: Runs *before*git pushtransfers objects to the remote repository.
Writing a Simple
pre-commit Hook (Bash Example)Let's create a
pre-commit hook that checks for a specific string (e.g., "DEBUG") in any staged Python files and prevents the commit if found.1. Navigate to your repository's
.git/hooks directory.2. Create a file named
pre-commit (or rename pre-commit.sample).3. Add the following content:
Code:
bash
#!/bin/sh
# This hook checks for "DEBUG" in staged Python files.
# If found, the commit is aborted.
echo "Running pre-commit hook..."
# Get a list of staged Python files
STAGED_PYTHON_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep '\.py$')
if [ -z "$STAGED_PYTHON_FILES" ]; then
echo "No Python files staged. Skipping DEBUG check."
exit 0
fi
# Check each staged Python file for "DEBUG"
for FILE in $STAGED_PYTHON_FILES; do
if grep -q "DEBUG" "$FILE"; then
echo "ERROR: Found 'DEBUG' in $FILE. Please remove it before committing."
exit 1 # Abort the commit
fi
done
echo "Pre-commit hook finished successfully."
exit 0 # Allow the commit4. Make the script executable:
chmod +x .git/hooks/pre-commitNow, if you try to commit a Python file that contains the string "DEBUG", the commit will be aborted with the error message.
Managing and Sharing Hooks
One challenge with Git hooks is that the
.git/hooks directory is not part of the repository's version control. This means hooks aren't automatically shared with other team members. Common strategies to manage and share hooks include:- Manual Copying: Simple but error-prone for larger teams.
- Symbolic Links: Store hooks in a version-controlled directory (e.g.,
scripts/hooks) and create symbolic links from.git/hooksto these scripts. Apost-checkoutorpost-mergehook could automate this. - Dedicated Hook Managers: Tools like Husky (for Node.js projects), pre-commit framework (for various languages), or lefthook simplify hook management by allowing you to define hooks in your
package.jsonor a configuration file, which then automatically installs them into.git/hooks. These are highly recommended for team environments.
Bypassing Hooks
Occasionally, you might need to bypass a hook (e.g., during an emergency fix or if a hook is temporarily broken). You can do this by adding the
--no-verify (or -n) flag to your Git command:
Bash:
git commit -m "Emergency fix" --no-verify
git push --no-verifyConclusion
Git hooks are a powerful, often underutilized feature that can significantly improve code quality, enforce consistency, and automate repetitive tasks in your development workflow. By integrating them into your team's practices, you can catch issues earlier, reduce manual review effort, and maintain a cleaner, more reliable codebase. Explore the different hook types and consider using a hook management tool to make their adoption seamless for your entire team.