Playground Git

Impara Git

Scrivi, esegui e condividi snippet di codice, senza configurare nulla.

Terminale Git

user$ git init -q

user$ git symbolic-ref HEAD refs/heads/main

user$ git config user.name "You"

user$ git config user.email "you@example.com"

user$ echo "hello" > file.txt

user$ git add file.txt

user$ git commit -q -m "Add file.txt"

user$ echo "bad change" >> file.txt

user$ git commit -q -am "Bad commit"

user$ git revert --no-edit HEAD

user$

Repository

Premi Esegui per vedere il grafo dei commit.

Ogni esecuzione riproduce l'intero script e salva uno snapshot del repository dopo ogni riga. Clicca su un passaggio per vedere il grafo in quel momento.

Prova i comandi Git più comuni

Anche Git funziona in questo terminale. Carica un flusso di lavoro già pronto nel prompt, premi Esegui per vedere ogni comando in azione, poi apri la guida completa di qualsiasi comando che vuoi capire.

Crea un repository e fai il tuo primo commitInizializza un repository, aggiungi un file allo staging, fai il commit e controlla lo stato.

git init
git config user.name "You"
git config user.email "you@example.com"
echo "# My Project" > README.md
git add README.md
git commit -m "Initial commit"
git status
git log --oneline

Crea un branch e fai il mergeCrea un branch, fai una modifica, il commit e poi il merge del branch in main.

Annulla l'ultimo commitFai un commit di cui ti penti, poi annullalo mantenendo le tue modifiche.

Fai il push su un remote per la prima voltaEsegui i tre comandi che GitHub mostra per un nuovo repository, su un remote locale.

Unisci più commit in uno (squash)Trasforma due commit di lavoro in corso in un unico commit pulito, senza editor.

Fai il cherry-pick di un commit da un altro branchCopia una singola correzione da un branch su main senza fare il merge dell'intero branch.

Guida ai comandi Git

Sfoglia tutti i comandi Git →

git init
echo "hello" > app.txt
git add app.txt
git commit -m "Add app.txt"
git checkout -b feature
echo "new feature" >> app.txt
git commit -am "Work on feature"
git checkout main
echo "fix" > fix.txt
git add fix.txt
git commit -m "Hotfix on main"
git merge feature
git log --oneline --graph --all

Un playground Git online con il grafo dei commit dal vivo

Un playground Git gratuito che esegue il vero git in un terminale Linux isolato, non un'imitazione in JavaScript. Scrivi i comandi a sinistra, git init, git add, git commit, git branch, git merge, git rebase, git reset, premi Esegui, e il pannello del repository a destra ridisegna il grafo dei commit, i branch, HEAD e il working tree dopo ogni riga del tuo script. È il modo più rapido per esercitarti con Git online e vedere davvero cosa ha fatto ogni comando.

Ogni esecuzione riproduce l'intero script partendo da una cartella vuota e salva uno snapshot del repository dopo ogni istruzione, così puoi cliccare su un passaggio qualsiasi e vedere il grafo in quel preciso momento. Un commit lasciato indietro da un git reset resta nell'immagine, sbiadito, così un annullamento mostra cosa ha annullato. Niente da installare, nessun account, e nessun tuo repository viene mai toccato.

Cosa rende diverso questo playground Git

Vero Git, vero output: la sandbox esegue il vero binario git su Linux, quindi messaggi di errore, git log --graph, git status e i flag si comportano come sul tuo computer, a differenza di un simulatore Git che conosce solo i comandi modellati dai suoi autori. L'unica differenza voluta: l'identità dell'autore e le date dei commit sono fisse, così gli hash restano uguali tra un'esecuzione e l'altra.
Un grafo dei commit che si aggiorna dopo ogni riga: i branch come corsie, i merge come curve, HEAD e ogni ref come etichetta sul proprio commit, più i file in staging, modificati, non tracciati e in conflitto letti da git status. Clicca su un passaggio per scorrere indietro nella cronologia della tua sessione.
Esercitati con i comandi più cercati: annullare un commit, fare lo squash dei commit, fare il rebase su main, cherry-pick, stash, risolvere un conflitto di merge, fare un force push in sicurezza. Carica qui sotto un flusso di lavoro già pronto, oppure apri una pagina qualsiasi della guida ai comandi Git e premi "Provalo dal vivo".
Remote senza rete: crea un repository bare locale, aggiungilo come origin ed esercitati con git push, git fetch, git pull e git clone. Il grafo mostra origin/main che si sposta accanto a main.
Esecuzioni deterministiche: date e identità sono fisse, quindi lo stesso script produce sempre gli stessi hash dei commit. Condividi uno script con un compagno di corso e vedrete entrambi lo stesso grafo.

Cosa provare nel playground Git

Branch e merge: git checkout -b feature, fai un commit sul branch, torna su main, fai un commit anche lì, poi git merge feature e guarda il commit di merge unire le due corsie.
Annulla in sicurezza: fai un commit di cui ti penti, esegui git reset --soft HEAD~1 e guarda il commit sbiadire nel grafo mentre le tue modifiche ricompaiono come file in staging. Poi prova git revert e confronta.
Rebase o merge: costruisci due volte la stessa cronologia con due branch, chiudi la prima con git merge e la seconda con git rebase main, e confronta la forma dei due grafi uno accanto all'altro.
Un conflitto di merge voluto: modifica la stessa riga su due branch, fai il merge e guarda il file finire nella riga Conflitti. Sistemalo, git add, git commit, e guarda il conflitto sparire.

Domande frequenti sul playground Git

Questo playground Git è gratuito?

Sì. Il playground Git è gratuito e non richiede registrazione né installazione. Apri la pagina, scrivi un comando, premi Esegui.

È vero Git o una simulazione?

Vero Git. Ogni esecuzione lancia il tuo script con il vero binario git dentro un container Linux isolato, quindi comandi, flag, output e messaggi di errore corrispondono a quello che vedi in locale. Due cose sono aggiunte apposta: un'identità dell'autore predefinita (che un tuo git config user.name sovrascrive, come in locale) e date dei commit fisse, così gli hash dei commit sono gli stessi a ogni esecuzione. Niente può chiederti input durante l'esecuzione, quindi un comando interattivo come git rebase -i ha bisogno di un editor programmato: gli esempi mostrano come fare.

Come funziona il grafo dei commit?

Dopo ogni istruzione del tuo script la sandbox registra commit, ref, HEAD, elenco degli stash e git status del repository. La pagina disegna il grafo a partire da questi snapshot: una corsia per branch, i merge come curve e ogni ref come etichetta. Clicca sul numero di un passaggio per vedere il repository com'era subito dopo quella riga. In una sessione molto lunga i prompt precedenti vengono catturati solo alla fine, e la barra dei passaggi mostra solo gli stati effettivamente registrati.

Posso esercitarmi con branch, merge e rebase qui?

Sì, il grafo serve proprio a questo. Crea branch, fai commit, merge, rebase, cherry-pick, reset e revert, e guarda ogni operazione cambiare l'immagine. È un'alternativa pratica ai giochi sui branch, con il vero Git sotto.

Posso usare git push, pull, fetch e clone?

Sì, verso un remote locale. La sandbox non ha accesso alla rete, quindi git clone https://… non può raggiungere internet. Crea un repository bare in una sottocartella (git init --bare remote.git), aggiungilo come origin e fai push, fetch, pull e clone da lì: i branch di tracciamento remoto compaiono nel grafo come farebbero con GitHub.

Il mio lavoro resta salvato tra un'esecuzione e l'altra?

No. Ogni esecuzione parte da una cartella vuota e riproduce l'intero script, ed è questo che rende possibile la cronologia dei passaggi. Tieni i tuoi comandi nel prompt (Maiusc+Invio aggiunge una riga) e usa Ripristina per tornare allo script iniziale.

In cosa è diverso dal terminale Linux online?

È lo stesso terminale isolato, dove gira anche Git, con in più un pannello del repository. La pagina del terminale Linux è pensata per comandi e script della shell; questa pagina organizza la tua sessione in modo che il grafo dei commit e lo stato del working tree vengano catturati dopo ogni riga.

C'è un corso che insegna Git da zero?

Sì. Il corso di Git gratuito di Coddy va da git init a branch, merge, rebase e remote con esercizi verificati, e ogni pagina della guida ai comandi Git ha un pulsante "Provalo dal vivo" che apre questo playground con un esempio pronto da eseguire.