-
- Joined
- Mar 22, 2026
-
- Messages
- 345
-
- Reaction score
- 0
-
- Points
- 0
Git hooks are powerful scripts that Git executes automatically before or after events like committing, pushing, or receiving. They are a built-in feature of Git and offer a flexible way to automate tasks, enforce policies, and integrate with external systems, significantly improving workflow consistency and developer productivity.
What are Git Hooks?
Essentially, Git hooks are executable scripts located in the
Types of Git Hooks
Git hooks are broadly categorized into two types:
1. Client-Side Hooks: These hooks run on the local repository on the developer's machine. They are typically used for personal workflow enhancements, enforcing local policies, or preparing commits.
*
*
*
*
*
*
*
2. Server-Side Hooks: These hooks run on the remote Git server. They are crucial for enforcing repository-wide policies, integrating with CI/CD pipelines, and auditing.
*
*
*
Implementing a Git Hook
Let's walk through creating a simple
1. Locate the Hooks Directory:
Navigate to your repository's
2. Create Your Hook Script:
Remove the
3. Write the Script:
Open
4. Make it Executable:
Grant execute permissions to the script.
Now, try to commit a
Best Practices
Git hooks are an indispensable tool for maintaining code quality, enforcing team standards, and automating repetitive tasks. By integrating them into your workflow, you can significantly enhance your development process.
What are Git Hooks?
Essentially, Git hooks are executable scripts located in the
.git/hooks directory of any Git repository. When a specific Git event occurs (e.g., git commit), Git checks for a corresponding hook script (e.g., pre-commit) in this directory and executes it if found. These scripts can be written in any language, as long as they are executable by your system (e.g., Bash, Python, Ruby, Perl).Types of Git Hooks
Git hooks are broadly categorized into two types:
1. Client-Side Hooks: These hooks run on the local repository on the developer's machine. They are typically used for personal workflow enhancements, enforcing local policies, or preparing commits.
*
pre-commit: Runs before a commit is created. Useful for linting code, running tests, or checking for large files. If this hook exits with a non-zero status, the commit is aborted.*
prepare-commit-msg: Runs after the pre-commit hook, but before the commit message editor is launched. It's often used to automatically generate a commit message template.*
commit-msg: Runs after the commit message has been entered but before the commit object is finalized. Ideal for enforcing commit message format standards (e.g., checking for JIRA ticket IDs).*
post-commit: Runs after a commit is successfully made. Useful for notification, triggering continuous integration, or updating a local ticket tracker.*
pre-rebase: Runs before a rebase. Can prevent rebasing on specific branches or enforce certain rebase rules.*
post-checkout / post-merge: Run after checking out a branch or merging. Useful for restoring IDE settings, installing dependencies, or performing custom cleanup.*
pre-push: Runs before git push. Can prevent pushes if tests fail or if the branch is not properly named.2. Server-Side Hooks: These hooks run on the remote Git server. They are crucial for enforcing repository-wide policies, integrating with CI/CD pipelines, and auditing.
*
pre-receive: Runs when the server receives pushes, before any references are updated. It can reject pushes based on content, branch names, or user permissions.*
update: Similar to pre-receive, but runs once for each ref being updated. It can check if the update is a fast-forward, for example.*
post-receive: Runs after a push has been successfully accepted by the server. Commonly used to trigger CI builds, update issue trackers, or deploy code to staging/production environments.Implementing a Git Hook
Let's walk through creating a simple
pre-commit hook to ensure no debug statements (like console.log in JavaScript) make it into a commit.1. Locate the Hooks Directory:
Navigate to your repository's
.git/hooks directory. You'll see several sample hook scripts with a .sample extension.
Code:
bash
cd your-repo/.git/hooks
ls -l2. Create Your Hook Script:
Remove the
.sample extension from the desired hook, or create a new file with the hook's name (e.g., pre-commit).
Code:
bash
# If pre-commit.sample exists, copy and rename it
cp pre-commit.sample pre-commit
# Or create a new file
touch pre-commit3. Write the Script:
Open
pre-commit in a text editor and add your script logic. For our console.log check:
Code:
bash
#!/bin/sh
# This hook checks for common debug statements before committing.
# Files to check (e.g., JavaScript files)
FILES_TO_CHECK=$(git diff --cached --name-only --diff-filter=ACM | grep '\.js$')
if [ -z "$FILES_TO_CHECK" ]; then
exit 0 # No relevant files changed, exit successfully
fi
# Patterns to look for
DEBUG_PATTERNS="console.log\|debugger"
for FILE in $FILES_TO_CHECK; do
if grep -Eq "$DEBUG_PATTERNS" "$FILE"; then
echo "ERROR: Found debug statements in $FILE. Please remove them before committing."
exit 1 # Abort commit
fi
done
exit 0 # All checks passed, proceed with commit4. Make it Executable:
Grant execute permissions to the script.
Code:
bash
chmod +x pre-commitNow, try to commit a
.js file containing console.log('debug');. The hook will detect it and abort the commit with the error message.Best Practices
- Version Control Your Hooks: Git hooks are local to each repository clone and not version-controlled by default. For team consistency, consider storing your hooks in a separate directory within your repository (e.g.,
scripts/git-hooks/) and then usinggit config core.hooksPath scripts/git-hooksto tell Git where to find them. - Keep Hooks Fast: Slow hooks can frustrate developers. Optimize your scripts to run quickly.
- Handle Errors Gracefully: Ensure your scripts provide clear, actionable feedback if a check fails.
- Allow Overriding (Client-Side): For client-side hooks, sometimes a developer might need to bypass a hook (e.g.,
git commit --no-verify). Be mindful that this option exists. - Use a Hook Management Tool: For complex setups, tools like Husky (for JavaScript projects) or pre-commit (for various languages) can simplify hook management and sharing across a team.
Git hooks are an indispensable tool for maintaining code quality, enforcing team standards, and automating repetitive tasks. By integrating them into your workflow, you can significantly enhance your development process.