Git
Förgrening

Syntax

• git branch [--set-upstream | --track | --no-track] [-l] [-f] <branchname> [<start-point>]
• git branch (--set-upstream-to=<upstream> | -u <upstream>) [<branchname>]
• git branch --unset-upstream [<branchname>]
• git branch (-m | -M) [<oldbranch>] <newbranch>
• git branch (-d | -D) [-r] <branchname>…​
• git branch --edit-description [<branchname>]
• git branch [--color[=<when>] | --no-color] [-r | -a] [--list] [-v [--abbrev=<length> | --no-abbrev]] [--column[=<options>] | --no-column] [(--merged | --no-merged | --contains) [<commit>]] [--sort=<key>] [--points-at <object>] [<pattern>…​]

parametrar

Anmärkningar

Lista grenar

Git tillhandahåller flera kommandon för listning av grenar. Alla kommandon använder funktionen av git branch , som ger en lista över vissa grenar, beroende på vilka alternativ som finns på kommandoraden. Git anger om möjligt den för närvarande valda grenen med en stjärna bredvid.

Anmärkningar :

• Att lägga till ytterligare v till -v t.ex. $ git branch -avv eller $ git branch -vv kommer också att skriva ut namnet på uppströmsgrenen.
• Grenar som visas i röd färg är avlägsna grenar

Skapa och kolla in nya grenar

För att skapa en ny gren, medan du stannar kvar i den nuvarande grenen, använd:

git branch <name>

I allmänhet får filialnamnet inte innehålla mellanslag och omfattas av andra specifikationer som anges här . Så här byter du till en befintlig filial:

git checkout <name>

Så här skapar du en ny gren och byter till den:

git checkout -b <name>

För att skapa en gren på en annan punkt än den senaste åtagandet för den nuvarande grenen (även känd som HEAD) använder du någon av dessa kommandon:

git branch <name> [<start-point>]
git checkout -b <name> [<start-point>]

<start-point> kan vara vilken revision som helst som är känd för git (t.ex. ett annat grennamn, begå SHA eller en symbolisk referens som HEAD eller ett tagnamn):

git checkout -b <name> some_other_branch
git checkout -b <name> af295
git checkout -b <name> HEAD~5
git checkout -b <name> v1.0.5

Så här skapar du en gren från en fjärrgren (standard <remote_name> är ursprung):

git branch <name> <remote_name>/<branch_name>
git checkout -b <name> <remote_name>/<branch_name>

Om ett visst grennamn bara finns på en fjärrkontroll kan du helt enkelt använda

git checkout -b <branch_name>

vilket motsvarar

git checkout -b <branch_name> <remote_name>/<branch_name>

Ibland kan du behöva flytta flera av dina senaste åtaganden till en ny filial. Detta kan uppnås genom att förgrena sig och "rulla tillbaka", så:

git branch <new_name>
git reset --hard HEAD~2 # Go back 2 commits, you will lose uncommitted work.
git checkout <new_name>

Här är en illustrativ förklaring av denna teknik:

 Initial state       After git branch <new_name>    After git reset --hard HEAD~2
                             newBranch                        newBranch
                                 ↓                                ↓
A-B-C-D-E (HEAD)         A-B-C-D-E (HEAD)                 A-B-C-D-E (HEAD)
        ↑                        ↑                            ↑
      master                   master                       master

Radera en gren lokalt

$ git branch -d dev

Tar bort den gren som heter dev om dess förändringar slås samman med en annan gren och inte går förlorade. Om dev grenen innehåller ändringar som ännu inte har släppts samman som skulle gå förlorade, kommer git branch -d att misslyckas:

$ git branch -d dev
error: The branch 'dev' is not fully merged.
If you are sure you want to delete it, run 'git branch -D dev'.

Enligt varningsmeddelandet kan du tvinga ta bort grenen (och förlora eventuella obegränsade ändringar i den grenen) med hjälp av -D flaggan:

$ git branch -D dev

Kolla in en ny filial som spårar en fjärrfilial

Det finns tre sätt att skapa en ny feature som spårar det fjärrgrenade origin/feature :

• git checkout --track -b feature origin/feature ,
• git checkout -t origin/feature ,
• git checkout feature - förutsatt att det inte finns någon lokal feature och att det bara finns en fjärrkontroll med feature .

Så här ställer du in uppströmmen för att spåra den fjärrgrenade typen:

• git branch --set-upstream-to=<remote>/<branch> <branch>
• git branch -u <remote>/<branch> <branch>

var:

• <remote> kan vara: origin , develop eller den som skapats av användaren,
• <branch> är användarens gren att spåra på fjärrkontrollen.

För att verifiera vilka fjärrgrenar dina lokala filialer spårar:

• git branch -vv

Byt namn på en gren

Byt namn på filialen du har checkat ut:

git branch -m new_branch_name

Byt namn på en annan gren:

git branch -m branch_you_want_to_rename new_branch_name

Skriv över en enda fil i den aktuella arbetskatalogen med samma från en annan gren

Den utcheckade filen kommer att skriva över ändringar som du gjorde i den här filen än.

Detta kommando kommer att kolla in filen file.example (som finns i path/to/ ) och skriv över alla ändringar du kan ha gjort i den här filen.

git checkout some-branch path/to/file

some-branch kan vara allt tree-ish känt för git (se Revisionsval och gitrevisioner för mer information)

Du måste lägga till -- innan sökvägen om din fil kan misstas för en fil (valfritt annars). Inga fler alternativ kan tillhandahållas efter -- .

git checkout some-branch -- some-file

Den andra some-file är en fil i det här exemplet.

Radera en fjärrgren

Om du vill ta bort en gren i origin fjärrlager kan du använda för Git version 1.5.0 och nyare

git push origin :<branchName>

och från Git version 1.7.0 kan du ta bort en fjärrgren med

git push origin --delete <branchName>

Så här tar du bort en lokal fjärrspårningsgren:

git branch --delete --remotes <remote>/<branch>
git branch -dr <remote>/<branch> # Shorter

git fetch <remote> --prune # Delete multiple obsolete tracking branches
git fetch <remote> -p      # Shorter

För att radera en gren lokalt. Observera att detta inte kommer att ta bort grenen om den inte har några ändrade ändringar:

git branch -d <branchName>

Så här tar du bort en gren, även om den har obearbetade ändringar:

git branch -D <branchName>

Skapa en föräldralös gren (dvs. filial utan förälderåtagande)

git checkout --orphan new-orphan-branch

Det första åtagandet som gjorts för denna nya gren kommer inte att ha några föräldrar och det kommer att vara roten till en ny historia helt kopplad från alla andra grenar och åtaganden.

källa

Tryck grenen till fjärrkontrollen

Används för att flytta åtaganden gjorda på din lokala filial till ett fjärrlager.

git push kommandot tar två argument:

• Ett fjärrnamn, till exempel, origin
• Ett filialnamn, till exempel master

Till exempel:

git push  <REMOTENAME> <BRANCHNAME>

Som ett exempel kör du vanligtvis git push origin master att driva dina lokala förändringar i ditt onlineförvar.

--set-upstream använder -u (förkortning för - --set-upstream ) kommer du att ställa in spårningsinformationen under tryckningen.

git push -u <REMOTENAME> <BRANCHNAME>

Som standard trycker git den lokala grenen till en fjärrgren med samma namn. Till exempel, om du har en lokal som kallas new-feature , om du trycker den lokala grenen kommer det att skapa en avlägsen gren new-feature också. Om du vill använda ett annat namn för fjärr gren, lägga fjärrkontrollen namn efter den lokala grenen namn, separerade med : :

git push <REMOTENAME> <LOCALBRANCHNAME>:<REMOTEBRANCHNAME>

Flytta nuvarande gren HEAD till ett godtyckligt engagemang

En gren är bara en pekare till en åtagande, så att du fritt kan flytta den runt. För att göra det så att grenen hänvisar till commit aabbcc , utfärda kommandot

git reset --hard aabbcc

Observera att detta kommer att skriva över filialens nuvarande åtagande, och som så, hela historien. Du kan tappa lite arbete genom att utfärda det här kommandot. Om så är fallet kan du använda refloggen för att återställa de förlorade åtagandena. Det kan rekommenderas att utföra detta kommando på en ny gren istället för din nuvarande.

Detta kommando kan emellertid vara särskilt användbart när du omsätter eller gör sådana andra stora historikmodifieringar.

Snabbväxling till föregående gren

Du kan snabbt växla till föregående gren med

git checkout -

Sök i grenar

För att lista lokala grenar som innehåller ett specifikt engagemang eller tagg

git branch --contains <commit>

För att lista lokala och fjärrgrenar som innehåller ett specifikt engagemang eller tagg

git branch -a --contains <commit>