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

4129

Tengo una mastery una developmentrama, ambas empujadas a GitHub . Tengo cloned, pulled y fetched, pero sigo siendo incapaz de recuperar otra cosa que la masterrama.

Estoy seguro de que me falta algo obvio, pero he leído el manual y no me alegro en absoluto.

Peter Coulton
fuente
133
La respuesta aceptada aquí ( git branch -a) le muestra las ramas en el control remoto, pero si intenta verificar cualquiera de ellas, estará en un estado de 'CABEZA separada'. La siguiente respuesta hacia abajo (la segunda mayoría de los votos a favor) responde a una pregunta diferente (a saber: cómo extraer todas las ramas y, de nuevo, esto solo funciona para aquellos que está rastreando localmente). Varios de los comentarios señalan que podría analizar los git branch -aresultados con un script de shell que rastrearía localmente todas las ramas remotas. Resumen: no hay una forma nativa de git de hacer lo que quieres y, de todos modos, podría no ser una idea tan genial.
Día Davis Waterbury
55
¿Tal vez solo copie toda la carpeta a la antigua? scp [email protected]:/home/some_user/project_folder ~No estoy seguro si esa solución funciona para github aunque ..
snapfractalpop
19
En lugar de decir "He clonado, extraído y obtenido", es mucho mejor mostrarnos los comandos exactos que ejecutó.
Bob Gilmore
57
Siempre me sorprende por qué "clonar" no es en el sentido de una copia exacta. Si es un clon exacto, ¿no deberían ser todas las ramas parte del repositorio local? Quiero decir, ¿no es ese el punto de ser distribuido? Entonces, cuando algo se ha ido, aún tiene una copia completa de todo. ¿O es que los llamados "remotos" ya forman parte del repositorio local?
huggie
21
Al ver todos los votos a favor, las respuestas, los comentarios sobre las respuestas y la cantidad alucinante de vistas, creo que es hora de que git agregue un comando para hacer esto. Y justo eres @huggie, mis pensamientos exactamente.
Sanaӽошƒаӽ

Respuestas:

4557

Primero, clone un repositorio Git remoto y cd en él:

$ git clone git://example.com/myproject
$ cd myproject

Luego, mire las sucursales locales en su repositorio:

$ git branch
* master

¡Pero hay otras ramas escondidas en su repositorio! Puedes ver esto usando la -abandera:

$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental

Si solo quieres echar un vistazo rápido a una rama aguas arriba, puedes echarle un vistazo directamente:

$ git checkout origin/experimental

Pero si desea trabajar en esa rama, deberá crear una rama de seguimiento local que se realiza automáticamente mediante:

$ git checkout experimental

y tu verás

Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'

Esa última línea arroja a algunas personas: "Nueva rama" - ¿eh? Lo que realmente significa es que la rama se toma del índice y se crea localmente para usted. La línea anterior es en realidad más informativa, ya que le indica que la rama se está configurando para rastrear la rama remota, lo que generalmente significa la rama origin / branch_name

Ahora, si observa sus sucursales locales, esto es lo que verá:

$ git branch
* experimental
  master

En realidad, puede rastrear más de un repositorio remoto utilizando git remote.

$ git remote add win32 git://example.com/users/joe/myproject-win32-port
$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental
  remotes/win32/master
  remotes/win32/new-widgets

En este punto, las cosas se están gitkvolviendo bastante locas, así que corre para ver qué está pasando:

$ gitk --all &
emk
fuente
119
¿Cómo puede alguien crear automáticamente todas las ramas remotas, por ejemplo, experimental para origen / experimental?
Cristian Ciupitu
54
Cristian: Solía ​​crear siempre una rama 'foo' para cada rama 'origin / foo', pero esto me llevó a dos problemas: (1) Terminé con muchas ramas de seguimiento realmente obsoletas que eran muchas confirmaciones detrás de la rama remota correspondiente , y (2) en versiones anteriores de git, ejecutar 'git push' intentaría empujar todas mis ramas locales a un control remoto, incluso cuando esas ramas estuvieran obsoletas. Entonces ahora solo mantengo sucursales locales para cosas que estoy desarrollando activamente, y accedo directamente a las sucursales de origen / * si necesito información sobre ellas. (Dicho esto, se puede utilizar un script de shell para analizar '-a git branch'.)
EMK
49
"git fetch <origin-name> <branch-name>" baja la rama localmente por ti.
137
Buena respuesta, pero extraña un poco la pregunta. Estaba buscando una línea para ver todas las sucursales remotas.
cmcginty
32
La pregunta era sobre clonar todas las ramas remotas, no verificarlas. Y, como señalé anteriormente, realmente no desea hacer más ramas de rastreo locales de las necesarias, porque cuando se vuelven realmente rancias, pueden causar dolores de cabeza.
emk
822

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

$ git pull --all

Ahora puede pagar cualquier rama que necesite, sin presionar el repositorio remoto.

Gabe Kopley
fuente
12
Si hago git clone, tengo la rama maestra localmente y 10 ramas "remotas". Así que ESTA respuesta de Gabe fue muy útil y responde la pregunta.
basZero
38
esto solo busca ramas remotas que se han agregado localmente, no ninguna rama remota
jujule
33
El primer comando es redundante. Simplemente git pull --allhará lo mismo: simplemente no obtendrá dos veces. Y infosec812 tiene razón en que esto no responde la pregunta de todos modos. Me pregunto cómo esto obtuvo tantos votos positivos.
Sven Marnach
66
Después de hacerlo git remote update, luego lo intenté git branch, solo veo sucursales locales. Pero si lo hago git branch -a, ahora puedo ver las ramas remotas y puedo hacer una git pull <branchname>para obtener la rama que quiero. - Llegué a esta pregunta de una búsqueda en Google, y esta respuesta resuelve mi problema.
WNRosenberg
38
Esto no es útil en absoluto, no extrae ninguna rama remota que no sea la existente.
Avinash R
446

Este script de 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 la maestra (que probablemente obtuvo del comando de clonación original). Creo que aún podrías necesitar hacer un

git fetch --all
git pull --all

para estar seguro.

One liner : 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 universe tal como lo conocemos

Los créditos para one-liner van al usuario cfi

gran pez
fuente
19
Esto está realmente cerca de ser una solución perfecta. Lo único que lo mejoraría es si esta funcionalidad estuviera incorporada como una opción en git.
Deven Phillips
51
"One liner": 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 copiarrm -rf universe as we know it
cfi
44
Este comando crea las ramas de funciones desde ramas remotas como normales (no ramas de funciones): ¿cómo solucionar esto?
Alex2php
44
Si tiene problemas con "/" en los nombres de las sucursales, a continuación encontrará una solución con un alias git. véase la respuesta por "nadie" en "contestado correctamente al 15 de mayo de '13 a las 11:02"
WEMU
8
Estoy recortando solo remotes/origin/para preservar los espacios de nombres:for BRANCH in $(git branch -a | grep remotes | grep -v HEAD | grep -v master); do git branch --track "${BRANCH#remotes/origin/}" "${BRANCH}"; done
kgadek
348

El uso de la --mirroropción parece copiar las remoteramas de seguimiento correctamente. Sin embargo, configura el repositorio como un repositorio simple, por lo que debe 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: Preguntas frecuentes de Git: ¿Cómo clono un repositorio con todas las ramas con seguimiento remoto?

Dave
fuente
77
Sabes que esto en realidad parece ser una buena respuesta a pesar de que no tiene votos. ¿Hay alguna dificultad para hacerlo de esa manera? Tuve que verificar explícitamente una rama después de ejecutar esos comandos.
bucle el
27
Esto combinado con git push --mirror es exactamente lo que necesitaba para crear un duplicado exacto de un repositorio de git remoto al pasar de github.com a una instalación empresarial de github. ¡Gracias!
Jacob Fike
3
@Dave: Agregue un último git checkoutcomo último comando para finalmente finalizar el encabezado de la rama actual en el repositorio clonado. Esta es una gran respuesta, con mucho, la mejor. Sé valiente, eventualmente te llevaremos a la cima :-)
cfi
3
@Dave: Hm. Estoy teniendo dudas: --mirror hace más que solo configurar todas las ramas como rastreadas. Copia todas las referencias del origen y las posteriores git remote updatelo harán nuevamente. El comportamiento del cambio de tirones. He vuelto a creer que la copia completa requiere un script de una línea.
cfi
55
git clone --mirrores muy bueno para hacer una copia de seguridad de sus repositorios git ^ _ ^
TrinitronX
220

Puede cambiar fácilmente a una rama sin utilizar 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 verificará si existe una rama con el mismo nombre en exactamente un control remoto, y si lo hace, lo rastreará 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 control remoto (llámelo <remote>) con un nombre coincidente, trate como equivalente a

$ git checkout -b <branch> --track <remote>/<branch>
Nikos C.
fuente
1
Entonces, si el nombre de la rama checkoutes idéntico al nombre de la rama remota, todo después de "/", entonces git creará una rama del mismo nombre, todo después de "/", "rastreando" ese control remoto ? Y mediante el seguimiento, nos referimos a: git push, git pull, etc. voluntad en la que la distancia? Si esto es correcto, amplíe su respuesta con más información, porque estoy de acuerdo con @Daniel, esta respuesta merece más rep.
Gerard Roche
55
@BullfrogBlues, la respuesta a todas sus preguntas parece ser sí (estoy usando git v1.7.7.4). Estoy de acuerdo en que este comportamiento debería ser mejor conocido. (No está en el manual de esta versión de git.) En realidad no me gusta este comportamiento, prefiero obtener un error y tengo que decirlo git checkout --track origin/somebranchexplícitamente.
dubiousjim
3
@dubiousjim: En realidad, esto está en el manual. git-checkout (1) dice: "Si no se encuentra <branch> pero existe una rama de seguimiento en exactamente un control remoto (llámelo <remote>) con un nombre coincidente, trate como equivalente a 'git checkout -b <branch > --track <remote> / <branch> '"(Git V.1.8.1.1).
sleske
Lo que necesitamos es $ git pull * <remote> / *, donde "*" es un comodín, por lo que extrae todas las ramas, incluidas las que aún no están en el sistema local. ¿Como hacer esto? ¿Realmente se supone que debemos pagar / extraer cada rama solo para obtener el código extraído de nuestro sistema local?
JosephK
98

Respecto a,

$ git checkout -b origen experimental / experimental

utilizando

$ 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.

murphytalk
fuente
¿Entonces quiere decir que la segunda forma solo es más fácil de recordar y no hay otra diferencia?
aderchox
79

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

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

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

Que debería devolver algo como:

Desarrollo de sucursal configurado para rastrear referencias remotas de sucursales / controles remotos / origen / dev.
Cambió 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 remota. Tenga en cuenta que buscará todas las ramas, pero solo arrastrará la que está hacia la parte superior del árbol.

Luuk Paulussen
fuente
14
No necesita referencias / controles remotos aquí. git checkout -b dev origin / dev funcionará bien.
emk
3
Esto siempre va a funcionar: git checkout -b newlocaldev --track origin/dev. Si desea que la rama local tenga el mismo nombre que la remota, y la remota no tiene un nombre complicado, puede omitir el -b newlocaldev. Con la branch.autosetupmergeconfiguración predeterminada , y suponiendo que no tenga una rama local llamada dev, estos dos comandos pueden hacer lo mismo: git checkout -b dev origin/devy simplemente git checkout dev. Finalmente, git checkout origin/devno crea una nueva rama, sino que lo pone en estado HEAD separado.
dubiousjim
¿Qué sucede cuando el control remoto ya no existe pero Git es demasiado estúpido para reconocer que se ha eliminado? Esto supone que actualizó y git branch -acontinúa enumerándolo como una rama remota.
jww
¿Y hacemos esto para docenas de sucursales?
JosephK
59

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

Para trabajar encima de una rama remota específica, suponiendo que sea el origen remoto:

git checkout -b branch origin/branchname
elmarco
fuente
2
Le agradezco su nota "se obtienen todas las ramas y etiquetas". Iba a comentar que tu respuesta era incorrecta, pero luego la revisé y descubrí que tienes toda la razón. Entonces, de alguna manera, has proporcionado la respuesta más corta: si clonaste, ya la tienes. Agradable. Uno podría intentar agregar: intente $ git branch -aaprender, qué ramas remotas ya están disponibles.
Jan Vlcinsky
Echa un vistazo a la respuesta que publiqué también. Esto podría ser útil si sabe que querrá trabajar localmente en muchas de las sucursales remotas y no tendrá que verificarlas una por una.
lacostenycoder
¿Me puede explicar cuál es la diferencia entre git checkout -b master origin/mastery git checkout --track origin/masterpor favor?
aderchox
1
@aderchox Hoy en día, creo que ninguno.
elmarco
58

Usa alias. Aunque no hay ninguna línea nativa de Git, puedes definir la tuya

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

y luego úsalo como

git clone-branches
nadie
fuente
Gracias. En realidad, esto clona todas las ramas remotas a diferencia de varias de las otras respuestas
FearlessHyena
50

¿Por qué solo ves "maestro"

git clonedescarga todas las ramas remotas pero aún las considera "remotas", aunque los archivos se encuentren en su nuevo repositorio. Hay una excepción a esto, que es que el proceso de clonación crea una rama local llamada "maestro" a partir de la rama remota llamada "maestro". De forma predeterminada, git branchsolo muestra sucursales locales, por lo que solo se ve "maestro".

git branch -amuestra todas las ramas, incluidas las ramas remotas .


Cómo obtener sucursales locales

Si realmente quiere 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 el contenido 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, branchonees el nombre de una sucursal local en la que está creando origin/branchone; si en su lugar desea crear sucursales locales con diferentes nombres, puede hacer esto:

git branch localbranchname origin/branchone

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

Cerran
fuente
Si origin/branchoneexiste, también puede usarlo git checkout branchonepara crear una sucursal local con el mismo nombre y configurarla para rastrear remotamente.
Evan
47

Esto no es demasiado complicado, los pasos muy simples y directos 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 está en la rama deseada con el siguiente comando;

git branch

La salida tendrá gusto de esto;

*your current branch 
some branch2
some branch3 

Observe el signo * que denota la rama actual.

Sam
fuente
1
Gracias suraj. La razón porque no se ha votado mucho. Y el interrogador no acepta el ans.
Sam
El "origen git fetch" no trajo ninguna de las ramas remotas a mi local, ¿o están escondidas en algún lugar? Leer todas las respuestas anteriores me dio dolor de cabeza. Estamos buscando "git traiga todas las ramas a local". Debe haber un camino aparte de bash-scripts para hacer esto.
JosephK
1
Justo después de ejecutar "git fetch origin", mostrará la salida como esta en su terminal - "* [nueva sucursal] nombre_búsqueda -> origen / nombre_bramilla", pero cuando ejecute "git branch" le mostrará solo su local en cambio, para ver todas las ramas, puede hacer "git branch -a" y luego para cambiar a la rama remota, debe ejecutar "git checkout --track origin / <branch you checkout>". Espero que esto ayude. :-)
Sam
44
Suraj, porque la pregunta era cómo "clonar todas las ramas remotas", no cómo actualizar manualmente una a la vez. Parece que no hay respuesta a la pregunta real, solo formas de escribir mucho si tienes muchas ramas.
JosephK
47

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 ramas (verifique con git branch). Puede usar en --mirrorlugar de --baresi su repositorio remoto tiene sus propios controles remotos.

Jacob Fike
fuente
Algo salió mal durante las ediciones aquí. Ahora esta respuesta no tiene sentido. El " --bare" mencionado en la última oración no existe en la lista de comandos dada.
Cerran
tomando de la respuesta de Dave a continuación. El uso de 'git config --bool core.bare false' en lugar de 'git config unset core.bare' parece hacer el trabajo.
Confundido Vorlon
Yo tengo el error: key does not contain a section: unset. La respuesta de Dave funciona mejor.
olibre
En git config --unset core.barerealidad es ... Para mí, esta parece la solución más limpia de todas las presentadas en las respuestas aquí. Una pena que tenga tan pocos votos positivos ...
Dirk Hillbrecht
1
Gracias @ChrisSim Estoy de acuerdo git config --bool core.bare false. Por eso recomiendo la respuesta de Dave . ¿Qué opinas sobre la respuesta de Dave ? Saludos
olibre
39

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 ramas, solo tiene que pagarlas, luego se creará su rama local.

rapero
fuente
25

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

git clone <your_http_url>

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

git branch -a

Y puede cambiar a cualquier rama que ya tenga.

git checkout <your_branch_name>

No se preocupe que después de "git clone", no necesita conectarse con el repositorio remoto, "git branch -a" y "git checkout" se pueden ejecutar con éxito cuando cierra su wifi. Por lo tanto, se demuestra que cuando hace "git clone", ya ha copiado todas las ramas del repositorio remoto. Después de eso, no necesita el repositorio remoto, su local ya tiene los códigos de todas las sucursales.

Haimei
fuente
Muy clara respuesta aquí. Mucha gente confundida sobre este tema.
XMAN
Me gustaría secundar su declaración "se puede ejecutar con éxito cuando cierre su wifi". "git clone" realmente da como resultado un repositorio que contiene todas las ramas.
bvgheluwe
Una gran respuesta clara y directa.
Amr
24

Se git clonesupone que A copia todo el repositorio. Intenta clonarlo y luego corre git branch -a. Debería enumerar todas las ramas. Si quiere cambiar a la rama "foo" en lugar de "master", use git checkout foo.

MattoxBeckman
fuente
1
Puede ejecutar comandos git con o sin el guión. Tanto "git-branch" como "git branch" funcionarán.
Peter Boughton
21
Tal vez esta respuesta se dio hace mucho tiempo cuando git funcionó de manera diferente, pero creo que hoy es engañoso. git clonedescarga todas las ramas remotas, pero solo crea una rama local de master. Como git branchsolo muestra sucursales locales, también necesita git branch -aver sucursales remotas.
Cerran
Gracias. Este es un tipo de comportamiento predeterminado extraño de la OMI. Solo lo atribuiré a un carácter más críptico. Si descargó las ramas, ¿por qué las ocultaría al llamar a git branch?
Adam Hughes
1
@Cerran, gracias; He actualizado mi respuesta en consecuencia.
MattoxBeckman
"descarga todas las ramas remotas, pero solo crea una rama local de maestro". Necesito ayuda para entender esto. Parece que git clone NO clona ninguna rama excepto la maestra, ya que cuando haces "git branch -a" muestra que la rama "desarrollo" solo está en "control remoto / origen / desarrollo". Esto debe estar diciendo que no tienes esta sucursal en ningún lugar localmente, solo existe actualmente en el origen ¿verdad?
John Little el
19

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 muy fáciles.

Cada vez que realiza una operación en su nombre, lo imprime en rojo en la consola. Con el tiempo, finalmente se pegan en 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 un software alfa ;-)

Aquí está la ayuda cuando ejecuta grb help:

git_remote_branch versión 0.2.6

  Uso:

  grb create branch_name [servidor_origen] 

  grb publica nombre_búsqueda [servidor_origen] 

  grb rename branch_name [servidor_origen] 

  grb delete branch_name [servidor_origen] 

  pista de grb nombre_búsqueda [servidor_origen] 



  Notas:
  - Si no se especifica origin_server, se asume el nombre 'origin' 
    (Por defecto de git)
  - La funcionalidad de cambio de nombre cambia el nombre de la rama actual

  El metacomando explicado: también puede anteponer cualquier comando con el 
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, matar, eliminar, rm
  publicar: publicar, remotizar
  renombrar: renombrar, rn, mv, mover
  rastrear: rastrear, seguir, agarrar, buscar
webmat
fuente
66
Palabra para el sabio: Parece que este proyecto fue abandonado en el momento en que se publicó esta respuesta. No puedo encontrar ninguna actualización después de 2008. Caveat emptor y todo eso. Si me equivoco, espero que alguien edite y proporcione un puntero actual, porque me encantaría tener una herramienta como esta a la mano.
bradheintz
@bradheintz verifique esta respuesta, configura un alias git: stackoverflow.com/a/16563327/151841
user151841
19

Todas las respuestas que vi 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, pero las ramas están ocultas. Con el comando

$ git branch -a

puedes 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 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 espejo 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.

  1. Segundo paso

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

$ git config --bool core.bare false
  1. Tercer paso

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

$ git reset --hard

Así que ahora puede escribir el comando "git branch" y ver que todas las ramas se descargan.

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

FedericoCapaldo
fuente
No me gusta su uso de la palabra "descargar" en ... "descargar" manualmente uno por uno . De hecho, toda la información ya se ha descargado después de haber clonado el repositorio. Lo único que hay que hacer es crear sucursales de rastreo locales (que también es posible sin conexión, lo que demuestra que toda la información está en el repositorio).
bvgheluwe
@bvgheluwe por eso está entre comillas.
FedericoCapaldo
15

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

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
raisercostin
fuente
13

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

Si solo lo haces git branch, están algo escondidos ...

Entonces, si desea ver el nombre de todas las ramas, simplemente agregue una --allbandera como esta:

git branch --all o git branch -a

Si solo realiza el pago en la sucursal, obtendrá todo lo que necesita.

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

En este caso, solo haz:

git fetch

y verifique todas las ramas nuevamente ...

Si desea obtener y pagar al mismo tiempo, puede hacer lo siguiente:

git fetch && git checkout your_branch_name

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

git branch --todos para obtener todas las ramas

Alireza
fuente
3
Hay una diferencia entre "lo tienes" y "lo ves". git branch -all ya NO listará las ramas remotas cuando elimine el repositorio remoto.
Gustave
12

Al mirar 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.

Tebe
fuente
Puede mejorar la expresión regular, o tal vez usar Awk en lugar de grep, para mejorar el filtro y evitar falsos positivos.
tripleee
todas las ramas son 'origin \ my_branch_name', que definitivamente no es lo que quiero.
Sнаđошƒаӽ
No he visto la construcción $ {branch ## * /} antes, parece realmente útil, ¿alguna idea de dónde puedo encontrar más información al respecto? parece que no puede encontrar debajo de bash en ningún lado. Gracias.
SaminOz
11
#!/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 extraerá todos los códigos de sucursales remotas al repositorio local.

Albert.Qing
fuente
10

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


Esta voluntad:

  1. echa un vistazo a master (para que podamos eliminar la rama en la que estamos)
  2. seleccione el control remoto para pagar (cámbielo a cualquier control remoto que tenga)
  3. recorrer todas las ramas del control remoto, excepto maestro y CABEZA
    1. eliminar sucursal local (para que podamos verificar las sucursales actualizadas a la fuerza)
    2. echa un vistazo a la sucursal desde el control remoto
  4. echa un vistazo a maestro (por el bien de eso)

Basado en la respuesta de VonC .

ikaruss
fuente
10

Escribí estas pequeñas funciones de Powershell para poder verificar todas mis ramas git, que están en 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 repositorio de configuración de git

gringo_dave
fuente
9

Aquí hay una respuesta que usa awk. Este método debería ser suficiente si se usa en un nuevo repositorio.

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

Las ramas existentes simplemente se retirarán o se declararán como ya en él, pero se pueden agregar filtros para evitar conflictos.

También se puede modificar para que llame a un git checkout -b <branch> -t <remote>/<branch>comando explícito .

Esta respuesta se desprende Nikos C 's idea .


Alternativamente, podemos especificar la rama remota en su lugar. Esto se basa en la respuesta de murphytalk .

git branch -r | awk '{ system("git checkout -t " $NF) }'

Lanza mensajes de error fatales sobre conflictos pero los veo inofensivos.


Ambos comandos pueden tener un alias.

Usando la respuesta de nadie como referencia, podemos tener los siguientes comandos para crear los alias:

git config --global alias.clone-branches '! git branch -r | awk -F/ "{ system(\"git checkout \" \$NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" \$NF) }"'

Personalmente usaría track-allo track-all-branches.

konsolebox
fuente
Sólo quería darle las gracias. Esto funcionó perfectamente y que no sufre de diversos problemas relacionados con la clonación de un acuerdo de recompra al descubierto como un comportamiento de tracción cambiando etc.
mahonya
8

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]
user43685
fuente
Vea la respuesta que publiqué más abajo para evitar tener que ejecutar este script.
lacostenycoder
8

Ninguna de estas respuestas lo cortó, 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 el maestro, por lo que cuando presioné el nuevo control remoto, solo se presionó 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
Gaui
fuente
8

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
Bernd Jungblut
fuente
7

Git generalmente (cuando no se especifica) obtiene todas las ramas y / o etiquetas (referencias, ver:) git ls-refsde uno o más repositorios junto con los objetos necesarios para completar sus historias. En otras palabras, recupera los objetos a los que pueden acceder los objetos que ya están descargados. Ver: ¿Qué hace git fetchrealmente?

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

git ls-remote -h -t origin

y buscarlos manualmente al conocer los nombres de referencia.

Entonces, para buscarlos a todos , intente:

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

El --depth=10000parámetro puede ayudar si ha reducido el repositorio.

Luego revise todas sus ramas nuevamente:

git branch -avv

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

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

por me git remote set-branchesgusta:

git remote set-branches --add origin missing_branch

por lo que puede aparecer debajo remotes/origindespué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 aún no puede obtener otra cosa que no sea la rama maestra, verifique lo siguiente:

  • Verifique sus controles remotos ( git remote -v), p. Ej.
    • Validar que git config branch.master.remotees origin.
    • Verifique si originapunta a la URL correcta a través de: git remote show origin(vea esta publicación ).
kenorb
fuente
7

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

git fetch <origin-name> <branch-name>derriba la rama para ti. Si bien esto no tira todas las ramas a la vez, puede ejecutar singularmente esta por rama.

cenizas999
fuente
Esto requiere que busque cada rama de una en una. No muy bueno si tienes muchas ramas.
lacostenycoder
6

Aquí hay otro comando breve 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

Funciona también correctamente si ya se han creado ramas locales de seguimiento. Puede llamarlo después del primero git cloneo en cualquier momento posterior.

Si no necesita que le mastersaquen una rama después de la clonación, use

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