Git hooks શું છે અને તેનો ઉપયોગ કેવી રીતે કરવામાં આવે છે?

Question

Accepted Answer

**Git hooks** એ સ્ક્રિપ્ટ્સ છે જે Git **આપોઆપ** Git વર્કફ્લોના અમુક બિંદુઓ પર ચલાવે છે (commits, pushes, merges, વગેરે પહેલા/પછી). તે automation સક્ષમ બનાવે છે — standards લાગુ કરવા, checks ચલાવવા, અને actions ટ્રિગર કરવા — અને code quality અને CI integration માટે વ્યાપકપણે ઉપયોગમાં આવે છે.

## Hooks કું છે

```text
Hooks are executable scripts in .git/hooks/ (or managed by tools) that Git runs on EVENTS:
  CLIENT-SIDE (local):
    pre-commit   → before a commit is created (lint, format, run quick tests)
    commit-msg   → validate/format the commit message
    pre-push     → before pushing (run tests, prevent pushing broken code)
    post-merge/checkout → after merge/checkout (e.g. reinstall dependencies)
  SERVER-SIDE (on the remote):
    pre-receive / update → enforce policies on push (reject bad pushes)
    post-receive → trigger deployment/CI/notifications after a push
```

## સામાન્ય ઉપયોગો

```text
✓ pre-commit → LINT and FORMAT code; run quick tests; block secrets/debug code
  → catch issues BEFORE they're committed (fast feedback, consistent quality)
✓ commit-msg → enforce message format (e.g. Conventional Commits)
✓ pre-push → run the test suite → don't push failing code
✓ server-side → enforce policies; trigger CI/CD and deployments
```

## ટીમમાં hooks સંચાલિત કરવું

```text
⚠️ .git/hooks/ is LOCAL and NOT committed → hooks aren't shared automatically.
To share hooks across a team, use tools:
  → HUSKY (JS ecosystem), pre-commit (Python framework), lefthook, etc.
  → these version hooks in the repo and install them for everyone
→ Combined with CI: hooks give FAST LOCAL feedback; CI is the enforced safety net
  (hooks can be bypassed with --no-verify, so CI must also enforce).
```

## શું મહત્ત્વપૂર્ણ છે

Git hooks સમજવું એ **quality checks અને workflow actions સ્વચાલિત કરવા**ના માટે મૂલ્યવાન senior-level જ્ઞાન છે, તેથી તે code quality જાળવવા અને CI/CD સાથે એકીકરણ માટે ઉપયોગી છે.

Hooks **key Git events પર automation** સક્ષમ બનાવે છે — commits, pushes, merges, વગેરે પહેલા/પછી આપોઆપ સ્ક્રિપ્ટ્સ ચલાવે છે — જે standards લાગુ કરવા અને સમસ્યાઓ જલ્દીથી પકડવા માટે વ્યાપકપણે ઉપયોગમાં આવે છે.

સૌથી સામાન્ય અને મૂલ્યવાન ઉપયોગ **pre-commit hook** છે જે **linting, formatting, quick tests, અને secret-detection commits પહેલા ચલાવે છે** — ઝડપી feedback આપે છે અને consistent quality આપોઆપ સુનિશ્ચિત કરે છે (જેથી સમસ્યાઓ commit સમયે પકડાય છે બદલે બાદમાં CI અથવા review માં), જે અત્યંત લોકપ્રિય પ્રથા છે.

ેટર ઉપયોગો (commit-msg hooks message conventions જેમ કે Conventional Commits લાગુ કરે છે, pre-push hooks broken code push કરવાથી રોકવા માટે tests ચલાવે છે, અને server-side hooks policies લાગુ કરે છે અથવા CI/CD અને deployments ટ્રિગર કરે છે) વર્કફ્લો જુઓ automation વિસ્તૃત કરે છે.

વ્યવહારિક **team management** પાસું સમજવું મહત્ત્વપૂર્ણ છે: `.git/hooks/` local છે અને **committed નથી**, તેથી hooks આપોઆપ શેર નથી — ટીમ જુઓ તેમને શેર કરવા માટે tools જેમ કે **Husky, pre-commit, અથવા lefthook** જરૂરી છે જે hooks repo માં version કરે છે અને બધા માટે તેમને install કરે છે.

નિર્ણાયક રીતે, સમજવું કે hooks **bypass કરી શકાય છે** (`--no-verify`) એટલે તેઓ ઝડપી *local* feedback આપે છે પણ **CI પણ must enforce કરવું જોઈએ** checks ને real safety net તરીકે — defense in depth વિશે key insight (local hooks ઝડપ માટે, CI enforcement માટે).

જે કારણે quality checks અને workflow actions સ્વચાલિત કરવું code quality અને consistency સુધારે છે, અને જે કારણે Git hooks (ખાસ કરીને pre-commit local checks માટે, tools દ્વારા સંચાલિત અને CI દ્વારા પૂરક) આ માટે વ્યાપકપણે-ઉપયોગમાં આવતા mechanism છે, Git hooks સમજવું — તે શું છે, સામાન્ય ઉપયોગો, tools સાથે team management, અને તેમના CI સાથેનું સંબંધ — automated, quality-focused development workflows બાંધવા માટે મૂલ્યવાન senior-level જ્ઞાન છે, જે professional teams માં quality જાળવવાની પ્રથા પ્રતિબિંબિત કરે છે.