Vad är Git hooks och hur används de?

Question

Accepted Answer

**Git hooks** är skript som Git kör **automatiskt** vid vissa punkter i Git-arbetsflödet (före/efter commits, pushes, merges, osv.). De möjliggör automatisering — upprätthållande av standarder, körning av kontroller och utlösning av åtgärder — och används i stor utsträckning för kodkvalitet och CI-integrering.

## Vad hooks är

```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
```

## Vanliga användningsområden

```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
```

## Hantering av hooks i ett team

```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).
```

## Varför det spelar roll

Att förstå Git hooks är värdefull kunskap på seniornivå för **automatisering av kvalitetskontroller och arbetsflödesåtgärder**, så det är användbart för att upprätthålla kodkvalitet och integrera med CI/CD.

Hooks möjliggör **automatisering vid viktiga Git-händelser** — körning av skript automatiskt före/efter commits, pushes, merges, osv. — vilket är i stor utsträckning används för att upprätthålla standarder och fånga problem tidigt.

Den vanligaste och mest värdefulla användningen är **pre-commit hook** för körning av **linting, formatering, snabba tester och hemlig-detektering före kod committas** — vilket ger snabb feedback och säkerställer konsekvent kvalitet automatiskt (så problem fångas vid commit-tidpunkten snarare än senare i CI eller review), en mycket populär praxis.

Övriga användningar (commit-msg hooks som tvingar meddelandekonventioner som Conventional Commits, pre-push hooks som kör tester för att förhindra pushing av bruten kod, och server-side hooks som tvingar policyer eller utlöser CI/CD och deployments) utökar automatiseringen över arbetsflödet.

Att förstå den praktiska **team-hantering**-aspekten är viktig: `.git/hooks/` är lokal och **committas inte**, så hooks delas inte automatiskt — delning av hooks inom ett team kräver verktyg som **Husky, pre-commit eller lefthook** som versionerar hooks i repot och installerar dem för alla.

Viktigtvis är det viktigt att förstå att hooks **kan kringgås** (`--no-verify`), vilket betyder att de ger snabb *lokal* feedback men **CI måste också upprätthålla** kontrollerna som det verkliga säkerhetsnätet — en viktig insikt om försvarsdjup (lokala hooks för hastighet, CI för upprätthållande).

Eftersom automatisering av kvalitetskontroller och arbetsflödesåtgärder förbättrar kodkvalitet och konsistens, och eftersom Git hooks (särskilt pre-commit för lokala kontroller, hanterade via verktyg och kompletterade av CI) är en mycket använd mekanism för detta, är förståelse för Git hooks — vad de är, vanliga användningsområden, team-hantering med verktyg och deras förhållande till CI — värdefull kunskap på seniornivå för att bygga automatiserade, kvalitetsfokuserade utvecklingsarbetsflöden, vilket återspeglar de metoder som används för att upprätthålla kvalitet i professionella team.