Sumario

Introducción y referencias....................................................................................................................4
Manuales en línea y configuración.......................................................................................................4
git <commando> --help...................................................................................................................4
git config..........................................................................................................................................5
Commit o versión.................................................................................................................................5
Branch o rama.......................................................................................................................................5
Directorio de trabajo.............................................................................................................................5
git init...............................................................................................................................................6
Índice o área de cambios (stagin area, index).......................................................................................6
git add .............................................................................................................................................6
git reset ............................................................................................................................................6
git commit .......................................................................................................................................7
git log –oneline................................................................................................................................7
Análisis del directorio de trabajo..........................................................................................................7
git status...........................................................................................................................................7
git diff .............................................................................................................................................8
git diff --cached ...............................................................................................................................8
git mv <old> <new>........................................................................................................................8
git rm <files>...................................................................................................................................9
git rm --cached <files>.....................................................................................................................9
git checkout <files>.........................................................................................................................9
git checkout .....................................................................................................................................9
Ejemplos.............................................................................................................................................10
Transformar un directorio en el directorio de trabajo git...............................................................10
Crear ficheros en el directorio de trabajo git.................................................................................10
Mostrar estado del directorio de trabajo........................................................................................11
Registrar nuevos ficheros en el índice...........................................................................................11
Mostrar estado del directorio de trabajo........................................................................................11
Crear nuevo commit y ver historia................................................................................................12
Inspeccionar historia y área de trabajo..........................................................................................12
Añadir nuevo fichero.....................................................................................................................13
Crear un nuevo commit a master...................................................................................................13
Ramas.................................................................................................................................................14
Crear una rama: git branch <nombre rama> <id commit base>..................................................14
Mostrar ramas existentes: git branch -v.........................................................................................15
Grafo de commits...............................................................................................................................15
Padres y ancestros de un commit...................................................................................................15
Mostrar historia de un commit o una rama....................................................................................16
git log -<n>................................................................................................................................16
git log --oneline --graph <rama>...............................................................................................16
git log --oneline <commit>.......................................................................................................16
git log --oneline --all …............................................................................................................16
git log --oneline --all --graph....................................................................................................16
Mostrar diferencias entre ficheros de diferentes commits.............................................................17
git diff …...................................................................................................................................17
git show …................................................................................................................................17
Restaurar commits en el directorio de trabajo...............................................................................17
git checkout <commit>.............................................................................................................17
El comando reset............................................................................................................................18
git reset <commit>....................................................................................................................18
 git reset --hard <commit>.........................................................................................................18
Ejemplo de uso para integración de varios commits.................................................................18
Ejemplos ramas..................................................................................................................................19
Mostrar ramas................................................................................................................................19
Mostrar historia..............................................................................................................................20
Crear rama......................................................................................................................................20
Mostrar ramas................................................................................................................................21
Mostrar rama en modo verboso.....................................................................................................21
Restaurar rama (en el directorio de trabajo)..................................................................................22
Mostrar historia..............................................................................................................................23
Integración de commits con merge.....................................................................................................23
git merge <commit>.......................................................................................................................23
git merge …...................................................................................................................................24
Conflictos de integración...............................................................................................................24
Ejemplo de integración..................................................................................................................25
Mostrar ramas en modo verboso...............................................................................................25
Crear nueva rama para realizar la integración...........................................................................26
Integrar master en inverse.........................................................................................................27
Resolver conflictos....................................................................................................................27
Crear commit de integración.....................................................................................................28
Conflictos vistos con diff..........................................................................................................28
Integración ff (fast-fordward)........................................................................................................29
Ejemplo de integración ff..........................................................................................................29
Mostrar ramas...........................................................................................................................30
Restaurar rama master...............................................................................................................30
Crear rama nueva......................................................................................................................31
Integrar en rama master.............................................................................................................32
Integración de ramas con rebase.........................................................................................................32
git rebase .......................................................................................................................................33
Ejemplo de rebase..........................................................................................................................34
Mostar ramas.............................................................................................................................34
Crear y restaurar rama...............................................................................................................34
Comenzar cambio de base.........................................................................................................35
Resolver conflictos....................................................................................................................35
Finalizar rebase, mostrar ramas y grafo....................................................................................36
Git y GitHub.......................................................................................................................................37
Tipos de repositorio.......................................................................................................................37
GitHub...........................................................................................................................................37
Crear repositorios remotos en GitHub...........................................................................................39
Crear un nuevo repositorio (New repository)...........................................................................39
.gitignore...................................................................................................................................40
Importar un repositorio a GitHub..............................................................................................41
Clonar un repositorio de GitHub...............................................................................................42
Referenciar un repositorio remoto.................................................................................................43
git remove [-v]..........................................................................................................................43
git remote add ….......................................................................................................................43
git remote remove …................................................................................................................43
Clonar un repositorio remoto en uno local....................................................................................44
Actualizar un repositorio en GitHub con push..............................................................................45
Git y GitHub.......................................................................................................................................47
Rama local, remota y tracking.......................................................................................................47
Crear, enlazar o listar ramas remotas.............................................................................................47
 git clone …................................................................................................................................47
git branch …..............................................................................................................................48
git fetch …................................................................................................................................48
Ejemplo de clonar un repositorio remoto..................................................................................49
Ejemplo de crear un remote...........................................................................................................50
Copiar una rama remota en una local............................................................................................52
El repositorio central..........................................................................................................................54
Ejemplo de clonar rep. CORE-UPM/cal e integrar rama cal_merge de jquemada/cal..................55
Traer cal_merge de jquemada/cal e integrar.............................................................................56
Actualizar rama master (tracking) de CORE-UPM/cal............................................................58
Actualizar ramas remotas...................................................................................................................60
Ejemplo de como enviar pull request desde CORE-UPM/cal a jquemada/cal en GiHub.............61
Preparar pull-request.................................................................................................................61
Editar pull_request....................................................................................................................62
Enviar pull_request...................................................................................................................62
Ejemplo de como integrar pull request en jquemada/cal...............................................................63
Resumen de evolución del proyecto..............................................................................................65
Introducción y referencias
Git es un gestor de repositorios de versiones software, desarrollado por Linus Torvalds en 2005 en
código libre. Lo diseño para soportar el desarrollo de Linux con un modelo descentralizado y
abierto.
git es un comando de UNIX/Linux.
• Documentación: https://git-scm.com/documentation

◦ Tutorial: https://www.atlassian.com/git/tutorials/setting-up-a-repository

• Instalación de git o actualización a la última versión

◦ Instrucciones de GitHub: https://help.github.com/articles/set-up-git/

◦ Instrucciones git-scm: https://git-scm.com/book/en/v2/Getting-Started-Installing-Git

◦ Tutorial Atlassian : https://www.atlassian.com/git/tutorials/install-gitgit –version, git --

help

Manuales en línea y configuración

git <commando> --help
git config

Commit o versión
Instantánea del estado de los ficheros de un proyecto (puede restaurarse). Algunos commits se
etiquetan con tags especiales de versión, p.e. v1, v1.3, ..

Branch o rama
Secuencia de commits ordenada por fechas que soporta un desarrollo. Los nuevos commits se
añaden al final de la rama de desarrollo.
La rama de desarrollo principal se denomina habitualmente master. La rama master se crea
automáticamente al crear el primer commit.

Directorio de trabajo
Directorio donde se crean las versiones del proyecto: código fuente, datos, … Se denomina
también:
• Área o espacio de trabajo (workspace).

• Árbol de trabajo (work-tree) por la estructura en árbol de los subdirectorios que agrupan
ficheros.
• Base de código (codebase).
git init
El comando git init transforma un directorio en un directorio de trabajo Git, añadiendo el repositorio
de commits al directorio, en un subdirectorio oculto .git (que contiene la base de datos donde
guardar los commits).
Muchos comandos git se invocan en el directorio de trabajo o un subdirectorio

Índice o área de cambios (stagin area, index)

El indice o área de cambios (staging area, index) es el registro de cambios del directorio de trabajo a
incluir en el próximo commit.
Los cambios no registrados en el índice no se incluyen al generar un nuevo commit.
Los ficheros no modificados del commit anterior permanecen en el siguiente commit.

git add ...

Registra en el índice los ficheros indicados:
• git add . → registra en el índice todos los ficheros nuevos o modificados

• git add LICENSE README.md → registra los ficheros LICENSE README.md en el

índice

git reset ...

Extrae <ficheros> del índice (deshace git add ..)
• git reset . → extrae del índice todos los ficheros
 • git reset LICENSE → extrae LICENSE del índice

git commit ...

Genera un nuevo commit con lo registrado en el índice:
• git commit -m "Descripción" guarda nuevo commit con mensaje o título “Descripción"

• git commit guarda nuevo commit y abre un editor para crear mensaje del commit

• git commit --amend -m “....” modifica el último commit con lo registrado en el índice !OJO
cambia commit
Y asigna un identificador único para el nuevo commit, que es un número hexadecimal de 40
dígitos generado como clave de hash SHA1 (973751d21c4a71f13a2e729ccf77f3a960885682).
Se suele usar el formato corto (formato largo es incómodo) con los 7-8 dígitos iniciales, que son
únicos en un proyecto (973751d2). Los comandos git permiten identificadores cortos o largos.

git log –oneline

Muestra la historia de commits (e ids cortos) de una rama

Análisis del directorio de trabajo

Un commit se genera por modificación del commit anterior, añadiendo, eliminado o modificando
ficheros del directorio de trabajo (y de sus subdirectorios).
Git controla los cambios en los ficheros respecto al commit anterior.

git status
Muestra estado de los ficheros del directorio:
• modified: modificados respecto al commit anterior

• untracked: no existentes en el commit anterior

• staged: registrados para el próximo commit

Con la opción -s (git status -s) muestra estado en formato compacto muy cómodo y conciso.
git diff ...
Muestra diferencias en los ficheros modified respecto al commit anterior
• git diff muestra los cambios en todos los ficheros modified del directorio de trabajo

• git diff README.md muestra solo los cambios en README.md, pero solo si es modified

git diff nuestra las diferencias en las líneas del código:

• Líneas añadidas: en verde y comienzan por +
• Líneas eliminadas: en rojo y comienzan por -

git diff --cached ...

Muestra diferencias en los ficheros staged respecto al commit anterior
• git diff –cached muestra los cambios en todos los ficheros staged del directorio de trabajo

• git diff --cached README.md muestra solo los cambios en README.md, pero solo si es
staged

git mv <old> <new>

Cambia el nombre de un fichero en el directorio de trabajo (y en el índice)
git mv file1.js file2.js cambia el nombre de file1.js a file2.js en el directorio de trabajo y en el índice

git rm <files>
Borra <files> del directorio de trabajo y registra lo borrado en el índice
git rm file1.js file2.js borra file1.js y file2.js del directorio de trabajo y del índice

git rm --cached <files>

Borra <files> del índice, los ficheros pasan de staged a untracked.
git rm --cached file1.js file2.js borra file1.js y file2.js solo del índice

git checkout <files>

Elimina cambios de <files> que pasan a unmodified (Peligro! Cambios se pierden).
git checkout file1.js elimina los cambios del fichero modified file.js

git checkout .
Elimina los cambios de todos los ficheros modified del directorio de trabajo que pasan a
unmodified (Peligro! Cambios se pierden).
git checkout . elimina cambios en todos los ficheros modified del directorio de trabajo
Ejemplos
Transformar un directorio en el directorio de trabajo git

Crear ficheros en el directorio de trabajo git

Mostrar estado del directorio de trabajo

Registrar nuevos ficheros en el índice

Mostrar estado del directorio de trabajo

Crear nuevo commit y ver historia

Inspeccionar historia y área de trabajo

Añadir nuevo fichero

Crear un nuevo commit a master

Ramas
Un módulo puede ser branched o bifurcado en un instante de tiempo de forma que, desde ese
momento en adelante se tienen dos copias (ramas) que evolucionan de forma independiente
siguiendo su propia línea de desarrollo. El módulo tiene entonces 2 (o más) "ramas". La ventaja es
que se puede hacer un "merge" de las modificaciones de ambas ramas, posibilitando la creación de
"ramas de prueba" que contengan código para evaluación, si se decide que las modificaciones
realizadas en la "rama de prueba" sean preservadas, se hace un "merge" con la rama principal. Son
motivos habituales para la creación de ramas la creación de nuevas funcionalidades o la corrección
de errores.

• La rama master es la rama principal de un repositorio, es una rama predefinida que se crea al
crear el primer commit.
• Las ramas soportan desarrollos separados de master. Una rama puede comenzar en cualquier
commit del repositorio.
• Los nuevos commits de una rama se deben añadir al final (la rama siempre crece). La flecha
indica el commit o los commits a partir de los se ha generado.
• El nombre de la rama es un puntero a su último commit, por ej.

◦ master identifica el commit 5558t8

◦ rama_x identifica el commit abc123

Crear una rama: git branch <nombre rama> <id commit base>
git branch rama_y 46g8g8 crea la rama de nombre rama_y con base en el commit C3 (46g8g8)
Mostrar ramas existentes: git branch -v

Grafo de commits

El grafo de commits de un repositorio es un grafo con la relación de todos los commits de las ramas
del repositorio.
Las flechas de salida de un commit indican su relación con las anteriores.
• Una flecha indica un commit generado por modificación del commit anterior.

• Dos flechas indica un commit generado por la integración de una rama en otra.

La historia de un commit es la secuencia ordenada, por fechas, de commits utilizados para generar
dicho commit.

Padres y ancestros de un commit

• <commit>^n respresenta el número (n) de padre de un commit de integración.

master^1 = C7 (g699g8) y master^2 = C4 (ah78j9)

 • <commit>~n representa el ancestro n de la historia de un commit, y siguen la línea del
primer padre (^1).
master~1=master^1=C7 (g699g8) y master~3=C2 (dd12f9)

Mostrar historia de un commit o una rama

git log -<n>
Muestra los <n> últimos commits de la historia del commit acutal (el HEAD).

git log --oneline --graph <rama>

Muestra el grafo de integración de commits de la rama <rama> (la rama se puede indicar por su
nombre o por su id corto).
git log --oneline --graph rama_x muestra el grafo de integración de commits de rama_x (formato 1 línea)

git log --oneline <commit>

Muestra la historia, en formato de una línea, del commit indicado (id corto, notación de padres,
notación de ancestros).
git log --oneline 46g8g8 muestra la historia del commit 46g8g8 (formato 1 línea)

git log --oneline master^2 muestra la historia del 2º padre de master (formato 1 línea)

git log --oneline master~3 muestra la historia del 3º ancestro de master (formato 1 línea)

git log --oneline --all …

Muestra la historia de commits de todo el repositorio.
git log --oneline --all -8 muestra los 8 últimos commits del repositorio ordenados por fechas

git log --oneline --all muestra todos los commits del repositorio ordenados por fechas

git log --oneline --all --graph

Muestra el grafo de commits de todo el repositorio.
git log --oneline --all –graph muestra el grafo completo de commits del repositorio
Mostrar diferencias entre ficheros de diferentes commits
git diff …
Muestra diferencias de código entre ficheros de diferentes commits
git diff rama_x master muestra los cambios en ficheros entre rama_x y master

git diff master~2 muestra los cambios en ficheros entre master~2 y HEAD

git diff rama_x master -- LICENSE muestra los cambios en el fichero LICENSE entre rama_x y master

git diff rama_x master LICENSE similar al anterior si no hay ambigüedad en los nombres

git show …
Muestra metadatos de commit y diferencias con el commit anterior
git show rama_x muestra los metadatos del último commit de rama_x y las diferencias con el commit
anterior

git show muestra los metadatos del commit actual (HEAD) y las diferencias con el commit anterior

Restaurar commits en el directorio de trabajo

git checkout <commit>
Restaura el <commit> en el directorio de trabajo y actualiza el HEAD.. Ojo! Los cambios no
guardados del commit previo se perderán.

El HEAD es un puntero al commit que está guardado en el directorio de trabajo, que se actualiza
automáticamente al hacer chekout.
El comando reset
El comando git reset permite compactar o eliminar commits del grafo. Normalmente se utiliza para
eliminar, compactar o rehacer la última parte de la historia de una rama.

git reset <commit>

Cambia el puntero de rama y HEAD a <commit>. Deja las diferencias entre HEAD y <commit> en
el directorio de trabajo. Es decir, restaura el contenido de commit, añadiendo las diferencias con
<commit>.
Peligro! Se pueden perder commits del grafo, si los eliminados no están guardados en otra rama.

Ejemplo:
git reset master~2 mueve HEAD y el puntero de rama al 2º ancestro, dejando las diferencias en el directorio
de trabajo

Nota: Los cambios introducidos en los 2 commits que desaparecen de la rama quedan en los ficheros
modified

git reset --hard <commit>

Cambia el puntero de rama y HEAD a <commit>. Muy peligroso! Los commits y su código se
pueden perder, si los eliminados no están guardados en otra rama.

Ejemplo:
git reset --hard master~2 mueve HEAD y el puntero de rama al 2º ancestro. Los cambios introducidos en los
dos últimos commits de la rama desaparecerían si no estuviesen en otra rama.

Ejemplo de uso para integración de varios commits

Si HEAD estuviese en master, git reset --master~1 eliminaría el commit C8 (5558t8) y, como los
cambios han quedado en el directorio de trabajo, estos se pueden integrar en un commit solo de
master.
Ejemplos ramas
Mostrar ramas
Mostrar historia

Crear rama
Mostrar ramas

Mostrar rama en modo verboso

Restaurar rama (en el directorio de trabajo)

Mostrar historia
Integración de commits con merge
git merge <commit>
Intenta automatizar la integración de un commit. Por defecto utiliza la estrategia recursiva que
integra el commit indicado, fichero a fichero, en el commit actual, aproximadamente así:
• Ficheros iguales en ambos commits: incluye el fichero común (sin conflicto)

• Fichero esta solo en uno de los commits: incluye el fichero (sin conflicto)

• Ficheros con diferencias disjuntas: une ambos ficheros con auto-merge (sin conflicto)

• Ficheros con ancestro común en sus historias: incluye el último fichero (sin conflicto)

• Ficheros con diferencias en el mismo contexto: une ambos, marca diferencias y genera
conflicto

Si al acabar no hay conflictos, genera un commit de integración de tipo auto-merge.

Si hay conflictos no se genera commit. Los conflictos se marcan en los ficheros donde ocurren.
Deben ser resueltos, cerrando el commit de integración con git commit ...

git merge …
Intenta integrar un commit con el activo (HEAD):
• git merge master → integra el último commit de master en el commit activo (HEAD)

• git merge g699g8 → integra el commit g699g8 con el commit activo (HEAD)

• git merge -m “msg” master → integra master en HEAD y asigna el mensaje “msg” al commit de
integración

• git merge --abort → aborta la integración sin generar commit de integración cuando ha habido
conflictos

Conflictos de integración
Si hay conflictos no se genera commit de integración.
• Los conflictos quedan marcados en el fichero en el directorio de trabajo, en un estado
especial denominado unmerged.
• Los conflictos se resuelven editando manualmente. Una vez resueltos los conflictos se
genera el commit de integración con git commit …
• Los ficheros sin conflictos quedan también en el directorio de trabajo, en estado staged.
Ejemplo de integración
Para integrar los 2 botones desarrollados en ramas diferentes, se deben integrar las 2 ramas con git
merge ...

1. Se va a integrar master en cal_merge (HEAD) con git merge master

2. Los conflictos generados se resolverán manualmente
3. Una vez resueltos se genera el commit de integración con git commit …
Mostrar ramas en modo verboso

Crear nueva rama para realizar la integración

Integrar master en inverse

Resolver conflictos
Crear commit de integración

Conflictos vistos con diff

Integración ff (fast-fordward)
git merge ... detecta si la integración pedida se ha realizado ya en otra rama, si es así, Git está
configurado para realizar una integración ff (Fast-Forward). Simplemente avanzara el puntero de
rama hasta el commit que contiene la integración solicitada. No se generará un nuevo commit, se
reutilizará el existente.

Ejemplo de integración ff
Siguiendo con el ejemplo anterior, si integramos ahora la rama cal_merge en la rama master, se
reutiliza, con fast-forward, la integración ya realizada en la rama cal_merge, porque master ya se ha
integrado en cal_merge (tal y como muestra el grafo de commits)
Mostrar ramas

Restaurar rama master

Crear rama nueva

Este paso no es necesario para la integración que queremos hacer, sólo es para dejar en una rama
propia el commit del x^2 button. De este modo, al final tendremos una rama para x^2 button, otra
para 1/x button y, en el master la integración de los dos botones.
Integrar en rama master

Integración de ramas con rebase

Una rama se usa para hacer desarrollos separados de la rama master. Al finalizar el desarrollo de la
rama, se puede integrar con master u otra rama.

Cambiar la base (rebase) de una rama permite también integrar desarrollos, integra los desarrollos
linealmente (muy limpio), pero elimina la historia de ramas utilizadas e integradas para el

desarrollo.
git rebase ...
• Una rama puede cambiar de base con git rebase .…

• git rebase .. arranca un bucle que integra un commit cada vuelta

◦ La primera iteración integra la base con el primer commit de la rama.

◦ La segunda iteración integra el primer commit ya integrado con el segundo commit de la

rama.
◦ y así hasta finalizar la rama

• En cada iteración del bucle la integración es similar a la realizada con merge.

La rama cal_rebase cambia la base “Read. & Lic.” por “x^2 button”. Este cambio de base integra
los botones de forma similar a merge.
Ejemplo de rebase
Mostar ramas

Crear y restaurar rama

Comenzar cambio de base

Resolver conflictos
Finalizar rebase, mostrar ramas y grafo
Git y GitHub

Tipos de repositorio
Repositorio sin directorio de trabajo (bare). Repositorio para compartir desarrollos con otros a
través de Internet. Suele estar alojado en un servidor de Internet y
Se sincroniza con uno local, con
• git push ... sube ramas de desarrollo a un repositorio bare

• git clone ... clona un repositorio en un repositorio local

• git fetch ... trae ramas de otro repositorio al repositorio local

• git pull ... integra una rama de otro repositorio con una rama local

Se crea con:
• git init –bare Crea solo un fichero con el repositorio de commits y sin directorio de trabajo

Repositorio con directorio trabajo (local o de trabajo). Repositorio para desarrollar en el

ordenador local. Git no permite hacer push hacia este tipo de repositorios.

GitHub
GitHub es un portal donde programadores comparten repositorios con proyectos Git. Nos da acceso
a ellos a través del navegador Web y a través de Git.
GitHub: https://github.com
Los repositorios públicos son gratis, los privados de pago.
Los repositorio sde GitHub se identifica en un repositorio local con un URL, p. e.
• https://github.com/jquemada/cal → URL del rep. jquemada/cal en GitHub

• https://github.com/jquemada/cal.git → con extensión .git explicita (equivalente)

• [email protected]/jquemada/cal.git → URL Git (equivalente, poco utilizado)

La función principal de GitHub es compartir repositorios con terceros.

Las operaciones principales de un usuario registrado son

• Crear repositorio remoto inicial nuevo para albergar un proyecto. Utilizando el botón:
Import repository
• Copia un repositorio albergado en GitHub a otra cuenta (para contribuir). Utilizando el
botón: Fork
• Importa un repositorio identificado por su URL a GitHub, incluso en otro formato.
Utilizando el botón: New repository. Equivale a crear repositorio vacío (New_repository) e
importar en él otro repositorio con un URL.
• Crear una organización para albergar múltiples proyectos relacionados. Utilizando el
botón: New organisation.
• Y otras operaciones de compartición, gestión y mantenimiento

Permite operaciones Git de sincronización de repositorios bare

• push (subir rama), clone (clonar repositorio), fetch (traer rama), pull ..
Crear repositorios remotos en GitHub
• Crear un repositorio vacío con New_repository: https://github.com/jquemada/cal. GitHub
lo crea en sus servidores invocando: git init --bare
• Copiar un repositorio a través de su URL con Import_repository:
htttps://github.com/jquemada/cal_2com. El repositorio puede importarse de otro servidor en
Internet o de GitHub, incluso cambiar el formato.
• Copiar un repositorio con Fork a otra cuenta u organización: https://github.com/CORE-
UPM/cal. Se copia de la cuenta jquemada a la organización CORE-UPM

Crear un nuevo repositorio (New repository)

El botón de New repository permite crear el repositorio inicial de un proyecto, con un commit
inicial típico que puede incluir hasta 3 ficheros:
• README.md fichero con descripción del proyecto o software.

• LICENSE fichero con la licencia de distribución del software.

• .gitignore fichero donde se indica que ficheros debe ignorar Git al generar versiones.

Es la forma habitual de arrancar un proyecto albergado en GitHub.

.gitignore
Importar un repositorio a GitHub
Clonar un repositorio de GitHub
Un equipo, de desarrollo, suele tener un repositorio remoto de referencia, donde se consolidan las
últimas versiones de un proyecto y es la referencia que utilizan todos los miembros del equipo y sus
usuarios. El repositorio remoto suele administrarse por unas pocas personas.

Otros desarrolladores lo copian con Fork a su cuenta en GitHub. Los desarrollos se realizan en la
copia en GitHub clonada con Fork. GitHub permite contribuir los desarrollos al repositorio de
referencia con pull request.
Referenciar un repositorio remoto
Un repositorio remoto se identifica en Internet con un URL, por ejemplo:
• https://github.com/jquemada/cal

• https://github.com/jquemada/cal_I

git remote ... permite asociar un nombre, denominado remote, a un URL. El nuevo nombre puede
utilizarse, en vez del URL, en los comandos para identificar el repositorio.

git remove [-v]

Muestra los repositorios remotos definidos en un repositorio (-v modo verboso).

git remote add …

Define un nuevo remote en el repositorio asociado a un URL.
• git remote add cal_2com https://github.com/jquemada/cal_2com → asocia el nombre
cal_2com con el URL https://github.com/jquemada/cal_2com

git remote remove …

Borra la definición de un remote en el repositorio.
• git remote remove cal_2com → Borra el nombre cal_2com del repositorio y ya no podrá ser
utilizado en comandos
Clonar un repositorio remoto en uno local
Un proyecto publicado en un servidor en Internet puede copiarse al ordenador local con git clone ...
para desarrollar en sus ramas.

git clone … crea un nuevo repositorio local, donde copia la rama master del repositorio remoto
clonado. Además asocia el nombre de remote origin al repositorio remoto origen de la clonación.
• git clone https://github.com/jquemada/cal_I → copia el repositorio remoto en el directorio
local cal_I (mismo nombre que el repositorio). origin referencia al repositorio clonado
https://github.com/jquemada/cal_I.
• git clone https://github.com/jquemada/cal_I mi_cal → Copia el repositorio remoto en el
directorio local mi_cal. origin referencia al repositorio clonado
https://github.com/jquemada/cal_I.
Actualizar un repositorio en GitHub con push
git push … Actualiza el repositorio remoto con los nuevos commits de una rama local:
• git push https://github.com/jquemada/cal master → actualiza los nuevos commits de la rama
master en el repositorio GitHub jquemada/cal
• git push https://github.com/jquemada/cal_2com master → actualiza los nuevos commits de
la rama master en el repositorio GitHub jquemada/cal_2com

Necesita 2 condiciones para finalizar con éxito:

1. Se debe tener credenciales de acceso al repositorio remoto.
2. La actualización de commits debe ser compatible con la rama actualizada en el remoto. Solo
debe añadir nuevos commits al final de la rama remota o actualizar un repositorio vacío.
Peligroso! La opción -f permite actualizar una rama incompatible, pero se pierden commits.
Git y GitHub
Rama local, remota y tracking
• Rama local: rama donde se realiza el desarrollo de nuevos commits. Las ramas locales
almacenan sus commits en el repositorio de commits en el directorio .git
• Rama remota: rama de un remote definido en el repositorio local. Son copias de las ramas
del remote mostradas en el grafo de commits del repositorio local. Su estado se actualiza en
las operaciones de sincronización: clone, fetch, pull o push
remote: nombre simbólico asociado al URL de un repositorio definido con git remote …
El nombre de la rama remota va precedido por <remote> por remotes/<remote>:
◦ origin/master o remotes/origin/master → identifica la rama master del remote origin

◦ cal/square o remotes/cal/square → identifica la rama square del remote cal

• Rama tracking: rama local asociada a una remota. La rama tracking simplifica las
operaciones de sincronización con la remota. Una rama de desarrollo local suele ser tracking
de la remota equivalente, por ej. master de origin/master

Crear, enlazar o listar ramas remotas

git clone …
Copiar un repositorio identificado por <URL> a un directorio local. Define el repositorio remoto
como repositorio remote origin, copia solo la rama master definiéndola como rama tracking de
origin/master y actualiza todas las ramas remotas de origin.
• git clone https://github.com/jquemada/cal → copia el repositorio remoto al directorio cal

• git clone https://github.com/jquemada/cal cal_2 → copia el repositorio remoto al directorio

cal_2
git branch …
Muestra ramas locales, remotas o tracking con opciones -a (--all), -r (--remote) o -vv (--verbose).
• git branch -r → muestra solo las ramas remotas de un repositorio local

• git branch -a → muestra las ramas locales y remotas de un repositorio local

• git branch -vv → muestra en las ramas tracking la rama remota asociada y su estado

git fetch …
Crea si no existen o actualiza las ramas remotas de un remote creado con git remote .…
• git fetch cal → crea las ramas remotas del remote cal o actualiza su estado si existen

• git fetch → actualiza el estado de todas las ramas tracking

• git fetch --all → crea o actualiza el estado de todas las ramas de todos los remotes definidos

• git fetch -p origin → la opción -p (--prune) actualiza las ramas de origin eliminando las que
ya no existen
Ejemplo de clonar un repositorio remoto
Ejemplo de crear un remote
Copiar una rama remota en una local
Para añadir desarrollos a una rama remota debemos copiarla en una local. Los desarrollos se
realizan sobre la rama local añadiendo nuevos commits.

git checkout …
Copia una rama remota en una local tracking y restaura la rama local (solo cuando no existe)
• git checkout square → crea y restaura la rama tracking square asociada a <remote>/square

Restaura una rama remota en mode detached HEAD, es decir no asociada a ninguna rama
• git checkout origin/square → restaura origin/square en modo detached HEAD

git fetch .…
Copia una rama remota en una local utilizando refspecs: [+]<local_branch>:<remote_branch>
• git fetch origin square:sqrt → Crea o actualiza la rama local sqrt con los commits de la
remota origin/square
• git fetch origin pull/1/head:s1 → Crea o actualiza la rama local s1 con el pull_request 1 del
repositorio remoto origin en GitHub
• git fetch cal_branches +s1:s1 → Crea o actualiza la rama local s1 con la remota
cal_branches/s1 aunque sean incompatibles (+)
• git fetch https://github.com/jquemada/cal square:square → Crea o actualiza la rama local
square con la rem. square de https://github.com/jquemada/cal

git pull .…
Traer la rama remota indicada e integrarla con una rama del repositorio local
• git pull cal_branches square → integra la rama square de cal_branches en la rama activa

• git pull origin pull/1/head → Integra el pull_reques #1 en la rama activa

El repositorio central
Repositorio central o de referencia de un proyecto publica las versiones maduras y probadas de un
proyecto, permitiendo descargarlas.
Este repositorio se clona con Fork en otra cuenta para contribuir. Las contribuciones se envían al
repositorio de referencia como pull requests. Fork y pull request sistematizan la forma de contribuir
a proyectos albergados en GitHub.
Los administradores del proyecto analizan las contribuciones (pull_requests) y las integran si
consideran que enriquecen el proyecto.
La calculadora con título se integra con la de 2 botones en CORE-UPM/cal. La integración se
contribuye con pull_request a jquemada/cal, donde se integra en master.

Ejemplo de clonar rep. CORE-UPM/cal e integrar rama

cal_merge de jquemada/cal
Traer cal_merge de jquemada/cal e integrar
Actualizar rama master (tracking) de CORE-UPM/cal
Actualizar ramas remotas
git push ... sube los cambios en las ramas locales a los repositorios remotos. Las ramas locales
sobre las que se trabaja son normalmente ramas tracking de las remotas.

git push ... copia una rama local en una remota. Puede utilizar refspecs: [+]<local_branch>:<remote_branch>
• git push → Actualiza las ramas remotas de las ramas locales tracking definidas en el
repositorio local
• git push -f cal_branches master → Actualiza la rama cal_branches/master con la local
master, aunque sean incompatibles.
• git push cal_branches sqrt:square → Actualiza la rama remota cal_branches/square con los
nuevos commits de la local sqrt
• git push https://github.com/jquemada/cal sqrt:square → Actualiza la rama remota cal/square
con los nuevos commits de la local sqrt

git push … borra ramas en un repositorio remoto (OJO! son las ramas reales del repositorio remoto)
• git push origin :sqrt → Borra la rama sqrt en el repositorio remoto origin

• git push origin --delete sqrt → Similar a anterior, opción posible en versiones recientes de
git
Ejemplo de como enviar pull request desde CORE-UPM/cal a
jquemada/cal en GiHub

Preparar pull-request
Editar pull_request

Enviar pull_request
Ejemplo de como integrar pull request en jquemada/cal
Resumen de evolución del proyecto