git-branch(1)

NAMN

git-branch - Lista, skapa eller radera grenar

SYNOPSIS

git branch [--color[=<när>] | --no-color] [--show-current]

            [-v [--abbrev=<n> | --no-abbrev]]
            [--column[=<alternativ>] | --no-column] [--sort=<nyckel>]
            [--merged [<commit>]] [--no-merged [<commit>]]
            [--contains [<commit>]] [--no-contains [<commit>]]
            [--points-at <objekt>] [--format=<format>]
            [(-r | --remotes) | (-a | --all)]
            [--list] [<mönster>...]

git branch [--track[=(direct|inherit)] | --no-track] [-f]

            [--recurse-submodules] <grennamn> [<startpunkt>]

git branch (--set-upstream-to=<upstream> | -u <upstream>) [<grennamn>] git branch --unset-upstream [<grennamn>] git branch (-m | -M) [<gammalgren>] <nygren> git branch (-c | -C) [<gammalgren>] <nygren> git branch (-d | -D) [-r] <grennamn>... git branch --edit-description [<grennamn>]

BESKRIVNING

Om --list anges, eller om det inte finns några icke-optionsargument, listas befintliga grenar; den aktuella grenen kommer att markeras i grönt och med en asterisk. Alla grenar som är utcheckade i länkade arbetskopior kommer att markeras i cyan och med ett plustecken. Alternativet -r gör att fjärrspårningsgrenar listas, och alternativet -a visar både lokala och fjärrgrenar.

Om ett <mönster> anges används det som ett shell-jokertecken för att begränsa utdata till matchande grenar. Om flera mönster anges visas en gren om den matchar något av mönstren.

Observera att när du anger ett <mönster> måste du använda --list; annars kan kommandot tolkas som skapande av en gren.

Med --contains visas endast de grenar som innehåller den namngivna committen (med andra ord, de grenar vars spets-commits är ättlingar till den namngivna committen), --no-contains inverterar detta. Med --merged listas endast grenar som slagits samman i den namngivna committen (dvs. de grenar vars spets-commits kan nås från den namngivna committen). Med --no-merged listas endast grenar som inte slagits samman i den namngivna committen. Om argumentet <commit> saknas är standardvärdet HEAD (dvs. spetsen av den aktuella grenen).

Kommandots andra form skapar en ny grenreferens med namnet <grennamn> som pekar på aktuella HEAD, eller <startpunkt> om den anges. Som ett specialfall för <startpunkt> kan du använda "A...B" som en genväg för sammanslagningsbasen av A och B om det finns exakt en sammanslagningsbas. Du kan utelämna högst en av A och B, i vilket fall standardvärdet är HEAD.

Observera att detta kommer att skapa den nya grenen, men det kommer inte att växla arbetskopian till den; använd "git switch <nygren>" för att växla till den nya grenen.

När en lokal gren startas från en fjärrspårningsgren konfigurerar Git grenen (specifikt konfigurationsposterna branch.<namn>.remote och branch.<namn>.merge) så att git pull på lämpligt sätt kommer att slå samman från fjärrspårningsgrenen. Detta beteende kan ändras via den globala konfigurationsflaggan branch.autoSetupMerge. Denna inställning kan åsidosättas med alternativen --track och --no-track, och ändras senare med git branch --set-upstream-to.

Med alternativet -m eller -M kommer <gammalgren> att döpas om till <nygren>. Om <gammalgren> hade en motsvarande reflog döps den om för att matcha <nygren>, och en reflog-post skapas för att komma ihåg omdöpningen av grenen. Om <nygren> existerar måste -M användas för att tvinga fram omdöpningen.

Alternativen -c och -C har exakt samma semantik som -m och -M, förutom att istället för att grenen döps om kommer den att kopieras till ett nytt namn, tillsammans med dess konfiguration och reflog.

Med alternativet -d eller -D kommer <grennamn> att raderas. Du kan ange mer än en gren för radering. Om grenen för närvarande har en reflog kommer refloggen också att raderas.

Använd -r tillsammans med -d för att radera fjärrspårningsgrenar. Observera att det bara är meningsfullt att radera fjärrspårningsgrenar om de inte längre existerar i fjärrarkivet eller om git fetch konfigurerades att inte hämta dem igen. Se även underkommandot prune i git-remote(1) för ett sätt att rensa alla obsoleta fjärrspårningsgrenar.

ALTERNATIV

• -d, --delete

Radera en gren. Grenen måste vara fullständigt sammanslagen i sin

  överordnade gren, eller i HEAD om ingen överordnad gren angavs
  med --track eller --set-upstream-to.

• -D

Kortkommando för --delete --force.

• --create-reflog

Skapa grenens reflog. Detta aktiverar registrering av alla ändringar

  som görs i grenreferensen, vilket möjliggör användning av
  datum-baserade sha1-uttryck som "<grennamn>@{yesterday}".
  Observera att i icke-rena arkiv är reflogs vanligtvis aktiverade som
  standard av konfigurationsalternativet core.logAllRefUpdates.
  Den negerade formen --no-create-reflog åsidosätter endast ett
  tidigare --create-reflog, men negerar för närvarande inte
  inställningen av core.logAllRefUpdates.

• -f, --force

Återställ <grennamn> till <startpunkt>, även om <grennamn> redan

  existerar. Utan -f vägrar git branch att ändra en befintlig
  gren. I kombination med -d (eller --delete), tillåt
  radering av grenen oavsett dess sammanslagningsstatus, eller om den
  ens pekar på en giltig commit. I kombination med -m (eller
  --move), tillåt omdöpning av grenen även om det nya
  grennamnet redan existerar, detsamma gäller för -c (eller
  --copy).

Observera att git branch -f <grennamn> [<startpunkt>], även med

  -f, vägrar att ändra en befintlig gren <grennamn> som är
  utcheckad i en annan arbetskopia som är länkad till samma arkiv.

• -m, --move

Flytta/döpa om en gren, tillsammans med dess konfiguration och reflog.

• -M

Kortkommando för --move --force.

• -c, --copy

Kopiera en gren, tillsammans med dess konfiguration och reflog.

• -C

Kortkommando för --copy --force.

• --color[=<när>]

Färglägg grenar för att markera aktuella, lokala och

  fjärrspårningsgrenar. Värdet måste vara always (standard), never
  eller auto.

• --no-color

Stäng av grenfärger, även om konfigurationsfilen ger standardvärdet

  att färglägga utdata. Samma som --color=never.

• -i, --ignore-case

Sortering och filtrering av grenar är skiftlägesokänsligt.

• --omit-empty

Skriv inte ut en ny rad efter formaterade referenser där formatet

  expanderar till en tom sträng.

• --column[=<alternativ>], --no-column

Visa grenlistan i kolumner. Se konfigurationsvariabeln

  column.branch för optionssyntax. --column och
  --no-column utan alternativ är ekvivalenta med always
  respektive never.

Detta alternativ är endast tillämpligt i icke-verbose-läge.

• -r, --remotes

Lista eller radera (om det används med -d) fjärrspårningsgrenarna.

  Kombinera med --list för att matcha de valfria mönstren.

• -a, --all

Lista både fjärrspårningsgrenar och lokala grenar. Kombinera med

  --list för att matcha valfria mönster.

• -l, --list

Lista grenar. Med valfritt <mönster>..., t.ex. git branch

  --list 'maint-*', lista endast de grenar som matchar mönstret/mönstren.

• --show-current

Skriv ut namnet på den aktuella grenen. I tillståndet detached HEAD

  skrivs inget ut.

• -v, -vv, --verbose

I listläge, visa sha1 och commit-ämnesrad för varje huvud, tillsammans

  med relationen till den överordnade grenen (om någon). Om det anges
  två gånger, skriv ut sökvägen till den länkade arbetskopian (om
  någon) och namnet på den överordnade grenen (se även git remote
  show <remote>). Observera att den aktuella arbetskopians HEAD
  inte kommer att få sin sökväg utskriven (det kommer alltid att vara
  din aktuella katalog).

• -q, --quiet

Var tystare vid skapande eller radering av en gren, undertryck

  icke-felmeddelanden.

• --abbrev=<n>

I den verbose-listan som visar commit-objektnamnet, visa det kortaste

  prefix som är minst <n> hexdigits långt och som unikt refererar
  objektet. Standardvärdet är 7 och kan åsidosättas av
  konfigurationsalternativet core.abbrev.

• --no-abbrev

Visa hela sha1:orna i utdatalistan istället för att förkorta dem.

• -t, --track[=(direct|inherit)]

Vid skapande av en ny gren, konfigurera

  branch.<namn>.remote och branch.<namn>.merge
  konfigurationsposter för att ställa in "överordnad" spårningskonfiguration
  för den nya grenen. Denna konfiguration kommer att tala om för git
  att visa relationen mellan de två grenarna i git status och
  git branch -v. Dessutom leder den git pull utan argument
  att hämta från den överordnade grenen när den nya grenen är utcheckad.

Den exakta överordnade grenen väljs beroende på det valfria

  argumentet: -t, --track eller --track=direct
  betyder att använda startpunktsgrenen själv som överordnad;
  --track=inherit betyder att kopiera den överordnade
  konfigurationen från startpunktsgrenen.

Konfigurationsvariabeln branch.autoSetupMerge anger hur git

  switch, git checkout och git branch ska bete sig när
  varken --track eller --no-track anges:

Standardalternativet, true, beter sig som om

   --track=direct angavs när startpunkten är en
   fjärrspårningsgren. false beter sig som om --no-track
   angavs. always beter sig som om --track=direct angavs.
   inherit beter sig som om --track=inherit angavs.
   simple beter sig som om --track=direct angavs endast
   när startpunkten är en fjärrspårningsgren och den nya grenen har
   samma namn som fjärrgrenen.

Se git-pull(1) och git-config(1) för ytterligare diskussion

  om hur alternativen branch.<namn>.remote och
  branch.<namn>.merge används.

• --no-track

Ställ inte in "överordnad" konfiguration, även om

  konfigurationsvariabeln branch.autoSetupMerge är inställd.

• --recurse-submodules

DETTA ALTERNATIV ÄR EXPERIMENTELLT! Gör att det aktuella kommandot

  rekursivt går in i submoduler om submodule.propagateBranches är
  aktiverat. Se submodule.propagateBranches i git-config(1).
  För närvarande stöds endast skapande av grenar.

När det används vid skapande av en gren kommer en ny gren

  <grennamn> att skapas i superprojektet och alla submoduler i
  superprojektets <startpunkt>. I submoduler kommer grenen att peka
  på submodulens commit i superprojektets <startpunkt> men grenens
  spårningsinformation kommer att ställas in baserat på submodulens
  grenar och fjärrarkiv, t.ex. git branch --recurse-submodules
  topic origin/main kommer att skapa submodulsgrenen "topic" som
  pekar på submodulens commit i superprojektets "origin/main", men
  spårar submodulens "origin/main".

• --set-upstream

Eftersom detta alternativ hade förvirrande syntax stöds det inte

  längre. Använd istället --track eller --set-upstream-to.

• -u <upstream>, --set-upstream-to=<upstream>

Ställ in <grennamn>'s spårningsinformation så att <upstream>

  betraktas som <grennamn>'s överordnade gren. Om inget <grennamn>
  anges är standardvärdet den aktuella grenen.

• --unset-upstream

Ta bort den överordnade informationen för <grennamn>. Om ingen gren

  anges är standardvärdet den aktuella grenen.

• --edit-description

Öppna en editor och redigera texten för att förklara vad grenen är

  till för, för att användas av olika andra kommandon (t.ex.
  format-patch, request-pull och merge (om aktiverat)).
  Flerradiga förklaringar kan användas.

• --contains [<commit>]

Lista endast grenar som innehåller den angivna committen (HEAD om

  inget anges). Implicerar --list.

• --no-contains [<commit>]

Lista endast grenar som inte innehåller den angivna committen (HEAD

  om inget anges). Implicerar --list.

• --merged [<commit>]

Lista endast grenar vars spetsar kan nås från den angivna committen

  (HEAD om inget anges). Implicerar --list.

• --no-merged [<commit>]

Lista endast grenar vars spetsar inte kan nås från den angivna

  committen (HEAD om inget anges). Implicerar --list.

• <grennamn>

Namnet på grenen som ska skapas eller raderas. Det nya grennamnet

  måste klara alla kontroller som definieras av
  git-check-ref-format(1). Vissa av dessa kontroller kan begränsa
  vilka tecken som är tillåtna i ett grennamn.

• <startpunkt>

Det nya grenhuvudet kommer att peka på denna commit. Det kan anges

  som ett grennamn, ett commit-id eller en tagg. Om detta alternativ
  utelämnas kommer den aktuella HEAD att användas istället.

• <gammalgren>

Namnet på en befintlig gren. Om detta alternativ utelämnas kommer

  namnet på den aktuella grenen att användas istället.

Det nya namnet för en befintlig gren. Samma begränsningar som för

  <grennamn> gäller.

• --sort=<nyckel>

Sortera baserat på den angivna nyckeln. Lägg till ett - i prefix för

  att sortera i fallande ordning efter värdet. Du kan använda
  alternativet --sort=<nyckel> flera gånger, i vilket fall den sista
  nyckeln blir primär nyckel. De nycklar som stöds är desamma som i
  git for-each-ref. Sorteringsordningen är som standard det värde som
  konfigurerats för variabeln branch.sort om den finns, eller till
  sortering baserat på det fullständiga referensnamnet (inklusive
  prefixet refs/...). Detta listar detached HEAD (om det finns) först,
  sedan lokala grenar och slutligen fjärrspårningsgrenar. Se
  git-config(1).

• --points-at <objekt>

Lista endast grenar för det givna objektet.

• --format <format>

En sträng som interpolerar %(fältnamn) från en grenreferens som visas

  och objektet den pekar på. Formatet är detsamma som för
  git-for-each-ref(1).

KONFIGURATION pager.branch respekteras endast vid listning av grenar, dvs. när --list används eller underförstås. Standard är att använda en pager. Se git-config(1).

Allt ovanför den här raden i det här avsnittet är inte inkluderat från dokumentationen för git-config(1). Innehållet som följer är detsamma som det som finns där: branch.autoSetupMerge::

   Talar om för git branch, git switch och git checkout att konfigurera
   nya grenar så att git-pull(1) på lämpligt sätt kommer att slå samman
   från startpunktsgrenen. Observera att även om det här alternativet
   inte är inställt kan det här beteendet väljas per gren med
   alternativen --track och --no-track. De giltiga inställningarna är:
   false — ingen automatisk konfiguration görs; true — automatisk
   konfiguration görs när startpunkten är en fjärrspårningsgren; always
   — automatisk konfiguration görs när startpunkten antingen är en
   lokal gren eller en fjärrspårningsgren; inherit — om startpunkten har
   en spårningskonfiguration kopieras den till den nya grenen; simple —
   automatisk konfiguration görs endast när startpunkten är en
   fjärrspårningsgren och den nya grenen har samma namn som
   fjärrgrenen. Detta alternativ har standardvärdet true.

branch.autoSetupRebase::

   När en ny gren skapas med git branch, git switch eller git checkout
   som spårar en annan gren, talar den här variabeln om för Git att
   konfigurera pull att använda rebase istället för merge (se
   "branch.<namn>.rebase"). När never är inställt kommer rebase aldrig
   automatiskt att ställas in på true. När local är inställt ställs
   rebase in på true för spårade grenar av andra lokala grenar. När
   remote är inställt ställs rebase in på true för spårade grenar av
   fjärrspårningsgrenar. När always är inställt kommer rebase att
   ställas in på true för alla spårade grenar. Se
   "branch.autoSetupMerge" för detaljer om hur man konfigurerar en gren
   att spåra en annan gren. Detta alternativ har standardvärdet never.

branch.sort::

   Den här variabeln styr sorteringsordningen för grenar när de visas av
   git-branch(1). Utan alternativet "--sort=<värde>" kommer värdet av
   den här variabeln att användas som standard. Se fältnamnen i
   git-for-each-ref(1) för giltiga värden.

branch.<namn>.remote::

   När du är på grenen <namn> talar den om för git fetch och git push
   vilket fjärrarkiv som ska hämtas från eller pushas till. Fjärrarkivet
   att pusha till kan åsidosättas med remote.pushDefault (för alla
   grenar). Fjärrarkivet att pusha till, för den aktuella grenen, kan
   ytterligare åsidosättas av branch.<namn>.pushRemote. Om inget
   fjärrarkiv är konfigurerat, eller om du inte är på någon gren och det
   finns mer än ett fjärrarkiv definierat i arkivet, är standardvärdet
   origin för hämtning och remote.pushDefault för pushning. Dessutom är
   . (en punkt) det aktuella lokala arkivet (ett punkt-arkiv), se den
   sista noten nedan för branch.<namn>.merge.

branch.<namn>.pushRemote::

   När du är på grenen <namn> åsidosätter den
   branch.<namn>.remote för pushning. Den åsidosätter också
   remote.pushDefault för pushning från grenen <namn>. När du hämtar
   från ett ställe (t.ex. din uppströms) och pushar till ett annat
   ställe (t.ex. ditt eget publiceringsarkiv) kan du vilja ställa in
   remote.pushDefault för att ange det fjärrarkiv du vill pusha till för
   alla grenar, och använda det här alternativet för att åsidosätta det
   för en specifik gren.

branch.<namn>.merge::

   Definierar, tillsammans med branch.<namn>.remote, den överordnade
   grenen för den givna grenen. Den talar om för git fetch/git pull/git
   rebase vilken gren som ska slås samman och kan också påverka git push
   (se push.default). När du är på grenen <namn> talar den om för git
   fetch vilken standard-refspec som ska markeras för sammanslagning i
   FETCH_HEAD. Värdet hanteras som den fjärranslutna delen av en
   refspec och måste matcha en referens som hämtas från det fjärrarkiv
   som anges av "branch.<namn>.remote". Sammanslagningsinformationen
   används av git pull (som först anropar git fetch) för att slå upp
   standardgrenen för sammanslagning. Utan det här alternativet kommer
   git pull som standard att slå samman den första hämtade refspecen.
   Ange flera värden för att få en bläckfisksammanslagning. Om du vill
   konfigurera git pull så att den slår samman till <namn> från en annan
   gren i det lokala arkivet kan du peka branch.<namn>.merge på den
   önskade grenen och använda den relativa sökvägsinställningen . (en
   punkt) för branch.<namn>.remote.

branch.<namn>.mergeOptions::

   Anger standardalternativ för sammanslagning till grenen <namn>.
   Syntaxen och de alternativ som stöds är desamma som för git-merge(1),
   men alternativvärden som innehåller blankstegstecken stöds för
   närvarande inte.

branch.<namn>.rebase::

   När true är inställt kommer grenen <namn> att rebasas ovanpå den
   hämtade grenen istället för att slå samman standardgrenen från det
   förvalda fjärrarkivet när "git pull" körs. Se "pull.rebase" för att
   göra detta på ett icke-grenspecifikt sätt.

   När merges (eller bara m) är inställt skickas alternativet
   --rebase-merges till git rebase så att de lokala
   sammanslagnings-commits inkluderas i rebaseringen (se git-rebase(1)
   för detaljer).

   När värdet är interactive (eller bara i) körs rebaseringen i
   interaktivt läge.

   OBS: detta är en potentiellt farlig operation; använd den inte om du
   inte förstår innebörden (se git-rebase(1) för detaljer).

branch.<namn>.description::

   Grenbeskrivning, kan redigeras med git branch --edit-description.
   Grenbeskrivningen läggs automatiskt till i format-patch-följebrevet
   eller request-pull-sammanfattningen.

EXEMPEL Starta utveckling från en känd tagg

       $ git clone git://git.kernel.org/pub/scm/.../linux-2.6 my2.6
       $ cd my2.6
       $ git branch my2.6.14 v2.6.14   (1)
       $ git switch my2.6.14

    1. Detta steg och nästa kan kombineras till ett enda steg med
       "checkout -b my2.6.14 v2.6.14".

Radera en onödig gren

       $ git clone git://git.kernel.org/.../git.git my.git
       $ cd my.git
       $ git branch -d -r origin/todo origin/html origin/man   (1)
       $ git branch -D test                                    (2)

    1. Radera fjärrspårningsgrenarna "todo", "html" och "man". Nästa
       fetch eller pull kommer att skapa dem igen om du inte konfigurerar
       dem att inte göra det. Se git-fetch(1).
    2. Radera grenen "test" även om grenen "master" (eller vilken gren
       som för närvarande är utcheckad) inte har alla commits från
       testgrenen.

Lista grenar från ett specifikt fjärrarkiv

       $ git branch -r -l '<fjärr>/<mönster>'                 (1)
       $ git for-each-ref 'refs/remotes/<fjärr>/<mönster>'    (2)

    1. Att använda -a skulle blanda ihop <fjärr> med eventuella lokala
       grenar du råkar ha prefix med samma <fjärr>-mönster.
    2. for-each-ref kan ta ett brett spektrum av alternativ. Se
       git-for-each-ref(1)

Mönster behöver normalt citeras. NOTERINGAR Om du skapar en gren som du omedelbart vill växla till är det enklare att använda kommandot "git switch" med dess -c-alternativ för att göra samma sak med ett enda kommando.

Alternativen --contains, --no-contains, --merged och --no-merged tjänar fyra relaterade men olika syften:

• --contains <commit> används för att hitta alla grenar som kommer att

 behöva särskild uppmärksamhet om <commit> skulle rebasas eller
 ändras, eftersom dessa grenar innehåller den angivna <commit>.

• --no-contains <commit> är det motsatta, dvs. grenar som inte

 innehåller den angivna <commit>.

• --merged används för att hitta alla grenar som säkert kan raderas,

 eftersom dessa grenar är fullständigt inkluderade i HEAD.

• --no-merged används för att hitta grenar som är kandidater för

 sammanslagning till HEAD, eftersom dessa grenar inte är fullständigt
 inkluderade i HEAD.

När flera --contains- och --no-contains-filter kombineras visas endast referenser som innehåller minst en av --contains-commits och inga av --no-contains-commits.

När flera --merged- och --no-merged-filter kombineras visas endast referenser som kan nås från minst en av --merged-commits och från ingen av --no-merged-commits. SE ÄVEN git-check-ref-format(1), git-fetch(1), git-remote(1), "Förstå historik: Vad är en gren?"[1] i Gits användarmanual. GIT Del av git(1)-sviten NOTERINGAR

1. "Förstå historik: Vad är en gren?"
   file:///home/mtk/share/doc/git-doc/user-manual.html#what-is-a-branch

KOLOFON Den här sidan är en del av projektet git (Git distribuerat versionshanteringssystem). Information om projektet finns på ⟨http://git-scm.com/⟩. Om du har en felrapport för den här manualsidan, se ⟨http://git-scm.com/community⟩. Den här sidan hämtades från projektets uppströms Git-arkiv ⟨https://github.com/git/git.git⟩ den 2025-02-02. (Vid den tidpunkten var datumet för den senast hittade commiten i arkivet 2025-01-31.) Om du upptäcker några renderingsproblem i den här HTML-versionen av sidan, eller om du tror att det finns en bättre eller mer aktuell källa för sidan, eller om du har korrigeringar eller förbättringar av informationen i den här KOLOFONEN (som *inte* är en del av den ursprungliga manualsidan), skicka ett e-postmeddelande till man-pages@man7.org