Alguien empujó una rama llamada testcon git push origin testun repositorio compartido. Puedo ver la rama con git branch -r.

Ahora estoy tratando de revisar la testrama remota .

He intentado:

• git checkout test que no hace nada

• git checkout origin/testda * (no branch). Lo cual es confuso. ¿Cómo puedo estar en "sin sucursal"?

¿Cómo verifico una sucursal remota de Git?

Actualizar

La respuesta de Jakub en realidad mejora esto. Con las versiones de Git ≥ 1.6.6, con un solo control remoto, solo puede hacer:

git fetch
git checkout test

Como el usuario masukomi señala en un comentario, git checkout testNO funcionará en git moderno si tiene múltiples controles remotos. En este caso use

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

o la taquigrafía

git checkout -t <name of remote>/test

Vieja respuesta

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

Para buscar una rama, simplemente necesita:

git fetch origin

Esto buscará todas las ramas remotas para usted. Puede ver las sucursales disponibles para pagar con:

git branch -v -a

Con las sucursales remotas en la mano, ahora debe verificar la sucursal que le interesa y obtener una copia de trabajo local:

git checkout -b test origin/test

Nota al margen: con Git moderno (> = 1.6.6 ), puede usar solo

git checkout test

(tenga en cuenta que es 'prueba' no 'origen / prueba') realizar un DWIM mágico -mery y crear una 'prueba' de sucursal local para usted, para lo cual aguas arriba sería una 'fuente / prueba' de seguimiento remoto.

El * (no branch)en git branchmedio de salida que son en la rama sin nombre, en el estado de la llamada "cabeza separada" (puntos se dirijan directamente a cometer, y no se hace referencia simbólica a alguna rama local). Si realizó algunas confirmaciones en esta rama sin nombre, siempre puede crear una rama local a partir de la confirmación actual:

git checkout -b test HEAD

** EDITAR (por editor no autor) **

Encontré un comentario enterrado debajo que parece modernizar esta respuesta:

@Dennis: git checkout, por ejemplo, git checkout origin / prueba resultados en HEAD / rama sin nombre, mientras que git checkout test o git checkout -b test origen / prueba resultados en sucursal local (con origen / prueba de sucursal de seguimiento remoto como aguas arriba ) - Jakub Narębski 9 de enero de 14 a las 8:17

enfásis en git checkout origin/test

En este caso, probablemente desee crear una testsucursal local que esté rastreando la testsucursal remota :

$ git branch test origin/test

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

¿La respuesta aceptada no funciona para usted?

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.
¿Tenía la intención de pagar 'origin / remote_branch' que no se puede resolver como commit?

Solución

Si recibe este mensaje, primero debe hacer un lugar git fetch origindonde originestá el nombre del repositorio remoto antes de ejecutarlo 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, la ejecución git fetch originrecuperó cualquier rama remota que aún no habíamos configurado para rastrear en nuestra máquina local. A partir de ahí, dado que ahora tenemos una referencia a la rama remota, simplemente podemos ejecutar git checkout remote_branchy obtendremos los beneficios del seguimiento remoto.

Intenté la solución anterior, pero no funcionó. Prueba esto, funciona:

git fetch origin 'remote_branch':'local_branch_name'

Esto buscará la rama remota y creará una nueva rama local (si aún no existe) con el nombre local_branch_namey rastreará la remota en ella.

Esto hará DWIM para un origen remoto no nombrado ( documentación ):

$ 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 obtiene los commits.

Utilizar:

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

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

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

Necesitas a fetchla rama ...

Simplemente puede buscar y luego pasar 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 puedas compartir las diferencias, ver cómo fetchfunciona y también cómo es diferente pull:

Para clonar un repositorio de Git, haga:

git clone <either ssh url /http url>

El comando anterior verifica todas las ramas, pero solo masterse inicializará la rama. Si desea pagar 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 al finalizar la compra:

git checkout -t -b enhancement origin/future_branch

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

Documentación

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

Primero, debes hacer:

git fetch # Si no sabe sobre el nombre de la sucursal

git fetch origin branch_name

En segundo lugar, puede verificar la sucursal remota en su local al:

git checkout -b branch_name origin/branch_name

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

Yo uso el siguiente comando:

git checkout --track origin/other_remote_branch

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 una latest fixes_for_devdedevelopment

Si la rama está en algo diferente al origincontrol remoto, me gustaría hacer lo siguiente:

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

Esto verificará la nextrama en el upstreamcontrol remoto en una rama local llamada second/next. Lo que significa que si ya tiene una sucursal local llamada a continuación, no entrará en conflicto.

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

git fetch && git checkout your-branch-name

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

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

Estaba atrapado en una situación viendo error: pathspec 'desired-branch' did not match any file(s) known to git.todas las sugerencias anteriores. Estoy en git versión 1.8.3.1.

Entonces esto funcionó para mí :

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

La explicación detrás es que me di cuenta de que al recuperar la rama remota, se recuperaba a FETCH_HEAD:

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

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

git fetch
git checkout test

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

git checkout --track origin/test

o

git checkout -b test origin/test

En 2.19 , Git aprendió la checkout.defaultRemoteconfiguración, que especifica un control remoto predeterminado para resolver dicha ambigüedad.

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

git remote update

Y luego intente revisar su rama remota nuevamente.

Esto funcionó para mí.

Creo que git fetchatrae todas las ramas remotas, que no es lo que quería el póster original.

El git remote show <origin name>comando enumerará todas las ramas (incluidas las ramas sin seguimiento). Luego puede encontrar el nombre de la sucursal 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

Recuperar desde el control remoto y pagar la sucursal.

git fetch <remote_name> && git checkout <branch_name> 

P.ej:

git fetch origin && git checkout feature / XYZ-1234-Add-alertas

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

prueba de pago git que no hace nada

Does nothing no es igual doesn't work , así que supongo que cuando escribe 'prueba de pago git' en su terminal y presiona la tecla enter, no aparece ningún mensaje y no se produce ningún error. Estoy en lo cierto?

Si la respuesta es 'sí', puedo decirte la causa.

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

Cuando se git checkout xxxanaliza,

1. Git mira xxx como nombre de una rama al principio, pero no hay ninguna rama llamada prueba.
2. Entonces Git piensa que xxxes un camino, y afortunadamente (o desafortunadamente), hay un archivo llamado prueba. Entonces git checkout xxxsignifica descartar cualquier modificación enxxx archivo.
3. Si tampoco hay un archivo con nombre xxx, entonces Git intentará crearlo de xxxacuerdo con algunas reglas. Una de las reglas es crear una rama llamada xxxsi remotes/origin/xxxexiste.

Para obtener ramas recién creadas

git fetch

Para cambiar a otra rama

git checkout BranchName

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

git checkout -b "Branch_name" [B significa Crear sucursal local]

git branch --todos

git checkout -b "Nombre de su sucursal"

rama de git

pago exitoso de la rama maestra a la rama dev

para obtener todas las ramas remotas use esto:

git fetch --all

luego pagar a la sucursal:

git checkout test

Úselo fetchpara jalar todo su control remoto

   git fetch --all

Para enumerar sucursales remotas:

   git branch -r

Para listar todas tus sucursales

   git branch -l
   >>outpots like-
     * develop
       test
       master

Para pagar / cambiar una sucursal

   git checkout master

Para nosotros, parece que la remote.origin.fetchconfiguración dio un problema. Por lo tanto, no pudimos ver ninguna otra rama remota master, por git fetch [--all]lo que no ayudó. Ni git checkout mybranchtampoco git checkout -b mybranch --track origin/mybranchfuncionó, aunque ciertamente estaba en remoto.

La configuración anterior solo permitía masterser obtenida:

$ git config --list | grep fetch
remote.origin.fetch=+refs/heads/master:refs/remotes/origin/master

Solucione el uso *y obtenga la nueva información del origen:

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

$ git fetch
...
 * [new branch] ...
...

Ahora podríamos git checkoutla sucursal remota localmente.

No tengo idea de cómo terminó esta configuración en nuestro repositorio local.

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

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

Por alguna razón, me preguntaba 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 afortunadamente funcionó bien.

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

Siga el comando para crear una carpeta vacía. Ingrese eso y use 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'