Si tiene muchas ramas remotas que desea obtener a la vez, haga lo siguiente:

$ git pull --all

Ahora puede realizar el checkout de cualquier rama que necesite, sin tener que acceder al repositorio remoto.

Este guión Bash me ayudó:

#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
    git branch --track "${branch##*/}" "$branch"
done

Creará ramas de seguimiento para todas las ramas remotas, excepto master (que probablemente obtuvo del comando clone original). Creo que es posible que todavía tenga que hacer un

git fetch --all
git pull --all

Para estar seguro.

Un forro: git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs Como de costumbre: prueba en tu configuración antes de copiar rm-rf universo como lo conocemos

Los créditos para una línea van al usuario cfi

Usando la opción --mirror parece copiar las ramas de seguimiento remote correctamente. Sin embargo, configura el repositorio como un repositorio desnudo, por lo que tiene que volver a convertirlo en un repositorio normal después.

git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch

^{Referencia: Git FAQ: ¿Cómo clono un repositorio con todas las ramas rastreadas remotamente?}

Puede cambiar fácilmente a una rama sin usar la elegante sintaxis "git checkout-b somebranch origin/somebranch". Solo puedes hacer:

git checkout somebranch

Git hará automáticamente lo correcto:

$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'

Git comprobará si una rama con el mismo nombre existe exactamente en un remoto, y si lo hace, la rastrea de la misma manera que si hubiera especificado explícitamente que es una rama remota. Desde la página man de git-checkout de Git 1.8.2.1:

Si no se encuentra pero existe una rama de seguimiento en exactamente un remoto (llámelo ) con un nombre coincidente, tratar como equivalente a

$ git checkout -b <branch> --track <remote>/<branch>

Con respecto a,

Git git checkout-b experimental origin / experimental

Usando

$ git checkout -t origin/experimental

O el más detallado pero más fácil de recordar

$ git checkout --track origin/experimental

Podría ser mejor, en términos de seguimiento de un repositorio remoto.

La búsqueda que está haciendo debería obtener todas las ramas remotas, pero no creará ramas locales para ellas. Si usas gitk, deberías ver las ramas remotas descritas como "remotes / origin / dev" o algo similar.

Para crear una rama local basada en una rama remota, haga algo como:

git checkout -b dev refs/remotes/origin/dev

Que debería devolver algo como:

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "dev"

Ahora, cuando estés en la rama dev, "git pull" actualizará tu dev local al mismo punto que la rama dev remota. Tenga en cuenta que obtendrá todas las ramas, pero solo tire de la que está en la parte superior del árbol.

Cuando haces "git clone git://location", se obtienen todas las ramas y etiquetas.

Para trabajar sobre una rama remota específica, asumiendo que es el origen remoto:

git checkout -b branch origin/branchname

Use alias. Aunque no hay ningún Git one-liners nativo, puedes definir el tuyo como

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'

Y luego usarlo como

git clone-branches

Esto no es demasiado complicado, los pasos muy simples y directos son los siguientes;

git fetch origin Esto traerá todas las ramas remotas a su local.

git branch -a Esto le mostrará todas las ramas remotas.

git checkout --track origin/<branch you want to checkout>

Verifique si está en la rama deseada con el siguiente comando;

git branch

A la salida le gustará esto;

*your current branch 
some branch2
some branch3 

Observe el signo*, que denota la rama actual.

Por qué solo ves"maestro"

git clone descarga todas las ramas remotas pero aún las considera "remotas", a pesar de que los archivos están ubicados en su nuevo repositorio. Hay una excepción a esto, que es que el proceso de clonación crea una rama local llamada "master" desde la rama remota llamada "master". De forma predeterminada, git branch solo muestra las ramas locales, por lo que solo ve "maestro".

git branch -a muestra todas las ramas, incluyendo remoto sucursales .

Cómo obtener sucursales locales

Si realmente desea trabajar en una rama, probablemente querrá una versión "local" de la misma. Para simplemente crear ramas locales a partir de ramas remotas (sin comprobarlas y, por lo tanto, cambiar el contenido de su directorio de trabajo) , puede hacerlo de la siguiente manera:

git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree

En este ejemplo, branchone es el nombre de una rama local que está creando basada en origin/branchone; si en su lugar desea crear ramas locales con diferentes nombres, puedes hacer esto:

git branch localbranchname origin/branchone

Una vez que haya creado una rama local, puede verla con git branch (recuerde, no necesita -a para ver ramas locales).

Mejor tarde que nunca, pero aquí está la mejor manera de hacer esto:

mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard

En este punto tiene una copia completa del repositorio remoto con todas sus ramas (verifique con git branch). Puede usar --mirror en lugar de --bare si su repositorio remoto tiene controles remotos propios.

Solo haz esto:

$ git clone git://example.com/myproject
$ cd myproject
$ git checkout branchxyz
Branch branchxyz set up to track remote branch branchxyz from origin.
Switched to a new branch 'branchxyz'
$ git pull
Already up-to-date.
$ git branch
* branchxyz
  master
$ git branch -a
* branchxyz
  master
  remotes/origin/HEAD -> origin/master
  remotes/origin/branchxyz
  remotes/origin/branch123

Verás, 'git clone git://example.com/myprojectt' obtiene todo, incluso las ramas, solo tienes que checkearlas, luego se creará tu rama local.

Solo necesitas usar "git clone" para obtener todas las ramas.

git clone <your_http_url>

Aunque solo veas la rama maestra, puedes usar "git branch-a" para ver todas las ramas.

git branch -a

Y puedes cambiar a cualquier rama que ya tengas.

git checkout <your_branch_name>

No te preocupes de que después de "git clone", no necesitas conectarte con el repositorio remoto, "git branch-a" y "git checkout" se pueden ejecutar con éxito cuando cierras tu wifi. Así que está demostrado que cuando haces "git clone", ya tiene copiado todas las ramas del repositorio remoto. Después de eso, no necesita el repositorio remoto, su local ya tiene todos los códigos de las sucursales.

A git clone se supone que copia todo el repositorio. Intente clonarlo y luego ejecute git branch -a. Debería enumerar todas las ramas. Si desea cambiar a la rama "foo" en lugar de "master", utilice git checkout foo.

Use mi herramienta git_remote_branch (necesita Ruby instalado en su máquina). Está construido específicamente para hacer que las manipulaciones de ramas remotas sean muy fáciles.

Cada vez que realiza una operación en su nombre, la imprime en rojo en la consola. Con el tiempo, finalmente se pegan en su cerebro: -)

Si no desea que grb ejecute comandos en su nombre, simplemente use la función 'explicar'. Los comandos se imprimirán en su consola en lugar de ejecutarse para usted.

Finalmente, todos los comandos tienen alias, para facilitar la memorización.

Tenga en cuenta que esto es software alfa ;-)

Aquí está la ayuda cuando ejecuta grb help:

git_remote_branch version 0.2.6

  Usage:

  grb create branch_name [origin_server] 

  grb publish branch_name [origin_server] 

  grb rename branch_name [origin_server] 

  grb delete branch_name [origin_server] 

  grb track branch_name [origin_server] 



  Notes:
  - If origin_server is not specified, the name 'origin' is assumed 
    (git's default)
  - The rename functionality renames the current branch

  The explain meta-command: you can also prepend any command with the 
keyword 'explain'. Instead of executing the command, git_remote_branch 
will simply output the list of commands you need to run to accomplish 
that goal.

  Example: 
    grb explain create
    grb explain create my_branch github

  All commands also have aliases:
  create: create, new
  delete: delete, destroy, kill, remove, rm
  publish: publish, remotize
  rename: rename, rn, mv, move
  track: track, follow, grab, fetch

Todas las respuestas que he visto aquí son válidas, pero hay una forma mucho más limpia de clonar un repositorio y extraer todas las ramas a la vez.

Cuando clonas un repositorio, toda la información de las ramas se descarga realmente, pero las ramas están ocultas. Con el comando

$ git branch -a

Puede mostrar todas las ramas del repositorio, y con el comando

$ git checkout -b branchname origin/branchname

Luego puede "descargarlos" manualmente uno a la vez.

Sin embargo, cuando desea clonar un repositorio con muchas ramas, todas las formas ilustradas son largas y tediosas con respecto a una forma mucho más limpia y rápida que voy a mostrar, aunque es un poco complicado. Necesitas tres pasos para lograr esto:

1. Primer paso

Cree una nueva carpeta vacía en su máquina y clone una copia espejo de la .carpeta git del repositorio:

$ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
$ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git

El repositorio local dentro de la carpeta my_repo_folder sigue vacío, solo hay un oculto .git carpeta ahora que se puede ver con un comando "ls-alt" desde el terminal.

1. Segundo paso

Cambie este repositorio de un repositorio vacío (desnudo) a un repositorio normal cambiando el valor booleano "desnudo" de las configuraciones de git a false:

$ git config --bool core.bare false

1. Tercer paso

Toma todo lo que está dentro de la carpeta actual y crea todas las ramas en la máquina local, por lo tanto, haciendo de esto un repo normal.

$ git reset --hard

Así que ahora puedes simplemente escriba el comando "git branch" y podrá ver que todas las ramas se descargan.

Esta es la forma rápida en la que puedes clonar un repositorio git con todas las ramas a la vez, pero no es algo que quieras hacer para cada proyecto de esta manera.

Mirando una de las respuestas a la pregunta me di cuenta de que es posible acortarla:

for branch in  `git branch -r | grep -v 'HEAD\|master'`; do  
 git branch --track ${branch##*/} $branch;
done

Pero tenga cuidado, si una de las ramas remotas se nombra como, por ejemplo, admin_master, ¡no se descargará!

Gracias a bigfish por la idea original

OK, cuando clonas tu repositorio, tienes todas las ramas allí...

Si solo haces git branch, están algo ocultos...

Así que si desea ver el nombre de todas las ramas, simplemente agregue --all la bandera como esta:

git branch --all o git branch -a

Si usted acaba de pagar a la rama, obtendrá todo lo que necesita.

Pero ¿qué tal si la rama creada por otra persona después de clonar?

En este caso, solo haz:

git fetch

Y comprobar todas las ramas nuevo...

Si desea buscar y pagar al mismo tiempo, puede hacer:

git fetch && git checkout your_branch_name

También creó la imagen de abajo para que simplifiques lo que dije:

Para copiar y pegar en la línea de comandos:

git checkout master ; remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'`; do git branch -D $brname ; git checkout -b $brname $remote/$brname ; done ; git checkout master

Para mayor facilidad:

git checkout master ;
remote=origin ;
for brname in `
    git branch -r | grep $remote | grep -v master | grep -v HEAD 
    | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'
`; do
    git branch -D $brname ;
    git checkout -b $brname $remote/$brname ;
done ;
git checkout master

1. echa un vistazo a master (para que podamos eliminar la rama en la que estamos)
2. seleccione remoto para pagar (cámbielo a cualquier remoto que tenga)
3. bucle a través de todas las ramas del control remoto excepto master y HEAD
   1. delete local branch (para que podamos revisar force-updated branches)
   2. comprobar out rama desde el remoto
4. echa un vistazo a master (por el bien de ello)

Basado en respuesta de VonC.

#!/bin/bash
for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master `; do
   git branch --track ${branch#remotes/origin/} $branch
done

Este código llevará todo el código de ramas remotas al repositorio local.

La clonación desde un repositorio local no funcionará con git clone & git fetch: muchas ramas/etiquetas permanecerán sin bloqueo.

Para obtener un clon con todas las ramas y etiquetas.

git clone --mirror git://example.com/myproject myproject-local-bare-repo.git

Para obtener un clon con todas las ramas y etiquetas, pero también con una copia de trabajo:

git clone --mirror git://example.com/myproject myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master

Necesitaba hacer exactamente lo mismo. Aquí está mi script Ruby .

#!/usr/bin/env ruby

local = []
remote = {}

# Prepare
%x[git reset --hard HEAD]
%x[git checkout master] # Makes sure that * is on master.
%x[git branch -a].each_line do |line|
  line.strip!
  if /origin\//.match(line)
     remote[line.gsub(/origin\//, '')] = line
   else
     local << line
   end
end
# Update 
remote.each_pair do |loc, rem|
  next if local.include?(loc)
  %x[git checkout --track -b #{loc} #{rem}]
end
%x[git fetch]

Escribí esta pequeña Powershell funciones para poder checkear todas mis ramas de git, que están en origin remote.

Function git-GetAllRemoteBranches {
     iex "git branch -r"                       <# get all remote branches #> `
     | % { $_ -Match "origin\/(?'name'\S+)" }  <# select only names of the branches #> `
     | % { Out-Null; $matches['name'] }        <# write does names #>
}


Function git-CheckoutAllBranches {
    git-GetAllRemoteBranches `
        | % { iex "git checkout $_" }          <# execute ' git checkout <branch>' #>
}

Se pueden encontrar más funciones de git en mi repositorio de configuración de git

Use comandos que pueda recordar

Estoy usando Bitbucket, un Servicio de Alojamiento de Repositorios de Atlassian. Así que trato de seguir a sus médicos. Y eso funciona perfectamente para mí. Con los siguientes comandos fáciles y cortos puede realizar la compra de su rama remota.

Primero clona tu repositorio, luego cambia a la carpeta de destino. Y por último, pero no menos importante, buscar y pagar:

git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>

Eso es todo. Aquí un pequeño ejemplo del mundo real:

git clone https://[email protected]/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

Usted encontrará el detalle información sobre los comandos en los documentos: Comando Clonar, Comando Fetch, Checkout Command

Git generalmente (cuando no se especifica) obtiene todas las ramas y/o etiquetas (refs, ver: git ls-refs) de uno o más repositorios junto con los objetos necesarios para completar sus historiales. En otras palabras, obtiene los objetos que son accesibles por los objetos que ya están descargados. Ver: ¿Qué hace git fetch realmente?

A veces puede tener ramas / etiquetas que no están directamente conectadas a la actual, por lo que git pull --all/git fetch --all no ayudará en ese caso, pero puede enumerar por:

git ls-remote -h -t origin

Y buscarlos manualmente conociendo los nombres de referencia.

Así que para buscarlos a todos, intenta:

git fetch origin --depth=10000 $(git ls-remote -h -t origin)

^{El parámetro --depth=10000 puede ser de ayuda si ha vaciado el repositorio.}

Luego revisa todas tus ramas de nuevo:

git branch -avv

Si lo anterior no ayuda, debe agregar manualmente las ramas que faltan a la lista de seguimiento (ya que se perdieron de alguna manera):

$ git remote -v show origin
...
  Remote branches:
    master      tracked

Por git remote set-branches como:

git remote set-branches --add origin missing_branch

Así que puede aparecer bajo remotes/origin después de buscar:

$ git remote -v show origin
...
  Remote branches:
    missing_branch new (next fetch will store in remotes/origin)
$ git fetch
From github.com:Foo/Bar
 * [new branch]      missing_branch -> origin/missing_branch

Solución de problemas

Si todavía no puede obtener nada que no sea la rama master, compruebe lo siguiente:

• Revise sus controles remotos (git remote -v), p.ej.
  • Valida que git config branch.master.remote es origin.
  • Compruebe si origin apunta a la URL derecha a través de: git remote show origin (ver este post ).

A principios de 2017, la respuesta en este comentario funciona:

git fetch <origin-name> <branch-name> baja la rama por ti. Si bien esto no extrae todas las ramas a la vez, puede ejecutar individualmente esta por rama.

Ninguna de estas respuestas es suficiente, excepto usuario nadie está en el camino correcto.

Estaba teniendo problemas para mover un repositorio de un servidor/sistema a otro. Cuando cloné el repositorio, solo creó una rama local para master, por lo que cuando empujé al nuevo control remoto, solo se empujó la rama master.

Así que encontré estos dos métodos MUY útiles. Espero que ayuden a alguien más.

Método 1:

git clone --mirror OLD_REPO_URL
cd new-cloned-project
mkdir .git
mv * .git
git config --local --bool core.bare false
git reset --hard HEAD
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

Método 2:

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
git clone OLD_REPO_URL
cd new-cloned-project
git clone-branches
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

Aquí hay otro comando corto de una línea que crea ramas locales para todas las ramas remotas:

(git branch -r | sed -n '/->/!s#^  origin/##p' && echo master) | xargs -L1 git checkout

También funciona correctamente si el seguimiento de las ramas locales ya están creados. Puede llamarlo después del primer git clone o en cualquier momento posterior.

Si no es necesario que la rama master se compruebe después de la clonación, utilice

git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout

Voy a agregar mis 2 centavos aquí porque llegué aquí tratando de averiguar cómo tirar hacia abajo una rama remota que había eliminado localmente. El origen no era mío, y no quería pasar por la molestia de volver a clonar todo

Esto funcionó para mí:

Asumiendo que necesita recrear la rama localmente:

git checkout -b recreated-branch-name
git branch -a (to list remote branches)
git rebase remotes/remote-origin/recreated-branch-name

Así que si bifurcara de gituser / master a sjp y luego lo ramificara a sjp / mynewbranch se vería así:

$ git checkout -b mynewbranch
$ git branch -a
  master
  remotes/sjp/master
  remotes/sjp/mynewbranch
$ git fetch (habit to always do before)
$ git rebase remotes/sjp/mynewbranch