remotas - ¿Cómo verifico una sucursal de Git remota?

git remote add

Question

Alguien empujó una rama llamada test con git push origin test a un repositorio compartido. Puedo ver la rama con la rama git branch -r .

Ahora estoy tratando de revisar la rama de test remota.

He intentado:

• git checkout test que no hace nada

• git checkout origin/test da * (no branch) . Lo cual es confuso. ¿Cómo puedo estar en "ninguna rama"?

¿Cómo puedo ver una sucursal de Git remota?

Answer 1

Actualizar

La respuesta de Jakub realmente mejora esto. Con versiones de Git ≥ 1.6.6, con solo un control remoto, puedes hacer:

git fetch
git checkout test

Como señala el usuario masukomi en un comentario, la git checkout test NO funcionará en git moderno si tiene varios controles remotos. En este caso usar

git checkout -b test <name of remote>/test

Respuesta antigua

Antes de que pueda comenzar a trabajar localmente en una rama remota, debe buscarlo como se indica en las respuestas a continuación.

Para obtener una rama, simplemente necesitas:

git fetch origin

Esto recuperará todas las ramas remotas para ti. Puedes ver las sucursales disponibles para pagar con:

git branch -v -a

Con las sucursales remotas en la mano, ahora necesita revisar la sucursal en la que está interesado y entregarle una copia de trabajo local:

git checkout -b test origin/test

Answer 2

¿La respuesta aceptada no funciona para ti?

Si bien la primera y la respuesta seleccionada es técnicamente correcta , existe la posibilidad de que aún no haya recuperado todos los objetos y referencias del repositorio remoto. Si ese es el caso, recibirá el siguiente error:

$ git checkout -b remote_branch origin/remote_branch

fatal: git checkout: la actualización de rutas es incompatible con el cambio de ramas.
¿Tuvo la intención de desproteger ''origin / remote_branch'' que no se puede resolver como confirmación?

Solución

Si recibe este mensaje, primero debe hacer un git fetch origin donde origin es el nombre del repositorio remoto antes de ejecutar git checkout remote_branch . Aquí hay un ejemplo completo con respuestas:

$ git fetch origin
remote: Counting objects: 140, done.
remote: Compressing objects: 100% (30/30), done.
remote: Total 69 (delta 36), reused 66 (delta 33)
Unpacking objects: 100% (69/69), done.
From https://github.com/githubuser/repo-name
   e6ef1e0..5029161  develop    -> origin/develop
 * [new branch]      demo       -> origin/demo
   d80f8d7..359eab0  master     -> origin/master

$ git checkout demo
Branch demo set up to track remote branch demo from origin.
Switched to a new branch ''demo''

Como puede ver, al ejecutar git fetch origin recuperaron las sucursales remotas que aún no estábamos configurados para rastrear en nuestra máquina local. Desde allí, ya que ahora tenemos una referencia a la sucursal remota, simplemente podemos ejecutar git checkout remote_branch y obtendremos los beneficios del seguimiento remoto.

Answer 3

Comandos

git fetch --all
git checkout -b <ur_new_local_branch_name> origin/<Remote_Branch_Name>

son iguales a

 git fetch --all

y entonces

 git checkout -b fixes_for_dev origin/development

Ambos crearán un latest fixes_for_dev desde el development

Answer 4

El comando git remote show <origin name> mostrará una lista de todas las ramas (incluidas las ramas sin seguimiento). Luego puede encontrar el nombre de la rama remota que necesita buscar.

Ejemplo:

$ git remote show origin

Siga estos pasos para buscar ramas remotas:

git fetch <origin name> <remote branch name>:<local branch name>
git checkout <local branch name > (local branch name should the name that you given fetching)

Ejemplo:

$ git fetch origin test:test
$ git checkout test

Answer 5

En este caso, es probable que desee crear una rama de test local que esté siguiendo la rama de test remota:

$ git branch test origin/test

En versiones anteriores de git , necesitaba una opción explícita --track , pero esa es la opción predeterminada ahora cuando se bifurca desde una rama remota.

Answer 6

Esto será DWIM para un origen remoto sin nombre ( documentation ):

$ git checkout -t remote_name/remote_branch

Para agregar un nuevo control remoto, primero deberá hacer lo siguiente:

$ git remote add remote_name location_of_remote
$ git fetch remote_name

El primero le dice a Git que el control remoto existe, el segundo recibe las confirmaciones.

Answer 7

Fetch origen y pago de la sucursal.

git fetch origin && git checkout branch_name 

Answer 8

Me quedé atascado en una situación al ver el error: pathspec ''desired-branch'' did not match any file(s) known to git. para todas las sugerencias anteriores. Estoy en la versión git 1.8.3.1.

Así que esto funcionó para mí :

git fetch origin desired-branch
git checkout -b desired-branch FETCH_HEAD

La explicación detrás es que he notado que al obtener la rama remota, se buscó en FETCH_HEAD:

$ git fetch origin desired-branch
From github.com:MYTEAM/my-repo
    * branch            desired-branch -> FETCH_HEAD

Answer 9

Ninguna de estas respuestas funcionó para mí. esto funcionó:

git checkout -b feature/branch remotes/origin/feature/branch

Answer 10

Otros chicos y chicas dan las soluciones, pero tal vez pueda decirte por qué.

prueba de comprobación de git que no hace nada

Does nothing hace Does nothing , no doesn''t work , así que supongo que cuando escribe ''git checkout test'' en su terminal y presiona la tecla Intro, no aparece ningún mensaje y no se produce ningún error. Estoy en lo cierto

Si la respuesta es ''sí'', te puedo decir la causa.

La causa es que hay un archivo (o carpeta) llamado "prueba" en su árbol de trabajo.

Cuando git checkout xxx analizó,

1. Git ve a xxx como un nombre de rama al principio, pero no hay ninguna rama llamada prueba.
2. Entonces Git piensa que xxx es una ruta, y afortunadamente (o desafortunadamente), hay un archivo llamado prueba. Entonces git checkout xxx significa descartar cualquier modificación en el archivo xxx .
3. Si tampoco hay un archivo llamado xxx , Git intentará crear el xxx acuerdo con algunas reglas. Una de las reglas es crear una rama llamada xxx si existen remotes/origin/xxx .

Answer 11

Para clonar un repositorio Git, haga:

git clone <either ssh url /http url>

El comando anterior verifica todas las ramas, pero solo se inicializará la rama master . Si desea retirar las otras sucursales, haga:

git checkout -t origin/future_branch (for example)

Este comando verifica la rama remota y el nombre de su rama local será el mismo que la rama remota.

Si desea anular el nombre de su sucursal local en el proceso de pago:

git checkout -t -b enhancement origin/future_branch

Ahora el nombre de su sucursal local es una enhancement , pero el nombre de su sucursal remota es future_branch .

Documentation

Answer 12

Por favor, siga el comando para crear una carpeta vacía. Ingresa eso y usa este comando:

saifurs-Mini:YO-iOS saifurrahman$ git clone your_project_url
Cloning into ''iPhoneV1''...
remote: Counting objects: 34230, done.
remote: Compressing objects: 100% (24028/24028), done.
remote: Total 34230 (delta 22212), reused 15340 (delta 9324)
Receiving objects: 100% (34230/34230), 202.53 MiB | 294.00 KiB/s, done.
Resolving deltas: 100% (22212/22212), done.
Checking connectivity... done.
saifurs-Mini:YO-iOS saifurrahman$ cd iPhoneV1/
saifurs-Mini:iPhoneV1 saifurrahman$ git checkout 1_4_0_content_discovery
Branch 1_4_0_content_discovery set up to track remote branch 1_4_0_content_discovery from origin.
Switched to a new branch ''1_4_0_content_discovery''

Answer 13

Primero, necesitas hacer:

git fetch # Si no sabes sobre el nombre de la rama

git fetch origin branch_name

En segundo lugar, puede consultar la sucursal remota en su local mediante:

git checkout -b branch_name origin/branch_name

-b creará una nueva rama con el nombre especificado de la rama remota seleccionada.

Answer 14

Probé la solución anterior, pero no funcionó. Intenta esto, funciona:

git fetch origin ''remote_branch'':''local_branch_name''

Esto recuperará la rama remota y creará una nueva rama local (si no existe ya) con el nombre local_branch_name y rastreará la remota en ella.

Answer 15

Puedes comenzar a rastrear todas las ramas remotas con el siguiente script de Bash:

#!/bin/bash
git fetch --all
for branch in `git branch -r --format="%(refname:short)" | sed ''s/origin////''`
  do git branch -f --track "$branch" "origin/$branch"
done

Aquí también hay una versión de una sola línea:

git fetch --all; for branch in `git branch -r --format="%(refname:short)" | sed ''s/origin////''`; do git branch --track "$branch" "origin/$branch" ; done ;

Answer 16

Puedes probar

git fetch remote
git checkout --track -b local_branch_name origin/branch_name

o

git fetch
git checkout -b local_branch_name origin/branch_name

Answer 17

Si el nombre de la rama remota comienza con caracteres especiales, debe usar comillas simples en el comando de pago o, de lo contrario, git no sabrá de qué rama está hablando.

Por ejemplo, traté de verificar una rama remota llamada #9773 pero el comando no funcionó correctamente, como se muestra en la siguiente imagen:

Por alguna razón, me pregunté si el símbolo agudo (#) podría tener algo que ver con eso, y luego intenté rodear el nombre de la rama con comillas simples, como ''#9773'' rathen que solo #9773 , y funcionó bien.

$ git checkout -b ''#9773'' origin/''#9773''

Answer 18

Si la sucursal se encuentra en otro lugar que no sea el origin remoto, me gusta hacer lo siguiente:

$ git fetch
$ git checkout -b second/next upstream/next

Esto realizará el pago de la next rama en el control remoto en una rama local llamada second/next . Lo que significa que si ya tienes una sucursal local llamada a continuación, no entrará en conflicto.

$ git branch -a
* second/next
  remotes/origin/next
  remotes/upstream/next

Answer 19

Simplemente ejecute git checkout con el nombre de la rama remota. Git creará automáticamente una sucursal local que rastrea la remota:

git fetch
git checkout test

Sin embargo, si ese nombre de rama se encuentra en más de un control remoto, esto no funcionará ya que Git no sabe cuál usar. En ese caso puedes usar cualquiera de los dos:

git checkout --track origin/test

o

git checkout -b test origin/test

En 2.19 , Git aprendió la configuración de checkout.defaultRemote , que especifica un control remoto que se establece de forma predeterminada al resolver tal ambigüedad.

Answer 20

Utilizar:

git checkout -b <BRANCH-NAME> <REMOTE-NAME>/<BRANCH-NAME>

Otras respuestas no funcionan con el Git moderno en mi caso benigno. Es posible que deba extraer primero si la rama remota es nueva, pero no he comprobado ese caso.

Answer 21

Yo uso el siguiente comando:

git checkout --track origin/other_remote_branch

Answer 22

git branch -r dice que el nombre del objeto no es válido, porque ese nombre no está en la lista de sucursales locales de Git. Actualice su lista de sucursales locales desde el origen con:

git remote update

Y luego intente revisar su rama remota de nuevo.

Esto funcionó para mí.

Creo que git fetch tira en todas las sucursales remotas, que no es lo que quería el póster original.

Answer 23

git fetch && git checkout your-branch-name

Answer 24

Nota: Con el Git moderno (> = 1.6.6 ), puedes usar solo

git checkout test

(tenga en cuenta que es ''prueba'' no ''origen / prueba'') realizar DWIM -mery mágico y crear ''prueba'' de rama local para usted, para lo que en sentido ascendente sería ''origen / prueba'' de la rama de seguimiento remoto.

El * (no branch) en la salida de git branch significa que está en una rama sin nombre, en el estado denominado "HEAD desasociado" (HEAD apunta directamente a confirmar, y no es una referencia simbólica a alguna rama local). Si realizó algunas confirmaciones en esta rama sin nombre, siempre puede crear una sucursal local a partir de la confirmación actual:

git checkout -b test HEAD

Answer 25

Bien , la respuesta es fácil ... Básicamente ves la rama, ¡pero aún no tienes una copia local! ...

Necesitas fetch a fetch la rama ...

Simplemente puede obtener y luego realizar el pago a la rama, use el comando de una línea a continuación para hacer eso:

git fetch && git checkout test

También creé la imagen a continuación para que comparta las diferencias, mire cómo funciona la fetch y también cómo es diferente pull :

Answer 26

Para obtener ramas de nueva creación

git fetch

Para cambiar a otra rama

git checkout BranchName