Genera file .gitignore puliti e deterministici per l'intero stack in pochi secondi. Combina regole ufficiali verificate, elimina duplicati e scarica configurazioni pronte per la produzione senza alcun tracciamento.
Gratuito · Generazione nel browser · Nessun account richiesto
# Created by https://dotgitignore.com
# Edit at https://dotgitignore.com/generator?select=node,nextjs,docker,macos
### Node ###
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*
.pnpm-debug.log*
### Next.js ###
.next/
out/
build/
dist/
### Environment Variables ###
.env
.env*.local
!.env.example
### Docker ###
.docker/
*.tar
### Operating System (macOS) ###
.DS_Store
.AppleDouble
.LSOverrideEsplora modelli preconfigurati con pattern verificati e dettaglio delle regole di esclusione.
Progettato specificamente per gli sviluppatori che esigono file di controllo versione puliti e deterministici:
La logica pura di fusione elimina duplicati esatti preservando rigorosamente le regole di negazione (!pattern) e l'ordine dei file.
Modelli ufficiali GitHub arricchiti con stack moderni selezionati (Vite, Astro, Svelte, Claude Code).
Esecuzione 100% lato client in TypeScript. Le tue scelte e i file generati restano in memoria e non vengono mai inviati a server esterni.
Un'interfaccia pulita, priva di distrazioni, con supporto completo a modalità Dark e Light senza complicazioni SaaS.
Nel controllo di versione con Git, i file non tracciati possono essere involontariamente inclusi durante la preparazione di un commit. Un file .gitignore indica esattamente a Git quali file, cartelle e pattern escludere deliberatamente dal tracciamento. Ciò impedisce di salvare nel repository librerie pesanti, credenziali segrete, binari compilati e file di cache temporanei.
I file di configurazione locale come .env, .env.local e le chiavi SSH private non devono mai entrare nel controllo versione per evitare falle di sicurezza.
Cartelle gestite come node_modules/, vendor/ o ambienti virtuali Python (.venv/) appesantiscono il repository e devono essere reinstallate dai manifest.
File binari e cartelle generati da compilatori come dist/, target/, *.class e *.dll sono riproducibili dai sorgenti e non devono appartenere alla cronologia Git.
Le moderne architetture software raramente si basano su un unico strumento. Uno stack full-stack tipico combina un runtime (Node.js o Python), un framework (Next.js o Spring Boot), container (Docker), strumenti di CI e sviluppatori che lavorano su macOS, Windows o Linux con diversi editor.
Un generatore di .gitignore ti consente di selezionare ogni tecnologia del tuo stack e sintetizzarle in un unico file pronto per la produzione. Invece di incollare frammenti sparsi da tutorial o repository differenti — con il rischio di duplicati ed errori di sintassi —, DotGitIgnore unisce le regole in modo deterministico e produce un file normalizzato pronto da scaricare o copiare.
Segui questo flusso di lavoro in cinque passaggi per generare e implementare il tuo .gitignore:
Cerca o seleziona le tue tecnologie nella workstation tra oltre 321 modelli ufficiali.
Esamina le anteprime categorizzate e il conteggio delle regole nel visualizzatore in tempo reale.
Clicca su Copia per trasferire le regole negli appunti oppure su Scarica per salvare un file pulito.
Salva il file nella cartella principale del tuo progetto con il nome esatto .gitignore.
Se alcuni file erano già stati committati prima delle regole, esegui git rm --cached per rimuoverli dal tracking.
Pattern rappresentativi per i principali linguaggi di programmazione e framework:
node_modules/ dist/ npm-debug.log* .env .env.local
__pycache__/ *.py[cod] .venv/ dist/ *.egg-info/
target/ *.class *.jar *.war .sts4-cache/
[Ll]ibrary/ [Tt]emp/ [Oo]bj/ [Bb]uild/ *.csproj
.terraform/ *.tfstate *.tfstate.* crash.log override.tf
*.pid docker-compose.override.yml .docker/ *.tar
Il pattern matching di Git sfrutta la sintassi glob per verificare i percorsi nel repository:
# commentLe righe che iniziano con il cancelletto # sono considerate commenti e vengono ignorate da Git.
temp/Uno slash finale forza la corrispondenza solo con le directory, non con file con lo stesso nome.
*.logUn asterisco corrisponde a zero o più caratteri all'interno di un singolo segmento di percorso (es. *.log).
/buildUno slash iniziale ancora il pattern direttamente alla radice in cui risiede il file .gitignore.
**/logsUn doppio asterisco corrisponde ricorsivamente a qualsiasi profondità dell'albero delle directory.
!important.logUn punto esclamativo nega una regola precedente, reincludendo un file altrimenti escluso.
Tutto ciò che devi sapere sulla sintassi dei pattern, sul posizionamento dei file e sui flussi di lavoro in Git.
Un file .gitignore è un file di testo posizionato nella radice del tuo repository Git. Specifica file e pattern non tracciati che Git deve ignorare intenzionalmente, impedendo che file di compilazione, secret locali, cartelle di dipendenze e file temporanei di sistema vengano inclusi nel controllo versione.
Posiziona il file .gitignore nella directory principale (root) del tuo progetto (es. /mio-progetto/.gitignore). Nella root, le sue regole si applicano in modo ricorsivo a tutte le cartelle e i file del repository. Puoi anche inserire file .gitignore aggiuntivi nelle sottocartelle se desideri regole specifiche per quei percorsi.
Sì. I progetti moderni combinano quasi sempre più tecnologie (es. Python + React + Docker + macOS + VS Code). DotGitIgnore ti consente di selezionare tutti i modelli necessari, risolvendo le sovrapposizioni e deduplicando le regole identiche in un unico file pulito.
Per ignorare una cartella e tutto il suo contenuto, aggiungi uno slash finale al nome nel file .gitignore (es. node_modules/ o build/). Un pattern senza slash corrisponde sia a file che a directory con quel nome, mentre lo slash finale limita la regola esclusivamente alle cartelle.
Aggiungere un file al .gitignore non lo rimuove da Git se era già tracciato nei commit precedenti. Per smettere di tracciarlo senza cancellarlo dal disco locale, esegui 'git rm --cached <file>' (o 'git rm -r --cached <cartella>/' per le directory) e conferma con un commit.
Sì. L'output generato da DotGitIgnore è testo di configurazione standard di Git. Puoi aggiungere liberamente percorsi specifici del progetto, segreti del tuo ambiente locale, commenti o disattivare singole regole nel generatore o nel tuo editor dopo il download.
Crea un file chiamato .gitignore nella root del repository, inserisci i percorsi relativi o pattern che desideri escludere (come dist/, .env o *.log) e committa il file con 'git add .gitignore && git commit -m "Add .gitignore"'. Da quel momento, Git ignorerà tutti i nuovi file non tracciati corrispondenti alle regole.
Durante le verifiche del working tree (es. con 'git status' o 'git add .'), Git confronta i file non tracciati con i pattern definiti nei file .gitignore. Se un file corrisponde a un'esclusione e non viene ripristinato da una successiva regola di negazione '!', Git lo esclude dall'indice.
Il file .gitignore indica a Git quali file e cartelle non tracciati escludere dal versionamento. Impedisce che file temporanei, binari compilati, pacchetti esterni, metadati del sistema operativo (.DS_Store) e credenziali di accesso sporchino la cronologia dei commit o vengano pubblicati su repository remoti.
Sì. Nella quasi totalità dei casi, il file .gitignore deve essere committato per garantire che tutti i colleghi di lavoro e le pipeline di CI/CD condividano le stesse regole di esclusione. Per preferenze personali del tuo editor locale, usa .git/info/exclude o un file gitignore globale.
Il motivo più frequente è che il file è già tracciato da Git. Il file .gitignore impedisce l'indicizzazione solo dei file non ancora tracciati. Per risolvere, rimuovi il file dall'indice con 'git rm --cached <file>' e committa. Altre cause comuni sono errori di sintassi o slash posizionati in modo errato.
Se .gitignore è già stato committato, inserirlo non ha alcun effetto perché Git lo sta già tracciando. Se lo aggiungi prima del primo commit, Git ignorerà il file .gitignore stesso, impedendoti di condividerlo con il team. In pratica, non dovresti mai ignorare il file .gitignore.
Puoi verificare se un file è ignorato con il comando 'git check-ignore -v <percorso>'. Se il file è escluso, Git mostrerà il file .gitignore corrispondente, il numero di riga e il pattern corrispondente. Puoi anche eseguire 'git status --ignored' per vedere l'elenco di tutti i file ignorati.
Crea il file prima del tuo primo commit nel progetto, organizza le regole per categorie logiche (dipendenze, build, secret locali), committa il file nel repository e gestisci gli strumenti specifici della tua macchina nel tuo gitignore globale. DotGitIgnore ti aiuta a partire con regole pulite e senza duplicati.
Includi le cartelle di build (dist/, build/), le cartelle di dipendenze (node_modules/, vendor/), i file di ambiente (.env*), i file binari (*.class, *.o) e i file di log (*.log). Non ignorare mai il codice sorgente, i file di esempio di configurazione (.env.example) o i lockfile dei pacchetti.
Sì. Git supporta più file .gitignore lungo la struttura delle cartelle. Le regole di un .gitignore in una sottocartella hanno priorità e si applicano a essa e alle sue cartelle figlie, prevalendo su quelle della radice. È ideale nei monorepo con più linguaggi o microservizi.
Per ignorare un file ovunque nel progetto, scrivi il suo nome in .gitignore (es. segreto.txt). Per limitarlo solo alla radice del repository, anteponi uno slash (/segreto.txt). Per una cartella specifica, indica il percorso relativo (config/credenziali.json).
Aggiungi .env e varianti locali (.env.local, .env.*.local) al tuo .gitignore per impedire la fuga di token di autenticazione e password. Committa sempre un file pulito come .env.example con valori segnaposto per far sapere ai collaboratori quali variabili sono necessarie.
Il file .gitignore è versionato in Git e condiviso con tutti i collaboratori, risultando perfetto per le regole comuni del progetto (dipendenze e build). Al contrario, .git/info/exclude si trova all'interno di .git/ sul tuo PC, non viene mai committato o pushato ed è ideale per regole strettamente personali.
Il punto esclamativo (!) nega un pattern per reincludere un file escluso da una regola precedente (es. *.log seguito da !importante.log). Tieni presente che Git non può reincludere un file se la sua cartella contenitore è già stata completamente ignorata.
Puoi forzare l'aggiunta di un file ignorato usando l'opzione -f (o --force): 'git add -f <percorso>'. Una volta committato, Git continuerà a tracciarlo anche se corrisponde a una regola del .gitignore, finché non viene esplicitamente rimosso con 'git rm --cached'.
Combina i modelli ufficiali, elimina le regole duplicate e genera file di configurazione pronti per la produzione in pochi secondi.