Tutorial Git avanzato - Programmazione

La distribuzione del tuo progetto tramite un repository remoto ti consente di gestirne ogni parte in modo flessibile. Correzioni di bug, aggiornamenti delle funzionalità, eliminazione di file, lavoro di squadra, contributi open source, distribuzione del codice e altro sono ora a portata di mano con una profonda conoscenza di Git.

Quindi, stai usando Git ma vuoi saperne di più? Ecco alcuni suggerimenti Git più avanzati che renderanno il controllo della versione del tuo progetto un gioco da ragazzi.

Ramo Git

Un ramo Git ti impedisce di spingere direttamente al ramo master. È utile se gestisci un progetto con un team di sviluppatori. Puoi creare tutti i rami Git che vuoi e poi unirli al ramo principale in un secondo momento.

Crea un ramo Git

Per creare un ramo Git, usa:

git branch branch_name

Passa a un ramo Git

Utilizzo guardare per passare a un ramo Git:

git checkout branch_name

Dopo essere passati a un ramo, puoi mettere in scena le tue modifiche usando git add --all . Quindi commettili usando il git commit -m 'nome commit' comando.

Confronta un ramo con Master

Utilizzare il git diff comando:

git diff master..branch_name

Per confrontare file specifici:

git diff master..testb -- main.html

Il confronto di due branch è simile a come si confronta un branch con il master:

git diff branch1..branch2

Per vedere le differenze in un file specifico tra due rami:

git diff branch1..branch2 -- main.html

Invia modifiche a un ramo remoto

Potresti volere che un altro sviluppatore esamini le modifiche che hai apportato a un file nel tuo ramo locale prima di pubblicarle. Una buona pratica è spostare il tuo ramo Git locale su una replica remota in modo che possano dare un'occhiata.

Supponiamo che tu abbia precedentemente creato un ramo locale chiamato i cambiamenti . Puoi passare a quel ramo locale, regolare tutti i file che desideri, quindi metterli in scena e inviarli a quel ramo.

Puoi quindi inviare tali modifiche alla versione remota del ramo:

git push origin changes

Unisci il ramo remoto con il master utilizzando la richiesta pull

Quindi un altro programmatore ha verificato le modifiche nel ramo remoto ( i cambiamenti ). Ma vuoi unirlo con il ramo principale e spingerlo dal vivo.

Ricorda che il tuo ramo remoto eredita il nome del tuo ramo Git locale ( i cambiamenti ). Ecco come unire le modifiche:

Passa al ramo principale:

git checkout master

Tirare l'origine o la TESTA del ramo ( i cambiamenti ) per unirlo al ramo master:

git pull origin changes

Invia questa unione dal vivo al ramo principale:

git push origin master

Usa invece Git Merge

Per unire un ramo con il master usando il andare comando:

Migrare al ramo principale:

git checkout master

Uniscilo al ramo ( i cambiamenti ):

git merge changes

Quindi spingi l'unione dal vivo al ramo principale:

perché il mio touchpad non funziona?

git push origin master

Assicurati di sostituire i cambiamenti con il nome della tua filiale.

Una volta che l'unione ha esito positivo, è possibile eliminare il ramo localmente e da remoto se non ti serve più:

Imparentato: Come rinominare un ramo in Git

Git Rebase

Se disponi di più rami con commit obsoleti, puoi rebase o riorientare il testa/rif di quei rami per ereditare il testa/rif di uno aggiornato.

Il rebasing, quindi, torna utile quando è necessario aggiornare alcuni rami con la base di uno corrente.

Tuttavia, il rebasing non dovrebbe essere un'azione frequente, soprattutto se lavori con un team in quanto può interrompere l'intero flusso di lavoro. Ma se lavori da solo e hai familiarità con il tuo flusso di lavoro e le diramazioni, il rebasing non dovrebbe causare scompiglio se sai dove e come usarlo.

Ad esempio, supponi di avere due rami; ramo1 e ramo2. Ora, non hai apportato alcuna modifica a branch1 per un po' di tempo. Ma si impegnano costantemente le modifiche a branch2, incluso di recente.

Quindi hai deciso di portare branch1 insieme al flusso. Ribasare branch1 su branch2, quindi, significa che stai dicendo a branch1 di ignorare i suoi precedenti commit ed ereditare il recente commit fatto a branch2.

Ecco come puoi farlo:

Passa al ramo abbandonato (ramo1):

git checkout branch1

Quindi rebase branch1 al branch2 aggiornato:

git rebase branch2

Git Squash

Git squash ti consente di unire più commit in uno. Aiuta quando corri git commit molte volte su un singolo aggiornamento. Un esempio pratico è quando ogni correzione di bug o refactoring del codice per una singola funzionalità ha un commit separato.

Ma potresti non voler spingere il commit HEAD con quelli di accompagnamento poiché hanno tutti lo stesso scopo. Un approccio consigliato è quello di schiacciarli in uno per evitare confusione durante il monitoraggio dei commit.

Il modo migliore per eliminare i commit è tramite la modalità rebase interattiva. Dai un'occhiata all'esempio qui sotto per capirlo meglio.

In questo esempio, supponi di avere cinque correzioni di bug. E c'è un impegno per ognuno di loro. Ecco come puoi ridurre questi cinque commit in uno:

Correre git reflog per visualizzare il codice hash dei tuoi commit:

git reflog

Ecco il risultato in questo caso:

Ora il tuo obiettivo è schiacciare gli ultimi cinque commit, iniziando con prima correzione fino a quinta correzione .

Per farlo, copia il codice hash del commit appena sotto prima correzione ( 0a83962 ). Quindi premere Q per uscire dal reflog .

Ora corri git rebase --interactive su quell'hash.

git rebase --interactive 0a83962

Git quindi apre un file di rebase interattivo simile a questo:

Per schiacciare i commit, escludendo il prima correzione , sostituire scegliere insieme a S per ciascuno degli altri impegni:

Salva e chiudi questo file.

Quindi si apre un altro file per rinominare il commit schiacciato:

ID evento 41 kernel-power

Pulisci quelli e digita un nome preferito per il commit schiacciato:

Salva quel file. Quindi chiudilo e dovresti ricevere un messaggio di successo nel tuo terminale.

Nota: Il file interattivo può essere aperto all'interno del terminale. Ma se sei su Windows, potresti voler forzare il tuo terminale ad aprire globalmente i file nel tuo editor di testo preferito per rendere facile lo schiacciamento.

Per farlo, apri la riga di comando ed esegui:

git config --global core.editor ''path to choice text editor' -n -w'

Git Fork contro Git Clone

Il fork e la clonazione sono due termini diversi in Git. Non puoi forkare il tuo repository perché è già lì con te. Puoi, tuttavia, effettuare il fork del repository di altre persone e clonarlo in seguito.

Il fork di un repository significa che stai prendendo una copia del repository di qualcuno e lo fai tuo. Una volta ottenuta una copia di quel repository, puoi clonarlo come faresti con uno qualsiasi dei tuoi repository git per le modifiche locali.

Ecco come clonare un repository remoto su GitHub e avvia un download nella tua directory locale:

git clone https://github.com/username/repository_name.git/

Ripristina un file al suo stato predefinito

Se vuoi cancellare le modifiche in un file dopo l'ultimo commit, puoi usare il git ripristino comando:

git restore filename

Modificare un impegno

Puoi tornare a un commit precedente se dimentichi di apportare modifiche ad alcuni file durante la fase di staging.

Apportare modifiche al file che hai dimenticato. Quindi usa correggimi per rivedere un commit:

git add file_forgotten  
git commit --amend

Unstage file

Puoi rimuovere file specifici che hai messo in scena per un commit usando vai rm comando:

git rm --cached filename

Puoi anche rimuovere più file contemporaneamente:

git rm --cached file1 file2 file3 file4

Ricorda di aggiungere l'estensione del file pertinente a qualsiasi file che stai esentando. Ad esempio, un file di testo normale dovrebbe essere nomefile.txt .

Imparentato: Come pulire Git e rimuovere i file non tracciati

Git Reset

Usando git reset è utile se vuoi eliminare tutti i file che hai messo in scena per un commit contemporaneamente:

git reset

Git reset HEAD, tuttavia, punta l'HEAD di un ramo a un commit specifico nel tuo albero di lavoro. Ad esempio, se non hai ancora inviato il commit corrente, puoi tornare al commit inviato di recente:

git reset --soft HEAD~1

Sostituire --morbido insieme a --duro se hai già inviato il commit corrente:

git reset --hard HEAD~1

Vai indietro

non mi piace il Ripristina comando, vai indietro mantiene l'integrità della cronologia dei commit. È utile se vuoi modificare un commit a causa di errori o bug.

Non abbandona il commit di destinazione né ne crea uno nuovo. Invece, ripristina le modifiche recenti apportate senza eliminare o rinominare tale commit. È un ottimo modo per mantenere i tuoi commit più puliti, inoltre è più sicuro rispetto al ripristino continuo.

Per ripristinare un commit:

git revert HEAD~1

In cui si TESTA~1 punta a un commit specifico nel tuo albero di lavoro.

Elimina un file tracciato o una directory

Puoi usare git rm -f per eliminare tutti i file tracciati nel tuo albero di lavoro. Nota, tuttavia, che Git non può rimuovere i file non tracciati, poiché non li memorizza nella cache.

Per eliminare un file organizzato:

git rm -f filename

Per rimuovere una cartella gestita:

git rm -r -f foldername

Registrazione Git

Per visualizzare i log dei commit e la cronologia in Git:

git log

Per registrare le attività in una filiale specifica:

git log branch_name

Imparentato: Come ispezionare la cronologia di un progetto con git log

A volte potresti voler ripristinare un commit abbandonato. Quindi, per visualizzare i commit abbandonati, inclusi quelli rilevanti:

git reflog

Per visualizzare i log di riferimento per un particolare ramo:

git reflog branch_name

Gestisci le versioni del tuo progetto come un professionista con Git

Con Git che offre molti vantaggi, puoi gestire le versioni dei tuoi progetti in remoto senza svaligiare file e cartelle on-premise nella tua filiale principale. Inoltre, ti consente di eseguire facilmente i progetti con un team.

Come hai visto, Git ha molte funzionalità che puoi esplorare. Ma fai attenzione a usare queste funzionalità in modo mirato. Altrimenti, potresti finire per rompere le cose. Detto questo, puoi ancora avviare un repository remoto demo e giocare con queste funzionalità.

Condividere Condividere Tweet E-mail Gestisci il controllo delle versioni dei tuoi file come un programmatore con Git

I programmatori hanno creato sistemi di controllo della versione (VCS) per risolvere i problemi di controllo della versione dei file. Diamo un'occhiata alle basi del controllo della versione utilizzando il sistema principale di oggi, Git.

Leggi Avanti Argomenti correlati

Programmazione
Sviluppo web
GitHub
Tutorial sulla programmazione

Circa l'autore Idisou Omisola(94 articoli pubblicati)

Idowu è appassionato di qualsiasi tecnologia intelligente e produttività. Nel tempo libero gioca con la programmazione e quando si annoia passa alla scacchiera, ma ama anche staccare ogni tanto dalla routine. La sua passione per mostrare alle persone la tecnologia moderna lo motiva a scrivere di più.

Altro da Idowu Omisola

Iscriviti alla nostra Newsletter

Iscriviti alla nostra newsletter per suggerimenti tecnici, recensioni, ebook gratuiti e offerte esclusive!

Clicca qui per iscriverti