Was sind die Unterschiede zwischen "Git Commit" und "Git Push"?

In einem Git-Tutorial, das ich gerade durchlaufe, git commitwerden die von Ihnen vorgenommenen Änderungen gespeichert.

Wofür wird git pushdann verwendet?

Grundsätzlich git commit" zeichnet Änderungen am Repository auf ", während git push" Remote-Refs zusammen mit zugehörigen Objekten aktualisiert werden ". Das erste wird also in Verbindung mit Ihrem lokalen Repository verwendet, während das letztere für die Interaktion mit einem Remote-Repository verwendet wird.

Hier ist ein schönes Bild von Oliver Steele , das das Git-Modell und die Befehle erklärt:

Lesen Sie mehr über git pushund git pullauf GitReady.com (der Artikel, auf den ich mich zuerst bezog)

Festschreiben : Hinzufügen von Änderungen zum lokalen Repository

push : um die letzten Commits auf einen Remote-Server zu übertragen

Im Grunde genommen speichert git commit Ihre Änderungen in Ihrem lokalen Repo, während git push Ihre Änderungen an den Remote-Standort sendet.

git pushwird verwendet, um Commits, die Sie im lokalen Repository vorgenommen haben, zu einem Remote-Repository hinzuzufügen. Zusammen mit git pullermöglicht es den Mitarbeitern, zusammenzuarbeiten.

Da git ein verteiltes Versionskontrollsystem ist, besteht der Unterschied darin, dass durch das Festschreiben Änderungen an Ihrem lokalen Repository festgeschrieben werden, während durch das Drücken Änderungen an ein Remote-Repo übertragen werden.

Festschreiben : Snapshot | Änderungssatz | History_record | Version | 'Speichern unter' eines Repositorys. Git-Repository = Reihe (Baum) von Commits .

Lokales Repository: Repository auf Ihrem Computer.

Remote- Repository: Repository auf einem Server ( Github ).

git commit: Hängen Sie ein neues Commit (letztes Commit + bereitgestellte Änderungen) an das lokale Repository an. (Alle Commits werden in gespeichert /.git)

git push, git pull: Synchronisieren Sie das lokale Repository mit dem zugehörigen Remote- Repository. push- Änderungen von lokal auf remotepull anwenden , - Änderungen von remote auf lokal anwenden .

git commitNotieren Sie Ihre Änderungen im lokalen Repository.

git push Aktualisieren Sie das Remote- Repository mit Ihren lokalen Änderungen.

Drei Dinge zu beachten:

1) Arbeitsverzeichnis ----- Ordner, in dem unsere Codedatei vorhanden ist

2) Lokales Repository ------ Dies befindet sich in unserem System. Wenn wir zum ersten Mal den Befehl COMMIT ausführen, wird dieses lokale Repository erstellt. An derselben Stelle, an der sich unser Arbeitsverzeichnis befindet, wird die
Checkit-Datei (.git) erstellt.
Wenn danach ein Commit durchgeführt wird, werden die Änderungen, die wir in der Datei des Arbeitsverzeichnisses vorgenommen haben, im lokalen Repository (.git) gespeichert.

3) Remote Repository ----- Dieses befindet sich außerhalb unseres Systems wie auf Servern auf der ganzen Welt. wie Github. Wenn wir den PUSH-Befehl ausführen, werden Codes aus unserem lokalen Repository in diesem Remote-Repository gespeichert

Ich möchte nur die folgenden Punkte hinzufügen:

Sie können nicht pushen, bis Sie ein Commit durchführen, da wir git pushCommits, die in Ihrem lokalen Zweig vorgenommen wurden, in ein Remote-Repository pushen.

Der git pushBefehl akzeptiert zwei Argumente:

Ein entfernter Name, z. B. origin Ein Filialname, z.master

Zum Beispiel:

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

Eine sehr grobe Analogie: Wenn wir mit git commitdem Speichern einer bearbeiteten Datei vergleichen , wird git pushdiese Datei an einen anderen Speicherort kopiert.

Bitte nehmen Sie diese Analogie nicht aus diesem Kontext heraus - Festschreiben und Pushing sind nicht ganz so, als würden Sie eine bearbeitete Datei speichern und kopieren. Das heißt, es sollte für Vergleiche gelten.

Es ist einfacher, die Verwendung der git-Befehle zu verstehen, addund commitwenn Sie sich vorstellen, dass eine Protokolldatei in Ihrem Repository auf Github verwaltet wird. Die Protokolldatei eines typischen Projekts sieht für mich möglicherweise folgendermaßen aus:

---------------- 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

Normalerweise beginne ich meinen Tag mit einer git pullAnfrage und beende ihn mit einer git pushAnfrage. Alles in einem Tagesbericht entspricht also dem, was zwischen ihnen passiert. Während eines jeden Tages erledige ich eine oder mehrere logische Aufgaben , bei denen einige Dateien geändert werden müssen. Die während dieser Aufgabe bearbeiteten Dateien werden in einem Index aufgelistet.

Jede dieser Unteraufgaben (Aufgabe A und Aufgabe B hier) sind individuelle Commits. Der git addBefehl fügt Dateien zur Liste "Index der geänderten Dateien" hinzu. Dieser Prozess wird auch als Staging bezeichnet und zeichnet in Wirklichkeit geänderte Dateien und die durchgeführten Änderungen auf. Der git commitBefehl zeichnet die Änderungen und die entsprechende Indexliste zusammen mit einer benutzerdefinierten Nachricht auf, die zur späteren Bezugnahme verwendet werden kann.

Denken Sie daran, dass Sie immer noch nur die lokale Kopie Ihres Repositorys ändern und nicht die auf Github. Danach werden nur dann, wenn Sie git pushalle diese aufgezeichneten Änderungen zusammen mit Ihren Indexdateien für jedes Commit ausführen, im Hauptrepository (auf Github) protokolliert.

Um beispielsweise den zweiten Eintrag in dieser imaginären Protokolldatei zu erhalten, hätte ich Folgendes getan:

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

Kurz gesagt, git addund git commitSie können eine Änderung am Haupt-Repository in systematische logische Unteränderungen aufteilen. Wie andere Antworten und Kommentare gezeigt haben, gibt es natürlich noch viel mehr Verwendungszwecke. Dies ist jedoch eine der häufigsten Anwendungen und ein treibendes Prinzip hinter Git, da es sich im Gegensatz zu anderen gängigen Systemen wie Svn um ein mehrstufiges Revisionskontrollsystem handelt.

Git Commit ist nichts anderes als das offizielle Speichern unserer Änderungen. Für jedes Commit, das wir Commit-Nachrichten senden, können wir es nach Abschluss der Commits auf Remote übertragen, um unsere Änderungen global zu sehen

Dies bedeutet, dass wir zahlreiche Commits ausführen können, bevor wir auf Remote übertragen (wir können die Liste der aufgetretenen Commits und auch die Nachrichten sehen). git speichert jedes Commit mit einer Commit-ID, die ein 40-stelliger Code ist

und ich benutze git push nur, wenn ich meine Änderung in remote sehen wollte (danach werde ich prüfen, ob mein Code in Jenkins funktioniert hat)

Im Grunde genommen speichert git commit Ihre Änderungen in Ihrem lokalen Repo, während git push Ihre Änderungen an den Remote-Standort sendet. Da git ein verteiltes Versionskontrollsystem ist, besteht der Unterschied darin, dass durch das Festschreiben Änderungen an Ihrem lokalen Repository festgeschrieben werden, während durch das Drücken Änderungen an ein Remote-Repo übertragen werden

Quelle Google

http://gitref.org/basic/ Dieser Link wird auch sehr nützlich sein

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

Für Laien git commitist dies der Schritt, bevor git pushSie sie in dieser Reihenfolge ausführen, um Ihre Datei erfolgreich an github zu senden.

git commitist das Festschreiben der Dateien, die im lokalen Repo bereitgestellt werden. git pushbesteht darin, den Hauptzweig der lokalen Seite schnell mit dem entfernten Hauptzweig zusammenzuführen. Die Fusion wird jedoch nicht immer erfolgreich sein. Wenn Ablehnung erscheint, müssen Sie, pulldamit Sie eine erfolgreiche machen können git push.