advanced git commands
Questo tutorial esplora comandi Git utili come Git Stash, Git Reset, Git Cherry Pick, Git Bisect e spiega come integrare GitHub con Jira:
Nei nostri tutorial precedenti di questa serie, abbiamo visto la maggior parte delle funzionalità di GitHub.
In questo tutorial, esamineremo quanto segue:
- Creazione di versioni
- Integrazione con Atlassian Jira
- Comandi Git più comunemente usati per gli sviluppatori
- Git Stash
- Git Cherry Pick
- Git Reset
- Git Bisect
=> Dai un'occhiata alla guida di GitHub qui.
cosa non riesce a trovare l'analisi statica
Cosa imparerai:
- Creazione di versioni
- Integrazione di GitHub con Jira
- Comandi Git avanzati per sviluppatori
- Conclusione
- Lettura consigliata
Creazione di versioni
Le versioni in GitHub vengono utilizzate per raggruppare il software, aggiungere note di rilascio e file binari (file WAR, EAR, JAR) affinché i clienti e le persone utilizzino lo stesso.
Per creare una versione, vai alla pagina principale del repository e fai clic su Rilasci scheda sotto Gestisci argomenti.
Clicca su Crea una nuova versione.
Fornisci un tag e un titolo di rilascio. Anche i file binari vengono aggiunti alla versione. Una volta fatto clic su Pubblica rilascio.
La versione è ora pronta con il codice sorgente e i binari.
Integrazione di GitHub con Jira
Uno degli aspetti importanti della tracciabilità è fare riferimento al problema di Jira con i commit in GitHub. GitHub può essere integrato con Jira non solo per fare riferimento al problema, ma anche per creare branch e pull Request dall'interno di Jira.
Quindi, in genere, una volta che lo sviluppatore inizia a lavorare sull'attività o sui bug, viene creato un ramo da lui. Dopo lo sviluppo o la risoluzione dei bug, è possibile creare una richiesta pull da Jira per unirla al main maestro ramo. Il ramo creato dallo sviluppatore può quindi essere eliminato.
Per impostare l'integrazione, abbiamo utilizzato un plugin Integrazione Git per Jira. Questo è un plugin commerciale. Il plugin può essere scaricato da Qui
Installa il plugin in Jira da Amministratore -> Componenti aggiuntivi.
Una volta installato il plugin, vai a Applicazione -> Archivi Git e connettiti a GitHub.
Immettere il nome utente e la password di GitHub. Clic Collegare .
Verranno visualizzati i repository menzionati per l'account utente. Clicca su Importa archivi per completare la configurazione dell'integrazione.
GitHub si impegna con Jira Issue
Come parte del messaggio di commit, immettere come mostrato di seguito. Clicca su Effettua modifiche .
Esempio 1: Di seguito è riportato un esempio di Smart Commit che consente agli sviluppatori di eseguire azioni sui problemi Jira dal messaggio di commit. Uno di questi comandi è il #commento insieme alla chiave Issue che aggiunge il commento al problema Jira come mostrato di seguito.
Sezione commenti aggiornata.
Esempio 2: Assegna a un utente e aggiorna il tempo impiegato come 4 h.
Usa il #assegnare e #tempo comando smart commit nel messaggio di commit.
Entrambe le azioni sono state completate.
Esempio 3: Modifica lo stato del problema in In corso .
Crea un ramo
Man mano che attività e bug vengono assegnati agli sviluppatori, è necessario che inizino a lavorare sullo sviluppo. Per questo creano un ramo per il problema su cui stanno lavorando, svolgono le attività di sviluppo e sollevano una richiesta pull per unirsi al ramo principale.
Nel numero di Jira in basso fare clic su Crea ramo.
Clicca su Crea ramo.
In GitHub, apporta una modifica al file nel ramo creato sopra e salva lo stesso.
Quando lo sviluppo è completato, l'utente può quindi sollevare una richiesta di pull da Jira.
In fondo al numero, fai clic su Crea richiesta pull.
Clicca su Creare. La richiesta di pull verrà visualizzata come aperta.
Il passaggio successivo consiste nell'unire la richiesta pull in GitHub.
Lo stato viene aggiornato di conseguenza a Jira.
Comandi Git avanzati per sviluppatori
In quest'ultima sezione, esamineremo alcuni dei comandi Git comunemente usati dagli sviluppatori. Niente a che vedere con GitHub, ma aiuterà gli sviluppatori prima di inviare le modifiche a GitHub.
Git Stash
Nella maggior parte degli scenari di progetto quando si lavora a una nuova funzionalità o miglioramento, improvvisamente ci sarebbe bisogno di lavorare su un difetto urgente che è stato segnalato ed è un ostacolo allo spettacolo. Dato che sei a metà del tuo nuovo lavoro e non lo hai completato, non ha senso eseguire i cambiamenti che sono a metà.
Quindi, è meglio sospendere o salvare temporaneamente il lavoro a metà, lavorare sul bug e tornare a lavorare sulla nuova funzionalità o miglioramento. Git stash fornisce una soluzione a questo. Puoi cambiare facilmente il contesto in cui eseguire le modifiche rapidamente.
Esempio 1 :Supponi di lavorare su un'attività assegnata a te e quando guardi lo stato, mostra che non è tracciato al momento.
All'improvviso ti viene assegnato un bug ad alta priorità. Pertanto, dobbiamo salvare o nascondere temporaneamente il lavoro su cui si sta lavorando.
Esegui il seguente comando.
git stash save 'Message'
In questo momento la directory di lavoro è pulita. È possibile effettuare qualsiasi nuovo commit e se ci sono bug, puoi cambiare ramo per lavorarci su ecc.
Quando vuoi riapplicare le modifiche dove avevi lasciato, usa il comando.
git stash pop
Il comando precedente rimuoverà la scorta dall'elenco e applicherà l'ultimo stato salvato.
Puoi anche usare:
git stash apply
Il comando precedente manterrà le modifiche nella scorta e non le rimuoverà.
Ora le modifiche vengono applicate nuovamente e puoi eseguire il commit delle modifiche.
Esempio 2: Conserva le modifiche, cambia ramo e unisci le modifiche.
Apporta la modifica al file Html in maestro modifiche al ramo e alla scorta.
Il prossimo è passare al bug branch, apportare modifiche e eseguire il commit delle modifiche.
git checkout -b bug
Apporta le modifiche al file Html.
git commit -a -m 'Risolto problema di posta elettronica'
Torna al file maestro branch e riapplicare le modifiche dalla scorta.
Ora unisci da bug ramo al maestro ramo. Effettua il commit delle modifiche dopo l'unione.
Esempio 3: Lavorare con Multiple Stash.
Nel repository locale sono presenti 2 file Html. Pertanto, è possibile che più sviluppatori lavorino su più file e memorizzino le modifiche necessarie per lavorare su richieste urgenti che arrivano per correggere le modifiche.
Lo sviluppatore 1 funziona su hello.html e lo sviluppatore 2 funziona su index.html.
Sviluppatore 1
La lista nascosta ha 1 voce ora.
Sviluppatore 2
La lista delle scorte ora ha 2 voci. L'ultima scorta è la prima nella pila che è stash @ {0}. Ora entrambi gli sviluppatori possono eseguire urgentemente qualsiasi altro commit o lavorare su qualche altro ramo e poi tornare al maestro branch e applicare le modifiche alla scorta.
Per applicare l'ultima scorta, puoi semplicemente correre
git stash pop
Per applicare una specifica scorta nello stack eseguire il seguente comando.
git stash pop stash @ {1}
Applichiamo la seconda scorta che è scorta @ {1}
Allo stesso modo, è possibile applicare l'altra scorta.
Git Cherry Pick
Oggi, gli sviluppatori lavorano su più rami come funzionalità, miglioramento, bug, ecc.
Ci sono situazioni in cui è necessario selezionare solo un paio di commit specifici e non unire l'intero ramo in un altro ramo. Questo si chiama Cherry Pick. Questo processo ti consente di scegliere arbitrariamente qualsiasi commit Git dagli altri rami e aggiungerlo all'attuale HEAD dell'albero di lavoro.
Esempio 1:
Nel repository git locale, abbiamo i seguenti 6 file.
Un file viene eliminato, ad esempio file5.txt.
Applica le modifiche.
Guarda il registro adesso. File5.txt viene eliminato.
Quindi, vogliamo Cherry-Pick il commit in cui abbiamo aggiunto file5.txt. Dobbiamo trovare l'id del commit di file5.tx ed eseguire il comando.
git cherry-pick
In questo caso, l'id del commit di quando è stato aggiunto file5.txt è a2f0124
File5.txt è ora ripristinato. Abbiamo scelto il commit.
Esempio 2:
Modifichiamo solo file6.txt e eseguire il commit delle modifiche nel file maestro ramo.
Guarda la seconda riga file6.txt dove l'email non è specificata correttamente.
Crea un ramo di bug e risolvi il problema. Allo stesso tempo, modifica anche file5.txt in modo da avere più commit eseguiti nel ramo bug, ma Cherry-Pick solo il commit fatto in file6.txt.
File6 modificato in bug ramo.
Quindi, nel complesso, abbiamo apportato modifiche a file5 e file6 nel ramo Bug.
Torniamo ora al maestro branch e Cherry-Pick il commit fatto solo per file6.txt.
Come puoi vedere, invece di unire il file bug ramo nel maestro branch, abbiamo appena selezionato Cherry solo un commit specifico e applicato nel ramo master.
Git Reset
Git reset è un potente comando per annullare le modifiche locali. Quindi, per annullare lo stage, tutti i file di staging viene utilizzato questo comando.
Esempio
Modificare un file e aggiungerlo allo staging. Reimpostare utilizzando il comando come mostrato quando le modifiche staged non sono in stage.
Parametri di git reset comando.
–Soft: Questo parametro indicherà HEAD a un altro commit. Tutti i file vengono modificati tra l'HEAD originale e il commit verrà gestito. La directory di lavoro è intatta.
Guarda la posizione attuale di HEAD.
Torniamo indietro di 5 commit nella storia.
Effettua nuovamente il commit delle modifiche.
-misto: L'opzione è simile al parametro soft. Di solito, quando ci sono dei commit errati, li rimuovi, li aggiusti in un secondo momento e li salva. Quindi, essenzialmente, dobbiamo aggiungere all'indice usando git add poi git commit. Le modifiche vengono lasciate nell'albero di lavoro.
Torniamo indietro di 2 commit nella cronologia e vediamo che i file non sono tracciati.
Ora aggiungi i file allo staging e salva le modifiche.
-difficile: Questo parametro si fermerà al punto in cui esisteva un particolare file. Le modifiche non saranno disponibili nell'albero di lavoro.
Guardando il registro sopra, torniamo al punto in cui è stato eseguito il commit solo del file 1, ovvero l'ultima voce.
Utilizzando git reset –hard
Git Bisect
Trova il commit esatto che ha infranto il codice (dopotutto siamo tutti esseri umani). Spesso durante il test dell'applicazione, sentiamo dai nostri tester che c'è un bug o che la funzionalità non funziona e tu, come sviluppatore, dirai che ha funzionato la scorsa settimana. Allora, cosa è successo e perché è apparso questo bug?
A volte una modifica nell'altro codice potrebbe aver influito sulla tua funzionalità. Devi passare del tempo a esaminare la cronologia in cui ci sono molti commit che richiedono tempo e sono difficili da tracciare quale modifica ha causato l'interruzione del codice.
Git Bisect è il comando per trovare il commit esatto quando è stato introdotto il bug. Con Git bisect devi scegliere due commit, uno buono e uno cattivo. Verrà eseguito il check out a circa metà strada tra i due commit. Controlli ogni commit sia cattivo che buono finché non viene trovato il commit che ha causato l'interruzione del bug o del codice.
Esempio:
- Crea un nuovo repository git locale e crea un file chiamato index.html
- Contenuto iniziale del file come mostrato.
- Aggiungi alla gestione temporanea e invia al repository.
- Crea una cronologia dei commit come mostrato, in modo che possiamo scegliere tra commit buoni e cattivi. Ora, al termine del commit iniziale, eseguire le altre modifiche come mostrato e eseguire il commit lo stesso. Complessivamente, faremo 7 commit.
Secondo cambiamento
Terzo cambiamento
Quarto cambiamento
Quinto cambiamento
Sesto cambiamento
Settimo cambiamento
Fermiamoci qui. Quindi, abbiamo sette commit.
Se guardi la pagina Html, le righe dopo 'Tutti i 4 eventi ...' sono sbagliate e quindi la documentazione non è corretta. Quindi, dobbiamo trovare il commit in cui è stato introdotto l'errore in modo da poter riposare la nostra HEAD su quel commit.
Diamo un'occhiata al registro e scopriamo il male e buon impegno.
L'ultimo commit non è corretto, quindi può essere un cattivo commit. Il commit è stato introdotto dopo il terzo commit, quindi possiamo avere il file Terzo cambiamento come buon impegno.
Il processo di bisecatura inizia con git bisect start e termina con git bisect reset.
git bisect male // Poiché l'ultimo commit è sbagliato. Non è necessario fornire l'ID commit.
git bisect buono
Ora puoi vedere che HEAD è ora a metà tra il cattivo e il buono commit.
Guarda il contenuto di index.html e vedi se c'è un buon commit. In caso contrario, l'errore non viene ancora trovato.
Non proprio che l'errore esista ancora. L'ultima riga è sbagliata. Quindi, corriamo ' git bisect bad '. C'è ancora un cattivo commit e il contenuto corrente non è accettabile.
Il contenuto di cui sopra è corretto e accettabile.
Esegui 'git log –oneline' e 'git bisect good'.
Così la Quinto cambiamento è stata la prima cattiva commessa e davvero così. L'errore viene identificato.
Il contenuto corrente dovrebbe essere nella documentazione finale.
Quando viene identificato il bad commit, puoi informare lo sviluppatore di correggere le modifiche che potrebbero essere il ripristino della testina al quarto cambiamento che era l'ultimo buon commit.
Correre ' git bisect reset 'Per terminare il processo.
Conclusione
In questo manuale pratico di GitHub, abbiamo cercato di coprire tutto ciò su cui uno sviluppatore avrebbe bisogno per lavorare, ad esempio dal controllo della versione e dal punto di vista del tracciamento.
Nei primi tre tutorial della serie GitHub abbiamo appreso le attività di controllo della versione, la creazione di repository, pull request, branch, code review, organizzazioni e team, fork di un repository, etichette, milestone, issue, project board, wiki, release, integrazione con Jira e alcuni comandi Git comunemente usati per gli sviluppatori.
Speriamo davvero che tutti gli sviluppatori trovino utile questo approccio pratico per GitHub e i comandi Git nei loro progetti.
=> Leggi la serie di formazione Easy GitHub.
Lettura consigliata
- Tutorial sull'integrazione di GitLab Jira
- Comandi Unix: comandi Unix di base e avanzati con esempi
- Integrazione del selenio con GitHub utilizzando Eclipse
- Tutorial sull'integrazione di JIRA e SVN
- Git vs GitHub: esplora le differenze con esempi
- Esercitazione sul selenio di cetriolo: integrazione del driver Web di selenio Java di cetriolo
- Tutorial su GitHub per sviluppatori | Come utilizzare GitHub
- Tutorial su Unix Pipes: Pipes nella programmazione Unix