Quali sono le differenze tra “git commit” e “git push”?

In un tutorial di Git che sto seguendo, git commit è usato per memorizzare le modifiche che hai apportato.

A che serve allora git push ?

In pratica git commitregistra i cambiamenti nel repository ” mentre git pushaggiorna i refs 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 immagine di Oliver Steele , che spiega il modello git ei comandi:

Comandi di trasporto dati Git

Leggi di più su git push e git pull su GitReady.com (l’articolo che ho citato per primo)

commit : aggiunta di modifiche al repository locale

push : per trasferire l’ultimo commit (s) a un server remoto

Bene, in pratica git commit inserisce le modifiche nel repository locale, mentre git push invia le modifiche nella posizione remota.

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

git push è usato per aggiungere i commit che hai fatto sul repository locale a uno remoto – insieme a git pull , permette alle persone di collaborare.

git commit registra le modifiche al repository locale .

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

Conferma : {Istantanea | Changeset | Record storico | Versione | ‘Salva come’} di un repository. Git repository = series (tree) of commits (più alcune cose extra).

Repository locale : repository sul proprio computer.

Repository remoto : repository su un server (es. Github ).

git commit : aggiunge un nuovo commit (ultimo commit + modifiche staged ) al repository locale .

git push , git pull : sincronizza il repository locale con un repository remoto . push – applica le modifiche da locale a remoto , pull – applica le modifiche da remoto a locale .

Voglio solo aggiungere i seguenti punti:

Non è ansible eseguire il push fino a quando non si esegue il commit mentre usiamo git push per inviare i commit effettuati sul ramo locale a un repository remoto.

Il comando git push accetta due argomenti:

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

Per esempio:

git push

Un’analogia molto approssimativa: se confrontiamo git commit con il salvataggio di un file modificato, git push copierà quel file in un’altra posizione.

Si prega di non prendere questa analogia da questo contesto – l’impegno e la spinta non sono come salvare un file modificato e copiarlo. Detto questo, dovrebbe valere solo per il confronto.

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 per la prima volta il comando COMMIT, viene creato questo repository locale. nello stesso luogo in cui si trova la nostra directory di lavoro,
Il file Checkit (.git) viene creato.
Dopodiché, quando eseguiamo il commit, questo memorizzerà le modifiche apportate nel file di Working Directory al repository locale (.git)

3) Repository remoto —– Si trova fuori dal 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

in parole git commit , git commit è il passo prima che git push ti git push a eseguirli in questo ordine per gitubare con successo il tuo file su github.

git commit non è altro che salvare i nostri cambiamenti ufficialmente, per ogni commit che forniamo un messaggio di commit, una volta che abbiamo finito con i commit possiamo spingerlo in remoto per vedere il nostro cambiamento a livello globale

il che significa che possiamo fare numerosi commit prima di passare al remoto (possiamo vedere la lista dei commit avvenuti e anche i messaggi) git salva ogni commit con commit id che è un codice a 40 cifre

e io uso git push solo quando volevo vedere il mio cambiamento in remoto (dopo avrò verificato se il mio codice funzionava in jenkins)

È più facile capire l’uso dei comandi git add e commit se si immagina che un file di registro sia mantenuto nel repository su Github. Un tipico file di registro del progetto per me può essere simile a:

 ---------------- 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 richiesta git pull e termina con una richiesta git push . Quindi tutto all’interno del record 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 quell’attività sono elencati in un indice.

Ognuna di queste attività secondarie (Attività A e Attività B qui) sono commit individuali. Il comando git add aggiunge i file all’elenco “Index of Files Changed”. Questo processo è anche chiamato staging e in realtà registra i file modificati e le modifiche eseguite. Il comando git commit registra / finalizza le modifiche e l’elenco di indice corrispondente insieme a un messaggio personalizzato che può essere utilizzato per riferimento futuro.

Ricorda che stai solo cambiando la copia locale del tuo repository e non quella su Github. Dopodiché, solo quando fai una git push fai tutte queste modifiche registrate, insieme ai tuoi file di indice per ogni commit, per accedere al repository principale (su Github).

Ad esempio, per ottenere la seconda voce in quel file di log 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 poche parole, git add e git commit ti consentono di suddividere una modifica al repository principale in sub-cambiamenti logici sistematici. Come hanno sottolineato altre risposte e commenti, ci sono naturalmente molti più usi per loro. Tuttavia, questo è uno degli usi più comuni e un principio di guida dietro Git è un sistema di controllo di revisione multistadio a differenza di altri popolari come Svn.

git commit è di impegnare i file che è messo in scena nel repository locale. git push è di far avanzare rapidamente il ramo master del lato locale con il ramo master remoto. Ma l’unione non avrà sempre successo. Se il rifiuto appare, devi pull modo da poter effettuare una git push successo.

Bene, in pratica git commit inserisce le modifiche nel repository locale, mentre git push invia le modifiche nella posizione remota. Poiché git è un sistema di controllo della versione distribuito, la differenza è che commit eseguirà modifiche al repository locale, mentre push sposterà le modifiche fino a un repository remoto

fonte Google

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

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