Utilizzo di Github. Idiota. Un rapido avvio all'utilizzo delle operazioni di base con spiegazioni. Prodotti e caratteristiche

Idiota. Un rapido avvio all'utilizzo delle operazioni di base con spiegazioni

I file sono ora saldamente stabiliti nell'HEAD della copia locale di lavoro. Non puoi cacciarli da lì, ma non sono ancora nel tuo repository remoto. Mettiamoli lì anche noi! Utilizzo:

Git push origin master

Invece di master, scrivi il nome del ramo desiderato. Oh sì, non sai ancora cosa sono i rami. Ok, ricorda questo posto per ora, e quando leggi della biforcazione, torna qui.

Oh sì, per i ragazzi fantastici che lavorano con i server (è opportuno parlare di GitHub, ad esempio), il comando sarà così:

Git remoto aggiungi origine [server]

Ramificazione

In inglese questa cosa si chiama ramificazione- è meglio approfondire questo problema e leggere la ramificazione in modo più dettagliato, te lo presenterò semplicemente. Ramificazione utilizzato per lo sviluppo simultaneo e indipendente di diverse funzionalità (beh, o per l'accumulo di più bug, perché c'è più codice sorgente). Il ramo principale è maestro- appare durante la creazione di un repository. Gli altri rami sono sandbox; quando ne hai giocati abbastanza, uniscili in un unico insieme in master. Ora ti spiegherò come si fa.

Creazione di una nuova filiale

Quindi hai deciso di lavorare su qualche nuova funzionalità. Crea un nuovo ramo per questo:

Git checkout -b [nuovo_ramo]

Oh sì, probabilmente la tua immaginazione sta lavorando al massimo, ma moderala quando si tratta di nominare i rami: puoi nominare un ramo solo con un nome accettabile per una variabile nella tua lingua preferita.

Passaggio da un ramo all'altro

Dovrei prendermi una pausa dal lavoro su questa funzionalità e passare a un altro ramo? Utilizza (se stai lavorando con un repository locale, non è necessario specificarne il nome):

Git checkout [repository]/[ramo]

Bene, se non vuoi lavorarci affatto, eliminalo completamente:

Git ramo -d [ramo]

Puoi fare qualsiasi oscenità con il tuo ramo: nessuno lo vedrà finché non lo invierai al repository remoto con il comando:

Git push origine [ramo]

Unione di rami

Per unire un ramo in quello su cui stai attualmente lavorando, usa:

Git unisci [ramo]

Ma, ovviamente, tutto ciò porta a conflitti. E questo è un vero problema. Quindi prova a correggere tutto manualmente direttamente nella directory del repository. In quel momento non dimenticare di sottolineare che li hai "trapelati":

Git aggiungi [nome file]

A proposito, i rami possono essere confrontati:

Git diff [un_ramo] [altro_ramo]

Quindi, ora intraprendiamo un'azione più decisiva. Aggiorneremo il nostro repository in conformità con l'ultimo commit. È molto facile da fare (ma non è molto facile rimetterlo a posto, quindi pensaci due volte prima di commettere questo terribile errore):

Vai a tirare

Ovviamente capisco che sei troppo gentile per lasciare appunti per il futuro - tieni tutto nella tua testa - ma ti consiglio comunque di lasciare dei tag. E questa non è una mia invenzione, molte persone fanno così:

Tag Git [primi_dieci_caratteri del_commit_corrispondente]

Non sai quali sono i primi caratteri del nome del commit desiderato? Nessun problema, guarda la cronologia del repository: il suo registro:

Ci sono un sacco di parametri diversi per l'utilizzo di questo utile gadget, vai avanti e cercali tu stesso su Google. Oh sì, comunque, ne abbiamo già scritto una volta.

Maledizione, ho fatto la cosa sbagliata!

Bene, ora lascia che ti dica come correggere i tuoi errori, anche se sei sicuro che non li commetterai. Se il problema riguarda solo un file, ecco Ctrl+Z per HEAD:

Git checkout -- [nome file]

Ma se il problema è già nel repository locale, cancella tutto lì e restituisci la versione dal server:

Git fetch origin git reset --hard origin/master

Sì, amico, qui è tutto difficile. Questo è scemo.

Funzionalità di Git

Se sei pigro e non vuoi scrivere tutto nella shell del tuo sistema operativo, puoi utilizzare la GUI di git:

Troverai un sacco di altre GUI.
Se trovi noioso l'output standard di git, coloralo:

Git config color.ui vero

Bene, esiste anche una cosa del genere: l'indicizzazione interattiva. Quando hai già un progetto abbastanza grande, puoi comprimere la rappresentazione dell'indice nel registro in questo modo:

Git aggiungi -i

Spero che questa guida ti aiuti nelle fasi iniziali a non confonderti nel lavorare con git e imparerai finalmente a monitorare i tuoi backup.

Git è un sistema di controllo della versione e di sviluppo collaborativo molto popolare per progetti open source. Con Git puoi tenere traccia delle modifiche al codice sorgente dei tuoi progetti, ripristinare le versioni precedenti in caso di errori critici e condividere il tuo codice con tutti e accettare le loro correzioni.

Questo è un potente sistema che ti consente di ottimizzare il lavoro sui tuoi progetti. Non ci sono requisiti di lingua o struttura dei file, quindi gli sviluppatori hanno completa libertà di azione. In questo articolo vedremo come utilizzare git per i principianti. Vediamo tutto nel dettaglio, dalla configurazione ai rami del progetto.

Per tradizione, prima di passare agli esempi e lavorare con il comando, diamo un'occhiata alle sue opzioni e parametri principali. La sintassi di git è molto semplice:

$ argomenti del comando opzioni git

Innanzitutto, diamo un'occhiata alle opzioni; influenzano il funzionamento dell'intera utility:

-C- utilizzare la cartella del repository specificata invece della cartella corrente;
-C parametro=valore- utilizzare il valore del parametro di configurazione specificato;
-P- scorrere l'intero output utilizzando meno;

Ora diamo un'occhiata ai comandi git, ce ne sono alcuni in più ed è con l'aiuto di essi che eseguirai tutte le azioni principali:

aggiungere- aggiungere un file o una cartella al repository git;
Sono- applicare tutte le patch dall'e-mail;
archivio- creare un archivio di file;
bisecare- utilizzare la ricerca binaria per trovare il commit desiderato;
ramo- gestire rami di progetto;
fascio- spostare oggetti e collegamenti nell'archivio;
guardare- passaggio tra filiali;
scegliere selettivamente- apportare modifiche ai commit esistenti;
pulito- eliminare tutti i file e le cartelle di progetto non tracciati;
clone- creare una copia del repository remoto in una cartella;
commettere- salvare le modifiche nel repository;
diff- vedere le modifiche tra i commit;
andare a prendere- scaricare il repository remoto;
dentro- creare un archivio;
unire- unire due rami;
tiro- integrare un repository remoto con uno locale;
spingere- inviare modifiche a un repository remoto;
etichetta- gestione dei tag;
worktree- gestione degli alberi di sviluppo.

Gli argomenti dipendono dal comando utilizzato, quindi li vedremo più in dettaglio negli esempi.

Come funziona Git?

Quindi, da tutto quanto sopra, probabilmente hai già capito che il controllo della versione ti consente di visualizzare le modifiche in qualsiasi fase di sviluppo e anche di tornare a qualsiasi punto. Ma non è così. Le modifiche vengono salvate come commit. In russo: fissazione. Si effettua un commit iniziale per salvare lo stato iniziale del progetto e poi per ogni modifica. Funziona come istantanee.

Inoltre, git ti consente di inviare dati a un server remoto. Non viene inviata solo la versione finale, ma anche tutte le istantanee, in modo che chiunque nel team possa vedere la cronologia delle modifiche. Devi fare un commento per ogni istantanea, quindi lavorare con git sarà più semplice e chiaro.

Come usare Git?

In genere, la struttura di un progetto Git dipenderà dalle dimensioni e dalla complessità del tuo programma. Ma prima utilizzeremo un progetto composto da un solo ramo. Ogni progetto contiene un ramo per impostazione predefinita, si chiama master. Il nostro primo progetto si chiamerà test.

Creazione di un progetto

Una volta completata la configurazione di git, passiamo al tuo progetto. All'inizio, devi solo creare una cartella per i file di progetto. Se lavorerai su più progetti, crea una cartella git nella tua directory home e posiziona lì le cartelle del progetto:

mkdir -p ~/git/test ; cd ~/git/testing

Questo comando creerà la struttura di cartelle desiderata e cambierà la directory corrente in quella appena creata. Ora creiamo il primo file del nostro progetto:

Il progetto è pronto, ma il sistema di controllo della versione git non lo sa ancora.

Impostazione di un progetto in Git

Prima che git inizi a tenere traccia delle modifiche, devi preparare tutti i file di configurazione necessari. Per prima cosa inizializziamo un repository vuoto nella nostra cartella:

Una volta creato il repository, devi aggiungervi i tuoi file. Ogni file deve essere aggiunto separatamente oppure è possibile indicare all'utilità di aggiungere tutti i file in modo esplicito. Finché non aggiungi il file stesso, non verrà tracciato. In futuro dovranno essere aggiunti anche nuovi file; non verranno aggiunti automaticamente. Per prima cosa aggiungiamo la cartella corrente:

Se tutto è andato bene, il comando non restituirà nulla.

Effettuare modifiche

Inoltre, le modifiche non vengono tracciate automaticamente. Il commit delle modifiche viene effettuato utilizzando il comando commit. Devi indicare cosa è stato cambiato con un piccolo commento, letteralmente poche frasi. È buona norma impegnarsi prima di ogni cambiamento importante.

In questo modo memorizzerai tutte le versioni del progetto, dalla prima a quella attuale, e potrai anche sapere cosa, quando e dove è stato modificato. Per creare la tua prima esecuzione di commit:

git commit -m "Commit iniziale" -a

Al comando devono essere passati due parametri, il primo è -m, il tuo commento, il secondo -a, significa che devi applicare l'azione a tutti i file modificati. Per la prima volta viene utilizzata questa opzione, ma di solito è necessario specificare i file o le directory modificati. Ad esempio, puoi fare questo:

git commit -m File "File modificato".

Invio di modifiche

Fino a questo punto abbiamo fatto tutto in un repository locale. Puoi utilizzare git localmente se hai solo bisogno del controllo della versione, ma a volte devi condividere informazioni con altri sviluppatori e inviare dati a un repository remoto.

Per prima cosa devi aggiungere un repository remoto usando il comando remote. Per fare ciò, devi passargli l'URL:

git remoto aggiungi origine https://github.com/Seriyyy95/testing.git

Quindi puoi visualizzare l'elenco dei repository remoti:

Puoi utilizzare non solo i server Github, ma anche tutti gli altri. Ora per inviare le modifiche utilizza questo comando:

git push origin master

Il comando push specifica che vogliamo inviare i dati a un repository remoto, origin è il nostro repository configurato e master è un ramo.

Gestione filiale

Per progetti semplici è sufficiente un ramo. Ma se il progetto è grande e ha diverse versioni, inclusa una versione di prova, potrebbe essere necessario creare un ramo separato per ciascuna di esse. Per prima cosa guardiamo i rami disponibili:

L'opzione -a specifica che devono essere visualizzati tutti i rami, anche quelli non sincronizzati. Un asterisco indica il ramo attivo. Ora creiamo un ramo di sviluppo utilizzando il comando checkout:

git checkout -b sviluppo

Puoi anche passare da un ramo all'altro utilizzando lo stesso comando:

git checkout master
Sviluppo di $ git checkout

Ora creiamo un altro file:

E aggiungilo al nostro nuovo ramo di sviluppo:

Effettuiamo il commit delle modifiche apportate:

git commit -m "sviluppa file" sviluppa

ramo git
$ls

Quindi passa al ramo master e guarda di nuovo:

git checkout master
ramo $git
$ls

Non c'è nessun file qui, è così che dovrebbe essere. Git ha una cosa così utile come la fusione. Con esso puoi unire due rami. Ad esempio, spostando il codice da un ramo funzionante a uno stabile. Per fare ciò basta eseguire il comando merge:

git merge development --no-ff

Prima che venga eseguita l'unione, è necessario inserire un commento sul motivo per cui è necessaria. Quindi se esegui nuovamente ls, vedrai che il file che ti serve è già lì. I nostri esempi di Git sono giunti al termine.

conclusioni

In questo articolo, abbiamo esaminato come utilizzare git per gestire le versioni dei tuoi progetti. Queste sono solo le nozioni di base e c'è molto altro che il controllo della versione di git può fare, ma esaminare le sue capacità avanzate va oltre lo scopo di questo articolo. Spero che tu abbia trovato utile questo articolo.

Sicuramente molti hanno sentito parlare del sistema di controllo della versione git. Oggi esamineremo l'intero percorso dall'installazione di git all'applicazione delle modifiche a un repository remoto utilizzando la libreria OsEngine come esempio. Innanzitutto, scarica il client git dal collegamento e installalo. Non ci saranno domande
dovrebbe, basta fare clic su Avanti ovunque. Successivamente verrà discussa l'interazione con git utilizzando l'esempio di lavoro con un client console.Il passo successivo è registrarsi sul sito Web https://github.com/. Ora possiamo iniziare a lavorare su OsEngine. Per fare ciò, vai al repository del progetto e fai clic sul pulsante Fork nell'angolo in alto a destra.

Con questa azione abbiamo creato un fork (in altre parole un ramo), che è archiviato nel repository del nostro account e ora possiamo apportarvi modifiche senza timore di rompere qualcosa nel ramo principale del progetto. Di seguito chiameremo questo stesso repository su github un repository remoto.
Ora iniziamo a lavorare con git stesso e la prima cosa che dobbiamo fare è creare una copia locale del repository remoto sul nostro computer. Per fare ciò, vai nella cartella desiderata, seleziona la voce Git Bash Here nel menu contestuale e la console si aprirà.

$ git clone "incolla qui il collegamento senza virgolette"

Inizierà il processo di copia del repository remoto su quello locale e nella cartella corrente apparirà una copia funzionante denominata OsEngine.

Lavorare con un repository locale

Configurazione di Git

Prima di iniziare a lavorare con git, devi configurarlo. Apri git bash, imposta nome utente e password utilizzando i comandi:

$ git config --global user.name “il tuo nome”
$ git config --global user.email “la tua email”

Puoi visualizzare il file di configurazione con il comando:

$ git config --global --list

Lavorare con i rami

I rami in git sono gli stessi dei rami in github. Per creare un nuovo ramo, esegui il comando nella console:

$ nome desiderato del ramo git

Per passare a questo ramo eseguire il comando:

$ nome del ramo di pagamento git

per tornare al ramo principale digitare:

Maestro del pagamento $git

rinominare il ramo:

$ git branch –m nuovo nome

squadra ramo $git ci permette di determinare in quale ramo ci troviamo attualmente. Il comando elimina un ramo

$git ramo –D nome del ramo

L'unione di un ramo con quello principale si effettua con il comando:

$ git merge nome del ramo

Quando si uniscono rami in cui file identici vengono modificati in modi diversi, potrebbe verificarsi un conflitto e l'unione non avrà luogo. Per uscire da questa situazione, è necessario correggere correttamente questi file.

Si impegna

Il punto centrale dell'utilizzo di git sono i commit. Un commit è una cosiddetta istantanea dello stato del progetto in una determinata fase
sviluppo. Ad esempio: abbiamo la libreria OsEngine, l'abbiamo aggiunta
e ho commesso un nuovo indicatore, quindi ho deciso di modificare alcuni file in
motore e successivamente l'applicazione si blocca o non vuole funzionare correttamente. A
per non fare lavoro extra e non modificare tutto, possiamo semplicemente
ripristinare un commit precedente quando l'applicazione funzionava come previsto. Rispettivamente
tutto il lavoro con Git ruota attorno alla creazione, eliminazione, modifica, fusione
commit e rami.

Aggiunta di file all'indice

Diciamo che abbiamo aggiunto un file README al progetto, ma prima di impegnarci dobbiamo aggiungere i file modificati a
indice, la cosiddetta memorizzazione temporanea delle modifiche. Questo viene fatto come segue: se è necessario indicizzare un file, eseguirlo

$git aggiungi README

e il file README verrà aggiunto all'indice, se è necessario indicizzare tutti i file nuovi e aggiornati, eseguire

$git aggiungi.

Nota che ha un punto alla fine e uno spazio prima.

Rimozione di file dall'indice

Se hai indicizzato accidentalmente un file non necessario, il comando git reset ti aiuterà a rimuoverlo dall'indice, ad esempio rimuovendo il file README dall'indice:

$git ripristina il README

Se cambi idea sul lasciare le modifiche apportate al file, esegui il comando

$ git checkout -- nome del file

e tornerà allo stato in cui si trovava durante l'ultimo commit, tieni presente che tutte le modifiche a questo file scompariranno.

Creazione di un impegno

Ora puoi confermare le modifiche, questo viene fatto usando il comando:

$ git commit –m “Qui dovrebbe esserci un commento tra virgolette”

Va ricordato che la presenza di un commento è un prerequisito. La cronologia delle modifiche può essere visualizzata con il comando

registro $git

$git mostra mostrerà solo le ultime modifiche. Per uscire dalla modalità di riproduzione, premere q.

Git ha la capacità di indicizzare tutte le modifiche e confermarle con un comando:

$ git commit –a –m “commento tra virgolette”

A significa: aggiungere tutte le modifiche all'indice prima del trasferimento.
-m: commento.

Modificare, eliminare, confermare

Se devi annullare l'ultimo commit, usa il comando:

$ git ripristina HEAD

I commit vengono contati da 0 a partire dall'ultimo, ad esempio, se devi annullare il terzo commit, dovresti eseguire:

$ git ripristina HEAD~2

Squadra $ git reset --soft HEAD~3 eliminerà gli ultimi 3 commit e riporterà il progetto allo stato del quarto commit, mantenendo tutte le modifiche degli ultimi tre commit nell'indice.

$ git reset -- hard HEAD~3

rimuoverà completamente gli ultimi tre commit.

Stato del file

Stato $git – il comando principale che monitora lo stato dei file. Mostra se sono presenti modifiche nei file monitorati o la presenza di file non tracciati. I file tracciati sono quei file che si trovano nel commit precedente. Se aggiungiamo un nuovo file al progetto, verrà considerato non tracciato.

Apportare modifiche locali a un repository remoto

Ora che le modifiche necessarie sono state apportate al repository locale, è possibile caricarle nel repository remoto.
Questo viene fatto eseguendo il comando:

$git spinge il master di origine

Dovrai inserire il nome utente e la password di GitHub. Tuttavia, il download potrebbe non avvenire. Il motivo potrebbe essere che sono presenti modifiche nel repository remoto che non sono presenti in quello locale. Per uscire dalla situazione, devi prenderli nuovi
modifiche al repository locale con il comando:

$git tira

Utilizzo delle chiavi SSH

Per eliminare la necessità di inserire login e password ogni volta che si inviano modifiche a un repository remoto, è possibile utilizzare le chiavi SSH. Innanzitutto, devi generare le chiavi eseguendo il comando:

$ssh-keygen

Quindi premere Invio 3 volte e nella directory predefinita C:\Utenti\nome utente\.ssh apparirà una cartella con le chiavi. È necessario aprire il file
id_rsa digita PUB in qualsiasi editor di testo e copia il suo contenuto. Quindi vai su github nelle impostazioni del tuo account

Successivamente nella colonna di sinistra seleziona la voce: Chiavi SSH e GPG e clicca sul pulsante verde a destra Nuova chiave SSH

impostare il Titolo, inserire i dati copiati dalla chiave nel campo Chiave e cliccare

Unione di rami su github

Dopo aver apportato tutte le modifiche necessarie al repository remoto, puoi inviare una richiesta di unione al repository principale del progetto OsEngine. Basta fare clic sul pulsante Nuova richiesta pull

poi

In questo articolo abbiamo esaminato i comandi base di git, saranno sufficienti per iniziare a lavorare sul progetto OsEngine utilizzando git e il servizio github.

Buon impegno!

È naturale che le persone resistano al cambiamento. Se non ti è stato presentato Git quando hai iniziato a lavorare con i sistemi di controllo della versione, probabilmente ti senti più a tuo agio con Subversion (SVN).

Le persone spesso dicono che Git è troppo difficile per i principianti. Tuttavia, mi permetto di dissentire su questo.

In questo tutorial ti mostrerò come utilizzare Git nei tuoi progetti. Supponiamo che tu stia costruendo un progetto da zero e desideri gestirlo utilizzando Git. Esplorare l'elenco dei comandi di base ti darà un'idea di come ospitare il tuo codice nel cloud utilizzando GitHub.

In questo articolo parleremo delle nozioni di base di Git: come inizializzare i tuoi progetti, come gestire file nuovi ed esistenti e come archiviare il tuo codice nel cloud.

Non toccheremo le parti relativamente complesse di Git, come le ramificazioni, poiché questo tutorial è destinato ai principianti.

Installazione di Git

Sul sito ufficiale di Git c'è informazioni dettagliate sull'installazione su Linux, Mac e Windows. Nel nostro caso, utilizzeremo Ubuntu 13.04 a scopo dimostrativo, dove installeremo Git utilizzando apt-get:

sudo apt-get install git

Configurazione iniziale

Creiamo una directory all'interno della quale lavoreremo. In alternativa, puoi utilizzare Git per gestire uno dei tuoi progetti esistenti; in questo caso non sarà necessario creare una directory demo come di seguito:

mkdir mio_git_project cd mio_git_project

Il primo passo è inizializzare Git nella directory. Questo può essere fatto utilizzando il comando init, che crea una directory .git contenente tutte le informazioni relative a Git per il tuo progetto.

git config --global utente.nome "Shaumik" git config --global utente.email " [e-mail protetta]" git config --global color.ui "auto"

È importante notare che se non fornisci il tuo nome e indirizzo email, verranno utilizzati i valori predefiniti. Nel nostro caso, i valori predefiniti sarebbero il nome utente donny e l'indirizzo email donny@ubuntu.

Impostiamo anche il colore dell'interfaccia utente su auto , che renderà l'output dei comandi Git codificato a colori.

Il prefisso --global prima dei comandi serve per evitare di dover inserire questi comandi di configurazione la prossima volta che eseguiremo un progetto Git sul nostro sistema.

Preparazione dei file per il commit

Il passo successivo è creare i file nella directory. Puoi utilizzare, ad esempio, l'editor di testo Vim. Tieni presente che se intendi aggiungere Git a una directory già esistente, non è necessario eseguire questo passaggio:

Controlla lo stato del repository

Ora che abbiamo alcuni file nel nostro repository, diamo un'occhiata a come Git li gestisce. Per verificare lo stato corrente del repository, è necessario utilizzare il comando git status:

Aggiunta di file a Git per il monitoraggio

Al momento non abbiamo file da monitorare con Git. Dobbiamo aggiungere file specificatamente a Git per dire a Git cosa tracciare.

Aggiungi file usando il comando add:

Controllando nuovamente lo stato del repository, possiamo vedere che è stato aggiunto un file:

Per aggiungere più file, puoi utilizzare la seguente voce di comando (nota che abbiamo aggiunto un altro file a scopo dimostrativo):

git aggiungi miofile2 miofile3

Puoi usare git add in modo ricorsivo, ma fai attenzione con questo comando. Esistono alcuni file (come i file compilati) che vengono generalmente archiviati al di fuori di un repository Git.

Se usi il comando add in modo ricorsivo, aggiungerà tutti questi file se esistono nel tuo repository.

Eliminazione di file

Ma l'esecuzione di un semplice comando git rm non solo rimuoverà il file da Git, ma anche dal tuo file system locale! A

Git ha smesso di tracciare il file, ma il file stesso rimane sul tuo sistema locale, esegui il seguente comando:

git rm --cached

Impegna le modifiche

Dopo aver ospitato i tuoi file, puoi inviarli a Git. Pensa a un commit come a catturare un momento specifico a cui puoi tornare per accedere al tuo repository in quel momento.

Puoi allegare un messaggio a ciascun commit, che viene aggiunto utilizzando il prefisso -m:

git commit -m "Il mio primo commit"

Dai ai tuoi commit messaggi utili perché questo ti aiuterà a identificare cosa hai cambiato in quel commit.

Evita messaggi troppo generici come " Bug risolti" Se disponi di un task tracker, puoi aggiungere messaggi come " Risolto bug n. 234».

È buona norma utilizzare il nome del ramo o della funzione come prefisso del messaggio di commit. Per esempio, " Gestione delle risorse: aggiunta la funzione per generare file PDF delle risorse” è un messaggio significativo.

Git identifica i commit aggiungendo un lungo numero esadecimale a ciascun commit. Di norma non è necessario copiare l'intera riga; i primi 5-6 caratteri sono sufficienti per identificare il tuo commit.

Nota che nello screenshot il nostro primo commit è definito dal codice 8dd76fc.

Ulteriori impegni

Ora modifichiamo alcuni file dopo il nostro primo commit. Dopo averli modificati, vedremo che come risultato dell'esecuzione del comando git status, Git ha rilevato modifiche nei file che monitora:

Puoi controllare le modifiche ai file tracciati apportate nell'ultimo commit utilizzando il comando git diff. Se vuoi visualizzare le modifiche a un file specifico, usa il comando git diff :

È necessario aggiungere nuovamente questi file per apportare modifiche ai file tracciati per il commit successivo. Puoi aggiungere tutti i file tracciati eseguendo il comando:

Puoi evitare di utilizzare questo comando utilizzando il prefisso -a del comando git commit, che aggiungerà tutte le modifiche ai file tracciati.

Questo processo, tuttavia, è molto pericoloso in quanto può danneggiare il progetto. Ad esempio, supponiamo che tu apra un file e lo modifichi per errore.

Se inserisci i file in modo selettivo, noterai modifiche in ciascun file. Ma se aggiungi il prefisso -a al tuo commit, tutti i file verranno sottoposti a commit e non sarai in grado di rilevare possibili errori.

Una volta inseriti i file, puoi iniziare a impegnarti. Ho detto che a ogni commit può essere associato un messaggio, che inseriamo utilizzando il prefisso -m.

È però possibile inserire un messaggio su più righe utilizzando il comando git commit, che apre un modulo di scrittura interattivo:

Gestione del progetto

Per visualizzare la cronologia del tuo progetto, puoi eseguire il seguente comando:

Questo mostrerà l'intera cronologia del progetto, ovvero un elenco di tutti i commit e le informazioni su di essi. Le informazioni sul commit includono l'hash del commit, l'autore, l'ora e il messaggio di commit. Esistono varie opzioni per git log che puoi esplorare una volta che hai padroneggiato il concetto di ramo in Git.

Per visualizzare informazioni dettagliate su un commit specifico e sui file che sono stati modificati, esegui il comando seguente:

git mostra

Dove questo è il numero esadecimale associato al commit. Poiché questo tutorial è rivolto ai principianti, non tratteremo come tornare allo stato di un commit specifico o come gestire i rami.

Hosting del codice nel cloud

Ora che hai imparato a gestire il codice sul tuo sistema, è il momento di ospitare il codice nel cloud.

I sistemi di controllo della versione distribuiti (DVCS) stanno gradualmente sostituendo quelli centralizzati. Se non ne hai ancora utilizzato uno, ora è il momento di provare.

In questo articolo cercherò di mostrare come puoi iniziare rapidamente a sperimentare con git utilizzando il sito github.com.

Questo articolo non discuterà le differenze tra i diversi DVCS. Inoltre, il lavoro con Git non verrà discusso in dettaglio; ci sono molte buone fonti su questo argomento, che fornirò alla fine dell'articolo.

Pertanto, il sito github.com è posizionato come servizio di hosting di progetti web utilizzando il sistema di controllo della versione git, nonché come social network per sviluppatori. Gli utenti possono creare un numero illimitato di repository, ognuno dei quali è dotato di un wiki, un sistema di tracciamento dei problemi, la possibilità di condurre revisioni del codice e molto altro. GitHub è attualmente il servizio più popolare nel suo genere, superando Sourceforge e Google Code.

Per i progetti open source l'utilizzo del sito è gratuito. Se hai bisogno di repository privati, puoi passare a un piano a pagamento:

Cominciamo con la registrazione. Segui il link github.com/signup/free e inserisci i tuoi dati.
Dopo la registrazione, veniamo indirizzati alla dashboard del nostro account:

Ora non abbiamo un unico repository e possiamo creare un nuovo repository o eseguire il fork dal repository esistente di qualcun altro e guidare il nostro ramo di sviluppo. Successivamente, se lo desideri, puoi proporre le tue modifiche all'autore del repository originale (richiesta Pull).

Ma prima installiamo git e configuriamolo per funzionare con il sito.

Se lavori su Windows, scarica e installa msysgit. Questa è la versione console di Git per Windows (inoltre la storia sarà basata sull'esempio di questo sistema operativo).
Istruzioni per MacOS X (ita)
Istruzioni per Linux (ita)
Non dovrebbero esserci problemi, basta fare clic su Avanti ovunque. Dopo l'installazione, seleziona dal menu contestuale di Git Bash Explorer:

Oppure tramite Git Bash.lnk nella cartella con il programma installato:

Inseriamo i nostri dati e le impostazioni di interruzione di riga nella console:
git config --global user.name "il tuo nome"
git config --global user.email "la tua email"
git config --global core.autocrlf true
git config --global core.safecrlf true

A proposito, ti consiglio di seguire un buon corso interattivo sull'uso di git dalla console. Il corso si completa in poche ore e fornisce le competenze di base necessarie.

Per coloro che preferiscono la GUI, esistono diversi strumenti simili per lavorare con Git su Windows. I due principali sono SmartGit (multipiattaforma) e TortoiseGit. Entrambi sono buoni e quale usare è una questione di gusti. Descriverò il lavoro con TortoiseGit.
Per i papaveri c'è anche la scelta del giu.

A mio avviso, il client ufficiale di GitHub è ancora piuttosto rozzo.
GitX: personalmente non mi è piaciuto
GitBox: la maggior parte segue il metodo Mac, consiglio vivamente di provarlo

Informazioni su Git in russo:
habrahabr.ru/blogs/Git/106912 "Un modello di ramificazione di successo per git" - traduzione di un buon articolo in inglese
corso interattivo su githowto.com su come lavorare con git dalla console
habrahabr.ru/blogs/Git/106912 “Perché git” + discussione
habrahabr.ru/blogs/development/68341 “Git per chi migra da SVN” + discussione