Cosa sono i Git hook e come vengono utilizzati?

Question

Accepted Answer

**Git hook** sono script che Git esegue **automaticamente** in determinati punti del flusso di lavoro Git (prima/dopo commit, push, merge, ecc.). Consentono l'automazione — applicare standard, eseguire controlli e attivare azioni — e sono ampiamente utilizzati per la qualità del codice e l'integrazione CI.

## Cosa sono gli hook

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

## Usi comuni

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

## Gestione degli hook in un 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).
```

## Perché è importante

Capire i Git hook è una conoscenza preziosa a livello senior per **automatizzare i controlli di qualità e le azioni del flusso di lavoro**, quindi è utile per mantenere la qualità del codice e integrarsi con CI/CD.

Gli hook abilitano **l'automazione a eventi Git chiave** — eseguono script automaticamente prima/dopo commit, push, merge, ecc. — che viene ampiamente utilizzata per applicare standard e rilevare i problemi tempestivamente.

L'uso più comune e prezioso è l'**hook pre-commit** per eseguire **linting, formattazione, test veloci e rilevamento dei secret prima che il codice sia sottoposto a commit** — fornisce feedback rapido e assicura una qualità coerente automaticamente (in modo che i problemi vengono rilevati al momento del commit piuttosto che in seguito in CI o in revisione), una pratica enormemente popolare.

Alti usi (hook commit-msg che applicano convenzioni di messaggi come Conventional Commits, hook pre-push che eseguono test per evitare di fare push di codice non funzionante, e hook lato server che applicano politiche o attivano CI/CD e deployment) estendono l'automazione nel flusso di lavoro.

Capire l'aspetto pratico della **gestione del team** è importante: `.git/hooks/` è locale e **non viene sottoposto a commit**, quindi gli hook non vengono condivisi automaticamente — condividerli tra un team richiede strumenti come **Husky, pre-commit o lefthook** che versionano gli hook nel repository e li installano per tutti.

Crucialmente, capire che gli hook **possono essere ignorati** (`--no-verify`) significa che forniscono feedback veloce a *livello locale* ma **CI deve anche applicare** i controlli come vero sistema di sicurezza — un'intuizione chiave riguardo alla difesa in profondità (hook locali per velocità, CI per applicazione).

Poiché l'automazione dei controlli di qualità e delle azioni del flusso di lavoro migliora la qualità e la coerenza del codice, e poiché i Git hook (in particolare pre-commit per controlli locali, gestiti tramite strumenti e complementati da CI) sono un meccanismo ampiamente utilizzato per questo, capire i Git hook — cosa sono, usi comuni, gestione del team con strumenti e la loro relazione con CI — è una conoscenza preziosa a livello senior per costruire flussi di lavoro di sviluppo automatizzati e orientati alla qualità, riflettendo le pratiche utilizzate per mantenere la qualità nei team professionali.