Come utilizzare Git Stash: Una guida passo per passo

Questa guida esplorerà git stash, iniziando con il suo concetto di base, la sua utilità e i casi d’uso. Verranno poi trattate le nozioni di base, come il recupero e la gestione di stash, e verranno esplorate le tecniche avanzate. Le best practice e la loro importanza nello sviluppo del software concluderanno la nostra guida, assicurando una comprensione completa di git stash.

Git e l’importanza di git stash

Prima di immergersi nelle specifiche di git stash, è fondamentale comprendere Git stesso. Git, in poche parole, è un sistema distribuito di controllo della versione, ampiamente utilizzato nello sviluppo di software per tenere traccia delle modifiche al codice sorgente durante lo sviluppo. La sua natura distribuita permette a più sviluppatori di lavorare contemporaneamente sulla stessa base di codice senza interferire con il lavoro degli altri. 

Le caratteristiche principali che rendono Git indispensabile per gli sviluppatori includono:

• Ramificazione e fusione: Il modello di ramificazione di Git consente agli sviluppatori di lavorare in ambienti isolati, chiamati “rami”, e di unire facilmente le loro modifiche al codice sorgente.
• Velocità ed efficienza: Git è progettato per le prestazioni. Le sue operazioni sono rapide e lo rendono adatto a progetti di qualsiasi dimensione.
• Integrità dei dati: Git garantisce l’integrità del codice sorgente, mantenendo una cronologia completa e funzionalità di tracciamento delle versioni.

La comprensione di questi aspetti di Git prepara il terreno per un’esplorazione più approfondita del comando git stash, uno strumento che, sebbene sia meno frequentemente discusso rispetto ad altri come git commit o git merge, può comunque essere una parte inestimabile del kit di strumenti di uno sviluppatore.

Che cos’è git stash?

Il comando git stash è una potente funzionalità di Git. È essenzialmente un meccanismo per salvare lo stato attuale della directory di lavoro e dell’indice senza eseguire il commit. È come una clipboard per le modifiche non impegnate, offrendo uno snapshot che può essere riapplicata in seguito. Tale funzionalità è parte integrante del controllo della versione, in quanto aiuta a gestire le modifiche al codice in modo più flessibile ed efficiente. Mette temporaneamente da parte le modifiche apportate alla directory di lavoro, consentendo di lavorare su qualcos’altro e tornarci in seguito.

I suoi casi d’uso comprendono:

• Commutazione di contesto: Passa rapidamente da un ramo all’altro o da un’attività all’altra, senza impegnare il lavoro a metà.
• Sperimentazione: Testa codici o idee nuovi senza influenzare il progetto principale.
• Gestione dei lavori in corso: Mantieni pulita la tua directory di lavoro, nascondendo il lavoro in corso che non è pronto per essere impegnato.

Nei progetti con più sviluppatori, git stash è preziosissimo

• Ispezione del codice semplificata: Consente un’ispezione più rapida del codice e il tracciamento dei bug, facilitando le pratiche di ispezione del codice da parte del team, che è fondamentale per identificare e risolvere rapidamente i problemi.
• Pulire la directory di lavoro: Contribuisce a mantenere uno stato di lavoro pulito, riducendo così il rischio di commit accidentali di lavori incompleti o di file sbagliati.
• Zona di sperimentazione sicura: Facilita le modifiche sperimentali senza influenzare la base di codice principale, consentendo agli sviluppatori di provare nuove idee senza interrompere il flusso di lavoro.
• Aiuto in ambienti scalabili: Può essere utile in reti fortemente containerizzate e/o scalate orizzontalmente, ad esempio in scenari di distribuzione a fasi, gestendo in modo efficiente le modifiche al codice attraverso i diversi stadi di distribuzione.

Scenari chiave per l’utilizzo di git stash

• Cambio urgente di ramo: Il cambio di ramo per le correzioni urgenti, che consente agli sviluppatori di cambiare rapidamente obiettivo senza perdere i progressi dell’attività corrente.
• Sospendere il lavoro in corso: Accantonare temporaneamente le modifiche per lavorare su qualcos’altro, il che aiuta a dare priorità alle attività senza confondere le diverse modifiche al codice.
• Prove di codice sicuro: Sperimentare il codice senza eseguire il commit nel ramo corrente, ideale per testare nuove funzionalità o correzioni senza alterare la base di codice principale o il ramo di lavoro corrente.

Nozioni di base di git stash

L’archiviazione delle modifiche in Git è semplice. È sufficiente usare git stash nella propria directory di lavoro. Questo comando mette da parte tutte le modifiche e gli stadi, lasciando una cartella di lavoro pulita.

Come si usa il comando git stash

1. Apporta le modifiche alla tua directory di lavoro.
2. Esegui git stash per memorizzare le modifiche.
3. La directory di lavoro torna allo stato dell’ultimo commit.

Come memorizzare le modifiche con un messaggio

Utilizza git stash save ‘messaggio’. Questo aiuta a organizzare e identificare gli stash, soprattutto quando si lavora con più stash.

Come visualizzare i tuoi stash

Utilizza git stash list. Questo comando visualizza un elenco di tutti gli stash, ciascuno con un identificatore e il messaggio (se fornito).

Limitazioni comuni di git stash

• Non sostituisce i commit.
• Gli stash sono locali, non condivisi tra i repository.
• I file non tracciati e ignorati non vengono archiviati per impostazione predefinita.

Casi d’uso di git stash

Git stash dispone di funzionalità significative che gli sviluppatori possono utilizzare in vari scenari. Ecco alcuni dei suoi casi d’uso.

1. Salvataggio dei lavori in corso

Scenario: Quando uno sviluppatore deve passare da un altro ramo per concentrarsi su un problema critico, ma è nel mezzo dell’implementazione di una nuova correzione di bug.

Caso d’uso: Git stash salva le modifiche correnti senza eseguire il commit, consentendo agli sviluppatori di passare ad un altro ramo o di apportare modifiche prima di ritornare al ramo originale e recuperare le modifiche archiviate.

2. Pulizia della directory di lavoro

Scenario: Quando uno sviluppatore ha modifiche non impegnate nella sua directory di lavoro che non può perdere, ma vuole iniziare a lavorare su una nuova funzionalità da zero.

Caso d’uso: Git stash rimuove temporaneamente le modifiche non impegnate. Pulisce una directory di lavoro, consentendo agli sviluppatori di creare una nuova funzionalità da zero e di riapplicare le modifiche precedenti.

3. Testare diversi approcci

Scenario: Quando uno sviluppatore sta lavorando ad una soluzione e vuole provare un nuovo approccio senza perdere il lavoro corrente.

Caso d’uso: Git stash consente agli sviluppatori di conservare le modifiche correnti e di provare diversi approcci. Se il nuovo approccio non funziona, possono ritornare alle modifiche conservate.

4. Risolvere i conflitti di fusione

Scenario: Quando uno sviluppatore vuole nascondere temporaneamente alcune modifiche per occuparsi di altri problemi urgenti mentre trova una soluzione per un conflitto di fusione complesso.

Caso d’uso: Git stash consente di salvare temporaneamente le modifiche, permettendo agli sviluppatori di concentrarsi su altri problemi e di tornare a risolvere i conflitti di fusione.

5. Stash parziale

Scenario: Quando uno sviluppatore vuole scegliere solo alcune delle modifiche multiple che desidera conservare tra quelle presenti nella sua directory di lavoro.

Caso d’uso: Git stash consente di archiviare file specifici o parti di essi, dando agli sviluppatori un maggiore controllo su ciò che viene conservato.

6. Lavorare con diverse funzionalità

Scenario: Quando uno sviluppatore deve passare da una funzionalità all’altra contemporaneamente.

Caso d’uso: Git stash consente agli sviluppatori di salvare i progressi della funzionalità a cui stanno lavorando, in modo da poter passare ad un’altra senza perdere le modifiche apportate. Gli sviluppatori possono conservare il proprio lavoro su una funzionalità, passare a un ramo per un’altra e riapplicare le modifiche conservate una volta tornati alla funzionalità su cui stanno lavorando.

7. Verifiche del codice

Scenario: Quando uno sviluppatore ha bisogno di lasciare modifiche non impegnate nella propria directory di lavoro per verificare il codice di un collega.

Caso d’uso: Git stash consente agli sviluppatori di conservare le proprie modifiche, di verificare il codice dei colleghi e di riapplicare le modifiche conservate una volta tornati alla propria directory di lavoro.

8. Backup del lavoro non impegnato

Scenario: Quando uno sviluppatore vuole eseguire il backup delle modifiche non impegnate in un altro ramo o in un repository remoto.

Caso d’uso: Git stash consente di conservare le modifiche, creare un nuovo ramo dallo stash, inviare il ramo a un repository remoto e fornire un backup del lavoro non impegnato di uno sviluppatore.

9. Lavoro collaborativo

Scenario: Quando uno sviluppatore ha bisogno di recuperare l’ultimo aggiornamento del repository senza perdere le proprie modifiche locali, ma sta lavorando su un repository condiviso.

Caso d’uso: Gits stash consente agli sviluppatori di conservare le proprie modifiche e quindi di recuperare le ultime modifiche o aggiornamenti dal repository remoto. In seguito, possono riapplicare le modifiche conservate.

10. Automazione del flusso di lavoro

Scenario: Quando uno sviluppatore utilizza script o hook che richiedono una directory di lavoro pulita.

Caso d’uso: Git stash consente agli sviluppatori di conservare le modifiche apportate prima di eseguire gli script o gli hook. Possono quindi riapplicarli in seguito per garantire una directory di lavoro pulita per i processi di automazione.

Questi sono solo i casi d’uso più comuni di Git stash, che dimostrano la sua flessibilità nel fornire soluzioni e semplificare i flussi di lavoro di sviluppo.

Recupero delle modifiche memorizzate

Per riapplicare le modifiche memorizzate più recenti

Utilizza git stash apply. Questo comando riapplica le modifiche memorizzate più recentemente, ma non le rimuove dall’elenco di stash.

La differenza tra apply e pop

git stash pop differisce da apply perché applica lo stash e poi lo rimuove dall’elenco degli stash. Si utilizza quando sei sicuro di non aver più bisogno delle modifiche conservate.

Applicare stash specifici da diversi stash memorizzati

1. Elenca gli stash con git stash list.
2. Applica lo stash desiderato usando il suo identificatore: git stash apply stash@{n}.

Ad esempio: Se git stash list mostra due stash, utilizza git stash apply stash@{1} per applicare il secondo (enumerato da zero).

Gestire e pulire gli stash

Come eliminare o cancellare in sicurezza le modifiche salvate nello stash

• Per eliminare uno stash specifico: Usa git stash drop stash@{n} 
• Per cancellare tutti gli stash, il comando è git stash clear.

Strategie per recuperare gli stash eliminati per sbaglio

Gli stash sono, per definizione, locali e non vengono impegnati o trasmessi. Recuperare gli stash eliminati è difficile, perché Git non fornisce un modo diretto. Tuttavia, a volte è possibile recuperarli utilizzando reflog se lo stash è stato eliminato di recente; questo strumento funziona solo a livello locale e potrebbe aiutare a trovare la posizione dei file temporanei con i file temporanei non ancora eliminati.

Le best practice nella gestione degli stash

• Manutenzione preventiva: Esamina e pulusci regolarmente gli stash non necessari.
• Ricorda i commenti: Utilizza messaggi descrittivi per facilitare l’identificazione.
• Utilizza lo strumento giusto per il lavoro: Evita di fare affidamento sugli stash a lungo termine; utilizza i commit per le modifiche a lungo termine.

Integrare la gestione degli stash nei flussi di lavoro

• Memorizza le modifiche prima di cambiare ramo.
• Utilizza gli stash per esperimenti temporanei.
• Applica o elimina regolarmente gli stash per mantenere l’elenco degli stash gestibile.

Tecniche avanzate di git stash

Per archiviare file o modifiche specifiche

Per conservare file specifici, usa git stash push [file1] [file2]. Questa opzione si rivolge solo ai file o alle modifiche specificate, fornendo un maggiore controllo su ciò che viene archiviato e migliorando la granularità del controllo dello stash.

Gestione dei conflitti durante l’applicazione delle modifiche memorizzate

Quando si applicano gli stash, potrebbero sorgere dei conflitti. Gestiscili come in caso di conflitto di merge: modifica i file per risolvere i conflitti, quindi aggiungili e fai il commit.

Git stash aiuta a cambiare ramo

• Memorizza le modifiche nel ramo corrente.
• Passare al ramo di destinazione.
• Applicare lo stash nel nuovo ramo.

Comandi avanzati di git stash

Ecco alcuni comandi avanzati di git stash che rispondono a casi d’uso comuni e più specialistici:

• Memorizzare i file non tracciati: git stash –include-untracked o git stash -u

Per impostazione predefinita, git stash conserva solo i file tracciati (quelli che sono stati aggiunti all’indice). Questo comando ti consente anche di salvare nello stash i file non tracciati (nuovi file che non sono ancora stati aggiunti all’indice), rendendolo utile quando hai nuovi file che non sei ancora pronto a commettere.

• Memorizzare file specifici: git stash push -m “messagio” — path/to/file1 path/to/file2

Questo comando memorizza file o directory specifiche, anziché l’intera directory di lavoro. È particolarmente utile quando desideri separare le modifiche in diversi file o directory e gestirle in modo indipendente.

• Creare un ramo da uno stash: git stash branch new_branch_name stash@{n}

Se hai uno stash (stash@{n}) e ti rendi conto che dovrebbe essere su un ramo separato, questo comando crea un nuovo ramo a partire dal commit in cui è stato creato lo stash, vi applica le modifiche dello stash e poi elimina lo stash. È un ottimo modo per gestire le modifiche che si sono evolute in una funzionalità più significativa o in una correzione di un bug. È utile quando uno stash non si applica in modo pulito al ramo corrente.

• Applicare uno stash senza indice: git stash apply –index

Normalmente, quando applichi uno stash, le modifiche che erano state messe in stage al momento della creazione dello stash non sono più in stage. Usando `–index`, lo stash viene riapplicato e le modifiche che erano state messe in stage al momento dello stash vengono anche rimesse in stage. È utile quando desideri preservare lo stato dell’indice delle modifiche memorizzate.

• Stash interattivo: git stash -p o git stash –patch

Questo comando consente di selezionare in modo interattivo i pezzi di modifiche da salvare in stash. Git ti chiederà per ogni modifica nella tua directory di lavoro e potrai scegliere se salvarla nello stash o meno. È particolarmente utile quando desideri un controllo preciso su ciò che viene memorizzato.

Le best practice di git stash

Come molti altri processi di sviluppo, anche git stash comprende strategie che aiutano gli sviluppatori a utilizzare le sue potenti funzionalità. Ecco alcune best practice di git stash:

Usa lo stash quando necessario: In altre parole, non utilizzare troppo git stash. Invece di usare lo stash, è preferibile utilizzare rami dedicati per il lavoro a lungo termine. Ricorda di usare il comando con moderazione, soprattutto quando serve solo per lavorare su un altro compito, perché influisce sulle modifiche da apportare in fase di commit.

Utilizza messaggi di stash chiari e descrittivi: Gli sviluppatori possono aggiungere un messaggio descrittivo delle modifiche che stanno salvando in stash. Per questo motivo, devono essere sempre chiari con i loro messaggi di stash ed evitare quelli non necessari. Rendere lo stash significativo e informativo permette agli sviluppatori di ricordare esattamente cosa c’è nel loro stash quando vi ritorneranno in seguito. I messaggi chiari facilitano inoltre l’identificazione e l’applicazione dello stash corretto in un secondo momento, per facilitarne il recupero.

Sfrutta i rami: Assicurati sempre che venga creato un nuovo ramo prima di salvare in stash le modifiche. Ciò consente di passare a compiti o rami diversi senza influire sulle modifiche in corso. Successivamente, puoi tornare al ramo e applicare lo stash quando vuoi lavorare di nuovo sulle modifiche.

Salva in stash i file non tracciati: Una delle best practice che gli sviluppatori dovrebbero sempre seguire è utilizzare comandi che includano i file non tracciati nello stash. In questo modo si riduce il rischio di perdita di dati o di modifiche importanti apportate in precedenza.

Gestisci vari stash: Esistono dei comandi che permettono agli sviluppatori di gestire in modo efficace più stash. Questi includono git stash list per visualizzare tutti gli stash esistenti, git stash apply stash@{<n>} (dove <n> rappresenta l’indice dello stash) per applicare uno stash specifico e git stash drop stash@{<n>} (dove <n> rappresenta l’indice dello stash) per eliminare uno stash non più necessario.

Considera attentamente lo stash pop: Come per la prima best practice, il comando stash pop (git stash pop) deve essere usato con discernimento. Sebbene questo comando offra un modo rapido per applicare e rimuovere uno stash, l’operazione può causare l’unione di conflitti se le modifiche in stash sono in conflitto con l’albero di lavoro corrente. In alternativa, puoi utilizzare il comando git stash apply per applicare lo stash senza cancellarlo. Ciò consente di risolvere manualmente eventuali conflitti prima di rimuovere lo stash con git stash drop.

Apporta le modifiche il più rapidamente possibile: L’archiviazione deve essere utilizzata solo come soluzione temporanea. Una volta terminato un insieme di modifiche, è necessario eseguire il commit nel repository per conservare un record delle modifiche.

Altre strategie utili per git stash

Come mantenere pulita la cronologia di Git

• Impegnarsi per la permanenza: Preferisci i commit agli stash per le modifiche permanenti.
  • git commit -m “messaggio di commit”
• Pulizia dello stash: Pulisci regolarmente gli stash.
  • git stash list seguito da git stash drop stash@{n}
• Soluzione temporanea: Usa gli stash per modifiche temporanee, non per quelle a lungo termine.

Le comuni insidie di git stash da evitare

• Evita di salvare in stash eccessivamente: Fare eccessivo affidamento sullo stash per le modifiche importanti.
• Ricorda di effettuare l’unstash: Dimenticare di applicare o eliminare gli stash.
  • git stash apply o git stash pop
• Consapevolezza degli stash: Perdere traccia di cosa contiene ciascun stash.
  • git stash list per rivedere gli stash
• Chiarire con commenti: Stash poco chiari a causa di commenti insufficienti.
  • git stash save “messaggio descrittivo”

Quando si utilizza git stash in progetti basati su team

• Comunica i tuoi stash: Informa sulle modifiche apportate se hanno un impatto sugli altri.
• Migliora il flusso di lavoro: Utilizza gli stash per migliorare il flusso di lavoro personale.
• Mantieni gli stash a livello locale: Evita di caricare gli stash nei repository condivisi, salvo che non sia necessario creare un nuovo ramo da uno stash per applicare le modifiche locali al repository nel modo più semplice possibile.

Risoluzione dei problemi comuni di git stash

Risolvere i conflitti tra applicazioni stash

• Problema: Conflitti durante l’applicazione di uno stash a causa di modifiche sovrapposte.
• Soluzione: Risolvi manualmente i conflitti nei file interessati, quindi aggiungi git ed esegui il commit.

Recupera gli stash smarriti

• Problema: Eliminazione accidentale o smarrimento degli stash.
• Soluzione: Usa git reflog per trovare l’hash di commit dello stash smarrito, quindi riapplicarlo con `git stash apply <commit-hash>`.

Gestione degli stash nello stato HEAD distaccato

• Problema: Applicare gli stash dopo aver lavorato in uno stato HEAD distaccato.
• Soluzione: Esegui il checkout nel ramo desiderato, quindi applica lo stash usando git stash apply o git stash pop.

Evitare la duplicazione dello stash

• Problema: Duplicare gli stash dopo l’applicazione senza eliminare.
• Soluzione: Dopo aver applicato uno stash, usa git stash drop per eliminarlo se non è più necessario.

Salvare in stash file non tracciati

Problema: git stash non include i file non tracciati per impostazione predefinita.

Soluzione: Usa git stash –include-untracked o git stash -u per memorizzare i file non tracciati.

Git stash, git commit, git reset e git stage: Quali sono le differenze?

Poiché abbiamo già parlato di git stash, vediamo come si differenzia da altri comandi di Git, come il commit, il reset e lo staging delle modifiche.

Git commit

Git commit è un comando che consente agli sviluppatori di salvare le modifiche apportate al codice sorgente, archiviandole nel repository locale. Lo fanno per conservare uno snapshot di un progetto in un momento specifico, in modo da avere un riferimento che rappresenti lo stato attuale del progetto, comprese le modifiche in corso, dal momento in cui ci stavano lavorando. Per contestualizzare il tutto, ecco una tabella delle loro distinzioni:

 

Funzionalità	Git stash	Git commit
Scopo	Salva temporaneamente le modifiche non impegnate	Salva in modo permanente le modifiche nella cronologia del progetto
Reversibilità	Può essere applicato o eliminato in un secondo momento	Richiede git revert o git reset per l’annullamento
Ramificazione	Può cambiare ramo senza impegnarsi	Non influisce sulla ramificazione
Sovrapponibile	È possibile creare più stash	I commit sono lineari

Git reset

Git reset è un comando complementare a git stash che consente di gestire le modifiche a un repository Git. Con questi due comandi combinati, gli sviluppatori possono recuperare i file di backup e quelli precedentemente cancellati e inviarli nuovamente al repository. Ma git stash e git reset hanno anche delle differenze, che si possono vedere nella tabella seguente:

Funzionalità	Git stash	Git reset
Scopo	Salva temporaneamente le modifiche non impegnate	Riporta il HEAD corrente a uno stato specifico
Reversibilità	Può essere applicato o eliminato in un secondo momento	Può essere annullato con git reflog ma può essere pericoloso
Perdita di dati	Conserva le modifiche non impegnate	Può perdere le modifiche non impegnate (a seconda delle opzioni)
Ramificazione	Può cambiare ramo senza impegnarsi	Può cambiare il ramo o crearne uno nuovo

Git stage

Git stage viene utilizzato per preparare le modifiche per il commit. Il processo prevede l’aggiunta delle modifiche all’area di staging o “indice”, consentendo agli sviluppatori di rivedere le modifiche apportate prima di effettuare un commit. La tabella seguente mostra le differenze principali tra Git stash e Git stage:

Funzionalità	Git stash	Git stage
Scopo	Salva temporaneamente le modifiche non impegnate	Prepara le modifiche per il commit
Posizione	Area degli stash	Area dello staging
Impegnarsi	Richiede git stash pop o git stash apply per effettuare il commit	Richiede git commit per eseguire il commit
Reversibilità	Può essere applicato o eliminato in un secondo momento	Le modifiche possono essere cancellate con git reset HEAD <file>
Ramificazione	Può cambiare ramo senza impegnarsi	Non influisce sulla ramificazione

La pratica si salvare in stash coltiva buone abitudini di sviluppo

Salvare in stash regolarmente le modifiche non impegnate incoraggia gli sviluppatori a mantenere una base di codice pulita e organizzata, che a sua volta riduce la probabilità di conflitti ed errori. È una pratica che, se usata con criterio, può migliorare significativamente l’efficienza e l’efficacia complessiva della gestione del controllo della versione.

Questa caratteristica non è solo un semplice comando nella vasta gamma di funzionalità di Git; è uno strumento fondamentale per flussi di lavoro di codifica efficienti e flessibili. La capacità di mettere temporaneamente da parte i lavori in corso consente agli sviluppatori di mantenere una directory di lavoro pulita, essenziale in ambienti di sviluppo software complessi in cui la concentrazione e l’organizzazione sono fondamentali.

La versatilità di git stash risiede nella sua semplicità e nell’ampia gamma di scenari a cui si rivolge: dal cambio rapido di contesto alla sperimentazione di nuove funzionalità senza interrompere la base di codice principale. Questa funzionalità è particolarmente utile in contesti collaborativi in cui più sviluppatori contribuiscono allo stesso progetto.

Gli stash aiutano a garantire che il lavoro di ogni sviluppatore rimanga intatto e non influenzato dalle modifiche degli altri, favorendo così una collaborazione più fluida e produttiva.

Che tu sia un programmatore principiante che sta appena iniziando con Git o un sviluppatore esperto, la capacità di utilizzare git stash n modo appropriato è una competenza preziosa nel tuo arsenale di sviluppo software. Offre un modo strategico di gestire le modifiche al codice, si allinea bene con le pratiche di sviluppo efficaci e, in ultima analisi, contribuisce a una gestione del progetto più agile e ottimizzata.