Ok, dopo aver visto questo post di PJ Hyett , ho deciso di saltare fino alla fine e andare con Git .

Quindi quello di cui ho bisogno è una guida pratica per principianti a Git. "Principiante" viene definito come qualcuno che sa come gestire il proprio compilatore, comprende a un certo livello cos'è un Makefile e ha toccato il controllo del codice sorgente senza capirlo molto bene.

"Pratico" viene definito come questa persona non vuole entrare nei dettagli riguardo a ciò che Git sta facendo in background e non gli importa nemmeno (o sa) che sia distribuito. Le tue risposte potrebbero suggerire le possibilità, ma prova a puntare al principiante che desidera mantenere un repository "principale" su un "server" di cui è stato eseguito il backup e la sicurezza e considerare il loro repository locale come una semplice risorsa "client".

Così:

Installazione / Configurazione

• Come installare Git
• Come si configura Git? Prova a coprire Linux, Windows, Mac, pensa alla mentalità "client / server".
  • Installa GIT Server con Msysgit su Windows
• Come si crea un nuovo progetto / repository?
• Come si configura per ignorare i file (.obj, .user, ecc.) Che non fanno realmente parte della base di codice?

Lavorare con il codice

• Come si ottiene l'ultimo codice?
• Come controlli il codice?
• Come si impegnano le modifiche?
• Come vedi cosa non è stato eseguito il commit o lo stato della tua base di codice corrente?
• Come si distruggono gli impegni indesiderati?
• Come si confrontano due revisioni di un file o il file corrente e una revisione precedente?
• Come vedi la cronologia delle revisioni di un file?
• Come gestite i file binari (documenti visio, ad esempio o ambienti di compilazione)?
• Come unire i file modificati allo "stesso tempo"?
• Come si annulla (ripristina o ripristina) un commit?

Tagging, branching, release, baseline

• Come si fa a 'contrassegnare' 'tag' o 'rilasciare' un particolare insieme di revisioni per un particolare insieme di file in modo da poterlo sempre estrarre in seguito?
• Come si estrae una particolare "versione"?
• Come si ramifica?
• Come si uniscono i rami?
• Come risolvere i conflitti e completare l'unione?
• Come si uniscono parti di un ramo in un altro ramo?
• Che cos'è il rebasing?
• Come posso tracciare filiali remote?
• Come posso creare un ramo su un repository remoto?
• Come posso eliminare un ramo su un repository remoto?
• Esempi di flusso di lavoro Git

Altro

• Descrivi e collega a una buona interfaccia grafica, plug-in IDE, ecc. Che rende Git una risorsa non a riga di comando, ma ti preghiamo di elencarne i limiti e la validità.
  • msysgit - Cross platform, inclusa con Git
  • gitk - Visualizzatore cronologico multipiattaforma, incluso in Git
  • gitnub - Mac OS X
  • gitx - Visualizzatore della cronologia di Mac OS X.
  • smartgit : multipiattaforma, commerciale, beta
  • tig - console GUI per Linux
  • qgit - GUI per Windows, Linux
  • Estensioni Git - pacchetto per Windows, include un'interfaccia grafica intuitiva
• Qualche altro compito comune che un principiante dovrebbe conoscere?
  • Git Status ti dice cosa hai appena fatto, quale ramo hai e altre informazioni utili
• Come posso lavorare efficacemente con un repository di sovversione impostato come sorgente di controllo del codice sorgente?

Altri riferimenti per principianti di Git

• Guida Git
• Libro Git
• Git magia
• gitcasts
• Guide GitHub
• Tutorial Git
• Progit - libro di Scott Chacon
• Git - SVN Crash Course
• Git dal basso verso l'alto
• Pronto
• gitref.org
• Chitheet visivo Git

Scavando in Git

• Comprensione concettuale di Git
• Git per informatici (e un'altra versione )

Di tanto in tanto esaminerò le voci e le 'sistemerò' in modo che abbiano un aspetto / aspetto coerente ed è facile scansionare l'elenco - sentitevi liberi di seguire una semplice "intestazione - breve spiegazione - elenco di istruzioni - gotchas e modello "informazioni extra". Collegherò anche le voci dall'elenco dei proiettili sopra, quindi è facile trovarle in seguito.

Come si crea un nuovo progetto / repository?

Un repository git è semplicemente una directory che contiene una .gitdirectory speciale .

Ciò è diverso dai sistemi di controllo versione "centralizzati" (come la sovversione), in cui un "repository" è ospitato su un server remoto, che si trova checkoutin una directory "copia di lavoro". Con git, la tua copia di lavoro è il repository.

Basta eseguire git initnella directory che contiene i file che si desidera tenere traccia.

Per esempio,

cd ~/code/project001/
git init

Questo crea una .gitcartella (nascosta) nella directory corrente.

Per creare un nuovo progetto, esegui git initcon un argomento aggiuntivo (il nome della directory da creare):

git init project002

(This is equivalent to: mkdir project002 && cd project002 && git init)

Per verificare se il percorso corrente corrente si trova all'interno di un repository git, esegui semplicemente git status- se non è un repository, riporterà "fatale: non un repository git"

È inoltre possibile elencare la .gitdirectory e verificare che contenga file / directory simili ai seguenti:

$ ls .git
HEAD         config       hooks/       objects/
branches/    description  info/        refs/

Se per qualsiasi motivo si desidera "de-git" un repository (si desidera smettere di usare git per tracciare quel progetto). Rimuovere semplicemente la .gitdirectory a livello base del repository.

cd ~/code/project001/
rm -rf .git/

Attenzione: questo distruggerà tutta la cronologia delle revisioni, tutti i tuoi tag, tutto ciò che git ha fatto. Non toccherà i file "correnti" (i file che puoi vedere attualmente), ma le modifiche precedenti, i file eliminati e così via saranno irrecuperabili!

GUI per git

Git GUI

Incluso con git - Esegui git guidalla riga di comando e il programma di installazione msysgit di Windows lo aggiunge al menu Start.

Git GUI può fare la maggior parte di ciò che avresti bisogno di fare con git. Compresi cambi di fase, configurazione di git e repository, push di modifiche, creazione / checkout / eliminazione di rami, unione e molte altre cose.

Una delle mie funzionalità preferite sono le scorciatoie "stage line" e "stage hunk" nel menu di scelta rapida, che consente di eseguire il commit di parti specifiche di un file. Puoi ottenere lo stesso tramite git add -i, ma trovo che sia più facile da usare.

Non è l'applicazione più carina, ma funziona su quasi tutte le piattaforme (essendo basata su Tcl / Tk)

Screenshot | uno screencast

gitk

Incluso anche con git. È un visualizzatore della cronologia git e consente di visualizzare la cronologia di un repository (inclusi i rami, quando vengono creati e uniti). È possibile visualizzare e cercare commit.

Si abbina bene con git-gui.

Gitnub

Applicazione per Mac OS X. Principalmente un equivalente di git log, ma ha una certa integrazione con github (come "Network view").

Sembra carino e si adatta a Mac OS X. Puoi cercare nei repository. La più grande critica di Gitnub è che mostra la storia in modo lineare (un singolo ramo alla volta) - non visualizza ramificazioni e fusioni, che possono essere importanti con Git, sebbene si tratti di un miglioramento pianificato.

Download di collegamenti, registro delle modifiche e schermate | repository git

GitX

Intende essere un "clone gitk per OS X".

Può visualizzare la cronologia delle ramificazioni non lineari, eseguire commit, visualizzare e cercare commit e ha alcune altre belle funzioni come la possibilità di "Quicklook" qualsiasi file in qualsiasi revisione (premere spazio nella vista elenco file), esportare qualsiasi file (tramite trascinamento della selezione).

È molto meglio integrato in OS X di git-gui/ gitk, ed è veloce e stabile anche con repository eccezionalmente grandi.

Il repository git originale Pieter non ha aggiornato di recente (più di un anno al momento della scrittura). Un ramo gestito più attivamente è disponibile su Brotherbard / Gitx - aggiunge "barra laterale, recupero, pull, push, aggiungi remoto, unisci, cherry-pick, rebase, clone, clone a"

Scarica | Screenshot | repository git | forchetta fratello | forchetta laullon

SmartGit

Dalla homepage:

SmartGit è un front-end per il sistema di controllo della versione distribuita Git e funziona su Windows, Mac OS X e Linux. SmartGit è destinato agli sviluppatori che preferiscono un'interfaccia utente grafica rispetto a un client da riga di comando, per essere ancora più produttivo con Git, il DVCS più potente oggi.

Puoi scaricarlo dal loro sito Web .

Scarica

TortoiseGit

TortoiseSVN Versione Git per utenti Windows.

Porta TortoiseSVN su TortoiseGit L'ultima versione 1.2.1.0 Questa versione può completare attività regolari, come commit, mostra registro, diff due versioni, crea ramo e tag, Crea patch e così via. Vedi le Note di rilascio per i dettagli. Benvenuti a contribuire a questo progetto.

Scarica

qgit

QGit è un visualizzatore di GUI git basato su Qt / C ++.

Con qgit potrai sfogliare la cronologia delle revisioni, visualizzare il contenuto delle patch e i file modificati, seguendo graficamente i diversi rami di sviluppo.

Scarica

gitg

gitg è un visualizzatore di repository git destinato a gtk + / GNOME. Uno dei suoi obiettivi principali è fornire un'esperienza utente più unificata per frontend git su più desktop. Non si tratta di scrivere un'applicazione multipiattaforma, ma di una stretta collaborazione con client simili per altri sistemi operativi (come GitX per OS X).

Caratteristiche

• Sfoglia cronologia delle revisioni.
• Gestire repository di grandi dimensioni (carica repository linux, 17000+ revisioni, meno di 1 secondo).
• Effettua modifiche.
• Metti in scena singoli stage.
• Annulla modifiche.
• Mostra differenze colorate delle modifiche nelle revisioni.
• Sfoglia l'albero per una data revisione.
• Esporta parti dell'albero di una data revisione.
• Fornisci qualsiasi refspec che un comando come 'git log' può capire per costruire la cronologia.
• Mostra e passa tra i rami nella vista cronologia.

Download: rilasci o fonte

Gitbox

Gitbox è un'interfaccia grafica per Mac OS X per il sistema di controllo della versione Git. In una singola finestra vengono visualizzati i rami, la cronologia e lo stato della directory di lavoro.

Le operazioni di tutti i giorni sono facili: metti in scena e metti in scena le modifiche con una casella. Impegna, tira, unisci e spingi con un solo clic. Fare doppio clic su una modifica per mostrare un diff con FileMerge.app.

Scarica

Gity

Il sito web di Gity non ha molte informazioni, ma dagli screenshot lì sembra essere una git gui OS X open source ricca di funzionalità.

Scarica o fonte

meld

La combinazione è uno strumento di diffusione e fusione visiva. È possibile confrontare due o tre file e modificarli in posizione (aggiornamento diff dinamico). È possibile confrontare due o tre cartelle e avviare confronti di file. Puoi sfogliare e visualizzare una copia funzionante dai sistemi di controllo versione più diffusi come CVS, Subversion, Bazaar-ng e Mercurial [ e Git ].

download

Katana

Una GUI Git per OSX di Steve Dekorte.

A colpo d'occhio, vedere quali rami remoti hanno modifiche da estrarre e i repository locali hanno modifiche da spingere. Sono supportate le operazioni git di add, commit, push, pull, tag e reset, così come le differenze visive e la navigazione visiva della gerarchia del progetto che evidenzia modifiche e aggiunte locali.

Gratuito per 1 repository, $ 25 per di più.

Scarica

Sprout (precedentemente GitMac)

Si concentra sul rendere Git facile da usare. Presenta un'interfaccia utente nativa di Cocoa (simile a un Mac), navigazione veloce nel repository, clonazione, push / pull, branch / merging, visual diff, branch remoti, facile accesso al Terminale e altro ancora.

Rendendo le azioni Git più comunemente utilizzate intuitive e facili da eseguire, Sprout (precedentemente GitMac) rende Git facile da usare. Compatibile con la maggior parte dei flussi di lavoro Git, Sprout è ideale per designer e sviluppatori, collaborazione in team e utenti esperti e principianti.

Scarica | Sito web

Torre

Una GUI Git ricca di funzionalità per Mac OSX. Prova gratuita di 30 giorni, $ 59 USD per una licenza per utente singolo.

Scarica | Sito web

EGit

EGit è un fornitore del team Eclipse per il sistema di controllo della versione Git. Git è un SCM distribuito, il che significa che ogni sviluppatore ha una copia completa di tutta la cronologia di ogni revisione del codice, rendendo le query sulla cronologia molto veloci e versatili.

Il progetto EGit sta implementando gli strumenti Eclipse oltre all'implementazione Jit di Java di Git.

Scarica | Sito web

Estensioni Git

Open Source per Windows: installa tutto il necessario per lavorare con Git in un unico pacchetto, facile da usare.

Git Extensions è un toolkit per rendere più intuitivo lavorare con Git su Windows. L'estensione della shell si integra in Esplora risorse e presenta un menu di scelta rapida su file e directory. C'è anche un plugin di Visual Studio per usare git da Visual Studio.

Scarica

Grazie mille a dbr per aver elaborato il materiale git gui.

SourceTree

SourceTree è un client Mac gratuito per Git, Mercurial e SVN. Costruito da Atlassian, la gente dietro BitBucket, sembra funzionare ugualmente bene con qualsiasi sistema VC, il che ti consente di padroneggiare un singolo strumento da utilizzare con tutti i tuoi progetti, tuttavia sono controllati dalla versione. Ricco di funzionalità e GRATUITO.

Esperto pronto e ricco di funzionalità per utenti principianti e avanzati:

Revisionare i changeset in uscita e in entrata. Ciliegia-pick tra i rami. Gestione delle patch, rebase, stash / shelve e molto altro.

Scarica | Sito web

Bene, nonostante il fatto che tu ci abbia chiesto di non "semplicemente" collegarci ad altre risorse, è piuttosto sciocco quando esiste già una risorsa cresciuta (e in crescita) della comunità che è davvero abbastanza buona: il Git Community Book . Seriamente, queste oltre 20 domande in una domanda saranno tutt'altro che concise e coerenti. Il Git Community Book è disponibile sia in formato HTML che PDF e risponde a molte delle tue domande con risposte chiare, ben formattate e sottoposte a peer review e in un formato che ti consente di passare direttamente al tuo problema.

Purtroppo, se il mio post ti disturba davvero, lo eliminerò. Dillo e basta.

Come configurarlo per ignorare i file:

La possibilità di avere git ignora i file che non desideri vengano monitorati è molto utile.

Per ignorare un file o un insieme di file, fornire un modello. La sintassi del pattern per git è abbastanza semplice, ma potente. È applicabile a tutti e tre i diversi file che citerò di seguito.

• Una riga vuota non ignora alcun file, viene generalmente utilizzata come separatore.
• Le righe che fissano con # servono come commenti.
• Il ! il prefisso è facoltativo e annullerà il modello. Qualsiasi modello negato corrispondente corrisponderà a quelli con precedenza inferiore.
• Supporta espressioni avanzate e caratteri jolly
  • Esempio: il modello: *. [Oa] ignorerà tutti i file nel repository che terminano con .o o .a (file oggetto e archivio)
• Se un pattern ha una directory che termina con uno slit git corrisponderà solo a questa directory e ai percorsi sottostanti. Ciò esclude dalla corrispondenza file regolari e collegamenti simbolici.
• Una barra iniziale corrisponderà a tutti i file con quel nome di percorso.
  • Esempio: il modello /*.c corrisponderà al file foo.c ma non a bar / awesome.c

Grande esempio dalla pagina man di gitignore (5) :

$ git status
[...]
# Untracked files:
[...]
#       Documentation/foo.html
#       Documentation/gitignore.html
#       file.o
#       lib.a
#       src/internal.o
[...]
$ cat .git/info/exclude
  # ignore objects and archives, anywhere in the tree.
  *.[oa]
$ cat Documentation/.gitignore
# ignore generated html files,
*.html
# except foo.html which is maintained by hand
!foo.html
$ git status
[...]
# Untracked files:
[...]
#       Documentation/foo.html
[...]

Generalmente ci sono tre modi diversi per ignorare i file non tracciati.

1) Ignora per tutti gli utenti del repository:

Aggiungi un file chiamato .gitignore alla radice della tua copia di lavoro.

Modifica .gitignore in modo che corrisponda alle tue preferenze per le quali i file non dovrebbero / non dovrebbero essere ignorati.

git add .gitignore 

e commetti quando hai finito.

2) Ignora solo per la tua copia del repository:

Aggiungi / Modifica il file $ GIT_DIR / info / exclude nella tua copia di lavoro, con i tuoi schemi preferiti.

Es: la mia copia di lavoro è ~ / src / project1, quindi modificherei ~ / src / project1 / .git / info / exclude

Hai finito!

3) Ignora in tutte le situazioni, sul tuo sistema:

I modelli globali di ignore per il tuo sistema possono essere inseriti in un file chiamato come desideri.

Il mio personalmente si chiama ~ / .gitglobalignore

Posso quindi informare git di questo file modificando il mio file ~ / .gitconfig con la seguente riga:

core.excludesfile = ~/.gitglobalignore

Hai finito!

Trovo che la pagina man di gitignore sia la miglior risorsa per maggiori informazioni.

Come si "tagga" un determinato insieme di revisioni

Come si fa a 'contrassegnare' 'tag' o 'rilasciare' un particolare insieme di revisioni per un particolare insieme di file in modo da poterlo sempre estrarre in seguito?

Usando il git tagcomando

Per semplicemente "taggare" la revisione corrente, dovresti semplicemente eseguire ...

git tag -a thetagname
git tag -a 0.1
git tag -a 2.6.1-rc1 -m 'Released on 01/02/03'

Per elencare i tag correnti, esegui semplicemente git tagsenza argomenti o -l(L minuscola):

$ git tag -a thetagname # and enter a message, or use -m 'My tag annotation'
$ git tag -l
thetagname

Per eliminare un tag, utilizzare il -dflag:

$ git tag -d thetagname 
Deleted tag 'thetagname'
$ git tag
[no output]

Per taggare un commit (precedente) specifico, devi semplicemente ..

git tag [tag name] [revision SHA1 hash]

Per esempio:

git tag 1.1.1 81b15a68c6c3e71f72e766931df4e6499990385b

Nota: per impostazione predefinita, git crea un tag "leggero" (sostanzialmente un riferimento a una revisione specifica). Il modo "giusto" è usare la -abandiera. Questo avvierà il tuo editor chiedendo un messaggio tag (identico a chiedere un messaggio di commit, puoi anche usare il -mflag per fornire il messaggio tag sulla riga di comando). L'utilizzo di un tag annotato crea un oggetto con ID, data, tag (autore) e facoltativamente una firma GPG (utilizzando il -stag). Per ulteriori informazioni al riguardo, consultare questo post

git tag mytagwithmsg -a -m 'This is a tag, with message'

E per elencare i tag con annotazioni, usa il -n1flag per mostrare 1 riga di ciascun messaggio tag ( -n245per mostrare le prime 245 righe di ogni annotazione, e così via):

$ git tag -l -n1
mytagwithmsg    This is a tag, with message

Per ulteriori informazioni, consultare la pagina di manuale git-tag (1)

Esempio di flusso di lavoro con GIT.

Git è estremamente flessibile e si adatta bene a qualsiasi flusso di lavoro, ma non applicare un flusso di lavoro particolare potrebbe avere l'effetto negativo di rendere difficile capire cosa si può fare con git oltre il flusso di lavoro "backup" lineare e quanto utile può essere la ramificazione .

Questo post sul blog spiega bene un flusso di lavoro molto semplice ma efficace che è davvero facile da configurare usando git.

citando dal post del blog: consideriamo origin / master il ramo principale in cui il codice sorgente di HEAD riflette sempre uno stato pronto per la produzione:

Il flusso di lavoro è diventato abbastanza popolare da aver realizzato un progetto che implementa questo flusso di lavoro: git-flow

Bella illustrazione di un semplice flusso di lavoro, in cui si apportano tutte le modifiche allo sviluppo e si spinge al master solo quando il codice si trova in uno stato di produzione:

Ora supponiamo che tu voglia lavorare su una nuova funzionalità o sul refactoring di un modulo. Potresti creare un nuovo ramo, quello che potremmo chiamare un ramo "caratteristica", qualcosa che richiederà del tempo e potrebbe rompere un po 'di codice. Una volta che la funzione è "abbastanza stabile" e si desidera spostarla "più vicina" alla produzione, si unisce il ramo della funzione allo sviluppo. Quando tutti i bug vengono risolti dopo l'unione e il codice ha superato tutti i test in modo solido, si spingono le modifiche in master.

Durante tutto questo processo, trovi un terribile bug di sicurezza, che deve essere risolto immediatamente. Potresti avere un ramo chiamato hotfix, che apporta modifiche che vengono rimandate più rapidamente nella produzione rispetto al normale ramo "sviluppo".

Qui hai un'illustrazione di come potrebbe apparire questa funzionalità / hotfix / sviluppo / flusso di lavoro di produzione (ben spiegato nel post sul blog, e ripeto, il post sul blog spiega l'intero processo in molti più dettagli e molto meglio di me .

Ecco una copia del post di PJ Hyett, in quanto non è più disponibile:

Git non è difficile

23 nov 2008

Quando diciamo alle persone perché dovrebbero usare Git su Subversion, la linea di partenza è: "Git fa Subversion meglio di Subversion, ma fa molto di più."

Il "molto di più" comprende un sacco di cose che fanno davvero brillare Git, ma può essere abbastanza travolgente per coloro che provengono da altri SCM come Subversion.

Detto questo, non c'è nulla che ti impedisca di usare Git proprio come usi Subversion mentre esegui la transizione.

Supponendo che tu abbia installato il software necessario e disponga di un repository remoto da qualche parte, ecco come prendere il codice e rinviare le modifiche con Subversion:

$ svn checkout svn://foo.googlecode.com/svn/trunk foo
# make your changes
$ svn commit -m "my first commit"

E come lo faresti in Git:

$ git clone git@github.com:pjhyett/foo.git
# make your changes
$ git commit -a -m "my first commit"
$ git push

Un altro comando per farlo accadere in Git. Quel comando in più ha grandi implicazioni, ma ai fini di questo post, questo è tutto ciò di cui stiamo parlando, un comando in più.

Vedi, non è poi così difficile.

Aggiornamento: mi dispiacerebbe non menzionare anche che l'equivalente dell'aggiornamento della tua copia locale in Subversion rispetto a Git è svn updatee git pull, rispettivamente. Un solo comando in entrambi i casi.

Come installare Git

Su Windows:

Installa msysgit

Esistono diversi download:

• Git: utilizzare questo a meno che non sia specificamente necessaria una delle altre opzioni di seguito.
• PortableGit: utilizzare questo se si desidera eseguire Git su un PC senza installarlo su quel PC (ad es. Eseguendo Git da un'unità USB)
• msysGit: usalo se vuoi sviluppare Git stesso. Se vuoi solo usare Git per il tuo codice sorgente, ma non vuoi modificare il codice sorgente di Git , non hai bisogno di questo.

Questo installa anche una shell bash di Cygwin, quindi puoi usarla gitin una shell più bella (rispetto a cmd.exe) e include anche git-gui (accessibile tramite git guicomando o Start > All Programs > Gitmenu)

Mac OS X

Usa git-osx-installer , oppure puoi anche installarlo dal sorgente

Tramite un gestore di pacchetti

Installa gitusando il tuo gestore pacchetti nativo. Ad esempio, su Debian (o Ubuntu):

apt-get install git-core

O su Mac OS X, tramite MacPorts :

sudo port install git-core+bash_completion+doc

... o fink:

fink install git

... o Homebrew :

brew install git

Sulle distribuzioni basate su Red Hat, come Fedora:

yum install git

In Cygwin il pacchetto Git può essere trovato nella sezione "sviluppo"

Dalla fonte (Mac OS X / Linux / BSD / ecc.)

In Mac OS X, se hai installato gli Strumenti di sviluppo, puoi compilare Git dal sorgente molto facilmente. Scarica l'ultima versione di Git come .tar.bzo .tar.gzda http://git-scm.com/ ed estraila (fai doppio clic su Finder)

Su Linux / BSD / ecc. dovrebbe essere più o meno lo stesso. Ad esempio, in Debian (e Ubuntu), è necessario installare il build-essentialpacchetto tramite apt.

Quindi in un Terminale, cddove hai estratto i file (Running cd ~/Downloads/git*/dovrebbe funzionare), quindi esegui ..

./configure && make && sudo make install

Questo installerà Git nella posizione predefinita ( /usr/local- così gitsarà in /usr/local/bin/git)

Ti verrà richiesto di inserire la password (per sudo), in questo modo può scrivere nella /usr/local/directory, a cui può accedere solo l'utente "root", quindi sudo è necessario!

Se devi installarlo in un posto separato (quindi i file di Git non sono mescolati con altri strumenti), usa --prefixcon il comando configure:

./configure --prefix=/usr/local/gitpath
make
sudo make install

Questo installerà il gitbinario in /usr/local/bin/gitpath/bin/git- quindi non è necessario digitarlo ogni volta che dovresti aggiungerlo nel tuo $PATHaggiungendo la seguente riga nel tuo ~/.profile:

export PATH="${PATH}:/usr/local/bin/gitpath/bin/"

Se non si dispone dell'accesso sudo, è possibile utilizzare --prefix=/Users/myusername/bine installare nella propria directory home. Ricorda di aggiungere ~/bin/a$PATH

Lo script x-git-update-to-latest-version automatizza molto questo:

Questo script aggiorna il mio clone locale del repository git (localy at ~/work/track/git), quindi configura, installa (at /usr/local/git- git describe) e aggiorna il /usr/local/gitlink simbolico.

In questo modo, posso avere /usr/local/git/binnel mio PATHe utilizzo sempre l'ultima versione.

L'ultima versione di questo script installa anche le pagine man. È necessario modificare il proprio MANPATHper includere la /usr/local/git/share/mandirectory.

Git Reset

Supponi di fare un pull, uniscilo nel tuo codice e decidi che non ti piace. Usa git-log, o tig, e trova l'hash dove vuoi tornare (probabilmente il tuo ultimo commit prima del pull / merge) copia l'hash e fai:

# Revert to a previous commit by hash:
git-reset --hard <hash>

Invece dell'hash, puoi usare HEAD ^ come scorciatoia per il commit precedente.

# Revert to previous commit:
git-reset --hard HEAD^

Come si configura un repository di team condiviso?

Qui viene descritto come impostare un repository normale , ma come si imposta un repository di team che tutti possono estrarre e spingere da e verso?

Utilizzo di un file system NFS condiviso

Supponendo che il tuo team abbia già ad esempio un'appartenenza al gruppo condivisa che può essere utilizzata.

mkdir /your/share/folder/project.git
cd /your/share/folder/project.git
newgrp yourteamgroup # if necessary
git init --bare --shared

Per iniziare a utilizzare questo repository, la cosa più semplice da fare è iniziare da un repository locale che hai già utilizzato:

cd your/local/workspace/project
git remote add origin /your/share/folder/project.git
git push origin master

Altri ora possono clonare questo e iniziare a lavorare:

cd your/local/workspace
git clone /your/share/folder/project.git

Usando SSH

Configurare un account utente sul server di destinazione. Il fatto che tu utilizzi un account senza password, un account con password o utilizzi authorized_keysdipende davvero dal livello di sicurezza richiesto. Dai un'occhiata a Configuring Git over SSH per ulteriori informazioni.

Se tutti gli sviluppatori utilizzano lo stesso account per accedere a questo repository condiviso, non è necessario utilizzare l' --sharedopzione come sopra.

Dopo aver avviato il repository come sopra, esegui il push iniziale in questo modo:

cd your/local/workspace/project
git remote add origin user@server:/path/to/project.git
git push origin master

Vedi la somiglianza con quanto sopra? L'unica cosa che potrebbe accadere in aggiunta è che SSH richiede una password se l'account ha una password. Se ricevi questo messaggio su un account senza password, probabilmente il server SSH è disabilitato PermitEmptyPasswords.

La clonazione ora si presenta così:

cd your/local/workspace
git clone user@server:/path/to/project.git

git statusè tuo amico, usalo spesso. Buono per rispondere a domande come:

• Che cosa ha appena fatto quel comando?
• Su quale ramo sono?
• Quali cambiamenti sto per impegnare e ho dimenticato qualcosa?
• Sono stato nel mezzo di qualcosa l'ultima volta che ho lavorato a questo progetto (giorni, settimane o forse mesi fa)?

A differenza, diciamo svn status,git status funziona quasi istantaneamente anche su grandi progetti. Spesso lo trovavo rassicurante mentre imparavo a usare git per usarlo frequentemente, per assicurarmi che il mio modello mentale di ciò che stava accadendo fosse accurato. Ora lo uso principalmente solo per ricordare a me stesso cosa sono cambiato dal mio ultimo commit.

Ovviamente, è molto più utile se .gitignore è configurato in modo corretto.

Effettua modifiche

Dopo aver modificato un file, devi eseguire il commit delle modifiche su git. Quando esegui questo comando, ti verrà richiesto un messaggio di commit, che è solo un semplice pezzo di testo che dice a tutti cosa hai cambiato.

$ git commit source/main.c

Commetterà il file main.c nella directory ./source/

$ git commit -a # the -a flag pulls in all modified files

impegnerà tutti i file modificati (ma non i nuovi file, questi devono essere aggiunti all'indice con git-add). Se vuoi eseguire il commit solo di determinati file, dovrai prima metterli in scena con git-add e poi eseguire il commit senza il flag -a.

Il commit modifica solo il repository locale sebbene non i repository remoti. Se si desidera inviare i commit al repository remoto, sarà necessario eseguire una push.

$ git push <remote> <branch> # push new commits to the <branch> on the <remote> repository

Per qualcuno proveniente da CVS o SVN questa è una modifica poiché il commit nel repository centrale ora richiede due passaggi.

Come si ramifica?

Viene chiamato il ramo predefinito in un repository git master.

Per creare un nuovo ramo utilizzare

git branch <branch-name>

Per visualizzare un elenco di tutti i rami nel tipo di repository corrente

git branch

Se vuoi passare a un altro ramo puoi usare

git checkout <branch-name>

Per creare un nuovo ramo e passare ad esso in un solo passaggio

git checkout -b <branch-name>

Per eliminare un ramo, utilizzare

git branch -d <branch-name>

Per creare un ramo con le modifiche dal ramo corrente, fare

git stash
git stash branch <branch-name>

Ottenere l'ultimo codice

$ git pull <remote> <branch> # fetches the code and merges it into 
                             # your working directory
$ git fetch <remote> <branch> # fetches the code but does not merge
                              # it into your working directory

$ git pull --tag <remote> <branch> # same as above but fetch tags as well
$ git fetch --tag <remote> <branch> # you get the idea

Questo praticamente copre ogni caso per ottenere l'ultima copia del codice dal repository remoto.

Il libro gratuito Pro Git è sicuramente il mio preferito, soprattutto per i principianti.

Git Magic è tutto ciò di cui avrai mai bisogno. Soddisfatto o rimborsato!

Come si uniscono i rami?

Se si desidera unire un ramo (ad esempio mastera release), assicurarsi che il ramo corrente è il ramo di destinazione che si desidera unire in (uso git brancho git statusdi vedere il vostro ramo corrente).

Quindi utilizzare

git merge master

(dove master trova il nome del ramo che si desidera unire al ramo corrente).

In caso di conflitti, è possibile utilizzare

git diff

per vedere i conflitti in sospeso devi risolvere.

Ho anche trovato molto utile Git Internals . È scritto da Scott Chacon (autore di Pro Git e manutentore del Git Community Book). Quello che mi piace di Git Internals è che si concentra prima sui concetti e poi sui comandi , ed essendo che è ~ 100 piccole pagine è rapidamente digeribile.

Come vedi la cronologia delle revisioni di un file?

git log -- filename

Come tenere traccia dei rami remoti

Supponendo che ci sia un repository remoto da cui hai clonato il tuo repository locale e anche supponendo che ci sia un ramo chiamato 'some_branch' su quel repository remoto, ecco come seguirlo localmente:

# list remote branches
git branch -r

# start tracking one remote branch
git branch --track some_branch origin/some_branch

# change to the branch locally
git checkout some_branch

# make changes and commit them locally
....

# push your changes to the remote repository:
git push

Un buon documento per capire come funziona Git è The Git Parable . Molto consigliato!

Come si confrontano due revisioni di un file o il file corrente e una revisione precedente?

Il comando Compare è git diff .

Per confrontare 2 revisioni di un file:

$ git diff <commit1> <commit2> <file_name>

Questo differisce da commit1 a commit2; se modifichi l'ordine, i file si differenziano al contrario, il che potrebbe non essere quello che ti aspetti ...

Per confrontare il file di gestione temporanea corrente con il repository:

$ git diff --staged <file_name>

Per confrontare il file non gestito corrente con il repository:

$ git diff <file_name>

Perché ancora un altro howto? Ci sono davvero buoni in rete, come la guida git che è perfetta per iniziare. Ha buoni collegamenti tra cui il libro git a cui si può contribuire (ospitato su git hub) e che è perfetto per questo compito collettivo.

Su StackOverflow, preferirei davvero vedere i tuoi trucchi preferiti!

Il mio, che ho scoperto solo di recente, è git stashspiegato qui , che ti consente di salvare il tuo lavoro attuale e andare in un altro ramo

EDIT: come il post precedente, se preferisci davvero il formato stackoverlow con i post come wiki eliminerò questa risposta

Interfaccia utente della console - Tig

Installazione:

apt-get install tig

uso

All'interno di un repository git, digitare 'tig', per visualizzare un registro interattivo, premere 'invio' su qualsiasi registro per visualizzare ulteriori informazioni al riguardo. h per assistenza, che elenca le funzionalità di base.

banalità

"Tig" è "Git" all'indietro.

Come posso creare un ramo su un repository remoto?

Supponendo di aver clonato il proprio repository remoto da un singolo repository remoto.

# create a new branch locally
git branch name_of_branch
git checkout name_of_branch
# edit/add/remove files    
# ... 
# Commit your changes locally
git add fileName
git commit -m Message
# push changes and new branch to remote repository:
git push origin name_of_branch:name_of_branch

Ho iniziato con il tutorial ufficiale di Git . Penso che sia abbastanza pratico per i principianti (ero, e lo sono ancora, un principiante, per tua definizione! Comprendo a malapena i makefile, ho giocato solo un po 'con Apache Subversion, ecc.).

Come posso eliminare un ramo su un repository remoto?

Esegui una spinta nel telecomando usando :prima del nome del ramo

git push origin :mybranchname

essendo originil nome del tuo telecomando emybranchname il nome del ramo che sta per essere eliminato

http://help.github.com/remotes/

Spingere e tirare le modifiche

In modo semplificato, basta fare git pushe git pull. Le modifiche vengono unite e se c'è un conflitto, git ti farà sapere e puoi risolverlo manualmente.

Quando si preme per la prima volta in un repository remoto, è necessario eseguire un git push origin master(il master è il ramo master). Da quel momento in poi fai semplicemente il git push.

Spingere i tag con git push --tags.

Codice di verifica

Prima vai su una directory vuota, usa "git init" per renderlo un repository, quindi clona il repository remoto nel tuo.

git clone user@host.com:/dir/to/repo

Ovunque tu cloni inizialmente è dove "git pull" verrà estratto per impostazione predefinita.

Gity: http://macendeavor.com/gity