Quali sono le differenze tra "git commit" e "git push"?

In un tutorial Git che sto attraversando, git commitviene utilizzato per memorizzare le modifiche apportate.

A cosa git pushserve allora?

Fondamentalmente git commit" registra le modifiche al repository " mentre git push" aggiorna i riferimenti remoti insieme agli oggetti associati ". Quindi il primo viene utilizzato in connessione con il repository locale, mentre il secondo viene utilizzato per interagire con un repository remoto.

Ecco una bella foto di Oliver Steele , che spiega il modello git e i comandi:

Maggiori informazioni su git pushe git pullsu GitReady.com (l'articolo a cui ho fatto riferimento prima)

commit : aggiunta di modifiche al repository locale

push : per trasferire gli ultimi commit su un server remoto

Bene, fondamentalmente git commit inserisce le modifiche nel repository locale, mentre git push invia le modifiche alla posizione remota.

git pushviene utilizzato per aggiungere commit a un repository locale su uno remoto - insieme a git pull, consente alle persone di collaborare.

Poiché git è un sistema di controllo della versione distribuito, la differenza è che commit commetterà le modifiche al repository locale, mentre push invierà le modifiche a un repository remoto.

Commit : Istantanea | Cambiet | History_record | Versione | "Salva come" di un repository. Git repository = serie (albero) di commit .

LocaleRepository : repository sul tuo computer.

Repository remoto : repository su un server ( Github ).

git commit: Aggiunge un nuovo commit (ultimo commit + modifiche gestite ) al repository locale . (Tutti i commit sono memorizzati in/.git )

git push, git pull: Sincronizza il repository locale con il repository remoto associato . push- applica le modifiche da locale a remoto , pull- applica le modifiche da remoto a locale .

git commitregistra le tue modifiche nel repository locale .

git push aggiorna il repository remoto con le tue modifiche locali.

Tre cose da notare:

1) Directory di lavoro ----- cartella in cui sono presenti i nostri file di codici

2) Repository locale ------ Questo è all'interno del nostro sistema. Quando eseguiamo il comando COMMIT per la prima volta, viene creato questo repository locale. nello stesso posto dove si trova la nostra directory di lavoro,
viene creato il file Checkit (.git).
Dopodiché, quando ci impegniamo, questo memorizzerà le modifiche apportate nel file della directory di lavoro al repository locale (.git)

3) Repository remoto ----- Questo è situato al di fuori del nostro sistema come su server situati in qualsiasi parte del mondo. come github. Quando eseguiamo il comando PUSH, i codici dal nostro repository locale vengono archiviati in questo repository remoto

Voglio solo aggiungere i seguenti punti:

Non è possibile eseguire il push fino a quando non si git pushesegue il commit in quanto vengono utilizzati per inviare i commit effettuati sulla propria filiale locale in un repository remoto.

Il git pushcomando accetta due argomenti:

Un nome remoto, ad esempio origin Un nome di filiale, ad esempio,master

Per esempio:

git push  <REMOTENAME> <BRANCHNAME> 
git push  origin       master

Un'analogia molto grossolana: se ci confrontiamo git commitcon il salvataggio di un file modificato, la git pushcopia di tale file in un'altra posizione.

Per favore, non togliere questa analogia da questo contesto - il commit e il push non sono come salvare un file modificato e copiarlo. Detto questo, dovrebbe valere per amor di confronto.

È più facile capire l'uso dei comandi git adde commitse immagini che un file di registro venga mantenuto nel tuo repository su Github. Il tipico file di registro di un progetto per me potrebbe apparire come:

---------------- Day 1 --------------------
Message: Completed Task A
Index of files changed: File1, File2

Message: Completed Task B
Index of files changed: File2, File3
-------------------------------------------

---------------- Day 2 --------------------
Message: Corrected typos
Index of files changed: File3, File1
-------------------------------------------
...
...
...and so on

Di solito inizio la mia giornata con una git pullrichiesta e finisco con una git pushrichiesta. Quindi, ogni cosa nel registro di un giorno corrisponde a ciò che accade tra di loro. Durante ogni giorno ci sono una o più attività logiche che ho completato che richiedono la modifica di alcuni file. I file modificati durante tale attività sono elencati in un indice.

Ognuna di queste attività secondarie (attività A e attività B qui) sono commit individuali. Il git addcomando aggiunge i file all'elenco "Indice dei file modificati". Questo processo è anche chiamato stadiazione e in realtà registra i file modificati e le modifiche eseguite. Il git commitcomando registra / finalizza le modifiche e l'elenco di indici corrispondente insieme a un messaggio personalizzato che può essere utilizzato per riferimento futuro.

Ricorda che stai ancora cambiando solo la copia locale del tuo repository e non quella su Github. Dopodiché, solo quando git pushesegui tutte queste modifiche registrate, insieme ai tuoi file indice per ciascun commit, accedi al repository principale (su Github).

Ad esempio, per ottenere la seconda voce in quel file di registro immaginario, avrei fatto:

git pull
# Make changes to File3 and File4
git add File3 File4
# Verify changes, run tests etc..
git commit -m 'Corrected typos'
git push

In breve, git adde git commitconsente di suddividere una modifica al repository principale in sub-modifiche logiche sistematiche. Come hanno sottolineato altre risposte e commenti, ci sono ovviamente molti più usi per loro. Tuttavia, questo è uno degli usi più comuni e un principio guida dietro Git è un sistema di controllo di revisione multi-stadio a differenza di altri popolari come Svn.

git commit non è altro che salvare le nostre modifiche ufficialmente, per ogni commit che inviamo messaggio di commit, una volta che avremo finito con i commit possiamo spingerlo a distanza per vedere i nostri cambiamenti a livello globale

il che significa che possiamo eseguire numerosi commit prima di passare a remoto (possiamo vedere l'elenco dei commit avvenuti e anche i messaggi) git salva ogni commit con ID commit che è un codice di 40 cifre

e uso git push solo quando volevo vedere la mia modifica in remoto (lì dopo controllerò se il mio codice ha funzionato in jenkins)

Bene, fondamentalmente git commit inserisce le modifiche nel repository locale, mentre git push invia le modifiche alla posizione remota. Poiché git è un sistema di controllo della versione distribuito, la differenza è che commit commetterà le modifiche al repository locale, mentre push invierà le modifiche a un repository remoto

fonte Google

http://gitref.org/basic/ anche questo link sarà molto utile

https://git-scm.com/docs/git-commit

in parole povere, git commitè il passaggio prima git pushdi eseguirli in quell'ordine per eseguire correttamente il git del file su github.

git commitconsiste nel commit dei file messi in scena nel repository locale. git pushconsiste nell'avanzare rapidamente unendo il ramo principale del lato locale con il ramo principale remoto. Ma la fusione non avrà sempre successo. Se viene visualizzato il rifiuto, è necessario in pullmodo da poter avere successo git push.