ver tag repositorio modificados example eliminar crear archivos git branch git-branch

tag - Cómo buscar todas las ramas de Git.



git tag (24)

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


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 .


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.


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


Basado en la respuesta de Learath2, esto es lo que hice después de hacer git clone [...] y cd -ing en el directorio creado:

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

Trabajó para mí, pero no puedo saber que funcionará para ti. Ten cuidado.


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


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.


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

git fetch && git checkout <branchname>


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.


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 "$@" ) 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.


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


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.


Para listar ramas remotas:
git branch -r

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


Para usuarios de Windows que utilizan 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


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.


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


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


Si tienes problemas con la búsqueda --todos

luego sigue tu rama remota

git checkout --track origin /% branchname%


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


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


Utilice git fetch && git checkout RemoteBranchName .

Funciona muy bien para mi ...


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


git remote add origin https://yourBitbucketLink git fetch origin git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)

Ahora, a nivel local, yourNewLocalBranchName es yourNewLocalBranchName requiredRemoteBranch .