Cómo buscar todas las ramas de Git

Cloné un repositorio de Git, que contiene aproximadamente cinco ramas. Sin embargo, cuando lo hago git branch, solo veo uno de ellos:

$ git branch
* master

Sé que puedo hacer git branch -apara ver todas las ramas, pero ¿cómo podría tirar todas las ramas localmente para que cuando lo haga git branch, muestre lo siguiente?

$ git branch
* master
* staging
* etc...

Puede buscar todas las ramas de todos los controles remotos como este:

git fetch --all

Básicamente es un movimiento de poder .

fetchactualiza copias locales de sucursales remotas para que esto siempre sea seguro para sus sucursales locales PERO :

1. fetchno actualizará sucursales locales (que rastrean sucursales remotas); si desea actualizar sus sucursales locales, aún necesita extraer todas las sucursales.

2. fetchno creará sucursales locales (que rastrean sucursales remotas), debe hacerlo manualmente. Si desea enumerar todas las ramas remotas: git branch -a

Para actualizar sucursales locales que rastrean sucursales remotas:

git pull --all

Sin embargo, esto puede ser aún insuficiente. Funcionará solo para sus sucursales locales que rastrean sucursales remotas. Para rastrear todas las ramas remotas, ejecute este oneliner ANTES git pull --all :

git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done

TL; versión DR

git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all

(Parece que pull obtiene todas las ramas de todos los controles remotos, pero siempre busco primero solo para estar seguro).

Ejecute el primer comando solo si hay sucursales remotas en el servidor que sus sucursales locales no rastrean.

PS AFAIK git fetch --ally git remote updateson equivalentes.

Comentario de Kamil Szot , que la gente ha encontrado útil.

Tuve que usar:

for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done

porque su código creó sucursales locales con nombre origin/branchnamey estaba obteniendo "refname 'origin / branchname' es ambiguo cada vez que me refería a él.

Para enumerar sucursales remotas:
git branch -r

Puede consultarlos como sucursales locales con:
git checkout -b LocalName origin/remotebranchname

Deberá crear sucursales locales que rastreen sucursales remotas.

Suponiendo que solo tiene un control remoto llamado origin, este fragmento creará sucursales locales para todos los rastreadores remotos:

for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done

Después de eso, git fetch --allactualizará todas las copias locales de sucursales remotas.

Además, git pull --allactualizará sus ramas de seguimiento locales, pero dependiendo de sus confirmaciones locales y de cómo se configura la opción de configuración 'fusionar', podría crear una confirmación de fusión, adelantar o fallar.

Si lo haces:

git fetch origin

entonces estarán todos allí localmente. Si luego realiza:

git branch -a

los verá listados como remotos / origin / branch-name. Como están allí localmente, puedes hacer lo que quieras con ellos. Por ejemplo:

git diff origin/branch-name 

o

git merge origin/branch-name

o

git checkout -b some-branch origin/branch-name

$ git remote update
$ git pull --all

Esto supone que se rastrean todas las ramas.

Si no lo están, puedes disparar esto en Bash:

for remote in `git branch -r `; do git branch --track $remote; done

Luego ejecuta el comando.

El forbucle Bash no estaba funcionando para mí, pero esto hizo exactamente lo que quería. Todas las ramas de mi origen reflejaban el mismo nombre localmente.

git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'

Vea el comentario de Mike DuPont a continuación. Creo que estaba tratando de hacer esto en un servidor Jenkins que lo deja en modo de cabeza separada.

Uso git fetch && git checkout RemoteBranchName.

Funciona muy bien para mi ...

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, hay una forma mucho más limpia y rápida, 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.

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

3. 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 simplemente escribir el comando git branchy puede ver que se descargan todas las ramas.

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.

Puedes buscar todas las ramas de la siguiente manera:

git fetch --all

o:

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

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

Para tirar de todas las ramas, use:

git pull --all

Si lo anterior no funciona, preceda el comando anterior con:

git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'

ya remote.origin.fetchque solo puede admitir una rama específica durante la recuperación, especialmente cuando clonaste tu repositorio --single-branch. Compruebe esto: git config remote.origin.fetch.

Después de eso, deberías poder pagar cualquier sucursal.

Ver también:

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

Para empujar todas las ramas al control remoto, use:

git push --all

eventualmente --mirrorpara reflejar todas las referencias.

Si su objetivo es duplicar un repositorio, consulte: Duplicación de un artículo de repositorio en GitHub.

Usualmente no uso nada más que comandos como este:

git fetch origin
git checkout --track origin/remote-branch

Una versión un poco más corta:

git fetch origin
git checkout -t origin/remote-branch

Creo que ha clonado el repositorio de la siguiente manera:

git clone https://github.com/pathOfrepository

Ahora ve a esa carpeta usando cd:

cd pathOfrepository

Si escribe git statuspuede ver todo:

   On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working directory clean

Para ver todos los tipos de ramas ocultas:

 git branch -a

Enumerará todas las sucursales remotas.

Ahora, si desea pagar en una sucursal en particular, simplemente escriba:

git checkout -b localBranchName origin/RemteBranchName

Si está buscando una solución para obtener todas las sucursales y luego migrar todo a otro servidor Git, organizo el siguiente proceso. Si solo desea actualizar todas las ramas localmente, deténgase en la primera línea vacía.

git clone <ORIGINAL_ORIGIN>
git branch -r | awk -F'origin/' '!/HEAD|master/{print $2 " " $1"origin/"$2}' | xargs -L 1 git branch -f --track 
git fetch --all --prune --tags
git pull --all

git remote set-url origin <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>

Después de clonar el repositorio principal, solo puede ejecutar

git fetch && git checkout <branchname>

Asegúrese de que todas las ramas remotas sean recuperables en el .git/configarchivo.

En este ejemplo, solo la origin/productionrama es recuperable, incluso si intenta hacergit fetch --all nada, solo irá a buscar la productionrama:

[origin]
fetch = +refs/heads/production:refs/remotes/origin/production

Esta línea debe ser reemplazada por:

[origin]
fetch = +refs/heads/*:refs/remotes/origin/*

Luego corre, git fetchetc.

Looping no parecía funcionar para mí y quería ignorar origin / master. Esto es lo que funcionó para mí.

git branch -r | grep -v HEAD | awk -F'/' '{print $2 " " $1"/"$2}' | xargs -L 1 git branch -f --track

Después de esto:

git fetch --all
git pull --all

Solo estos tres comandos obtendrán todas las ramas:

git clone --mirror repo.git  .git     (gets just .git  - bare repository)

git config --bool core.bare false

git reset --hard

¿Por qué nadie responde a la pregunta de los chicos y explica qué está sucediendo?

1. Asegúrese de rastrear todas las ramas remotas (o las que desee rastrear) .
2. Actualice sus sucursales locales para reflejar las sucursales remotas.

Rastrea todas las ramas remotas:

Rastree todas las ramas que existen en el repositorio remoto.

Hazlo manualmente:

Reemplazaría <branch>con una rama que se muestra desde la salida de git branch -r.

git branch -r
git branch --track <branch>

Hazlo con un script bash

for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done

Actualice la información sobre las sucursales remotas en su computadora local:

Esto obtiene actualizaciones en las ramas del repositorio remoto que está rastreando en su repositorio local. Esto no altera sus sucursales locales. Su repositorio local de git ahora está al tanto de las cosas que han sucedido en las sucursales remotas del repositorio. Un ejemplo sería que se ha enviado una nueva confirmación al maestro remoto, al realizar una búsqueda ahora se le avisará que su maestro local está retrasado por 1 confirmación.

git fetch --all

Actualice la información sobre las sucursales remotas en su computadora local y actualice las sucursales locales:

Hace una búsqueda seguida de una fusión para todas las ramas desde la rama remota a la local. Un ejemplo sería que se ha enviado una nueva confirmación al maestro remoto; si realiza una extracción, se actualizará su repositorio local sobre los cambios en la rama remota y luego se fusionarán en su rama local. Esto puede crear un gran desastre debido a la fusión de conflictos.

git pull --all

Escribí un pequeño script para gestionar la clonación de un nuevo repositorio y crear sucursales locales para todas las sucursales remotas.

Puedes encontrar la última versión aquí :

#!/bin/bash

# Clones as usual but creates local tracking branches for all remote branches.
# To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc)

clone_output=$((git clone "$@" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
    exit 1
fi
pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\./\1/') > /dev/null 2>&1
this_branch=$(git branch | sed 's/^..//')
for i in $(git branch -r | grep -v HEAD); do
  branch=$(echo $i | perl -pe 's/^.*?\///')
  # this doesn't have to be done for each branch, but that's how I did it.
  remote=$(echo $i | sed 's/\/.*//')
  if [[ "$this_branch" != "$branch" ]]; then
      git branch -t $branch $remote/$branch
  fi
done
popd > /dev/null 2>&1

Para usarlo, simplemente cópielo en su directorio git bin (para mí, eso es C:\Program Files (x86)\Git\bin\git-cloneall), luego, en la línea de comando:

git cloneall [standard-clone-options] <url>

Se clona como de costumbre, pero crea ramas de seguimiento locales para todas las ramas remotas.

Cómo recuperar todas las ramas de Git Rastreo remoto único.

Esto ha sido probado y funciona en Red Hat y Git Bash en Windows 10.

TLDR:

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Explicación:

El único revestimiento revisa y luego busca todas las ramas excepto HEAD.

Enumere las ramas de seguimiento remoto.

git branch -r

Ignorar CABEZA.

grep -v ' -> '

Quite el nombre de la sucursal de los controles remotos.

cut -d"/" -f2

Verifique todas las sucursales que rastrean un solo control remoto.

git checkout $branch

Fetch para la rama desprotegida.

git fetch

Técnicamente, la búsqueda no es necesaria para nuevas sucursales locales.

Esto puede usarse para cualquiera fetchopull ramas que son nuevos y tienen cambios en distancia (s).

Solo asegúrate de tirar solo si estás listo para fusionar.

Configuración de prueba

Echa un vistazo a un repositorio con SSH URL.

git clone git@repository.git

antes de

Consultar sucursales en local.

$ git branch
* master

Ejecutar comandos

Ejecute el un trazador de líneas.

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Después

Verifique que las sucursales locales incluyan sucursales remotas.

$ git branch
  cicd
  master
* preprod

Para usuarios de Windows que usan PowerShell:

git branch -r | ForEach-Object {
    # Skip default branch, this script assumes
    # you already checked-out that branch when cloned the repo
    if (-not ($_ -match " -> ")) {
        $localBranch = ($_ -replace "^.*?/", "")
        $remoteBranch = $_.Trim()
        git branch --track "$localBranch" "$remoteBranch"
    }
}
git fetch --all
git pull --all

Aquí hay algo que consideraría robusto:

• No actualiza el seguimiento remoto para sucursales existentes
• No intenta actualizar HEADpara rastrearorigin/HEAD
• Permite controles remotos nombrados que no sean origin
• Propiamente citado

for b in $(git branch -r --format='%(refname:short)'); do
  [[ "${b#*/}" = HEAD ]] && continue
  git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all

No es necesario que git fetch --allpase -alla git pullpasa esta opción a la internafetch .

Crédito a esta respuesta .

Aquí hay una versión de Perl del one-liner proporcionada en la respuesta aceptada:

git branch -r | perl -e 'while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin\/(.*)/); print "git branch --track $local $remote\n";}' > some-output-file

Puede ejecutar el archivo de salida como un script de Shell si lo desea.

Eliminamos nuestro repositorio de proyectos Stash por accidente. Afortunadamente, alguien había creado un tenedor justo antes de la pérdida accidental. Cloné el tenedor en mi local (omitirá los detalles de cómo lo hice). Una vez que tuve el tenedor completamente en mi local, corrí una línea. Modifiqué la URL del control remoto (origen en mi caso) para apuntar al repositorio de destino al que nos estábamos recuperando:

git remote set-url origin <remote-url>

Y finalmente empujó todas las ramas al origen así:

git push --all origin

y estábamos de vuelta en el negocio.

Podemos poner todos los nombres de ramas o etiquetas en un archivo temporal, luego hacemos git pull para cada nombre / etiqueta:

git branch -r | grep origin | grep -v HEAD| awk -F/ '{print $NF}' > /tmp/all.txt
git tag -l >> /tmp/all.txt
for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done

Si tiene problemas con el fetch --allseguimiento de su rama remota:

git checkout --track origin/%branchname%

Para evitar el mensaje de error 'fatal: ya existe una rama llamada' origen / maestro '.', Necesita esto:

git branch -r | grep -v '\->'  | grep -v `git branch | awk '/\*/ { print $2; }'`| while read remote; do git branch --track "${remote#origin/}" "$remote"; done

Basado en la respuesta de Learath2, esto es lo que hice después de hacer git clone [...]e cdingresar al directorio creado:

git branch -r | grep -v master | awk {print\$1} | sed 's/^origin\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b

Funcionó para mí pero no puedo saber que funcionará para usted. Ten cuidado.

git remote add origin https://yourBitbucketLink

git fetch origin

git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)

Ahora localmente tu yourNewLocalBranchNamees tu requiredRemoteBranch.

Para usuarios de Visual Studio, en la consola de Package Manager:

rama de git | % {git buscar aguas arriba; git merge upstream / master}

Lo he intentado de muchas maneras, solo esta es simple y funciona para mí.

for branch in $(git ls-remote -h git@<your_repository>.git | awk '{print $2}' | sed 's:refs/heads/::')
do
  git checkout "$branch"
  git pull
done

Establecer alias: (basado en la respuesta principal)

git config --global alias.track-all-branches '!git fetch --all && for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done && git fetch --all'

Ahora para rastrear todas las ramas:

git track-all-branches