¿Cómo clonar todas las ramas remotas en Git?

Si tiene muchas ramas remotas que desea obtener de una vez, haga lo siguiente:

$ git pull --all

Ahora puede retirar cualquier rama que necesite, sin tener que acceder al repositorio remoto.

Este Bash script me ayudó a salir:

#!/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 la maestra (que probablemente obtuvo del comando de clonación original). Creo que todavía necesitas hacer una 

git fetch --all
git pull --all

para estar seguro.

Un trazador de líneas : 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: pruebe en su configuración antes de copiar el universo rm -rf como lo conocemos 

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

El uso de la opción --mirror parece copiar el remote rastreando las ramas correctamente. Sin embargo, configura el repositorio como un repositorio simple, por lo que tiene que volver a convertirlo en un repositorio normal posteriormente.

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

^{Referencia: Preguntas frecuentes de Git: ¿Cómo puedo clonar un repositorio con todas las sucursales rastreadas remotamente?}

Puede cambiar fácilmente a una rama sin utilizar la elegante sintaxis "git checkout -b somebranch Origin/somebranch". Usted puede simplemente hacer:

git checkout somebranch

Git automáticamente hará 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 existe una rama con el mismo nombre en exactamente un control 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 de manual de git-checkout de Git 1.8.2.1:

Si no se encuentra <branch> pero existe una rama de seguimiento en Exactamente un remoto (llámelo <remote>) con un nombre coincidente, trate como Equivalente a

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

Respecto a,

$ git checkout -b Origen experimental/experimental

utilizando

$ git checkout -t Origin/experimental

o cuanto 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 recuperación que está realizando debería obtener todas las sucursales remotas, pero no creará sucursales 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

Lo que debería devolver algo como:

Configuración de rama para rastrear refs remotos remotos/Origen/desarrollo 
 Cambiado a una nueva rama "dev"

Ahora, cuando esté en la rama de desarrollo, "git pull" actualizará su desarrollo local al mismo punto que la rama de desarrollo remoto. Tenga en cuenta que recuperará todas las ramas, pero solo tire de la que está en la parte superior del árbol.

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

Para trabajar en la parte superior de una rama remota específica, asumiendo que es el remoto de Origin:

git checkout -b branch Origin/branchname

Utilizar alias. Si bien no hay ninguna línea nativa de Git, puedes definir la tuya 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 simples y sencillos son los siguientes;

git fetch Origin Esto traerá todas las sucursales 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 se encuentra 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 remotas pero aún las considera "remotas", aunque los archivos se encuentran en su nuevo repositorio. Hay una excepción a esto, que es que el proceso de clonación crea una rama local llamada "maestra" desde la rama remota llamada "maestra". Por defecto, git branch solo muestra sucursales locales, por lo que solo ve "master".

git branch -a muestra todas las sucursales, incluidas las sucursales remotas .

Cómo conseguir sucursales locales

Si realmente desea trabajar en una rama, probablemente querrá una versión "local" de la misma. Para crear simplemente sucursales locales desde sucursales remotas (sin desprotegerlas y, por lo tanto, cambiar los contenidos de su directorio de trabajo) , puede hacerlo así:

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 en base a Origin/branchone; Si, en cambio, desea crear sucursales locales con nombres diferentes, puede hacer esto:

git branch localbranchname Origin/branchone

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

Mejor tarde que nunca, pero esta es 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 sucursales (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á, 'git clone git: //example.com/myprojectt' recupera todo, incluso las sucursales, solo tiene que verificarlas, luego se creará su sucursal local.

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

git clone <your_http_url>

Aunque solo vea la rama maestra, puede usar "git rama -a" para ver todas las ramas.

git branch -a

Y puedes cambiar a cualquier rama que ya tengas.

git checkout <your_branch_name>

No se preocupe después de que "git clone", no necesite conectarse con el repositorio remoto, "git branch -a" y "git checkout" se pueden ejecutar correctamente cuando cierre su wifi. Así que está probado que cuando haces "git clone", ya ha copiado todas las ramas desde el repositorio remoto. Después de eso, no necesita el repositorio remoto, su local ya tiene todos los códigos de sucursales. 

Se supone que un git clone copia todo el repositorio. Intenta clonarlo y luego ejecuta git branch -a. Debería enumerar todas las ramas. Si desea cambiar a la rama "foo" en lugar de "master", use git checkout foo.

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

Cada vez que realiza una operación en su nombre, la imprime en rojo en la consola. Con el tiempo, finalmente se adhieren a tu 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 por usted.

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

Tenga en cuenta que este es software alfa ;-)

Aquí está la ayuda cuando ejecutas grb help:

 git_remote_branch versión 0.2.6 
 
 Uso: 
 
 grb create branch_name [Origin_server] 
 
 grb publish branch_name [Origin_server] 
 
 grb renombrar branch_name [Origin_server] 
 
 grb delete branch_name [Origin_server] 
 
 grb track branch_name [ Origin_server] 
 
 
 
 Notas: 
 - Si no se especifica Origin_server, se asume el nombre 'Origin' 
 (Git's predeterminado) 
 - La funcionalidad de cambio de nombre cambia el nombre de la rama actual 
 
 El meta-comando de explicación: también puede anteponer cualquier comando con la palabra clave 
 'explicar'. En lugar de ejecutar el comando, git_remote_branch 
 Simplemente mostrará la lista de comandos que necesita ejecutar para lograr 
 Ese objetivo. 
 
 Ejemplo: 
 grb explicar crear 
 grb explicar crear my_branch github 
 
 Todos los comandos también tienen alias: 
 crear: crear, nuevo 
 eliminar: eliminar, destruir, mata, elimina, rm 
 publica: publica, remotiza 
 renombra: renombra, rn, mv, mueve 
 pista: sigue, agarra, busca 

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

Cuando clonas un repositorio, toda la información de las sucursales se descarga, pero las sucursales 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

a continuación, puede "descargar" manualmente uno a la vez. 

Sin embargo, cuando quieres clonar un repositorio con muchas ramas, todas las formas ilustradas arriba 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. Necesita tres pasos para lograr esto:

1. Primer paso

cree una nueva carpeta vacía en su máquina y clone una copia duplicada de la carpeta .git desde el 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 todavía está vacío, solo hay una carpeta oculta .git ahora que puede ver con un comando "ls -alt" desde el terminal.

2. Segundo paso

cambie este repositorio de un repositorio vacío (desnudo) a un repositorio regular cambiando el valor booleano "bare" de las configuraciones de git a falso:

$ git config --bool core.bare false

3. Tercer paso

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

$ git reset --hard

Así que ahora solo puede escribir el comando "git branch" y puede ver que todas las sucursales están descargadas. 

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

Mirando una de las respuestas a la pregunta, noté que es posible acortarla:

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

Pero 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 ocultos ...

Entonces, si desea ver el nombre de todas las sucursales, simplemente agregue el código --all de esta manera:

git branch --all o git branch -a

Si acaba de pagar en la sucursal, obtendrá todo lo que necesita.

Pero, ¿qué tal si la rama creada por otra persona después de la clonación?

En este caso, solo haz:

git fetch

y comprueba todas las ramas de nuevo ...

Si te gusta buscar y pagar al mismo tiempo, puedes hacer:

git fetch && git checkout your_branch_name

También creó la imagen a continuación para que simplifiques lo que dije:

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

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

#!/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

Estos códigos llevarán todo el código de sucursales remotas al repositorio local.

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

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 más legibilidad:

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 al maestro (para que podamos eliminar la rama en la que estamos)
2. selecciona el control remoto para finalizar (cámbialo a cualquier control remoto que tengas)
3. recorre todas las ramas del control remoto excepto master y HEAD
   1. eliminar sucursal local (para que podamos revisar las sucursales actualizadas por la fuerza)
   2. revisa branch desde el control remoto
4. echa un vistazo a maestro (por el bien de ella)

Basado en respuesta de VonC .

Escribí este pequeño Powershell funciones para poder verificar todas mis sucursales de git, que se encuentran en el Origen remoto.

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 configuración de git repo

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

#!/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]

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

En ocasiones, es posible que tenga sucursales/etiquetas que no estén conectadas directamente a la actual, por lo que git pull --all/git fetch --all no ayudará en ese caso, pero puede enumerarlas por:

git ls-remote -h -t Origin

y trátelos manualmente conociendo los nombres de referencia.

Así que para tráelos a todos , intente:

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

^{El parámetro --depth=10000 puede ayudar si tienes un repositorio superficial.}

Luego revisa todas tus ramas de nuevo:

git branch -avv

Si lo anterior no ayuda, debe agregar las ramas faltantes manualmente 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 me gusta:

git remote set-branches --add Origin missing_branch

por lo que puede aparecer en remotes/Origin después de la búsqueda:

$ 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 aún no puede obtener otra cosa que no sea la rama maestra, verifique lo siguiente:

• Verifique sus controles remotos (git remote -v), por ejemplo
  • Valide que git config branch.master.remote es Origin.
  • Verifique si Origin apunta a la URL correcta a través de: git remote show Origin (vea esto publicar ).

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

git fetch <Origin-name> <branch-name> trae la rama por ti. Si bien esto no arrastra todas las ramas a la vez, puede ejecutar esta rama por separado.

Ninguna de estas respuestas lo corta, excepto que el 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 maestro, así que cuando presioné el nuevo control remoto, solo se empujó la rama maestra.

Entonces 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

Usa comandos que puedas recordar

Estoy usando Bitbucket, un servicio de alojamiento de repositorios de Atlassian. Así que trato de seguir sus documentos. Y eso funciona perfectamente para mí. Con los siguientes comandos sencillos y cortos, puede verificar su sucursal remota.

Al principio, clone su repositorio, luego cambie a la carpeta de destino. Y por último, pero no menos importante, la recuperación y el pago:

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

Eso es. Aquí un poco más de ejemplo del mundo real:

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

Encontrará información detallada sobre los comandos en los documentos: Comando de clonación , Comando de captura , Comando de verificación

Aquí hay otro comando breve de una línea que Crea sucursales locales para todas las sucursales remotas:

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

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

Si no necesita tener la rama master desprotegida después de la clonación, use 

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

git clone --mirror en el repositorio original funciona bien para esto.

git clone --mirror /path/to/original.git
git remote set-url Origin /path/to/new-repo.git
git Push -u Origin

Voy a agregar mis 2 centavos aquí porque llegué tratando de descubrir cómo bajar una sucursal remota que había eliminado localmente. Origin 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 me bifurco de gituser/master a sjp y luego lo bifurque 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

Un poco tarde para la fiesta, pero creo que esto hace el truco:

mkdir YourRepo
cd YourRepo
git init --bare .git                       # create a bare repo
git remote add Origin REMOTE_URL           # add a remote
git fetch Origin refs/heads/*:refs/heads/* # fetch heads
git fetch Origin refs/tags/*:refs/tags/*   # fetch tags
git init                                   # reinit work tree
git checkout master                        # checkout a branch

Si esto hace algo indeseable, me encantaría saberlo. Sin embargo, hasta ahora, esto funciona para mí.

Esta variación clonará un repositorio remoto con todas las sucursales disponibles localmente sin tener que retirar cada una de ellas. No hay scripts de fantasía necesarios.

Haga una carpeta con el mismo nombre del repositorio que desea clonar y grabar en, por ejemplo:

mkdir somerepo
cd somerepo

Ahora haga estos comandos pero con el nombre de usuario/nombre de usuario de repo real 

git clone --bare [email protected]:someuser/somerepo.git .git
git config --bool core.bare false
git reset --hard
git branch

Voiala! Tienes todas las ramas allí!

Aquí hay un script de bash para obtener todas las ramas y etiquetas de un proyecto git como instantáneas en carpetas separadas. 

https://Gist.github.com/hfossli/7562257

Tal vez no lo que se preguntó directamente, pero algunas personas podrían venir aquí en busca de esta solución.