branch ver - Cómo buscar todas las ramas de Git.




archivos modificados (21)

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

$ git branch
* master

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

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

Answers

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

git fetch && git checkout <branchname>

Asegúrese de que todas las ramas remotas se puedan recuperar en el archivo .git/config .

En este ejemplo, solo se puede obtener la rama de origin/production , incluso si intentas hacer git fetch --all no pasará nada, pero se buscará la rama de production :

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

Esta línea debe ser reemplazada por:

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

A continuación, ejecute git fetch etc ...


Creo que tienes clonar el repositorio por

git clone https://github.com/pathOfrepository

ahora ve a esa carpeta usando cd

cd pathOfrepository

si git status

puedes 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

se listará toda la rama remota

Ahora, si desea realizar el pago en cualquier rama en particular, simplemente escriba

git checkout -b localBranchName origin/RemteBranchName

El bash for loop no estaba funcionando para mí, pero esto hizo exactamente lo que quería. Todas las ramas de mi origen reflejadas como el mismo nombre localmente.

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

Editado: Ver 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.


Si lo haces:

git fetch origin

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

git branch -a

Los verá listados como remotos / origen / nombre de rama. Ya que están 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

Podemos poner todos los nombres de rama o etiqueta en un archivo temporal, luego hacer 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

Puedes obtener una rama de todos los controles remotos como este:

git fetch --all

fetch actualizaciones de copias locales de sucursales remotas para que siempre sea seguro para sus sucursales locales, PERO :

  1. fetch no actualizará las sucursales locales (que rastrean las sucursales remotas); Si desea actualizar sus sucursales locales, todavía necesita extraer todas las sucursales.

  2. fetch no creará sucursales locales (que rastrean sucursales remotas), debe hacerlo manualmente. Si quieres listar todas las sucursales remotas: git branch -a

Para actualizar las sucursales locales que rastrean las sucursales remotas:

git pull --all

Sin embargo, esto puede ser aún insuficiente. Solo funcionará para las sucursales locales que rastrean las sucursales remotas. Para rastrear todas las ramas remotas, ejecute este oneliner ANTES de 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 recupera todas las ramas de todos los mandos a distancia, pero siempre lo hago primero para estar seguro)

Ejecute el primer comando solo si hay sucursales remotas en el servidor que no están siendo rastreadas por sus sucursales locales.

PS AFAIK git fetch --all git remote update son equivalentes.

El comment Kamil Szot, que 74 (al menos) personas encontraron ú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 llamadas origin/branchname y recibí "refname 'origin / branchname' es ambiguo cuando me referí a él.


Si está aquí buscando una solución para obtener todas las sucursales y luego migrar todo a otro servidor Git, armo el siguiente proceso. Si solo desea obtener todas las sucursales actualizadas 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>

Necesitará crear sucursales locales que sigan sucursales remotas.

Suponiendo que solo tenga un origin remoto llamado, este fragmento creará sucursales locales para todos los de seguimiento remoto:

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

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

Además, git pull --all todo actualizará sus sucursales de seguimiento locales, pero, dependiendo de sus confirmaciones locales y de cómo esté configurada la opción de configuración 'fusionar', podría crear una confirmación de fusión, un avance rápido o un error.


Loops no parecía funcionar para mí y quería ignorar el origen / 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

Utilice git fetch && git checkout RemoteBranchName .

Funciona muy bien para mi ...


Aquí hay algo que consideraría robusto:

  • No actualiza el seguimiento remoto para sucursales existentes
  • No intenta actualizar HEAD para rastrear el origin/HEAD
  • Permite mandos remotos con nombre distinto al origin
  • Correctamente citado shell
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 git fetch --all como pasar - -all para que git pull pase esta opción a la fetch interna.

Crédito a esta respuesta .


Puedes traer todas las ramas por:

git fetch --all

o:

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

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

Para jalar todas las ramas, usa:

git pull --all

Si lo anterior no funciona, entonces precede el comando anterior con:

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

ya que remote.origin.fetch podría admitir solo una rama específica mientras se recupera, especialmente cuando clonó su repositorio con --single-branch . Compruebe esto por: git config remote.origin.fetch .

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

Ver también:

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

Para empujar todas las ramas hacia el control remoto, use:

git push --all

eventualmente --mirror espejo para reflejar todas las referencias.

Si su objetivo es duplicar un repositorio, consulte: Duplicar un artículo del repositorio en GitHub.


Si tienes problemas con la búsqueda --todos

luego sigue tu rama remota

git checkout --track origin /% branchname%


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

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.


Solo esos 3 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                  

Aquí hay una versión de Perl de una sola línea 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 a mi local (omitiré los detalles de cómo lo hice). Una vez que tuve el tenedor completamente en mi local, corrí una de una sola línea. Modifiqué la URL del control remoto (origen en mi caso) para que apunte al repositorio de destino que estábamos recuperando:

git remote set-url origin <remote-url>

Y finalmente empujó todas las ramas a su origen como tal:

git push --all origin

y estábamos de vuelta en el negocio.


$ git remote update
$ git pull --all

Esto supone que todas las ramas son rastreadas.

Si no lo son, puedes disparar esto en Bash:

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

A continuación, ejecute el comando.


Para listar ramas remotas:
git branch -r

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


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

Puedes encontrar la última versión here :

#!/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 "[email protected]" ) 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 de 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 sucursales locales de seguimiento para todas las sucursales remotas.


Para los usuarios de Git GUI no podría ser mucho más simple. En Git GUI, elija el nombre de la rama en la lista desplegable en el cuadro de diálogo "Cambiar nombre de rama" creado desde el elemento del menú Rama: Cambiar nombre, escriba un nuevo nombre y haga clic en "Cambiar nombre". He resaltado dónde encontrar la lista desplegable.





git branch git-branch