Mi colega y yo estamos trabajando en el mismo repositorio. Lo hemos ramificado en dos ramas, cada una técnicamente para diferentes proyectos, pero tienen similitudes, por lo que a veces querremos comprometernos con el * masterdesde el branch.

Sin embargo, tengo el branch. ¿Cómo puede mi colega sacar esa rama específicamente?

Una parte git clonedel repositorio no parece crear las ramas localmente para él, aunque puedo verlas en vivo sin problemas después de un empujón en mi extremo.

Además, cuando originalmente hice la rama, lo hice -b checkout. ¿Eso hace mucha diferencia?

$ git branch -r
origin/HEAD -> origin/master
origin/daves_branch
origin/discover
origin/master

$ git fetch origin discover
$ git checkout discover

Estos son los comandos que ejecuté. Pero definitivamente no está funcionando.

Quiero poder revisar esa rama y luego presionar y confirmar solo los cambios de las ramas de varios colaboradores o estaciones de trabajo .

Necesita crear una rama local que rastree una rama remota. El siguiente comando creará una rama local llamada daves_branch , rastreando la rama remota origen / daves_branch . Cuando presiona sus cambios, la rama remota se actualizará.

Para las versiones más recientes de Git:

git checkout --track origin/daves_branch

--trackes la abreviatura de git checkout -b [branch] [remotename]/[branch]donde [remotename] es origen en este caso y [rama] es dos veces lo mismo, daves_branch en este caso.

Para Git 1.5.6.5 necesitabas esto:

git checkout --track -b daves_branch origin/daves_branch

Para Git 1.7.2.3 y superior, esto es suficiente (podría haber comenzado antes, pero esta es la confirmación más temprana que pude encontrar rápidamente):

git checkout daves_branch

Tenga en cuenta que con las versiones recientes de Git, este comando no creará una rama local y lo pondrá en un estado 'HEAD separado'. Si desea una sucursal local, use la --trackopción

Los detalles completos están aquí: 3.5 Git Branching - Ramas remotas, ramas de seguimiento

He usado fetchseguido de checkout...

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

... ¿dónde <rbranch>está la sucursal remota o la referencia de origen y <lbranch>es la sucursal local o la referencia de destino que aún no existe que desea rastrear y que probablemente desee nombrar igual que la sucursal remota o la referencia de origen. Esto se explica en las opciones en la explicación de .<refspec>

Git es tan inteligente que completa automáticamente el primer comando si tabulo después de las primeras letras de la rama remota. Es decir, ni siquiera tengo que nombrar la sucursal local, Git copia automáticamente el nombre de la sucursal remota por mí. Gracias Git!

Además, como muestra la respuesta en esta publicación similar de Desbordamiento de pila , si no nombra la sucursal local fetch, aún puede crearla cuando la extraiga utilizando la -bbandera. Es decir, git fetch <remote> <branch> seguido de git checkout -b <branch> <remote>/<branch>hace exactamente lo mismo que mi respuesta inicial. Y, evidentemente, si su repositorio tiene solo un control remoto, puede hacerlo git checkout <branch>después fetchy creará una sucursal local para usted. Por ejemplo, acaba de clonar un repositorio y desea consultar ramas adicionales desde el control remoto.

Creo que parte de la documentación fetchpuede haber sido copiada literalmente pull. En particular la sección <refspec>de opciones es el mismo. Sin embargo, no creo que eso fetchsuceda nunca merge, de modo que si deja vacío el lado de destino del colon, fetch no debería hacer nada .

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

Supongo que esto solo es útil si desea copiar una sucursal remota localmente, pero no necesariamente verificarla de inmediato. De lo contrario, ahora usaría la respuesta aceptada , que se explica en detalle en la primera sección de la descripción del pago y luego en la sección de opciones bajo la explicación de --track, ya que es una línea. Bueno ... una especie de frase, porque aún tendrías que correr git fetch <remote>primero.

FYI: El orden de <refspecs>(fuente: destino) explica el extraño método pre Git 1.7 para eliminar ramas remotas . Es decir, no introduzca nada en la referencia de destino.

Si está intentando "pagar" 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 supone que desea buscar desde el origen . Si no, reemplace el origen por su nombre remoto .

Para verificar myBranch que existe de forma remota 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/brancha al control remoto y crear una sucursal local.

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

El título y la pregunta son confusos:

• Git fetch rama remota
• ¿Cómo puede mi colega sacar esa rama específicamente?

Si la pregunta es, ¿cómo puedo obtener una sucursal remota para trabajar o cómo puedo hacer un checkout de Git en una sucursal remota? , una solución más simple es:

Con Git (> = 1.6.6) puede usar:

git checkout <branch_name>

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

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

Ver documentación para el pago de Git

Para tu amigo:

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

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

git fetch origin <branchName> # Will fetch the branch locally
git checkout <branchName> # To move to that branch

Utilizar:

git checkout -b serverfix origin/serverfix

Esta es una operación bastante común que Git proporciona la --trackabreviatura:

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á tratando de pagar (a) no existe y (b) coincide exactamente con un nombre en un solo control remoto, Git creará una rama de seguimiento para usted:

git checkout serverfix

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

git checkout -b sf origin/serverfix

Ahora, su sucursal local sfse retirará automáticamente origin/serverfix.

Fuente: Pro Git, 2da edición , escrita por Scott Chacon y Ben Straub (corte para facilitar la lectura)

Con este simple comando:

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

Para buscar una rama que existe en remoto, la forma más simple es:

git fetch origin branchName
git checkout branchName

Puede ver si ya existe en el control remoto con:

git branch -r

Esto buscará la rama remota a su local y rastreará automáticamente la remota.

Lo que me ayudó fue

1) Para ver todas las sucursales remotas disponibles (por ejemplo, 'nombre-sucursal remota')

git branch -r

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

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

También puede buscar y pagar la rama remota de una vez:

git fetch && git checkout the-branch-name

git fetch

git branch -r

git checkout <branch_name>

escribí

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

A veces se le pide que no juegue con la rama maestra y trabaje solo con la rama remota (como se me pidió). Entonces, todo lo que necesita es la rama remota.

Entonces, para clonar solo la rama remota (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 clones la rama remota en tu rama local con el nombre de la rama remota.

Ahora, si confirma su código y lo empuja, el código se enviará solo a esa rama.

[Respuesta rápida]

Hay muchas alternativas, y mis favoritas son:

- Alternativa 1:

git fetch --all
git checkout YourBranch

Usando esta alternativa usando una rama que existe remotamente, pero no en su local.

- Alternativa 2:

git checkout -b 'YourBranch' origin/'YourRemote'

Probablemente, esta es la forma más simple.

Digamos que su control remoto es git@xyz.git y desea su rama random_branch. El proceso debe ser el siguiente:

1. Primero revise la lista de sus controles remotos por

   git remote -v

2. Si no tiene el control remoto git@xyz.git en la salida del comando anterior, lo agregará por

   git remote add xyz git@xyz.git

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

   git fetch xyz

4. Ahora revisa la rama de ese control remoto por

   git checkout -b my_copy_random_branch xyz/random_branch

5. Verifique 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 --all & git checkout <branch name>

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

Quiero darle un comando de línea única para buscar todas las ramas remotas en su local y cambiar a su rama local recién creada deseada:

git fetch && git checkout discover

Después de ejecutar el comando anterior, recibirá el siguiente mensaje:

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

La primera línea dice que cambió a una nueva rama : ¿por qué nueva? Ya está allí en remoto!

Pero en realidad también debes crearlo localmente. La rama se toma del índice remoto y se crea localmente para usted.

Aquí discoverhay una nueva rama que se creó a partir de la rama remota de su repositoriodiscover .

Pero la segunda línea da más información que la primera que nos dice que:

Nuestra sucursal está configurada para rastrear sucursales remotas con el mismo nombre.

Aunque git fetch recupera todas las ramas a local. Pero si corre git branchtras él, verá solo una masterbifurcación en local. ¿Por qué ?

Porque para cada sucursal que tiene en remoto, también debe crearla localmente, para rastrearla como git checkout <branchname> como lo hemos hecho en el ejemplo anterior.

Después de ejecutar el git checkoutcomando puede ejecutar git branch, y ahora puede ver tanto la rama:

1. master y 2. descubra en su listado local.

Si desea obtener todas las ramas remotas, escriba solo:

git fetch --all

Simplemente intente:

git pull origin your_branch_name

Si tiene un repositorio que se clonó, --depth 1entonces muchos de los comandos que se enumeraron no funcionarán. Por ejemplo, mira 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, reclinaría el repositorio, pero quizás existan otras técnicas, por ejemplo, git shallow clone (clone --depth) pierde ramas remotas

Si ya conoce su rama remota así ...

git remote
=> One
=> Two

y conoce el nombre de la sucursal que desea pagar, por ejemplo, br1.2.3.4 , luego

git fetch One
=> returns all meta data of remote, that is, the branch name in question.

Todo lo que queda es pagar la sucursal

git checkout br.1.2.3.4

Luego, haga nuevas ramas fuera de él.

Los pasos son los siguientes;

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

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

Luego trabaje en esta rama y puede verificar si está en esa rama o no escribiendo

git branch

Muestra la rama en la que te encuentras actualmente.

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

Verifique su .git/configarchivo, particularmente qué seguimiento está presente en la búsqueda de ese control remoto.

[remote "randomRemote"]
    url = git@github.com:someUser/someRepo.git
    fetch = +refs/heads/*:refs/remotes/randomRemote/*

Si tiene heads/*apuntando a randomRemote/*, cuando corresgit fetch randomRemote , buscará todas las ramas.

Entonces puedes pagar esa rama.

De otra manera,

1. Debe agregar ramas remotas al seguimiento con esto. Comprueba tu .git/configdespués de ejecutar esto. Tu entenderás.

   git remote set-branches --add randomRemote randomBranch
   

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

3. Ahora puedes correr git checkout randomBranch.

Utiliza 'git pull' para mantener tus ramas separadas. Usaré el repositorio real y los nombres de las ramas para ayudar, ya que 'lbranch' y 'rbranch' son difíciles de descifrar.

Vamos a usar:

git init
git pull git@myteam.unfuddle.com:myteam/tlc daves_branch:refs/remotes/origin/daves_branch

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

git checkout -b branch_name
git pull remote_name branch_name