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

listar ramas remotas git

Question

Tengo un master y una rama de development , ambos empujados a GitHub . He clone d, pull ed y fetch ed, pero sigo sin poder recuperar nada más que la rama master .

Estoy seguro de que me estoy perdiendo algo obvio, pero leí el manual y no me alegro en absoluto.

Answer 1

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 pequeño 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 Clonar , Comando Fetch , Comando Checkout

Answer 2

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 ves "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 a partir de sucursales remotas (sin verificarlas 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 función de 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).

Answer 3

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 origen remoto:

git checkout -b branch origin/branchname

Answer 4

Escribí estas pequeñas funciones de Powershell 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>'' #>
}

Más funciones de git se pueden encontrar en mi repositorio de configuraciones de git

Answer 5

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

Créditos para una sola línea ir al usuario cfi

Answer 6

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

Answer 7

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

Answer 8

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:

Branch dev set up to track remote branch refs/remotes/origin/dev. Switched to a new branch "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 recogerá todas las ramas, pero solo tire de la que está en la parte superior del árbol.

Answer 9

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 la git branch ). Puede usar --mirror lugar de --bare si su repositorio remoto tiene controles remotos propios.

Answer 10

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 llama como, por ejemplo, admin_master, no se descargará!

Gracias a Bigfish por la idea original.

Answer 11

Necesitaba hacer exactamente lo mismo. Aquí está mi guión de 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]

Answer 12

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 al maestro (para que podamos eliminar la rama en la que estamos)
2. seleccione el control remoto para el pago (cámbielo al control remoto que tenga)
3. Recorrer todas las ramas del mando a distancia excepto el maestro y la CABEZA
   1. eliminar una sucursal local (para que podamos revisar las sucursales actualizadas por la fuerza)
   2. echa un vistazo a la rama desde el mando a distancia
4. echa un vistazo a maestro (por el bien de ella)

Basado en la answer de VonC .

Answer 13

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

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

A continuación, mire las sucursales locales en su repositorio:

$ git branch
* master

¡Pero hay otras ramas que se esconden en tu repositorio! Puedes verlos usando la bandera -a :

$ 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 sucursal en sentido ascendente, puedes hacerlo 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 dice que la rama se está configurando para rastrear la rama remota, lo que generalmente significa la rama origin / branch_name

Ahora, si miras tus sucursales locales, esto es lo que verás:

$ git branch
* experimental
  master

Realmente puedes rastrear más de un repositorio remoto usando 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 gitk bastante locas, así que ejecuta gitk para ver qué está pasando:

$ gitk --all &

Answer 14

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 verificará 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>

Answer 15

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.

Answer 16

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

Answer 17

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.

Answer 18

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.

Answer 19

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.

Answer 20

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 se quiere 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. 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

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

$ git reset --hard

Entonces ahora solo puede escribir el comando "git branch" y puede ver que todas las sucursales se descargan.

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.

Answer 21

Usar la opción --mirror parece copiar las ramas de seguimiento remote correctamente. Sin embargo, configura el repositorio como un repositorio simple, por lo que tendrá 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: Git Preguntas frecuentes: ¿Cómo puedo clonar un repositorio con todas las sucursales rastreadas remotamente?}

Answer 22

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 el git_remote_branch ;-)

Aquí está la ayuda cuando ejecutas 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

Answer 23

Utilizar alias. Aunque 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

Answer 24

De acuerdo, 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 --all indicadores como este:

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 de abajo para que simplifiques lo que dije:

Answer 25

Aquí hay otro comando breve de una sola 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 ya se han creado sucursales locales. Puedes llamarlo después del primero git cloneo en cualquier momento posterior.

Si no necesita tener la masterrama activada después de la clonación, use

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

Answer 26

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 se creó una rama local para maestro, de modo 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

Answer 27

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

git fetch <origin-name> <branch-name>trae la rama hacia abajo para usted. Si bien esto no arrastra todas las ramas a la vez, puede ejecutar esta rama por separado.

Answer 28

Por lo general, Git (cuando no se especifica) recupera todas las ramas y / o etiquetas (refs, ver:) git ls-refsde uno o más repositorios 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 git fetchrealmente?

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 --allno ayudará en ese caso, pero puede enumerarlas por:

git ls-remote -h -t origin

y tráelos manualmente conociendo los nombres de referencia.

Así que para traerlos a todos , intente:

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

^{El --depth=10000parámetro puede ayudar si tienes 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-branchescomo

git remote set-branches --add origin missing_branch

por lo que puede aparecer debajo remotes/origindespué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.remotees origin.
  • Compruebe si originapunta a la URL correcta a través de: git remote show origin(ver esta post ).

Answer 29

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 ramifico 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

Answer 30

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