# git fetch

El `git fetch`comando descarga confirmaciones, archivos y referencias desde un repositorio remoto a su repositorio local. Buscar es lo que hace cuando quiere ver en qué han estado trabajando todos los demás. Es similar a `svn update`que te permite ver cómo ha progresado el historial central, pero no te obliga a fusionar los cambios en tu repositorio. Git aísla el contenido obtenido del contenido local existente; no tiene absolutamente ningún efecto en su trabajo de desarrollo local. El contenido obtenido se debe verificar explícitamente mediante el [`git checkout`](https://www.atlassian.com/git/tutorials/using-branches/git-checkout) comando. Esto hace que la búsqueda sea una forma segura de revisar las confirmaciones antes de integrarlas con su repositorio local.

Al descargar el contenido de un acuerdo de recompra a distancia, `git pull`y `git fetch`comandos están disponibles para realizar la tarea. Puede considerar `git fetch`la versión 'segura' de los dos comandos. Descargará el contenido remoto pero no actualizará el estado de trabajo de su repositorio local, dejando intacto su trabajo actual. `git pull`es la alternativa más agresiva; descargará el contenido remoto para la rama local activa y se ejecutará inmediatamente `git merge`para crear una combinación de confirmación para el nuevo contenido remoto. Si tiene cambios pendientes en curso, esto provocará conflictos y dará inicio al flujo de resolución de conflictos de fusión.

### Cómo funciona git fetch con ramas remotas

Para comprender mejor cómo `git fetch`funciona, analicemos cómo Git organiza y almacena los compromisos. Detrás de escena, en el `./.git/objects`directorio del repositorio , Git almacena todas las confirmaciones, locales y remotas. Git mantiene las confirmaciones de sucursales remotas y locales claramente separadas mediante el uso de referencias de sucursales. Las referencias de las sucursales locales se almacenan en el archivo `./.git/refs/heads/`. La ejecución del [`git branch`](https://www.atlassian.com/git/tutorials/using-branches) comando generará una lista de las referencias de la rama local. El siguiente es un ejemplo de `git branch`salida con algunos nombres de rama de demostración.

```
git branch
master
feature1
debug2
```

Examinar el contenido del `/.git/refs/heads/`directorio revelaría un resultado similar.

```
ls ./.git/refs/heads/
master
feature1
debug2
```

Las ramas remotas son como las ramas locales, excepto que se asignan a las confirmaciones del repositorio de otra persona. Las sucursales remotas tienen el prefijo del control remoto al que pertenecen para que no se mezclen con las sucursales locales. Al igual que las sucursales locales, Git también tiene referencias para sucursales remotas. Las referencias de rama remota viven en el `./.git/refs/remotes/`directorio. El siguiente fragmento de código de ejemplo muestra las ramas que puede ver después de obtener un repositorio remoto convenientemente llamado repositorio remoto:

```
git branch -r
# origin/master
# origin/feature1
# origin/debug2
# remote-repo/master
# remote-repo/other-feature
```

Esta salida muestra las ramas locales que habíamos examinado anteriormente, pero ahora las muestra con el prefijo `origin/`. Además, ahora vemos las ramas remotas con el prefijo `remote-repo`. Puede verificar una rama remota como una local, pero esto lo pone en un `HEAD`estado separado (como ver una confirmación anterior). Puede pensar en ellos como ramas de solo lectura. Para ver sus ramas remotas, simplemente pase la `-r`bandera al `git branch`comando.

Puede inspeccionar ramas remotas con los comandos habituales `git checkout`y `git log`. Si aprueba los cambios que contiene una rama remota, puede fusionarla en una rama local con una rama normal `git merge`. Entonces, a diferencia de SVN, sincronizar su repositorio local con un repositorio remoto es en realidad un proceso de dos pasos: buscar y luego fusionar. El `git pull`comando es un atajo conveniente para este proceso.

### Git fetch comandos y opciones

```
git fetch <remote>
```

Obtenga todas las ramas del repositorio. Esto también descarga todas las confirmaciones y archivos requeridos del otro repositorio.

```
git fetch <remote> <branch>
```

Igual que el comando anterior, pero solo obtiene la rama especificada.

```
git fetch --all
```

Un movimiento de poder que recupera todos los controles remotos registrados y sus sucursales:

```
git fetch --dry-run
```

La `--dry-run`opción realizará una ejecución de demostración del comando. Generará ejemplos de acciones que llevará a cabo durante la recuperación, pero no las aplicará.

### Ejemplos de Git fetch

### git busca una rama remota

El siguiente ejemplo demostrará cómo buscar una rama remota y actualizar su estado de trabajo local al contenido remoto. En este ejemplo, supongamos que hay un origen de repositorio central desde el que se ha clonado el repositorio local mediante el `git clone`comando. Supongamos también un repositorio remoto adicional llamado coworkers\_repo que contiene un feature\_branch que configuraremos y buscaremos. Con estos supuestos establecidos, continuemos con el ejemplo.

Primero, necesitaremos configurar el repositorio remoto usando el [`git remote`](https://www.atlassian.com/git/tutorials/syncing) comando.

```
git remote add coworkers_repo git@bitbucket.org:coworker/coworkers_repo.git
```

Aquí hemos creado una referencia al repositorio del compañero de trabajo utilizando la URL del repositorio. Ahora pasaremos ese nombre remoto a `git fetch`para descargar el contenido.

```
git fetch coworkers feature_branch
fetching coworkers/feature_branch
```

Ahora tenemos localmente el contenido de coworkers / feature\_branch, necesitaremos integrarlo en nuestra copia de trabajo local. Comenzamos este proceso usando el [`git checkout`](https://www.atlassian.com/git/tutorials/using-branches/git-checkout) comando para verificar la rama remota recién descargada.

```
git checkout coworkers/feature_branch
Note: checking out coworkers/feature_branch'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

git checkout -b <new-branch-name>
```

El resultado de esta operación de pago indica que estamos en un `HEAD`estado separado . Esto es de esperar y significa que nuestra `HEAD`referencia está apuntando a una referencia que no está en secuencia con nuestra historia local. Siendo que `HEAD`apunta a la ref. Coworkers / feature\_branch, podemos crear una nueva rama local a partir de esa ref. La `HEAD`salida 'separada ' nos muestra cómo hacer esto usando el `git checkout`comando:

```
git checkout -b local_feature_branch
```

Aquí hemos creado una nueva rama local llamada local\_feature\_branch. Esto pone actualizaciones `HEAD`para señalar el contenido remoto más reciente y podemos continuar con el desarrollo desde este punto.

### Sincronizar el origen con git fetch

El siguiente ejemplo muestra el flujo de trabajo típico para sincronizar su repositorio local con la rama principal del repositorio central.

```
git fetch origin
```

Esto mostrará las ramas que se descargaron:

```
a1e8fb5..45e66a4 master -> origin/master
a1e8fb5..9e8ab1c develop -> origin/develop
* [new branch] some-feature -> origin/some-feature
```

Las confirmaciones de estas nuevas ramas remotas se muestran como cuadrados en lugar de círculos en el diagrama a continuación. Como puede ver, `git fetch`le da acceso a toda la estructura de la rama de otro repositorio.![](https://wac-cdn.atlassian.com/dam/jcr:0718ae20-0dc5-482c-a38c-25e4f1a1a3b0/02.svg?cdnVersion=1379)

Para ver qué confirmaciones se han agregado al maestro ascendente, puede ejecutar un `git log`usando origin / master como filtro: &#x20;

```
git log --oneline master..origin/master
```

Para aprobar los cambios y fusionarlos en su rama maestra local, use los siguientes comandos:

```
git checkout master
git log origin/master
```

Entonces podemos usar `git merge origin/master`:

```
git merge origin/master
```

Las ramas origen / maestra y maestra ahora apuntan a la misma confirmación y usted está sincronizado con los desarrollos anteriores.

### Resumen de búsqueda de Git

En resumen, `git fetch`es un comando principal que se utiliza para descargar contenidos de un repositorio remoto. `git fetch`se utiliza en conjunción con `git remote`, `git branch`, `git checkout`, y [`git reset`](https://www.atlassian.com/git/tutorials/undoing-changes/git-reset) para actualizar un repositorio local al estado de un control remoto. El `git fetch`comando es una pieza fundamental de los flujos de trabajo colaborativos de git. `git fetch`tiene un comportamiento similar `git pull`, sin embargo,  `git fetch`puede considerarse una versión más segura y no destructiva.\\
