Zusammenfassung der häufig verwendeten Git-Befehle

Git-TutorialIn der Spalte werden häufig verwendete Git-Befehle vorgestellt Alle lokalen Filialen anzeigen

git status Aktuellen Status anzeigen

git commit Submit

git branch -a Alle Branches anzeigengit branch -r Alle Remote-Branches anzeigengit commit -am "init" Kommentare absenden und hinzufügen

git remote add origin git @192.168.1.119:ndshow

git push origin master Schieben Sie die Datei auf den Server

git remote show origin Zeigt die Ressourcen in der Remote-Bibliothek origin an

git push origin master:develop

git push origin master:hb -dev Ordnen Sie die lokale Bibliothek der Bibliothek auf dem Server zu

git checkout --track origin/dev Wechseln Sie zum Remote-Dev-Zweig

git branch -D master Develop Löschen Sie die lokale Bibliothek Develop

git checkout -b dev Erstellen Sie a neuer lokaler Zweig dev

git merge origin/dev Zweig dev mit dem aktuellen Zweig zusammenführen

git checkout dev Zum lokalen Entwicklungszweig wechseln

git remote show Remote-Bibliothek anzeigen

git add .

git rm file name ( einschließlich Pfad) aus Löschen Sie die angegebene Datei in Git

git clone git://github.com/schacon/grit.git Ziehen Sie den Code vom Server ab

git config --list, um alle Benutzer anzuzeigen

git ls-files um zu sehen, was übermittelt wurde.

git rm [Dateiname] löscht eine Datei.

git commit -a schreibt alle Änderungen an den aktuellen Repos fest.

git add [Dateiname] fügt eine Datei zum Git-Index hinzu.

git commit -v, wenn Sie -v verwenden. Sie können den Unterschied beim Festschreiben sehen, wenn Sie Parameter angeben den Git-Index und dann Commit.

git commit -a -v Allgemeiner Commit-Befehl git rm --cached a.a Dateien entfernen (nur aus dem Staging-Bereich löschen)

git commit -m "remove" Dateien entfernen (aus Git löschen)

git rm -f a.a Geänderte Dateien zwangsweise entfernen (aus dem Staging-Bereich gelöscht und workspace)

git diff --cached oder $ git diff --staged, um nicht festgeschriebene Updates anzuzeigen

git stash push verschiebt die Datei in einen temporären Bereich

git stash pop wird die Datei aus dem temporären Bereich entfernen

- ----------------------------------------------- --- ------------

git remote add origin git@github.com:username/Hello-World.git

git push origin master Senden Sie das lokale Projekt an den Server

---- ---------------------------------------------- ---- ------

git pull lokale und Server-Synchronisierung

--------------------------------- - ---------------------------------

git push (Name des Remote-Lagers) (Name der Filiale) wird lokal Push Verzweigung zum Server.

git push origin serverfix:awesomebranch

------------------------------------------------------- --------------------------

git fetch entspricht dem Abrufen der neuesten Version von der Fernbedienung auf die lokale Version, es wird nicht automatisch zusammengeführt

git commit -a -m "log_message" (-a dient zum Übermitteln aller Änderungen, -m dient zum Hinzufügen von Protokollinformationen) Lokale Änderungen werden mit dem Server synchronisiert:

git branch branch_0.1 master Erstellen Sie den Zweig branch_0.1 aus dem Hauptzweig Master

git branch -m branch_0.1 branch_1.0 Branch_0.1 in branch_1.0 umbenennen

git checkout branch_1.0/master Zu branch_1.0/master wechseln branch

du -hs

git branch Löschen Remote-Zweig

git push origin :branch_remote_name

git branch -r -d branch_remote_name

-------------------------------------------- ---------- ---------

Initialisieren Sie das Repository und senden Sie es an den Remote-Server

mkdir WebApp

cd WebApp

git init lokale Initialisierung

touch README

git add README Dateien hinzufügen

git commit -m 'first commit'

git remote add origin git@github.com:daixu/WebApp.git

Add ein Remote-Server

Der obige Befehl fügt hinzu: Die URL-Adresse lautet „git@github.com:daixu/WebApp.git“, und die Remote-Server-Bibliothek heißt „Origin“. Wenn Sie in Zukunft Code senden, müssen Sie nur noch verwenden Ursprungsalias

2. Git-Befehls-Spickzettel

Kurzbeschreibung des Befehls

git zum Staging-Bereich hinzufügen

git add – interaktives Hinzufügen von Git-Anwendungen

git am-Anwendung E-Mail-Format-Patch

Git-Annotate-Synonym, äquivalent zu Git Blame

Git-Archivdateiarchivierung und -verpackung

Git-Bisect-Binärsuche

Git-Blamme-Datei zeilenweise Nachverfolgung

Git-Branch-Branch-Management

Git-Cat-Datei Tool zur Recherche von Repository-Objekten

git checkout Zum Arbeitsbereich auschecken, wechseln Oder einen Zweig erstellen

git Cherry-Pick-Übermittlungsauswahl

git citool grafische Übermittlung, äquivalent zum Git-GUI-Befehl

git clean löscht nicht verfolgte Dateien im Arbeitsbereich

git clone klont das Repository

git commit

git config Konfiguration abfragen und ändern

git discover zeigt Commit-IDs anhand von Meilensteinen visuell an.

git diff-Differenzvergleich.

git difftool ruft das grafische Differenzvergleichstool auf.

git fetch, um die Commits des Remote-Repositorys abzurufen.

git format-patch erstellt eine Patchdatei im E-Mail-Format . Siehe Git-AM-Befehl

Git Grep-Tool zum Suchen und Speichern von Dateiinhalten

Git GUI ist ein grafisches Tool, das auf Tcl/Tk basiert und sich auf Vorgänge wie die Übermittlung konzentriert.

git Help

git init Repository-Initialisierung

git init-db * Synonyme, äquivalent zu git init. Git Log zeigt das Commit-Protokoll an das Remote-Repository

Git Rebase Branch Rebase

Git Rebase – interaktives interaktives Branch Rebase

Git Reflog Branch und andere Referenz-Änderungsdatensatzverwaltung

Git Remote Remote Repository Management

Git Repo-Config* Synonym, äquivalent zu Git Config

git reset setzt den „Cursor“ des Änderungszweigs zurück, auf den zeigt

git rev-parse konvertiert verschiedene Referenzdarstellungen in Hashes usw.

git revert kehrt Commits um

git rm löscht Dateien

git show zeigt jeden A-Objekttyp an

Git Stage* Synonym, äquivalent zu Git Add

Git Stash Save and Restore Fortschritt

Git Status zeigt den Status der Arbeitsbereichsdatei an

Git Tag Meilensteinverwaltung

2. Befehle für den Objektbibliotheksvorgang

Befehl Kurzbeschreibung

Git Commit -tree erstellt Commits aus Baumobjekten.

git hash-object berechnet Hashes oder erstellt Objekte aus Standardeingaben oder Dateien.

git ls-files zeigt Workspace- und Staging-Area-Dateien an.

git ls-tree zeigt die im Baumobjekt enthaltenen Dateien an

git mktag liest die Standardeingabe und erstellt ein Meilensteinobjekt.

git mktree liest die Standardeingabe und erstellt ein Baumobjekt.

git read-tree liest das Baumobjekt in den Staging-Bereich der Staging-Bereich und die Staging-Bereichsverwaltung

git unpack-file erstellt eine temporäre Datei mit dem Inhalt des angegebenen Blobs

git write-tree erstellt ein Baumobjekt aus dem Staging-Bereich

3 Befehle im Zusammenhang mit Referenzoperationen

Befehl Kurzbeschreibung

git check-ref-format prüft, ob der Referenzname der Spezifikation entspricht

git for-each-ref Referenziterator, der für die Shell-Programmierung verwendet wird

git ls-remote zeigt Referenzen auf Remote-Repositorys an

git name- rev zeigt die Commit-ID als Anzeigenamen an

git peek-remote* veralteter Befehl, bitte verwenden Sie git ls-remote

git rev-list zeigt den Versionsbereich an

git show-branch zeigt die Verzweigungsliste und die topologische Beziehung an

git show-ref zeigt lokale Referenzen an.

git symbolic-ref zeigt symbolische Referenzen an oder legt sie fest Beschreibung des Befehls

git count-objects zeigt die Anzahl der losen Objekte und die Festplattennutzung an.

git Filter-Branch-Repository-Rekonstruktion Git gc Repository-Speicheroptimierung

git index-pack erstellt die entsprechende Indexdatei aus der gepackten Datei

git lost-found* ist veraltet, bitte verwenden Sie den Befehl git fsck –lost-found

git pack-objects liest aus dem Standard Geben Sie die Objekt-ID ein und packen Sie sie in eine Datei.

git pack-redundant findet redundante Packdateien.

git pack-refs packt Referenzen in .git/packed-refs-Dateien.

git prune löscht abgelaufene Objekte aus der Objektbibliothek.

git prune-packed löscht die gepackten losen Objekte.

git relink stellt einen festen Link für dasselbe Objekt im lokalen Repository her.

git repack packt die entpackten losen Objekte im Repository.

git show-index liest die Indexdatei des Pakets und zeigt den Inhalt an in der gepackten Datei: git unpack-objects gibt die Datei aus der gepackten Datei frei Führt git fetch aus. Oder führen Sie diesen Befehl lokal aus, wenn Sie den Befehl git pull ausführen, der zum Abrufen fehlender Objekte aus anderen Repositorys verwendet wird. Git Receive-Pack. Dieser Befehl wird remote ausgeführt, wenn der Befehl Git Push ausgeführt wird, der zum Empfangen von Push-Daten verwendet wird -pack Ein Befehl, der lokal beim Ausführen des Befehls „git push“ ausgeführt wird und zum Übertragen von Daten in andere Repositorys verwendet wird.

git upload-archive Beim Ausführen des Befehls „git archive –remote“ zum Erstellen eines Archivs basierend auf dem Remote-Repository führt das Remote-Repository diesen Befehl aus um das Archiv zu übertragen

git Wenn upload-pack den Befehl git fetch oder git pull ausführt, führen Sie diesen Befehl remote aus, um das Objekt zu packen und hochzuladen

Kurze Beschreibung des Befehls

git imap -send sendet den Patch über IMAP.

git mailinfo from Mail exportiert Übermittlungsanweisungen und Patches.

git mailsplit extrahiert E-Mails in Postfächern im Mbox- oder Maildir-Format einzeln in Dateien.

git request-pull erstellt Informationen, die Unterschiede zwischen Übermittlungen und Adressen enthalten Durchführen von PULL-Operationen

git send-email sendet E-Mails

7. Protokollbezogene Befehle

Kurze Beschreibung des Befehls

git-Daemon implementiert das Git-Protokoll

git http-backend implementiert das CGI-Programm des HTTP-Protokolls und unterstützt das Intelligentes HTTP-Protokoll

git instaweb startet sofort den Browser und durchsucht die aktuelle Versionsbibliothek über gitweb

Git-Shell Eine eingeschränkte Shell, die SSH-Zugriff bietet, um nur Git-Befehle auszuführen

git update-server-info aktualisiert die vom Dumb-Protokoll benötigten Hilfsdateien.

git http-fetch ruft das Repository über das HTTP-Protokoll ab.

git http-push pusht über das HTTP/DAV-Protokoll.

git remote-ext wird aufgerufen über den Git-Befehl bieten externe Befehle erweiterte Protokollunterstützung.

git remote-fd wird vom Git-Befehl aufgerufen, wobei Dateideskriptoren als Protokollschnittstelle verwendet werden.

git remote-ftp wird vom Git-Befehl aufgerufen und bietet Unterstützung für FTP Protokoll

git remote-ftps wird vom Git-Befehl aufgerufen und bietet Unterstützung für das FTPS-Protokoll.

git remote-http wird vom Git-Befehl aufgerufen und bietet Unterstützung für das HTTP-Protokoll.

git remote-https wird vom aufgerufen Git-Befehl, der Unterstützung für das HTTPS-Protokoll bietet Das Bundle übermittelt das Packen und Entpacken zur Übertragung zwischen verschiedenen Repositorys.

git cvsexportcommit Git Ein Commit fungiert als CVS-Checkout.

git cvsimport importiert ein CVS-Repository in Git. Oder verwenden Sie cvs2git

git cvsserverGits CVS-Protokollsimulator, der CVS-Befehlen den Zugriff auf Git-Repositorys ermöglicht

git fast-export zum Exportieren von Übermittlungen in das Git-Fast-Import-Format

git Fast-Import zum Migrieren anderer Repositorys zum Git General-Tool

git svnGit als Front-End-Operation Subversion

9. Merge-bezogene Hilfsbefehle

Kurze Beschreibung des Befehls

git merge-base kann von anderen Skripten aufgerufen werden, um den nächsten gemeinsamen Vorfahren von zwei oder mehr Commits zu finden

git merge -file führt eine Drei-Wege-Dateizusammenführung für zwei verschiedene Versionen der Datei durch.

git merge-index ruft das angegebene Konfliktlösungstool für widersprüchliche Dateien im Index auf.

git merge-octopus führt mehr als zwei Zweige zusammen. Sehen Sie sich die Octopus-Merge-Strategie von Git Merge an. Siehe git merge für unsere Zusammenführungsstrategie

git merge-recursive für eine Drei-Wege-Zusammenführung zweier Zweige. Sehen Sie sich die rekursive Zusammenführungsstrategie von Git Merge an. Git Merge-Resolve für eine Drei-Wege-Zusammenführung zweier Zweige. Sehen Sie sich die Resolve-Merge-Strategie von Git Merge an

git merge-subtree subtree merge. Sehen Sie sich die Subtree-Merge-Strategie von Git Merge an. Git Merge-Tree liefert explizite Drei-Wege-Merge-Ergebnisse, ohne den Staging-Bereich zu ändern. Git FMT-Merge-Msg wird für Skriptaufrufe zur Durchführung von Merge-Vorgängen und zum Erstellen einer Merge verwendet Beschreibung festschreiben

git rerere verwendet die aufgezeichnete Konfliktlösung wieder

10. Verschiedenes

Kurzbeschreibung des Befehls

git bisect–helper wird vom Befehl git bisect aufgerufen, um den Fortschritt der binären Suche zu bestätigen

git check-attr zeigt an, ob ein bestimmter Datei ist auf Attribute festgelegt

git checkout-index kopiert Dateien aus dem Staging-Bereich in den Arbeitsbereich.

git Cherry sucht nach Commits, die nicht in den Upstream zusammengeführt wurden git diff –raw

git diff-index vergleicht den Staging-Bereich und das Repository, was git diff –cached –raw

git diff-tree vergleicht zwei Baumobjekte, was git diff –raw A B

entspricht git difftool–helper wird vom Befehl git difftool aufgerufen. Das zu verwendende Standard-Differenzvergleichstool. Git get-tar-commit-id extrahiert die Commit-ID aus dem TAR-Paket, das mit dem Befehl git archive erstellt wurde GUI erhält Benutzerpasswort-Eingabeschnittstelle

Git Notes Submission Comment Management

git Patch-ID generiert eine eindeutige Patch-ID nach dem Filtern von Zeilennummern und Leerzeichen

git Quiltimport wendet die Quilt-Patchliste auf den aktuellen Zweig an

git Replacement sendet die Ersatz

git shortlog fasst die Ausgabe von git log zusammen, geeignet für Produktversionshinweise

git stripspace löscht leere Zeilen für andere Skriptaufrufe

git submodule submodule management

git tar-tree veralteter Befehl, bitte verwenden Sie git archive

git var zum Anzeigen von Git-Umgebungsvariablen

git Web – Browser zum Durchsuchen des Startups zum Anzeigen von Verzeichnissen oder Dateien

git whatchanged zeigt den Commit-Verlauf und die Änderungen jedes Commits an

git-mergetool–lib ist in anderen Skripten enthalten, um die Auswahl und Ausführung bereitzustellen von Merge/Diff-Vergleichstools

git-parse-remote In anderen Skripten enthalten und bietet Funktionen für den Betrieb von Remote-Repositorys

git-sh-setup In anderen Skripten enthalten und stellt Funktionsbibliotheken für die Shell-Programmierung bereit

Git-Befehlsreferenzhandbuch ( Textversion)

git init​ #Initialization Lokales Git-Repository (ein neues Repository erstellen)

git config --global user.name "xxx"                                                                                                                                                             Lokales Git-RepositoryIgit Config -Global Color.ui True # Git Status und andere Befehle automatisch gefärbt

Global Color.status Auto

git Config -Global Color.diff Auto

-Global Color.branch Auto

git config --global color .interactive auto

git clone git+ssh://git@192.168.53.168/VT.git   ​​​ # Überprüfen Sie den aktuellen Versionsstatus (ob geändert)

git add. xyz                                                                                                     Alle geänderten Dateien im zu indizierenden Unterverzeichnis

git commit -m 'xxx'                                                                                                                                                                                       . Den letzten Commit zusammenführen (für wiederholte Änderungen)

git commit -am 'xxx '                                                             # Dateien im Index löschen

git rm -r.                                                                                                                                                                                                                                            Für n Zeilen

git log -5

git log --stat   m

git show dfb02e6e4f2f7b573337763e5c0013802e392818                                                                                            #Sie können nur die ersten paar Ziffern der Commit-ID verwenden

git show HEAD# Vorhandene Tags

Git Tag -a v2. # Vergleichen Sie die Unterschiede mit der vorherigen Version

git diff HEAD -- ./lib # Vergleich mit der Head-Version des LIB-Verzeichnisses

git Diff Origin/Master # Im Vergleich zum Remote Branch Master gibt es lokale Branches Master

git Diff Origin/Master. Master -Stat # zeigt nur Unterschiede, es wird kein spezifischer Inhalt angezeigt

git remote add origin git+ssh://git@192.168.53.168/VT.git # Remote-Definition hinzufügen (für Push/Pull/Fetch)

Git Ast

Git Branch -enthält 50089 Ast -r -Zweig

git branch --no-merged                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Fehlerrollback ändern. Zweig des Remote-Warehouse

git push --tags # Alle Tags in das Remote-Repository verschieben

git                                                             (Zusammenführung erforderlich)

git fetch --prune                                                                

git mv README README2                                           Benennen Sie die Datei README in README2 um

git reset --hard HEAD                                                                              # Zweig löschen (Änderungen dieses Zweigs wurden in andere Zweige zusammengeführt)

git branch -D hotfixes/BJVEP933                                                                                 # Listen Sie die im Git-Index enthaltenen Dateien auf

Git Show-Branch Branch -Al # 示 Gesamter Zweigverlauf

git WhatChanged # Zeigt die Dateien an, die den entsprechenden Verlauf des Verlaufs übermitteln 63E5C0013802E392818

git LS-Tree Head # Interner Befehl: Zeigt ein bestimmtes Git-Objekt an

git rev-parse v2. 0                                                                                              Alle Commits, einschließlich verwaiste Knoten

git show HEAD@{5}

git show master@{gestern}                                                                         Master-Zweigstatus von gestern

git log -pretty = Format: ' %h %s' -graph # Symbol zum Senden von Protokollen

git show head ~ 3

git show git stash                                                                                                                                                                                 # Alle Stashes

git stash show -p stash@{0}   {0}                                                                                                                                                                   „Git Grep „Delete from“ # file Durchsuchen Sie den Text „Delete from“

git Grep -e '#Define' -And -E Sort_dirent

git GC

Git FSCK

Git ist eine sehr leistungsstarke Versionskontrolle für verteilte Formeln System. Es eignet sich nicht nur für die Verwaltung des Quellcodes umfangreicher Open-Source-Software, sondern bietet auch viele Vorteile bei der Verwaltung privater Dokumente und Quellcodes.

Allgemeine Git-Betriebsbefehle:

1) Remote-Warehouse-bezogene Befehle

Sehen Sie sich das Warehouse an: $ git clone git://github.com/jquery/jquery.git

Sehen Sie sich das Remote-Warehouse an: $ git remote -v

Ein Remote-Repository hinzufügen: $ git remote add [name] [url]

Ein Remote-Repository löschen: $ git remote rm [name]

Ein Remote-Repository ändern: $ git remote set-url --push [name] [newUrl]

Ziehen Sie das Remote-Warehouse: $ git pull [remoteName] [localBranchName]

Pushen Sie das Remote-Warehouse: $ git push [remoteName] [localBranchName]

*Wenn Sie einen lokalen Zweigtest an die Fernbedienung senden möchten Warehouse und verwenden Sie es als Remote-Warehouse-Master-Zweig oder als einen anderen Zweig mit dem Namen test wie folgt:

$git push origin test:master // Senden Sie den lokalen Testzweig als Remote-Master-Zweig

$git push origin test :test // Senden Sie den lokalen Test. Der Zweig wird als Remote-Testzweig verwendet

2) Befehle für den Zweigbetrieb

Lokalen Zweig anzeigen: $ git branch

Remote-Zweig anzeigen: $ git branch -r

Erstellen ein lokaler Zweig: $ git branch [name] - ---Beachten Sie, dass der neue Zweig nach seiner Erstellung nicht automatisch zum aktuellen Zweig wechselt

Zweig wechseln: $ git checkout [name]

Erstellen Sie einen neuen Zweig und wechseln Sie Sofort zum neuen Zweig: $ git checkout -b [Name]

Zweig löschen:$ git branch -d [Name] ---- Die Option -d kann nur Zweige löschen, die an der Zusammenführung teilgenommen haben, und keine Zweige die nicht zusammengeführt wurden. Wenn Sie einen Zweig erzwingen möchten, können Sie die Option -D verwenden der lokale Zweig zum entfernten Zweig): $ git push origin [name]

Entfernten Zweig löschen: $ git push origin :heads/[name] oder $ gitpush origin :[name]

*Erstellen Sie einen leeren Zweig: (Denken Sie daran Übertragen Sie Ihren aktuellen Zweig, bevor Sie den Befehl „Änderungen am Zweig“ ausführen, andernfalls wird er ohne Reue zwangsweise gelöscht -fdx

3) Version (Tag) betriebsbezogene Befehle

Version anzeigen: $ git tag

Version erstellen: $ git tag [Name]

Version löschen: $ git tag -d [name]

Remote-Version anzeigen : $ git tag -r

Erstellen Sie eine Remote-Version (schieben Sie die lokale Version auf die Remote-Version): $ git push origin [name]

Löschen Sie die Remote-Version: $ git push origin :refs/tags/[name]

Füge die Tags des Remote-Warehouses mit dem lokalen zusammen: $ git pull origin --tags

Lokale Tags in das Remote-Repository hochladen: $ git push origin --tags

Annotierte Tags erstellen: $ git tag -a [name] - m 'yourMessage'

4) Submodulbezogener Operationsbefehl

Submodul hinzufügen: $ git submodule add [url] [path]

Zum Beispiel: $git submodule add git://github.com/soberh/ui-libs. git src/main/webapp/ui-libs

Submodul initialisieren: $ git submodule init ---- Führen Sie es einfach einmal aus, wenn Sie das Warehouse zum ersten Mal auschecken

Submodul aktualisieren: $ git submodule update ---- Sie müssen es jedes Mal ausführen, wenn Sie Zweige aktualisieren oder wechseln.

Submodule löschen: (Vier Schritte)

1) $ git rm --cached [path]

2) Bearbeiten Sie die Datei „.gitmodules“ und löschen Sie die entsprechende Konfiguration Knoten des Submoduls

3) Bearbeiten Sie die Datei „.git/config“, löschen Sie die relevanten Konfigurationsknoten des Submoduls

4) Löschen Sie manuell die verbleibenden Verzeichnisse des Submoduls

5) Ignorieren Sie einige Dateien und Ordner und übermitteln Sie sie nicht

Erstellen Sie einen Namen im Stammverzeichnis des Warehouse: „.gitignore“-Dateien, schreiben Sie unnötige Ordnernamen oder Dateien, jedes Element kann eine Zeile belegen, z. B.

target

bin

*. db

git branch -a Alle Zweige anzeigen

git branch -r Alle lokalen Zweige anzeigen

git commit -am "init" Senden und Kommentare hinzufügen

git remote add origin git@192.168.1.119:ndshow

git push origin master Schieben Sie die Datei auf den Server. Git Remote Show Origin zeigt die Ressourcen in der Remote-Bibliothek Origin an. Git Push Origin Master: Develop. Git Push Origin Master: Hb-dev verknüpft die lokale Bibliothek mit der Bibliothek auf dem Server git checkout --track origin/dev wechselt zum Remote-Dev-Branch

git branch -D master development Lösche die lokale Bibliothek Develop

git checkout -b dev Erstelle einen neuen lokalen Branch dev

git merge origin/dev Füge Branch dev mit zusammen der aktuelle Zweig

git checkout dev Wechseln Sie zum lokalen Entwicklungszweig

git remote show, um die Remote-Bibliothek anzuzeigen

git add .

git rm-Dateiname (einschließlich Pfad) Löschen Sie die angegebene Datei aus git

git clone git://github.com/schacon/grit.git Ziehen Sie den Code vom Server ab

git config - -list um alle Benutzer zu sehen

git ls-files um zu sehen, was übermittelt wurde

git rm [Dateiname] um eine Datei zu löschen

git commit -a um alle Änderungen an den aktuellen Repos zu übernehmen

git add [Dateiname] um eine Datei zum Git-Index hinzuzufügen

git commit -v Wenn Sie den Parameter -v verwenden, können Sie den Unterschied bei Commits sehen

git commit -m „Dies ist die Nachricht, die den Commit beschreibt.“ Commit-Informationen hinzufügen

git commit -a -a steht für „add“, fügt alle Änderungen zum Git-Index hinzu und führt dann einen Commit aus. Git Commit -a -v Allgemeiner Commit-Befehl

git rm a.a Dateien entfernen (aus dem Staging-Bereich und Arbeitsbereich)

git rm --cached a.a Dateien entfernen (nur aus dem Staging-Bereich)

git commit -m "remove" Dateien entfernen (aus Git Delete)

git rm -f a.a, um die geänderte Datei zwangsweise zu entfernen (aus dem Staging-Bereich und Arbeitsbereich löschen)

git diff --cached oder $ git diff --staged, um nicht festgeschriebene Updates anzuzeigen

git stash push Schieben Sie die Datei in einen temporären Bereich

git stash pop Pop die Datei aus dem temporären Bereich

----------------------------------------- ---------- ------------------------

git remote add origin git@github.com:username/Hello-World.git

git push origin master Submit das lokale Projekt auf den Server

--------------------------------- -------- --------------- ------- -------------------------------------------

git push (Remote Warehouse Name) (Zweigname) Pushen Sie den lokalen Zweig an den Server.

git push origin serverfix:awesomebranch

------------------------------------------------------- --------------------------

git fetch entspricht dem Abrufen der neuesten Version von der Fernbedienung auf die lokale Version, es wird nicht automatisch zusammengeführt

git commit -a -m "log_message" (-a soll alle Änderungen übermitteln, -m soll Protokollinformationen hinzufügen) Lokale Änderungen mit dem Server synchronisieren:

git branch branch_0.1 master Erstellen Sie branch_0.1-Zweig vom Hauptzweig branch master

git branch -m branch_0.1 branch_1.0 Branch_0.1 in branch_1.0 umbenennen

git checkout branch_1.0/master Wechsel zu branch_1.0/master branch

du -hs

---- ------ -------------------------------------------- ------

mkdir WebApp

cd WebApp

git init

touch README

git add README

git commit -m 'first commit'

git remote add origin git@github.com:daixu /WebApp.git

git push -u origin master

Das obige ist der detaillierte Inhalt vonZusammenfassung der häufig verwendeten Git-Befehle. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!