Come usare Git Branches per strutturare il tuo progetto di programmazione

Film e televisione interpretano la programmazione come un'attività frenetica. Hacks: il meglio e il peggiore hacking in film Hacks: il meglio e il peggiore hacking nei film Hollywood e hacking non vanno d'accordo. Mentre l'hacking della vita reale è difficile, l'hacking dei film spesso richiede solo una tastiera, come se le tue dita stessero andando fuori moda. Leggi di più . Il timer di una bomba conta alla rovescia, e il nerddy sidekick che fino a quel momento era un fardello lavora febbrilmente su un laptop. Il codice vola sullo schermo fino a quando non colpisce la chiave di ritorno finale con un soddisfacente schiocco! Il timer si ferma e tutto torna a posto nel mondo. Ma la programmazione non è niente del genere. Comprende documenti di progettazione, modelli di interfaccia utente e revisioni del codice. E più di ogni altra cosa comporta tentativi ed errori, specialmente se sei un principiante (come me).

Ora, potresti già essere convinto del valore di mantenere i tuoi progetti di codifica nel controllo del codice sorgente Qual è Git e Perché dovresti usare il controllo della versione Se sei uno sviluppatore Cos'è Git e Perché dovresti usare il controllo della versione Se sei uno sviluppatore Come sviluppatori web, molte volte tendiamo a lavorare su siti di sviluppo locali, quindi basta caricare tutto quando abbiamo finito. Questo va bene quando sei solo tu e le modifiche sono piccole, ... Per saperne di più. L'invio di tutte queste prove ed errori al repository creerà un progetto ampio e disordinato, con molte revisioni. La maggior parte dei commit effettuati conterrà cose che sono rotte, quindi perché salvarlo? Il git ramo funzionalità può aiutare a mantenere tutto questo codice disordinato lontano dalle cose che sai funziona.

In questo articolo vedremo cosa significa branching del codice, come farlo e come gestire gli aggiornamenti al “principale” ramo.

Creazione di un ramo Git

Abbiamo imparato dalla nostra introduzione al controllo del codice sorgente Gestire il controllo del file come un programmatore con Git Gestire il controllo del file come un programmatore con Git I programmatori hanno creato i VCS (version control systems) per risolvere i problemi di controllo della versione del file. Diamo un'occhiata alle nozioni di base sul controllo della versione usando oggi il sistema principale, Git. Leggi di più che puoi creare un nuovo repository con il seguente comando in un terminale:

git init

Quando si esegue questa operazione, viene creata una directory nascosta nel percorso corrente, chiamata “.idiota.” Se non riesci a vederlo, consulta alcuni dei nostri articoli precedenti sulla visualizzazione nascosta. Il modo più semplice per mostrare file e cartelle nascosti in Windows 10, 8.1 e 7 Il modo più semplice per mostrare file e cartelle nascosti in Windows 10, 8.1 e 7 Hai bisogno di vedere i file e le cartelle nascosti in Windows? Ecco come visualizzarli in Windows 10, 8.1 e 7 in modo che nulla sia nascosto da te. Leggi altri file Nascondi e trova tutti i file su Mac OS X Nascondi e trova tutti i file su Mac OS X Non esiste un modo semplice per nascondere o rivelare rapidamente i file nascosti su Mac OS X come in Windows, ma è possibile. Leggi di più . Questa directory contiene tutte le informazioni necessarie per mantenere la cronologia delle revisioni dei file. Una volta impostato il file manager per mostrare i file nascosti, puoi aprire la cartella .git e vedere un numero di sottodirectory. Uno di questi è chiamato “refs” (mostrato nell'immagine qui sotto), e il suo “teste” la sottodirectory contiene gli elenchi di tutti i rami del progetto. All'inizio ne avrete una sola, doppiata “maestro.”

La directory refs conserva un record del ramo, ma non il ramo stesso. Almeno, non il ramo che sei attualmente in uso. Questi file sono tenuti nella directory di lavoro (“~ / Temp / post-programmazione-git-branch” nell'esempio sopra) in modo da poterli accedere in un modo normale. Facendo esattamente questo, creiamo il nostro primo file (chiamato “primo file.txt”) nella directory di lavoro, ad es. al di fuori la directory .git. Controlla questo usando i trusty command dall'introduzione precedente per git article Gestisci il tuo file Versioning Like a Programmer con Git Gestisci il tuo file Versioning Like a Programmer con Git I programmatori hanno creato i VCS (version control systems) per risolvere i problemi di controllo della versione dei file. Diamo un'occhiata alle nozioni di base sul controllo della versione usando oggi il sistema principale, Git. Leggi di più :

Possiamo vedere ora che la directory di lavoro ha due file, quello che abbiamo commesso e uno creato automaticamente da git (contiene il messaggio di commit appena inserito).

Ora, creiamo un nuovo ramo git chiamato “analisi”:

test di ramo di git

Controllando il ramo e lavorando in esso

Possiamo emettere il comando precedente senza alcun nome al fine di ottenere un elenco di tutti i rami, nonché quello che stiamo attualmente utilizzando (vale a dire che è “controllato”):

Ora, se esaminiamo la struttura delle directory, vedremo “.GIT / refs / teste” ora ha due file, uno per ciascuno “maestro” e “analisi.”

Ognuno di questi è un elenco dei commit che comprendono il ramo. Ad esempio, se esaminiamo il “maestro” ramo con il “log git” comando, possiamo vedere una linea per ciascuno dei commit fatti su quel ramo.

Il processo di “check-out” un ramo significa che le modifiche apportate ai file faranno parte di quel ramo, ma non di altri rami. Ad esempio, supponiamo di controllare il ramo git di test con il seguente comando:

test di verifica del git

Quindi aggiungiamo una riga di testo a first-file.txt, ovviamente in seguito. Se torni al ramo principale, troverai che il file è ancora vuoto (il file gatto comando visualizza i contenuti di un file nel terminale):

Ma tornando al “analisi” ramo, il file ha ancora il testo aggiunto:

Ma tutto ciò che vediamo nella directory corretta è il singolo file “primo file.txt.” Dove sono quindi queste due versioni alternative dello stesso file? La directory .git tiene conto di queste modifiche, ma non nel modo in cui ci si potrebbe aspettare.

Come Git memorizza le cose

Se si dovesse esaminare un repository per altri sistemi di controllo della versione come Subversion, si scoprirà che mantengono una copia per revisione per ogni singolo file. Ciò significa che se si dispone di un repository di un file, quindi si creano due rami, il repository contiene due diverse copie di quel file. In effetti, tu effettivamente usi “svn copia” come comando per creare un ramo in Subversion! D'altra parte, git opera sul concetto di “i cambiamenti.”

L'output di cui sopra ci dice l'intero contenuto di “tronco” (Versione SVN di “maestro”) è stato copiato. Un aspetto in un file manager lo conferma:

Il “.GIT / oggetti” directory è ciò che contiene tutte queste piccole modifiche e ciascuna di esse viene tracciata con un ID. Ad esempio, nell'immagine sottostante, vedrai i file con lunghi nomi di stile ID. Ciascuno vive in una cartella denominata con due caratteri esadecimali (8c e 8d sotto).

Insieme, questi nomi di cartelle e file costituiscono l'ID per una particolare modifica (in realtà un hash SHA1). Puoi esplorare i loro contenuti usando il git cat-file comando. In base alle date modificate, possiamo vedere l'inizio “8d” è venuto prima, e non mostra nulla. Mentre quello che inizia “8c” contiene la riga di testo che abbiamo aggiunto al file nel file “analisi” ramo.

Il takeaway è quel ramo git (incluso il default “maestro”) non sono separati “cartelle” contenente copie di file. Piuttosto, sono elenchi di modifiche apportate ai file nel tempo. Questo è più efficiente in termini di spazio di archiviazione, ma il risultato è lo stesso. Tutto ciò che fai (pausa?) In un ramo git rimane lì finché non lo unisci.

Strategie per la fusione di nuovo al ramo principale (per eliminare o non eliminare?)

Supponiamo che tu avessi un progetto esistente con un numero di file, a cui poi hai diramato “analisi,” e ci ha lavorato un po '. Ora vuoi riportare queste modifiche nel “maestro” ramo. Puoi fare con quanto segue dal “maestro” ramo:

git unire test

Purché non ci siano conflitti, il modificare composto dal nuovo testo sarà applicato a “maestro.” Il risultato è “primo file.txt” sarà identico in entrambi i rami. Eppure non ci sono mai stati realmente alternativi versioni del file.

Ora arriva la domanda, cosa fare con il ramo? Esistono due strategie comuni per affrontare i rami.

1. Uno è quello di mantenere un ramo git come “analisi” per giocare in (mostrato sopra). Provi alcune cose e, se riesci a farle funzionare, ricollega le modifiche “maestro.” Quindi puoi terminare il lavoro su quel ramo, o addirittura sbarazzartene del tutto. Questo significa il tuo “maestro” è la versione più stabile del codice, perché dovrebbe contenere solo cose che sai funzionare. Puoi anche pensare a questo approccio come usando “feature branch.” Questo perché il loro scopo è di perfezionare una (o più) aggiunte specifiche al codice.
2. Un approccio diverso è quello di fare tutto il tuo lavoro principale nel “maestro” ramo, commettendo commit lungo la strada. Una volta che sei soddisfatto della funzionalità, crei un ramo al suo interno che eseguirai il bug fixing e simili. Ciò si traduce in più di a “ramo di rilascio” (mostrato sotto), mentre terminano con il rilascio. Significa anche il tuo “maestro” il ramo è tipicamente la versione più instabile del tuo codice.

Usa il metodo migliore per te

Il primo approccio qui è più comune quando si lavora con git. Le sue altre caratteristiche (in particolare i tag) rendono facile marcare una particolare istantanea del codice come “stabile.” Si presta anche meglio a progetti di collaborazione più ampi. Ma quando lavori sui tuoi progetti personali, sentiti libero di usare qualsiasi di questi ha più senso per te. La cosa grandiosa dell'uso di git è che acquisisci tutte le tue modifiche, così puoi sempre tornare indietro e trovare qualcosa. E organizzare il tuo progetto con i rami git rende un po 'più facile.

Come ti avvicini alle filiali nei tuoi progetti? Li usi per sperimentare, poi li cestiniamo in seguito? Oppure rappresentano una storia dettagliata del tuo lavoro sul progetto?

Facci sapere di seguito nei commenti se hai qualche modo intelligente di trattare con i rami nei tuoi progetti git!