I 20 migliori comandi GIT con cui iniziare

Come forse saprai, GIT è un sistema di controllo della versione distribuito. Gli ingegneri lo utilizzano per tenere traccia delle modifiche apportate al codice sorgente durante il processo di sviluppo del software. Se sei uno sviluppatore, in particolare se sei appena entrato nella professione, devi imparare alcuni dei comandi GIT più utili.

Diamo un'occhiata ai migliori comandi bash GIT su cui dovresti imparare.

Per l'impostazione del progetto: una spiegazione dei prompt GIT

Consigliato per te: 5 fantastiche app gratuite che ti aiuteranno a imparare a programmare.

GIT INIT

Supponiamo che tu abbia appena creato un progetto nel tuo IDE preferito e devi conoscere i prompt GIT di PowerShell. Dovrai impostare un repository GIT funzionante.

Mentre lo fai, devi dire a GIT quale directory deve essere utilizzata ed eseguita. La funzione git init è come lo faresti. GIT creerà un file nascosto. git e usala per mantenere i suoi file organizzati come altre sottodirectory.

Ecco un elenco di comandi git init per i prossimi editor popolari:

CONFIG

Dopo aver creato il tuo repository, forse potresti configurare alcuni elementi essenziali al suo interno, come impostare il tuo nome utente. Ecco perché avrai bisogno di un comando CONFIG. Qualsiasi comando di un elenco GIT lo includerà.

Puoi impostare il tuo nome utente eseguendo:

 git config user.name=<replace_with_your_username>.

Questo posizionerà il nome utente nel repository vicino. Tuttavia, tieni presente che in seguito, se desideri creare un secondo repository, dovrai impostare le informazioni utente ancora una volta.

Non è necessario eseguire questa operazione se si aggiunge un'opzione di comando globale. Imposterà globalmente le tue informazioni:

 git config --global user.name=<replace_with_your_username>.

Puoi anche usare un comando CONFIG per configurare altri aspetti. È possibile inserire il comando all'interno del file di configurazione.

CLONE

Per ottenere un repository remoto sul tuo computer, devi configurare un comando CLONE. Puoi farlo con la tua impostazione git clone e passando l'URL come parametro. Questo comando dovrebbe clonare l'intero repository remoto all'interno della tua macchina. Questo è un altro dei comandi dell'hub GIT che ti servirà bene come sviluppatore.

 $ git clone git://git.kernel.org/pub/scm/git/git.git

ALIAS

Con un comando ALIAS, puoi creare collegamenti ai tuoi comandi preferiti. È uno strumento che ti aiuta a racchiudere una sequenza di comandi e salvarli con un nome. Questo sarebbe considerato uno dei comandi GIT comuni che userai spesso come dev.

Puoi anche aggiungere gli alias direttamente nel tuo file di configurazione. In tal caso, la direttiva nell'esempio verrà trasformata nella seguente configurazione nel file di configurazione globale. Ad esempio, potresti impostare le seguenti scorciatoie per i comandi più comuni:

 $ git config --global alias.co checkout $ git config --global alias.br branch $ git config --global alias.ci commit $ git config --global alias.st status

Comandi per eseguire e annullare le modifiche

STATO

Questo è il comando che useresti se volessi visualizzare lo stato dell'area di staging e la tua configurazione di lavoro. Usandolo, puoi vedere quali alterazioni sono state messe in scena e quali no.

AGGIUNGERE

Prima di impegnare il tuo file modificato o nuovo, deve essere aggiunto alla tua area di staging. Fallo eseguendo una direttiva git add . Devi passare il nome del file e della directory come parametro. Puoi inserire f_tuo_file>. A quel punto, il tuo file verrà rimosso dall'elenco delle "modifiche da confermare".

L'aggiunta di -p (o —patch) consente di selezionare parti di ciascun file tracciato per il commit. Quindi ogni commit contiene solo le modifiche correlate.

COMMETTERE

Supponiamo che tu abbia completato l'implementazione di alcune funzionalità e desideri salvare le modifiche. Guarda l'elenco delle "modifiche da confermare". Una volta fatto, saprai che tutti i file necessari sono stati messi in scena. Questo è quando puoi eseguire git commit .

Dopo aver eseguito questo comando, si aprirà l'editor predefinito. Dovresti quindi inserire il tuo messaggio COMMIT.

Se il tuo messaggio è breve, includilo nel comando GIT COMMIT come segue:

 git commit -m “Your_first_commit_message.”

Puoi anche aggiungere l'opzione -a. In questo modo, puoi assicurarti che GIT esamini il tuo albero di lavoro. Quindi eseguirà GIT ADD per i file nuovi e modificati, nonché git rm per tutti i file eliminati prima del commit.

Forse hai dimenticato di aggiungere un file al tuo commit. Non vuoi creare un altro comando commit per quel file. Puoi invece utilizzare un'opzione di modifica.

I commit pubblici non dovrebbero mai essere modificati. Ricorda che i tuoi colleghi potrebbero aver basato il loro lavoro su quel commit. Non vuoi confonderli a causa di eventuali modifiche che hanno apportato.

RIPRISTINA

git reset è un altro strumento che dovrebbe esserti utile mentre inizi la tua vita lavorativa come sviluppatore. Questo è un comando che ti aiuta a riformattare le modifiche. Esistono diversi modi in cui può essere utilizzato, ma un esempio comune è quando fornisci una modalità e l'identificazione del commit come se ci fossero argomenti, come questo:

 git reset <mode> <commit>.

Esistono diverse possibilità di ripristino. Per capirli, dovresti essere a conoscenza dei tre alberi GIT.

SCORTA

Diciamo che hai lavorato per un po' di tempo su una certa area di funzionalità. Vedi che c'è un bug che deve essere corretto proprio in quel momento. Ma le implementazioni delle tue funzionalità sono ancora in corso e non vuoi infliggere alcuna modifica al ramo incompiuto. Il tuo comando git stash è ciò di cui avrai bisogno.

Questo metodo ti consente di mantenere le tue modifiche nello stack STASH. Successivamente, puoi crearne un elenco, insieme all'elenco git stash.

Non ci sono restrizioni per il ramo su cui puoi applicare la tua scorta. Puoi nascondere le modifiche in un ramo e applicarle a un altro quando lo desideri.

Per rendere effettive le modifiche memorizzate, usa la tua direttiva git stash apply. Applica le modifiche più recenti memorizzate nello stack. Se desideri applicare modifiche precedenti, puoi specificare il nome come git stash apply [email protected]{1}. Questo vale per un'altra scorta nella pila.

Una volta applicato uno stash utilizzando una direttiva apply, non verrà rimosso da quello stack. Puoi visualizzarlo come un comando di flusso GIT che utilizzerai frequentemente.

Ti potrebbe piacere: Quali sono le tendenze sullo sviluppo di applicazioni mobili nel 2020?

RITORNO

Forse hai ritenuto opportuno spingere le tue modifiche completate al suo ramo originale e hai notato che uno dei tuoi commit non aveva bisogno di essere lì. Risolvilo aggiungendo un'altra direttiva che eliminerà quella precedente. La direttiva REVERT ti assiste in questo. Devi specificare il tuo commit id e annullare come parametro: git revert <commit_id> .

Il comando rileverà informazioni utili, incluso il nome del ramo, il numero di commit effettuati dopo o prima che diventasse remoto. Inoltre, puoi vedere i file nuovi e modificati come elenchi multipli:

Comandi Git per gli sforzi del team

RAMO

Con le direttive git branch , il tuo sistema utilizzerà l'elenco dei rami. Se vuoi guardare i rami remoti, allora il ramo git -r è come lo fai. Se desideri vedere rami locali e remoti, usa git branch -a.

Puoi eliminare un ramo usando: git branch -d <branch_name>.

Check-out

Questa è un'altra direttiva GIT usata regolarmente. Per lavorare nel ramo, devi eseguire uno switch. git checkout è il modo in cui si passa facilmente da un ramo a un altro. Potresti usarlo per esaminare i file, così come i commit. Git checkout <name-of-your-branch> è come viene eseguito.

Ricorda quanto segue se vuoi passare da un ramo all'altro con successo:

Le modifiche nel ramo corrente possono essere salvate o nascoste quando si passa

Qualsiasi filiale che controlli deve esistere nel tuo locale

C'è anche un comando di scelta rapida che ti consente di creare e passare a un ramo in una volta:

 git checkout -b <name-of-your-branch>.

Questo è un comando che crea una direttiva diversa nel tuo locale (-b sta per il ramo). Esamina l'ultimo ramo subito dopo che è stato creato.

TIRO

Con la direttiva git pull , esegui un nuovo download di dati attraverso un repository remoto e un'integrazione con quello più vicino. Quando esegui questo comando, aggiorni i rami locali, insieme a qualsiasi modifica dal tuo terminale remoto.

Esiste un modo predefinito per integrare anche le nuove modifiche. Usa un'unione. Puoi cambiarlo in rebase se usi l'opzione: git pull –rebase .

Si consiglia di inserire sempre le modifiche in un repository vicino pulito senza modifiche non salvate.

COMMETTERE

Questa è una direttiva che potrebbe "istantanea" o registrare il file nella cronologia delle versioni. Inserisci git commit -m "[ Digita il messaggio di commit]" usandolo.

È il comando che esegue il commit di tutti i file aggiunti, insieme al comando GIT ADD. Inoltre salva efficacemente i file che sono stati modificati da allora.

SPINGERE

Dopo aver commesso eventuali modifiche, probabilmente vorrai eseguire il push in un repository remoto. In questo modo, sono disponibili per i tuoi compagni di squadra.

Se esegui GIT PUSH, ciò "spingerà" le modifiche recenti di un'area corrente al suo telecomando. Se attraverso la creazione di un ramo in locale, spingi l'intero ramo in un repository remoto, va bene. Questa direttiva ti consente di farlo: git push -u origin <replace_with_branch_name> .

Questo è il modo in cui invii un ramo con un nome specificato al repository di origine. Il ramo remoto dovrebbe utilizzare lo stesso nome di quello locale.

UNISCI

Abbiamo anche dovuto inserire MERGE in questo elenco di prompt GIT. A un certo punto vorrai integrare il feature branch o correggere eventuali bug su un altro branch. L'unione del tuo ramo ti consente di farlo. L'esecuzione di un comando git merge è ciò che devi fare.

Dopo aver eseguito il comando, possono verificarsi due tipi di unione: l'unione a tre vie o l'avanzamento rapido.

Un'unione veloce è per quando c'è un percorso lineare tra i rami che desideri unire. Diciamo che hai creato un ramo bugfix dal master. Hai risolto il problema e vorrai unirlo in un master. Tuttavia, nessuno ha effettuato un aggiornamento del ramo. GIT può unire un ramo stesso, il che risolverà il problema.

Un'unione a tre vie si verifica quando non esiste un percorso lineare tra i rami. Come con l'ultimo esempio, hai ideato un ramo per la correzione di bug dalla versione principale. Hai corretto il bug e ora devi unirlo con git merge <branch> .

Forse scopri che qualcuno ha aggiornato il master. Per connettere i rami, GIT deve creare un nuovo commit in cui si combinano le modifiche.

È allora che nasce un problema. Entrambi i rami hanno cambiato il blocco di codice identico. GIT non può mescolare insieme le modifiche senza il tuo aiuto. Accettare una modifica è il modo più semplice per farlo.

Tuttavia, puoi anche combinare le modifiche. Quando ciò si verifica, GIT modifica i file interessati con alcuni indicatori visivi. Ciò consente di individuare facilmente i problemi. Vengono utilizzati alcuni indicatori visivi:

 <<<<<< — shows the place the conflict began ====== — separates changes from different branches >>>>>> — shows where the conflict ends

Una volta risolti i conflitti ed eliminati i marcatori, le aree in conflitto verranno aggiunte alla tua area di staging con git add .

Se è stato commesso un errore o vuoi andare in una direzione diversa, esegui git merge –abort. In questo modo, il tuo ramo non verrà modificato.

In caso contrario, usa i comandi git commit. Concluderà l'unione, creando un nuovo commit.

Un altro comando utile è il comando git mergetool che avvia semplicemente un assistente di unione esterno in caso di problemi con un'unione in Git.

Ti potrebbe piacere anche: Miglior linguaggio di programmazione per lo sviluppo di app iOS.

REBASE

Integra le modifiche utilizzando prima REBASE e poi unisci. Con REBASE, stai riscrivendo il retroscena del programma. I commit pubblici non dovrebbero mai essere ribasati poiché, ad esempio, un membro del team potrebbe basare il proprio lavoro su di essi.

Invece di scegliere di unire un ramo specifico al tuo, puoi ribasare il tuo ramo su uno specifico. Ma cos'è che sta facendo questo protocollo rebase che stai usando?

Ciò che accadrà è che le modifiche otterranno l'integrazione da un ramo specifico in un altro. La base del secondo ramo verrà modificata da un commit a un altro. Sembrerà che il secondo ramo sia stato creato dal primo. Questo ti dà una cronologia chiara e lineare.

Git rebase <name_of_branch_to_rebase_on> è il modo in cui esegui il comando.

Questa è la prima o modalità standard del comando rebase. Poi c'è la seconda modalità, detta anche modalità interattiva. Puoi usarlo per modificare facilmente una sequenza di commit prima di includerli in un altro ramo, altrimenti noto come remoto.

Dopo aver commesso i comandi

TRONCO D'ALBERO

Questa direttiva serve per elencare la cronologia delle versioni del ramo corrente. Per eseguirlo, inserisci git log –follow[file] .

Questa direttiva elenca una cronologia delle versioni del file. La ridenominazione dei file sarà inclusa. git log stampa una cronologia dei commit.

Diverse opzioni possono essere utilizzate in questo scenario. Uno di questi è git log –stat. Per ogni commit nella cronologia, verrà stampato un elenco di nomi. I file che sono stati rimossi, modificati o aggiunti saranno accessibili. È possibile visualizzare gli importi delle righe che sono stati rimossi o aggiunti. Noterai che c'è anche un riepilogo che puoi esaminare.

SPETTACOLO

Il prompt Mostra utilizzato dagli sviluppatori può mostrare i dettagli per vari oggetti. Quando diciamo "oggetti", stiamo parlando di commit o tag. git show può essere utilizzato per visualizzare una versione precedente del file. Ad esempio, potresti usare questo comando per mostrare una versione di un file da due commit fa.

Si spera che questo tutorial sui comandi GIT abbia contribuito a fungere da introduzione a questo strumento. Come sviluppatore, più impari su GIT, migliore sarà la tua posizione per essere assunto da un team alla ricerca di un programmatore affidabile.

Man mano che diventi più avanzato in questo campo, imparerai più suggerimenti GIT e la tua programmazione diventerà molto più fluida. Sarai in grado di scrivere codice utilizzabile che può essere aggiunto dai tuoi compagni di squadra.

 Questo articolo è stato scritto da Slava Vaniukov. È co-fondatore e CEO di Softermii, agenzia di sviluppo di software e app. Ha oltre 9 anni di esperienza nel settore dello sviluppo web e mobile. Oltre a ciò, è uno degli autori del blog Softermii e blogger tecnologico presente in una vasta gamma di altre risorse web. Puoi seguirlo su LinkedIn.