Git fetch rama remota

He utilizado fetch seguido por checkout ...

git fetch <remote> <rbranch>:<lbranch> 
git checkout <lbranch>

... donde <rbranch>es la rama remota o fuente ref y <lbranch>es la todavía inexistente rama local o destino ref que desea rastrear y que probablemente desee nombrar lo mismo que la rama remota o fuente ref. Esto se explica en opciones en la explicación de <refspec>.

Git es tan inteligente que automáticamente completa el primer comando si tab después de las primeras letras de la rama remota. IE: Ni siquiera tengo que nombrar la rama local, Git copia automáticamente el nombre de la rama remota para mí. Gracias Git!

También como la respuesta en este post similar SO muestra, si no nombra la rama local en fetch, aún puede crearla cuando la compruebe usando la bandera -b. IE: git fetch <remote> <branch> seguido de git checkout -b <branch> <remote>/<branch> hace exactamente lo mismo que mi respuesta inicial. Y evidentemente si su repo tiene solo un remoto, entonces solo puede hacer git checkout <branch> después de fetch y creará una rama local para usted. EG: Acabas de clonar un repositorio y quieres ver ramas adicionales desde el control remoto.

Creo que parte de la documentación de fetch puede haber sido copiada textualmente de pull. En particular, la sección sobre <refspec> en opciones es la misma. Sin embargo, no creo que fetch alguna vez merge, para que si dejas el lado de destino del colon vacío fetch no debería hacer nada.

NOTA: Que git fetch <remote> <refspec> es la abreviatura de git fetch <remote> <refspec>: que por lo tanto no haría nada, pero git fetch <remote> <tag> es lo mismo que git fetch <remote> <tag>:<tag> que debería copiar el remoto <tag> localmente.

Supongo que esto solo es útil si desea copiar una rama remota localmente, pero no necesariamente verificarla de inmediato. De lo contrario, ahora usaría la respuesta aceptada anterior , que se explica en detalle en la primera sección de la descripción de pagoy más adelante en la sección opciones bajo la explicación de --track, ya que es un 1-liner. Bueno... una especie de 1-liner, porque todavía tiene que ejecutar git fetch <remote> primero.

Para su información: El orden del <refspecs> (fuente:destino) explica el extraño método pre Git-1.7 para eliminar ramas remotas. IE: No introducir nada en el refspec de destino.

Si está tratando de "checkout" una nueva rama remota (que existe solo en el remoto, pero no localmente), esto es lo que necesitará:

git fetch origin
git checkout --track origin/<remote_branch_name>

Esto asume que desea obtener desde origin. Si no es así, reemplace origin por su nombre remote.

Para checkout myBranch que existe remotamente y no localmente - Esto funcionó para mí:

git fetch --all
git checkout myBranch

Recibí este mensaje:

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

Use git branch -a (ramas locales y remotas) o git branch -r (solo ramas remotas) para ver todos los controles remotos y sus ramas. Luego puede hacer un git checkout -t remotes/repo/branch al remoto y crear una rama local.

También hay un comando git ls-remote para ver todas las referencias y etiquetas de ese control remoto.

El título y la pregunta se confunden:

• Git fetch rama remota
• ¿cómo puede mi colega tirar de esa rama específicamente?

Si la pregunta es cómo puedo obtener una rama remota para trabajar o cómo git checkout una rama remota, una solución más simple es:

Con git (>=1.6.6) puedes usar:

git checkout <branch_name>

Si local <branch_name> no se encuentra pero existe una rama de seguimiento en exactamente un remoto con un nombre coincidente, tratar como equivalente a:

git checkout -b <branch_name> --track <remote>/<branch_name>

Consulte la documentación de git checkout

Para tu amigo:

$ git checkout discover
Branch discover set up to track remote branch discover
Switched to a new branch 'discover'

git checkout -b serverfix origin/serverfix

Esta es una operación bastante común que git proporciona la abreviatura track track:

git checkout --track origin/serverfix

De hecho, esto es tan común que incluso hay un atajo para ese atajo. Si el nombre de la rama que estás intentando checkout (a) no existe y (b) coincide exactamente con un nombre en un solo control remoto, Git creará una rama de seguimiento para ti:

git checkout serverfix

Para configurar una rama local con un nombre diferente al de la rama remota, puede usar fácilmente la primera versión con una rama local diferente nombre:

git checkout -b sf origin/serverfix

Ahora, su rama local sf automáticamente extraerá de origin/serverfix.

Fuente: Pro Git 2a Edición, escrito por Scott Chacon y Ben Straub (corte para legibilidad)

Con este sencillo comando:

git checkout -b 'your_branch' origin/'remote branch'

git fetch

git branch -r

git checkout <branch_name>

También puede obtener y verificar la rama remota de una sola vez: -

git fetch && git checkout the-branch-name

He escrito

git checkout <branch_name>

Y consiguió

Branch <branch_name> set up to track remote branch <branch_name> from origin.
Switched to a new branch '<branch_name>'

La forma más fácil de hacerlo, al menos para mí:

git fetch origin <branchName>

A veces se le pide que no juegue con la rama master y trabaje solo con la rama remota (como se me pidió). Así que todo lo que necesitas es la rama remota.

Así que para clonar la rama remota sola (sin el maestro), haga esto

git clone url --branch remote_branch_name

Donde, remote_branch_name es el nombre de la rama remota

Por ejemplo,

git clone git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git --branch v3.15

Esto asegurará que clone la rama remota a su rama local con el nombre de la rama remota.

Ahora si confirmas tu code y push, el código será enviado a esa rama sola.

git fetch --all & git checkout <branch name>

Digamos que tu control remoto es [email protected] y quieres su rama random_branch. El proceso debe ser el siguiente:

1. Primero compruebe la lista de sus controles remotos por

   git remote -v

2. Si no tienes el [email protected] remote en la salida del comando anterior, lo agregarías por

   git remote add xyz [email protected]

3. Ahora puede obtener el contenido de ese control remoto por

   git fetch xyz

4. Ahora checkout el rama de ese remoto por

   git checkout -b my_copy_random_branch xyz/random_branch

5. Compruebe la lista de sucursales por

   git branch -a

La rama local my_copy_random_branch estaría rastreando la rama random_branch de su control remoto.

git fetch && git checkout <your friend's branch name> debería hacer el truco

Los pasos son los siguientes;

1. git fetch origin o git fetch --all, esto traerá todas las ramas remotas a su local y luego esta es la segunda opción con la que puede procesar.

2. git checkout --track origin/<The_remote_branch you want to switch over>

Luego trabaja en esta rama y puedes verificar si estás en esa rama o no escribiendo

git branch

Muestra la rama en la que se encuentra actualmente.

Si ya conoce su rama remota así...

git remote
=> One
=> Two

Y usted sabe el nombre de la rama que desea checkout ex. br1.2.3.4 entonces haga

git fetch One
=> returns all meta data of remote i.e. the branch name in question.

Todo lo que queda es pagar la rama

git checkout br.1.2.3.4

Luego haga cualquier rama nueva fuera de él.

Compruebe su .git/config, en particular qué seguimiento está presente en fetch para ese control remoto.

[remote "randomRemote"]
    url = [email protected]:someUser/someRepo.git
    fetch = +refs/heads/*:refs/remotes/randomRemote/*

Si tiene heads/* apuntando a randomRemote/*, cuando ejecute git fetch randomRemote, obtendrá todas las ramas. Entonces puedes simplemente revisar esa sucursal.

De lo contrario,

1. Necesita agregar ramas remotas al seguimiento usando esto. Compruebe su .git/config después de ejecutar esto. Lo entenderás. git remote set-branches add add randomRemote randomBranch

2. Ejecutar git fetch randomRemote. Esto buscará la rama remota.

3. Ahora puedes correr git checkout randomBranch

Utilizas 'git pull' para mantener tus ramas separadas. Usaré repo real y nombres de rama para ayudar ya que 'lbranch' y 'rbranch' es difícil de descifrar.

Vamos a usar:

git init
git pull [email protected]:myteam/tlc daves_branch:refs/remotes/origin/daves_branch

Simplemente intente

Origin git pull origin your_branch_name

Si usted tiene un repositorio que fue clonado con depth depth 1 entonces muchos de los comandos que fueron listados no funcionarán. Por ejemplo, ver aquí

% git clone --depth 1 https://github.com/repo/code
Cloning into 'code'...
cd code
remote: Counting objects: 1778, done.
remote: Compressing objects: 100% (1105/1105), done.
remote: Total 1778 (delta 87), reused 1390 (delta 58), pack-reused 0
Receiving objects: 100% (1778/1778), 5.54 MiB | 4.33 MiB/s, done.
Resolving deltas: 100% (87/87), done.
Checking connectivity... done.
Checking out files: 100% (1215/1215), done.
% cd code
% git checkout other_branch
error: pathspec 'other_branch' did not match any file(s) known to git.
% git fetch origin other_branch
remote: Counting objects: 47289, done.
remote: Compressing objects: 100% (15906/15906), done.
remote: Total 47289 (delta 30151), reused 46699 (delta 29570), pack-reused 0
Receiving objects: 100% (47289/47289), 31.03 MiB | 5.70 MiB/s, done.
Resolving deltas: 100% (30151/30151), completed with 362 local objects.
From https://github.com/repo/code
 * branch            other_branch-> FETCH_HEAD
% git checkout other_branch
error: pathspec 'other_branch' did not match any file(s) known to git.
%

En este caso me gustaría volver a colocar el repositorio, pero tal vez hay otras técnicas, por ejemplo, git shallow clone (clone depth depth) misses remote branches

Un simple comando -"git checkout remote_branch_name" te ayudará a crear una rama local que tenga todos los cambios en la rama remota.

git branch <name> --track origin/<name>

Lo que me ayudó fue

1) Para ver todas las ramas remotas disponibles (por ejemplo, 'remote-branch-name')

git branch -r

2) Crear una rama local usando el nombre de la rama remota

git fetch && git checkout 'remote-branch-name'