Share
Stai già utilizzando il controllo del codice sorgente per la gestione del codice, giusto? Potresti persino utilizzare il tuo SCM come parte centrale del tuo flusso di lavoro, come facciamo con New Relic.
In questo articolo, non esamineremo le nozioni di base sulla gestione del controllo del codice sorgente, a prescindere dal suo utilizzo. Supponiamo che tu sappia già come muoverti. Quello che copriremo è come i professionisti usano git. Daremo un'occhiata ad alcune delle funzionalità e dei flussi di lavoro avanzati che potresti non avere già familiarità con. Spero che te ne andrai con la bocca aperta per le sole possibilità che offre!
Se sei come me, ti piace esplorare come funzionano gli altri sviluppatori.
Per chi non lo sapesse o per chi proviene da un altro SCM, Git è un sistema di controllo della versione distribuito. È gratuito e open source, ha un ingombro minimo e può adattarsi al flusso di lavoro più adatto a te. Generalmente, non ti obbliga a lavorare in un modo particolare, il che significa che ci sono molte metodologie differenti su come usare le sue funzionalità, come le aree di staging, le branching e le uscite di tagging. Se sei come me, ti piace esplorare come funzionano gli altri sviluppatori. Quindi preparati a iniziare a modificare il tuo .gitconfig, perché sei pronto per una festa. Vediamo come i professionisti usano git.
Probabilmente hai familiarità con la modifica accidentale di un singolo file per due diversi motivi senza impegnarti in mezzo.
Hai certamente familiarità con l'aggiunta di file all'area di staging con il nome appropriato Inserisci comando. E probabilmente hai familiarità con la modifica accidentale di un singolo file per due diversi motivi senza impegnarti in mezzo. Quindi avrai sicuramente un log git pieno di messaggi come "Modifica X e modifica Y non correlata". Se questo sembra il tuo flusso di lavoro, l'aggiunta interattiva è il tuo nuovo migliore amico.
L'aggiunta interattiva, o l'aggiunta di una patch, ti guida attraverso le modifiche di un singolo pezzo alla volta. Quando aggiungi un file con -p comando, ti verrà richiesto ad ogni cambio logico (cioè, le linee modificate successivamente saranno raggruppate insieme). Ci sono un certo numero di scelte che puoi fare su ogni pezzo, dalla suddivisione del pezzo corrente in pezzi più piccoli, saltare un pezzo, o anche modificarlo manualmente. Utilizzare il ? opzione per vedere un elenco completo di comandi.
Iniziare con gli hunk staging è semplice come:
git aggiungi -p
Come un buon cittadino di codice, quando ti imbatti in qualcosa che ha bisogno di una soluzione rapida o di una pulizia, probabilmente dovresti prendere un momento per cambiarlo. Ma se si sta utilizzando un flusso di lavoro con funzionalità speciali, non si desidera una correzione non correlata nel ramo delle funzionalità. Questo significa che dovrai farlo scorta le tue modifiche attuali, passa al tuo ramo principale e poi fai la correzione lì. Rimbalzare tra i rami può essere noioso, ma, fortunatamente, c'è una scorciatoia rapida per passare all'ultimo ramo. (via Zach Holman)
git checkout -
Questa sintassi dovrebbe apparire abbastanza familiare agli utenti * NIX. Il CD comando ha una scorciatoia simile (CD -) che salterà all'ultima directory in cui ti trovavi. Non dovrai mai ricordare cosa hai chiamato quel ramo di funzionalità quando devi tornare indietro; appena git checkout -.
Quando si lavora con i rami di feature, è possibile creare rapidamente così tanti che ingombrano l'output di git branch --list. Ogni tanto vuoi sbarazzarti dei rami che sono diventati padroni. Ma probabilmente hai una breve pausa prima di te git branch -d , ma con i comandi sottostanti puoi tranquillamente cancellarli senza pensarci due volte. (via Zach Holman)
Se vuoi vedere quali rami locali hai unito al ramo in cui ti trovi attualmente, tutto ciò di cui hai bisogno è:
git branch --merged
È anche disponibile il retro. Mostra quali rami non sono stati uniti nel ramo attualmente selezionato con:
git branch --no-merged
Mash up con un paio di semplici strumenti UNIX e puoi eliminare rapidamente tutto ciò che è già stato unito:
git branch --merged | xargs git branch -d
Diciamo che stai sperimentando alcuni refactoring e hai alcuni rami che hanno vari cambiamenti che hai fatto. Se hai delle modifiche in un file in un ramo distante che vuoi portare nel tuo attuale ramo di lavoro, allora potresti fare un numero qualsiasi di passi. Senza il suggerimento qui sotto, probabilmente stai nascondendo le tue modifiche attuali, cambia succursali e prendi il contenuto del file che vuoi cambiare, torna indietro (con git checkout - ovviamente) e fai le tue modifiche. Oppure puoi semplicemente eseguire il checkout di quel file che lo unirà al tuo attuale ramo (tramite Zach Holman):
git checkout-- path / to / file.rb
Quindi hai la lista di filiali ingombra di cui abbiamo parlato prima; alcuni di quelli che hai ripulito con --fuse bandiera. Ma che dire di tutti quegli altri rami? Come fai a sapere quali sono utili o del tutto obsoleti? Il for-each-ref comando genererà un elenco per ogni ramo e mostrerà le informazioni di riferimento per l'ultimo commit. Possiamo personalizzare l'output per includere alcune informazioni utili, ma, cosa più importante, possiamo ordinare l'elenco per data. Questo comando ci fornirà un elenco di rami con l'ultimo messaggio di commit e committer, ordinati in ordine decrescente. (via Rein Henrichs)
git for-each-ref --sort = -committerdate --format = '% (committerdate: short)% (refname: short) [% (committername)]'
Mentre potresti digitare questo comando ogni volta, ti raccomando caldamente di renderlo un alias e risparmiarti qualche serio mal di testa.
git config --global alias.latest "for-each-ref --sort = -committerdate --format = '% (committerdate: short)% (refname: short) [% (committername)]'"
O almeno non dovrebbero usare prendi la colpa senza uno dei flag di opzioni qui sotto. La colpa di Git è potente; è fondamentalmente come usare la scienza per dimostrare che hai ragione. Ma attenzione, molti cambiamenti sono superficiali e trovare la vera fonte del codice in-domanda richiede un po 'più di caccia. Cose come rimuovendo lo spazio bianco, spostando il testo su nuove linee o persino spostando il testo da un altro file possono essere ignorate per ottenere l'autore originale del codice molto più facilmente.
Prima di dare la colpa a qualcuno, assicurati di controllare uno di questi:
git blame -w # ignora lo spazio bianco git blame -M # ignora il testo in movimento git blame -C # ignora lo spostamento del testo in altri file
Di tanto in tanto, devi dare la caccia a una riga di codice che hai scritto ma che non riesci a trovare. Potrebbe essere bloccato in qualche ramo distante, cancellato molto tempo fa o nascosto in un sito semplice; ma in entrambi i casi è possibile trovare qualsiasi stringa nell'intera cronologia git semplicemente aggiungendo alcuni comandi. Per prima cosa, otterremo una lista di tutti i commit, e poi grep ognuno per la nostra stringa.
git rev-list --all | xargs git grep -F ''
Probabilmente hai un amico che ha accidentalmente commesso dati sensibili su un repo: chiavi di accesso, password, la ricetta segreta di tua nonna marinara. La prima cosa che dovrebbero fare è cambiare le loro password e revocare l'accesso con quelle chiavi (e chiedere scusa a tua nonna). Successivamente, ti consigliamo di dare la caccia al file incriminato e rimuoverlo dall'intera cronologia git, che sembra molto più semplice di quanto non sia in realtà. Una volta completato questo processo, chiunque tocchi le modifiche pulite avrà anche i dati sensibili rimossi. I fork del tuo repository che non uniscono le tue modifiche upstream conterranno comunque i file compromessi (quindi non saltare le password di modifica e revocare le chiavi di accesso).
Innanzitutto, riscriveremo la cronologia git per ogni ramo, rimuovendo il file con i dati sensibili.
git filter-branch --index-filter 'git rm --cached --ignore-unmatch'--prune-empty --tag-name-filter cat - --all
Aggiungi il file a .gitignore e impegnarsi ad aggiornare .gitignore.
eco>> .gitignore git add .gitignore git commit -m "Aggiungi sensibile file per gitignore "
Dato che stiamo riscrivendo la cronologia, dovrai forzare le modifiche al tuo telecomando.
git push origin master --force
I file compromessi sono ancora presenti nel repository locale, quindi è necessario eseguire alcune attività di pulizia per eliminarli completamente.
rm -rf .git / refs / original / git reflog expire --expire = now --all git gc --prune = now git gc --aggressive --prune = now
Il repository dei tuoi amici dovrebbe essere privo di dati sensibili e sarai l'eroe per aiutarli con la tua conoscenza proattiva. (tramite StackOverflow e GitHub)
Lavorare con il codice di qualcun altro nel proprio ambiente può significare che è necessario apportare un numero qualsiasi di modifiche di configurazione per far funzionare l'applicazione. È fin troppo facile commettere accidentalmente una modifica a quelle configurazioni che erano destinate esclusivamente al proprio ambiente. Quindi, invece di stare sempre attenti a quei file e farli indugiare nell'area di staging "modificata", puoi semplicemente dire all'indice di git di ignorare le modifiche a quel file. Puoi pensare a questo in qualche modo come un file git ignorato che rimane con il repository. (via Arnaud Coomans)
git update-index --assume-immutato
A volte partire da zero è esattamente quello che devi fare, per un numero qualsiasi di motivi. Forse hai ereditato un codice base che non puoi garantire sia sicuro per l'open source, forse stai solo provando qualcosa di completamente nuovo, o forse stai aggiungendo un ramo che serve a uno scopo separato che vuoi mantenere con il repo (come GitHub Pages). In questo caso, c'è un modo molto semplice per creare un nuovo ramo nel repository che essenzialmente non ha cronologia. (via Nicola Paolucci)
vai alla cassa --orphan
Smetti di perdere tempo scrivendo comandi lunghi e renditi qualche utile alias.
Nessuna discussione su git sarebbe completa senza parlare di vari alias che letteralmente ti faranno risparmiare minuti all'anno con i tasti salvati. Smetti di perdere tempo scrivendo comandi lunghi e renditi qualche utile alias. Gli alias possono essere creati aggiungendoli al file .gitconfig o utilizzando la riga di comando git config - alias globale.. Di seguito sono riportati alcuni esempi di alias che è possibile utilizzare come trampolino di lancio per le idee.
cO: con un flusso di lavoro di feature branch, ti sposti regolarmente tra i rami. Salva te stesso sei personaggi ogni volta.
co = checkout
ds: è sempre buona pratica esaminare le modifiche che si stanno per eseguire prima di effettuare l'effettivo commit. Ciò consente di rilevare errori di battitura, inclusione accidentale di dati sensibili e il raggruppamento di codice in gruppi logici. Metti in scena i tuoi cambiamenti e poi usali git ds per vedere la differenza di questi cambiamenti.
ds = diff -staged
st: dovresti essere abbastanza familiare con l'output dettagliato di git status. Ad un certo punto vorrai saltare tutte le formalità e metterti al lavoro. Questo alias mostra la forma abbreviata di stato e include i dettagli del ramo.
st = stato -sb
modificare: hai dimenticato di includere un file con il tuo ultimo commit, o forse hai avuto un tweak che dovevi fare? Modifica le modifiche graduali all'ultima commit.
modify = commit --amend -C HEAD
disfare: a volte, modificare l'ultimo commit non è sufficiente e devi annullarlo. Questo alias farà un passo indietro di un commit e lascerà le modifiche da quel commit messo in scena. Ora puoi apportare ulteriori modifiche o ricominciare con un nuovo messaggio.
undo = reset --soft HEAD ^
ls: lavorare su un codebase con un gruppo di sviluppatori significa cercare di stare al passo con ciò su cui le persone stanno lavorando. Questo alias fornirà un log git a una riga che include la data e il nome del committer.
ls = log --pretty = formato: "% C (giallo)% h% C (blu)% ad% C (rosso)% d% C (ripristinato)% s% C (verde) [% cn]" - decorare --data = breve
in piedi: questo alias è ottimo per rivedere ciò che hai lavorato ieri per qualsiasi tipo di alzata quotidiana, o semplicemente per rinfrescare la memoria al mattino.
standup = log --since '1 giorno fa' --oneline --author
grafico: una storia di git complessa può essere difficile da recensire in linea retta. L'uso della bandiera del grafico mostra come e quando i commit sono stati aggiunti al ramo corrente.
graph = log --graph --pretty = format ':% C (giallo)% h% Cblue% d% Creset% s% C (bianco)% an,% ar% Creset'
Git può essere incredibilmente semplice e incredibilmente complesso. Puoi iniziare con le basi e lavorare da solo in una manipolazione del grafico più complessa nel tempo. Non è necessario riempirlo tutto prima di poterlo usare. Il comando che sarà più potente mentre impari è amico-. Prova a utilizzarlo prima di fare riferimento a Google per una risposta.
Puoi imparare di più su come la società che lavoro per te, New Relic, usa git sul nostro blog o dare a New Relic Pro una prova gratuita. Grazie per aver letto! Se avete domande, fatecelo sapere qui sotto!
Accentsconagua