Instalación de Git en los distintos sistemas operativos

Instalar git en Linux de terminal:

apt-get install git

Los demás sistema operativos lo iremos poniendo según vaya surgiendo.

Inicializar repositorio local

$ git init # Añade repositorio.. crea un directorio oculto .git en esa misma ruta
$ git add . # Marca todos los ficheros para el próximo commit.
$ git commit -m "Estado inicial" # Crea un nuevo commit con los ficheros marcados.

Estos 3 comandos son las que necesitamos para crear un repositorio, en las que añadimos todos los ficheros que tenemos en directorio actual, creando un commit de inicio.

Una vez iniciado el repositorio ya podemos ponernos a currar en él. Añadir, modificar, eliminar ficheros y lineas de código con la garantía y la ventaja que tiene utilizar un control de versiones.

Los programadores al empezar a utilizar git, inicialmente comitaremos todo aquello que hagamos, ya que siempre pensamos que podemos necesitar ver los cambios que realizamos en nuestro código.

¡ Tener cuidado que se hace muy adictivo !

Primer commit en Git

Para realizar el primer commit una iniciado, debemos indicarle a git si queremos que guarde todos los cambios en el commit o parte ellos.

Para saber que fichero hemos añadido o modificado con la instruccion:

git status

Indicando los ficheros  que "Cambios no preparados para el commit:" que son aquellos ficheros que eliminados o modificamos y por otro lado "Archivos sin seguimiento: " que son los que no se añadieron nunca GIT, lo ormal en el primer commit.

Si queremos añadir para comit tanto uno como otros , con la siguiente instruccion:

git add .

Una vez añadidos con la instrucción anterior , si volvemos a realizar:

git status

Nos listará los ficheros que preparamos para realizar el commit, estos cambiarán de color, en vez rojo aparecera en verde.

Si por cualquier motivo no hubiera añadido todos, nos aparecera en rojo los ficheros que no están preparados para el commit.

Cuando eliminamos un fichero de nuestro proyecto que estaba en seguimiento no los indica en rojo, indicando que "deleted fichero tal". Estos cambios no podemos añadirlo con "add . " directamente , debemos eliminarlo de en el repositorio.

Se va eliminar del repositorio ahora, en este momento , en este commit, si algún momento volvemos a instaneas anteriores ( commits ) lo tendremos esos fichero eliminados.

Para eliminar un fichero que tenemos en seguimiento podemos realizarlos de las siguientes formas:

git rm RutaNombreFicheroEliminado

Esta opción para un fichero no es mala, pero si tuvieramos mucho ficheros para hacerlo podríamos utilizar

git rm $(git ls-files -d)

Está instruccion hace lo  mismo eliminado del seguimiento para este commit de todos los ficheros eliminados.

Lo añadir al status esos ficheros como preparados indicando que se eliminaro o se renombraron.

Otra forma más intuitiva para añadir los cambios y indicar los que eliminamos es con el siguiente comando:

git add -i

Donde nos muestra un menu como este:

*** Commands *** 
1: status   2: update   3: revert   4: add untracked
5: patch   6: diff   7: quit   8: help

Seleccionando cualquiera de las opciones , nos permite con simple numero , y secuencias como 1-12, 13 ,15 añadir varios ficheros a la vez... marcándolos con * cuando estén añadidos.

Como veís este menu tiene muchas más opciones como la 6:diff donde nos indica las diferencias que hay en fichero desde el ultimo commit.

UNA VEZ TENGAMOS AÑADIDO LOS FICHEROS QUEREMOS COMITAR, SOLO QUEDA A HACERLO

git commit - m " Texto breve de los queremos comitar

El texto de descripción del comit debe ser claro y breve , que podamos reconocer rápidamente lo que hicimos, pero no siempre es posible que sea breve , por lo que si no ponemos  -m , no abre el editor nano, " me imagino que el que tengamos por defecto git".

Donde podemos expandirnos más.

¿ Antes de comitar quiero ver las diferencias que tiene un fichero determinado?

Esto realmente es lo necesario de un CSV, por eso en git un sin fin de forma de ver los cambios.

Tiene varios comando para realizar esto, pero el principal

git diff [ruta/del/fichero]

Si no expecificamos la ruta del fichero, nos mostrará todos los cambios de todos lo ficheros con respeto al ultimos commit.

Este comando tiene muchas opciones y posibilidades ver más información el entrada Git Diff -Ejemplos

 

¿ Quiero dejar todo como estaba ?

Esa pregunta, o esa preocupación, creo que no hay programador que no le pasará, ya que muchas veces necesitamos recuperar el estado de unos ficheros , que fuimos cambiando o se cambiaron , por algún motivo...

Pues si queremos volver a recuperar el estado del ultimo commit , podemos realizar:

git reset --hard HEAD

Donde está instrucción deja el repositorio en el ultimo comit de esa rama.

Con esta ultima instrucción los ficheros que hubieras eliminado, los recuperas, los ficheros que modificaste te los pone de nuevo, lo que no hace, es eliminar los ficheros que tiene a mayores, que con git status puedes verlos.

 ¿ Quiero ver lo que cambie en commit anteriores ?

Para listar los commit realizados ( nuetras arbol) . Con la instruccion :

git log

Nos muestra un listado de los commit que tenemos en el proyecto, en orden descendente, es decir muestra el ultimo al primero.

Ahora si queremos que nos muestre en una sola linea una forma comoda es:

git log --pretty=format:"%h - %an, %ar : %s"

Si ademas nos gustaría que nos informe de los ficheros que cambiamos (M) Modificamos (D) Eliminamos , pero solo el nombre...

git log --pretty=format:"%h - %an, %ar : %s" --name-status

Una vez localicemos el commit , anotando el numero que nos indica, podemos ver los ficheros que cambiamos en ese commit, con la instrucción

git whatchanged -1 [8 digitos por lo menos del numero commit]

Entonces nos listará los ficheros que cambiamos en ese commit.

Con este mismo commando podemos listar todos los commit que afectaron a un fichero.

git whatchanged [/ruta/del/fichero]

Y si antes de la ruta , ponemos la opción -p , ya nos muestra los cambios en cada commit.

¿ Queremos comparar un fichero en distintos commit?

Ahora imaginar que necesitas saber los cambios que realizamos en un ficheros con respecto al estado actual de ese fichero. Conociendo el numero commit, con git diff ya puedes verlo:

git diff [numero commit] /ruta/del/fichero

Nos muestra los cambios que tenemos en el fichero ( estado actual)  comparando con el mismo fichero en momento realizar el commit.

Si quisieramos comparar ese fichero pero cuando comitamos , es decir comparar el estado del archivo en los momento de dos comit.

git diff [nºcommit1] [nºcommit2] /ruta/del/fichero

Más retorcido todavía....

Y si queremos comparar un fichero con otro fichero e incluso fuera del repositorio de git.

diff -u /ruta/del/fichero1 /ruta/del/fichero2

¡¡ IMPRESIONANTE !!...

 

Ramas en  Git : Locales o remotas

Una rama es un puntero a un commit específico en el repositorio, es difurcación con la queremos seguir trabajando a ver a donde llegamos.

Nosotros especialmente la utilizamos para tener una rama "master" que es la de producción y la "desarrollo" que es donde vamos realizar los cambios, mejoras o tratamiento de errores. Una testeados esos cambios los validamos y la fusionamos con master.

Hasta ahora hablamos de ramas locales, ya que tenemos que tener en cuenta que podemos trabajar con repositorio remotos, por lo cual tendremos ramas remotas.

Ahora solo lo vamos tratar instrucciones básicas para ramas creadas en local, si quieres más información os recomiendo estos dos links:

Ramas locales : Explicación básica

Metodos de crear un ramas locales

$ git branch <nombre>                
# Crear la rama en el punto actual.
$ git checkout

Con la siguiente instrucción , nos ahorramos la primera instrucción ( git branch )

$ git checkout -b <nombre>

Las dos instrucciones anteriores realizan lo mismo.

Como cambiar el nombre de una rama.

$ git branch -m <actual> <nuevo>      
# Renombrar la rama $ git branch -d <nombre> # Borrar la rama

Como crear una rama desde un commit determinado

$ git branch <nombre> <COMMIT>
$ git checkout      
 # Crea la rama a partir del commit dado. Es necesario hacer checkout.

$ git checkout -b <nombre> <COMMIT>          
 # Crear rama a partir del commit dado.

De las dos formas que podermos crear una Rama , indicando el commit desde el queremos crear la nueva rama.

Listar ramas

$ git branch
# Lista las ramas existentes.

Nos muestras las ramas existentes en repositorio de Git.

Moverse a una rama o a un commit específico

$ git checkout <rama>

 

$ git branch               # Listar todas las ramas $ git branch -v    # Mostrar último commit en cada rama y su situación respecto a su rama remota (si hay) $ git branch --merged # Mostrar ramas que se han fusionado con la actual, y por tanto pueden borrarse $ git branch --no-merged # Mostrar ramas con trabajos sin funsionar. Intentar borrarlas dará un error.

 

$ git checkout <COMMIT> # No toca los cambios locales $ git checkout -f <COMMIT> # Sobreescribe los cambios locales

Se puede hacer una rama desde el commit actual para continuar el desarrollo (git branch). Si se hacen cambios en un commit intermedio (no es un HEAD) y se commitean sin hacer una rama, se crea un commit separado que sale del actual (rama sin nombre).

Fusionar ramas (merge)

$ git merge <nombre>       # Fusiona la rama indicada en la rama actual

Las diferencias se resuelven automáticamente si es posible. En caso de conflictos (código o ficheros binarios modificados en ambas ramas) el proceso se detiene (merging) a la espera de una resolución manual.

1-Resolver conflictos de fusionado:

Dentro de cada fichero en conflicto se añaden marcas alrededor del código conflictivo, mostrando al mismo tiempo la versión de una y otra rama (excepto en ficheros binarios).

La sección “Unmerged paths” de git status muestra los ficheros que requieren atención. Debe resolverse cada conflicto manualmente dentro del fichero (eliminando las marcas agregadas por git) y marcarlo como resuelto con git add.

En vez de editar los ficheros es posible escoger una de las dos versiones disponibles (rama actual o rama que se está fusionando):

$ git checkout --ours -- <file> # Obtener la versión del fichero en la rama actual $ git checkout --theirs -- <file> # Obtener la versión del fichero en la rama que se está fusionando con la actual

Para abortar la acción o anularla una vez realizada:

2- Resolución gráfica de conflictos:

$ git mergetool # Inicia la herramienta gráfica de resolución de conflictos

La herramienta crea ficheros adicionales por cada fichero en conflicto (backup, base, local, remote) para que la herramienta de resolución pueda mostrarlos al usuario al mismo tiempo y éste establecer la versión final. Estos ficheros deberían borrarse automáticamente tras la edición (en caso de que persistan es necesario borrarlos manualmente).

La resolución básica sólo sirve para ficheros de texto. En ficheros binarios usar git checkout –ours o git checkout –theirs para escoger una de las dos versiones disponibles.

Deshacer cambios

$ git revert <COMMIT> # La recuperación hace un nuevo commit en la rama actual sin ir "hacia atrás" en la historia $ git reset --hard # Deshace los cambios locales $ git reset --hard HEAD~1 # Elimina el último commit

Recuperar una versión determinada de un fichero o path:

$ git reset <COMMIT> -- <path> # git reset NO sobreescribe cambios locales $ git reset -p <COMMIT> -- <path> # Seleccionar interactivamente las partes a restaurar $ git checkout <COMMIT> -- <path> # Sobreescribe cambios locales sin preguntar

En Windows se puede abrir git-bash directamente en cualquier subcarpeta carpeta del proyecto (boton derecho – git bash here). Entonces para recuperar un fichero o path local:

$ git checkout <COMMIT> -- ./<path>

Historial de proyecto

Si queremos saber los commit que realizaron en es proyecto debemos ejecutar dentro del proyecto

$ git log <path>
# Mostrar todos los commits para un fichero especifico con info detallada
$ git log -n 2 -- <path>
# Mostrar sólo los dos últimos commits para ese fichero
$ git log -oneline -- <path>
# Formato abreviado con id de commit y comentario
$ git log <SINCE>..<UNTIL> -- <path>
# Mostrar los commits para ese fichero entre dos commits indicados

Abrir GITK mostrando gráficamente el historial para un fichero o ruta dado:

$ gitk <path>

Localizar y restaurar ficheros borrados

$ git log --diff-filter=D --summary # Mostrar los ficheros borrados en los últimos commits $ git checkout <COMMIT>^ -- <path> # Restaurar un fichero borrado en un commit dado

El ^ al final del commit es para restaurar el fichero desde el commit anterior al que fue borrado. Equivale a ~1.

Guardar cambios actuales para recuperarlos después

Guarda los cambios desde el último commit. Al recuperarlos, si hay colisiones se hace un merge.

$ git stash # Guarda cambios hechos desde el ultimo commit $ git stash pop # Recupera los cambios guardados $ git stash list # Lista los estados guardados $ git stash apply # Aplica cambios guardados sin borrarlos de la lista

Marcar el commit actual (Tag)

$ git tag -s <nombre> -m <mensaje>

El tag queda firmado usando la firma GPG asociada al autor (ver Creating SSH keys).

El nombre identifica al tag y se usa en los demás comandos (ej. git checkout). Por ejemplo, v2.32.45r1

$ git tag # Mostrar lista de tags $ git tag -n # Mostrar lista y descripción

$ git tag -d <nombre> # Eliminar Tag $ git tag -a <nombre> # Crear Tag no firmado $ git push --tags # Subir Tags al repositorio remoto $ git push origin :refs/tags/<nombre> # Eliminar Tag borrado localmente

Localizar ficheros con una cadena de texto

$ git grep <texto> # Mira en todos los ficheros del repositorio $ git grep <texto> -- <ruta> # Mira sólo en la ruta o rutas especificadas # Admite patrones (ej. *.cpp)

Link de referencia:

Podemos encontrarlo en Git, guia rapida.

1. Trabajo con repositorios remotos.

2. Tareas especiales.