Archivo de la etiqueta: tutorial git en español

Tutorial de Git – Aprende Git y GitHub/GitLab de manera fácil, rápida y sencilla – Parte 5

En el siguiente enlace tienes el indice para acceder al resto de entradas de este tutorial:

Hola a todos:

El el post anterior aprendimos lo que era un repositorio remoto y como crear una cuenta de GitHub y alojar nuestro proyecto en GitHub, hoy vamos a seguir aprendiendo un poco más sobre GitHub.

Clonar un repositorio: git clone

Si queremos descargar el código desde github, por ejemplo si borramos nuestro proyecto y queremos volver a descargarlo o queremos instalar nuestro proyecto en otra maquina solo tenemos que copiar la url de nuestro proyecto en github, para ello pulsamos en clone or download y copiamos la url.

Por ejemplo vamos a eliminar la carpeta proyectoGit1 de nuestro proyecto en nuestro ordenador.

Supongamos que la hemos borrado por error y hemos perdido todo nuestro proyecto.

Bien al tener alojado nuestro repositorio en GitHub podemos recuperarlo de la siguiente manera:

Primero vamos a nuestro repositorio en GitHub y pulsamos en el botón “Clone or download” y copiamos la url de nuestro repositorio:

Luego desde el bash navegamos hasta el lugar donde queremos clonar el proyecto y escribimos git clone y la url de nuestro proyecto, por ejemplo:

git clone https://github.com/Reviblog/holamundo.git

Ahora tendremos una copia exacta de nuestro repositorio en GitHub.

Como GitHub es una plataforma donde hay miles de proyectos de código abierto podemos clonar cualquier repositorio público, puedes descubrir proyectos muy interesantes en GitHub y clonarlos para estudiar su código y/o adaptarlo a tus necesidades.

Actualizar los cambios del repositorio remoto a nuestro repositorio local – fetch y pull

Imaginemos que se han realizado cambios en el repositorio remoto, por ejemplo que otro usuario ha añadido cambios y queremos actualizar estos cambios en nuestro repositorio local.

Para verlo con un ejemplo vamos a añadir un archivo desde GitHub a nuestro repositorio:

Para ello pulsamos en el botón Create new file:

Y editamos un archivo al que le podemos llamar por ejemplo productos.html y si queremos podemos poner unas líneas de código html dentro:

Para que la creación del nuevo archivo se haga efectiva tenemos que hacer un commit, debajo del editor veremos que hay un formulario para hacer commit, escribimos una descripción para el commit y pulsamos el botón Commit new file.

Ahora tenemos el archivo productos.html en el repositorio remoto de GitHub, sin embargo en nuestro repositorio local no lo tenemos, vamos a ver como actualizar nuestro repositorio local para que los cambios que se han producido en el repositorio remoto se sincronicen.

fetch

Siempre en un repositorio tienes una rama oculta, que puedes ver al usar git branch -a.

Esa rama oculta es origin/master.

Al usar git fetch origin, bajamos los cambios del repositorio remoto a la rama origin/master:

git fetch origin

Ahora ya tienes los cambios en origin/master, aparente no ha pasado nada, seguimos sin tener el archivo productos.html, para que los cambios se hagan efectivos tenemos que pasarlos a la rama master, para eso usamos el siguiente comando:

git merge origin/master

Ahora ya tenemos el archivo productos.html en nuestro repositorio local.

pull

Al usar el comando git pull estamos combinando git fetch + git merge.

Vamos a seguir los mismos pasos que dimos para crear el archivo productos.html y vamos a crear en GitHub un archivo que se llame por ejemplo vendedores.html.

Una vez que lo tengas creado y hayas hecho el commit vamos a actualizar este cambio del repositorio remoto a nuestro repositorio local, pero esta vez en lugar de utilizar el comando git fetch vamos a utilizar el siguiente comando:

git pull origin master

Ahora ya tenemos el archivo vendedores.html que acabamos de crear en GitHub en nuestro repositorio local.

Con git pull  nos ahorramos el usar un comando más, pero no conviene utilizar git pull si no estamos seguros de que cambios se pueda traer del repositorio remoto.

Fork

GitHub nos permite hacer una copia exacta de un repositorio para poder hacer modificaciones del repositorio original sin afectar a este, a esto se le llama fork.

Puedes encontrar un repositorio público de un proyecto que te resulte interesante y realizar cambios en este si afectar al original.

Cuando accedes a la página principal de GitHub te da la opción de explorar repositorios públicos:

Cuando entramos en un repositorio en la parte de arriba a la derecha tenemos un botón “Fork” donde se indica además el número de forks que se han realizado de este repositorio.

Al pulsar en el botón automáticamente se creará una copia exacta del repositorio en tu cuenta de github.

Los cambios que realicemos en este repositorio no van a modificar el repositorio original sino nuestra copia.

Una vez que hemos hecho el fork del repositorio para traerlo a nuestro ordenador solo tenemos que crear una carpeta, situarnos dentro de ella desde el terminal y utilizar el comando git clone ruta_del_repositorio.

Por ejemplo: 

git clone https://github.com/Reviblog/holamundo.git

pull request

Cuando varias personas colaboran en un mismo proyecto es común que cada colaborador haga un fork del proyecto original para poder realizar cambios sin afectar al proyecto original, una vez hechos los cambios el colaborador debe solicitar al administrador del proyecto original para que integre esos cambios en la rama original.

Vamos a ver con un ejemplo práctico cómo funciona:

Imaginemos que hemos hecho un fork de un repositorio,  para verlo con más claridad vamos a simular que somos otro usuario, para ello podemos hacer la prueba creando otra cuenta de GitHub con otra cuenta de correo que tengamos y haciendo un fork del repositorio holamundo  que tenemos en nuestra primera cuenta.

Para poder estar logeado con las dos cuentas puedes utilizar dos navegadores (Firefox y Chrome… o los que tengas instalados), si solo tienes un navegador deberás cerrar sesión antes de iniciar con la otra cuenta.

Para hacer un fork iniciamos sesión en GitHub con la segunda cuenta que hemos creado y en el buscador de la cabecera ponemos el nombre de nuestro usuario de la primera cuenta y  el nombre del repositorio, después pulsamos el botón “All GitHub” para que busque en todo GitHub.

Una vez localizado nuestro repositorio entramos en él y hacemos un fork desde nuestra segunda cuenta de GitHub pulsando en el botón fork:

Tras unos segundos tendremos una copia del proyecto holamundo en nuestra segunda cuenta de GitHub.

Entramos en la copia del proyecto  que se ha creado en nuestra segunda cuenta de usuario y copiamos la url del proyecto para hacer un clone:

Creamos una carpeta que podemos llamar prueba_pull_request y situándonos en ella desde la consola hacemos un clone:

git clone https://github.com/edurevilla/holamundo.git

Esto habrá creado una carpeta holamundo dentro de la carpeta con el contenido del proyecto.

Desde consola entramos en la carpeta holamundo que se acaba de crear:

cd holamundo

Ahora vamos a editar el archivo productos.html y añadimos algunas lineas de código:

<html>
  <head></head>
  <body>
<h1>Listado de productos</h1>
    <ul>
	<li>Producto 1</li>
	<li>Producto 2</li>
	<li>Producto 3</li>
	<li>Producto 4</li>
    </ul>
  </body>
</html>

Una vez modificado el archivo añadimos los cambios al stage:

git add .

Y hacemos un commit:

git commit -m "Hemos modificado productos.html"

Por último subimos los cambios al repositorio de github:

git push -u origin master

Nos pedirá que introduzcamos el usuario y contraseña de nuestra cuenta de GitHub, en este caso el de la segunda cuenta que hemos creado de prueba.

Bien, ahora tenemos dos versiones diferentes del proyecto holamundo, la original y la del fork que hemos realizado con nuestra segunda cuenta de usuario.

Queremos que los cambios que hemos realizado en nuestro fork del proyecto se integren en el repositorio original, para ello tenemos que hacer una petición “pull request“.

Para ello tenemos que seleccionar el botón “New pull request“:

A continuación se mostrará un resumen de los cambios con respecto a la rama original, una vez revisados los cambios pulsamos el botón “Create pull request“.

Podemos poner un comentario para explicar los cambios que hemos realizado:

Por último pulsamos en el Botón “Create pull request” para mandar la solicitud.

Si ahora accedemos a nuestra primera cuenta de GitHub donde tenemos el proyecto holamundo original podemos ver en la pestaña Pull requests que tenemos una solicitud:

Seleccionamos la pestaña Pull request y vemos que tenemos una solicitud que pone “Hemos modificado productos.html”, si seleccionamos la solicitud nos da la opción de  integrar los cambios pulsando el botón “Merge pull request“, también podemos dejar un comentario, por ejemplo si consideramos que algo está mal y queremos solicitar un cambio en el código antes de hacer el merge.

En este caso podemos poner que todo está correcto y pulsar el botón “Comment“, y después pulsar el botón “Merge pull request” para incorporar los cambios al repositorio original.

Nos pide que confirmemos el merge así que pulsamos el botón “Confirm merge” y ya tenemos los cambios hechos por el segundo colaborador en el repositorio original.

Como puedes ver se puede mantener una conversación entre los colaboradores del proyecto para comentar los cambios que se hacen.

El administrador del proyecto original es el que decidirá qué cambios se incorporan al repositorio.

Si revisamos ahora el contenido del archivo productos.html  en el repositorio original de GitHub veremos que ahora ya contiene los cambios que le hemos añadido desde el fork.

GitHub es una herramienta muy potente para el desarrollo colaborativo de código abierto. Tiene muchas funciones avanzadas que se escapan al propósito de este tutorial de iniciación, pero con lo que has aprendido ya puedes empezar a alojar tus proyectos en GitHub y/o colaborar en proyectos existentes.

Eso es todo por hoy, en el próximo post veremos uno de los mayores competidores de GitHub, me estoy refiriendo como no a GitLab.

Tutorial de Git – Aprende Git y GitHub/GitLab de manera fácil, rápida y sencilla – Parte 4

En el siguiente enlace tienes el indice para acceder al resto de entradas de este tutorial:

Hola a todos, hasta ahora hemos estado trabajando con un repositorio local, es decir todo el código de nuestro proyecto se encontraba en nuestro ordenador y solo nosotros accedemos a él.

Repositorios remotos

Lo normal en proyectos colaborativos o en los que trabajan más de una persona es tener un repositorio remoto alojado bien en algún servidor de la red interna, o directamente en internet.

Nosotros trabajaremos en nuestro repositorio local y después subiremos los cambios al repositorio remoto.

Aunque existen más, en este tutorial nos vamos a centrar en dos de las plataformas Git para alojar nuestro proyectos mas conocidas: GitHub y GitLab.

GitHub

GitHub es una plataforma de desarrollo colaborativo para alojar proyectos utilizando el sistema de control de versiones Git

En GitHub puedes almacenar tus proyectos de forma pública gratuitamente. Esto significa que tus proyectos están accesibles a cualquier persona. Por eso GitHub es muy utilizado en proyecto open source donde cualquiera puede tener acceso al código de un proyecto para poder hacer cambios o añadir funcionalidades.

Si necesitas tener  proyectos privados GitHub dispone de una opción de pago para almacenar proyectos de forma privada.

Microsoft acaba de comprar GitHub, habrá que estar atentos a la evolución que tenga la plataforma bajo la tutela de Microsoft.

Lo primero que necesitamos hacer es crear una cuenta en GitHub, para ello vamos a su página accediendo a la siguiente url:  https://github.com/

Creamos una cuenta rellenando los campos del formulario Username (nombre de usuario), Email y Password (contraseña).

Una vez registrados nos mostrará una pantalla similar a esta:

En este paso nos pide que seleccionemos el plan que queremos, por defecto marca repositorios públicos ilimitados gratis con la opción de seleccionar repositorios privados ilimitados con un coste en el momento de escribir estas líneas de 7 dólares.

Si seleccionamos la opción de pago nos pedirá los datos de facturación.

Si no tienes muy claro que plan necesitas no te preocupes, puedes empezar con la opción gratuita y más adelante si quieres puedes actualizar al plan de pago.

Una vez seleccionado el plan que queramos pulsamos en botón continuar .

En el último paso nos muestra una pequeña encuesta donde nos preguntan cual es nuestro nivel de experiencia como programadores, para qué tipo de proyectos vamos a utilizar GitHub, cual es tu perfil …

Este paso es opcional,  después de rellenar la encuesta  (o no) tras pulsar el botón continuar ya has completado la inscripción en GitHub.

Te enviarán un correo para verificar tu email, debes acceder al link que te indican en el correo para verificar la dirección de correo (Verify email address).

Al acceder al link se activará la cuenta y nos mostrará un formulario de login.

Accedes con el usuario y contraseña de la cuenta de GitHub que acabas de crear y listo.

En este punto ya podemos crear nuestro primer repositorio en GitHub:

Pulsamos el botón Start a project y accedemos al formulario para crear nuestro primer repositorio en GitHub:

Lo primero que tenemos que hacer es dar un nombre al repositorio, como no podía ser de otra manera para este primer ejemplo le vamos a  vamos a poner holamundo.

En la descripción ponemos la descripción de nuestro proyecto.

Después seleccionamos si nuestro proyecto va a ser público o privado,  recuerda que para poder tener repositorios privados debemos tener el plan de pago.

De momento no vamos a marcar la casilla Initialize this repository with a README, Este archivo lo crearemos más tarde y aprenderemos cómo se edita.

También nos da la opción de añadir un archivo .gitignore y una licencia, para este ejemplo lo dejamos en none.

Pulsamos en el botón Create repository y ya tenemos listo nuestro primer repositorio en GitHub.

Importar un proyecto desde un repositorio local – push

Lo primero que aparece al crear el repositorio es la url para acceder al mismo, tendrá el siguiente formato:

https://github.com/tu_usuario/tu_proyecto.git

Debajo nos muestra tres opciones, la primera es para crear un proyecto local desde cero, añadirle el archivo README.md y subirlo al repositorio que acabamos de crear.

La segunda opción es para subir un repositorio que ya tengamos creado en local.

Por último nos da la opción de importar un repositorio desde otro sistema de control de versiones como Subversion o Mercurial.

Como nosotros ya tenemos creado nuestro proyecto en local vamos a usar la segunda opción, entonces no tenemos más que seguir los pasos indicados:

Desde consola (Git bash o el terminal ) nos situamos en la carpeta de nuestro proyecto proyectoGit1 y añadimos el origen de nuestro repositorio remoto:

git remote add origin https://github.com/Reviblog/holamundo.git

Ahora para subir el contenido de nuestro proyecto utilizamos el siguiente comando:

git push -u origin master

Al ejecutar este comando nos pedirá que introduzcamos el usuario o el correo electrónico de nuestro usuario en GitHub y la contraseña:

Una vez logeado correctamente los archivos de nuestro repositorio local se subirán al repositorio remoto en GitHub.

Si refrescamos ahora la página en Github veremos que aparecen los archivos de nuestro repositorio local.

Ahora cada vez que hagamos cambios en nuestro repositorio local después de hacer el commit debemos utilizar el comando git push -u origin master para que los cambios se sincronicen con nuestro repositorio remoto en GitHub.

Vemos en que en la cabecera nos indica el número de commits que se han realizado, si pulsamos sobre  la palabra commits podemos ver los commits que se han realizado en nuestro proyecto, el decir, no solo se ha subido el código a nuestro repositorio si no que tenemos toda la información de los commits que tenemos en el repositorio local lo que nos permite hacer un seguimiento y volver a un punto anterior de nuestro proyecto en cualquier momento.

El archivo README.md

El archivo README.md  es un archivo de descripción de nuestro proyecto y suele contener una descripción del proyecto, modo de instalación, forma de utilización , tipo de licencia y cualquier otra información relevante sobre el proyecto.

Este archivo tiene un formato especial para representar su contenido, vamos a ver a continuación cómo se edita y como se da formato al texto contenido en el.

Si volvemos a la página inicial de nuestro proyecto  (podemos pinchar en el enlace holamundo en la parte superior de la pantalla) vemos que después del listado de los archivos  de nuestro proyecto hay un botón con el texto “Add a README“, si hacemos click sobre él nos abre un editor para editar el archivo README.md:

Tenemos dos pestañas,  “Edit files” y “Preview”.

README.md utiliza un formato Markdown.

Vamos a ver brevemente cómo utilizar el formato Markdown para nuestro archivo README.md:

Encabezados

Podemos observar que hola-mundo tiene el carácter  almohadilla “#” por delante, esto hace que se vea como un encabezado.

Una almohadilla antes del texto corresponde con un encabezado h1 de html, dos almohadillas sería igual a un h2, tres almohadillas sería igual a un h3 y así sucesivamente:

# Encabezado h1 
## Encabezado h2
### Encabezado h3
#### Encabezado h4

Citas

Para resaltar una cita usamos el símbolo  mayor que “>” antes del texto:

> "If it compiles, it is good, if it boots up it is perfect". - Linus Linus Torvalds

Cursiva y negrita

Agregamos un asterisco  “*” antes y después de la palabra o frase que queremos resaltar para cursiva y dos para negrita “**”:

*Cursiva* 

**Negrita**

Código

Se utiliza el acento grave para identificar código, y corchetes para identificar el lenguaje de programación:

 `Código`
 ``` [language]
 Código en 
 varias líneas
 ```

Listas

Para los elementos de listas no ordenadas utilizamos  el asterisco “*“:

* Primer elemento
* Segundo elemento
* Tercer elemento

Para las listar ordenadas indicamos el número del elemento con un punto:

1. Primer elemento de la lista
2. Segundo elemento de la lista
3. Tercer elemento de la lista

Enlaces

Para añadir un enlace a nuestro documento ponemos el texto del enlace entre corchetes y la url del enlace entre paréntesis:

 [Reviblog](www.reviblog.net)

Imágenes

Para incluir imágenes utilizamos el símbolo de exclamación “!” y entre corchetes el texto alternativo de la imagen seguido entre paréntesis de la url de la imagen:

![Un gato](https://reviblog.net/wp-content/uploads/2018/06/IMG_20180608_104752.jpg)

Vamos a ver como quedaría todo los que hemos visto, dejamos el archivo README.md de la siguiente manera:

# hola-mundo
Este es mi primer repositorio en GitHub

Encabezados:

# Encabezado h1
## Encabezado h2
### Encabezado h3
#### Encabezado h4

Citas:

> "If it compiles, it is good, if it boots up it is perfect". - Linus Linus Torvalds

Cursiva:

*Cursiva*

Negrita:

**Negrita**

Código:

``` [language]
Código en
varias líneas
```
Listas:

* Primer elemento
* Segundo elemento
* Tercer elemento

1. Primer elemento de la lista
2. Segundo elemento de la lista
3. Tercer elemento de la lista

Link:
[Reviblog](www.reviblog.net)

Imagen:

![Un gato](https://reviblog.net/wp-content/uploads/2018/06/IMG_20180608_104752.jpg)

Si seleccionamos la pestaña Preview changes obtendremos algo como esto:

 

Por último para que  los cambios en README.md  se hagan efectivos tenemos que hacer un commit,  podemos añadir una descripción al commit o dejar por defecto en cuyo caso la descripción del commit será “Create README.md” , después pulsamos en el Botón Commit  new File.

Por hoy lo dejamos aquí, ya hemos aprendido a crear un repositorio en GitHub y a importar nuestro proyecto local, también hemos aprendido a editar el archivo README.md.

En el siguiente post seguiremos aprendiendo un poco más sobre GitHub.

Tutorial de Git – Aprende Git y GitHub/GitLab de manera fácil, rápida y sencilla – Parte 3

En el siguiente enlace tienes el indice para acceder al resto de entradas de este tutorial:

Hola a todos, hoy vamos a continuar con el  tutorial de iniciación a Git, en el post anterior conocimos nuevos comandos de git, hoy vamos a seguir aprendiendo a utilizar esta herramienta:

Gitignore

Si tenemos archivos o carpetas dentro de la carpeta de nuestro proyecto que no queremos que sean gestionadas por git, como por ejemplo archivos que genera el propio IDE o editor que estamos utilizando, archivos compilados, o cualquier archivo que no necesitamos sincronizar tenemos que crear un archivo llamado .gitignore y dentro indicaremos los archivos y/o carpetas que no queremos que git procese.

Podemos utilizar * como comodín el el nombre de los archivos por ejemplo si queremos excluir todos los archivos que empiecen por config podemos utilizar config*.

A continuación vemos un ejemplo de un archivo .gitignore para un proyecto en java:

# Compiled class file
*.class

# Log file
*.log

# BlueJ files
*.ctxt

# Mobile Tools for Java (J2ME)
.mtj.tmp/

# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar

# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*

Este ejemplo está sacado de la siguiente página de github donde podemos ver ejemplos de diferentes archivos .gitignore según el lenguaje de programación:

https://github.com/github/gitignore

Ramas: git branch

Una rama es una bifurcación o división dentro de tu proyecto donde puedes hacer cambios sin modificar la rama principal, esto nos permite por ejemplo probar cambios sin afectar al proyecto y después una vez comprobado que esos cambios funcionan correctamente  si queremos podemos incorporarlos a la rama principal.

Para crear una nueva rama utilizamos el siguiente comando:

git branch nombre_rama

nombre_rama es el nombre que le queremos dar a la nueva rama, por ejemplo si queremos desarrollar una nueva funcionalidad para nuestro proyecto le podemos dar el nombre de esa funcionalidad para identificarlo mejor.

Para probarlo vamos crear una nueva funcionalidad en nuestro proyecto que consiste en un archivo que muestre un listado de usuarios.

Para no alterar la rama principal y preservar esta tal y como está vamos a crear una nueva rama a la que vamos a llamar listado:

git branch listado

Con git log  a secas no vemos la creación de la nueva rama, para verlo podemos utilizar git log –oneline:

Vemos que en la primera linea nos muestra (Head -> master, listado).

Head -> master nos indica que la rama activa en estos momentos es la rama master, y separado por una coma nos indica que tenemos también la rama listado que acabamos de crear.

Si ejecutamos el comando git branch sin parámetros nos muestra las ramas que tenemos en nuestro proyecto y marca con color la rama activa en este momento:

Para cambiar a la rama que acabamos de crear utilizamos el comando git checkout:

git checkout listado

También podemos crear una nueva rama y hacer un checkout a la rama que acabamos de crear con una única sentencia:

git checkout -b nueva_rama ← esto crea la rama y cambia el control de git a la rama recién creada.

Ahora que la rama activa es listado para nuestra prueba vamos a crear un archivo al que vamos a llamar listado.html, de momento para este ejemplo no nos importa el contenido del archivo, podemos dejarlo en blanco.

Una vez creado el archivo lo añadimos:

git add .

Y  por ultimo hacemos el commit:

git commit -m "se ha anadido listado.html"

Si ejecutamos git status nos indica que estamos en la rama listado.

Como hemos comentado todos los cambios que realicemos en esta rama no afectarán a la rama principal.

Para volver a la rama principal solo tenemos que escribir:

git checkout master

Si hemos creado archivos en la rama que hemos creado al cambiar a la rama principal veremos que esos archivos desaparecen de la carpeta ya que todas las modificaciones que hagamos en una rama solo afectan a esa rama, de la misma manera los cambios que hemos realizado en la rama vuelven a aparecer cuando cambiamos a dicha rama.

Podemos crear tantas ramas como necesitemos en un proyecto.

Uniones: git merge

Si queremos unir los cambios de la rama secundaria que hemos creado con la rama principal tenemos que hacer un merge.

Primero nos situamos en la rama principal:

git checkout master

Ahora para unir las dos ramas utilizamos en comando merge de la siguiente manera:

git merge listado

Ahora todos los cambios que hayamos realizado en la rama listado estarán también en la rama principal (master), en este caso vemos que ahora tenemos el archivo listado.html también en la rama master.

Una vez hecho el merge podemos eliminar la rama listado con el siguiente comando:

git branch -d listado

Resolver conflictos al hacer Merge

Si creamos una rama y modificamos un archivo en esa rama, luego volvemos a la rama principal y modificamos ese mismo archivo, al tratar de hacer un merge git no nos dejará y nos informará de que hay un conflicto.

Vamos a verlo con un ejemplo:

Primero vamos a crear una nueva rama a la que vamos a llamar holamundo2:

git branch holamundo2

Situamos el control en la rama que acabamos de crear:

git checkout holamundo2

Ahora vamos a modificar el archivo holamundo.html, lo editamos y lo dejamos de la siguiente manera:

<html>
    <head>
        <title>Hola mundo</title>
    </head>
    <body>
        <h1>Hola mundo de nuevo...</h1>
        <h2>Hoy es un buen dia para aprender Git</h2>
    </body>
</html>

Lo añadimos al stage:

git add .

Y hacemos el commit:

git commit -m "Hemos vuelto a modificar holamundo.html"

Ahora vamos a volver a la rama principal:

git checkout master

Y vamos a modificar holamundo.html desde la rama principal, por ejemplo lo dejamos de esta manera:

<html>
    <head>
        <title>Hola mundo</title>
    </head>
    <body>
        <h1>Hola mundo</h1>
        <h2>Hoy no me apetece aprender Git</h2>
    </body>
</html>

Una vez más lo añadimos al stage:

git add .

Y hacemos el commit:

git commit -m "Hemos vuelto a modificar holamundo.html"

Ahora tenemos el archivo holamundo.html con dos modificaciones diferentes en la rama master y en la rama holamundo2, vamos a ver que pasa si intentamos hacer un merge:

git merge holamundo2

Vemos que nos muestra un mensaje indicando que hay conflictos al hacer el Merge:

Si editamos el archivo holamundo.html vemos que nos ha añadido código indicando las lineas donde hay conflicto:

<html>
    <head>
        <title>Hola mundo</title>
    </head>
    <body>
<<<<<<< HEAD
        <h1>Hola mundo</h1>
        <h2>Hoy no me apetece aprender Git</h2>
=======
        <h1>Hola mundo de nuevo...</h1>
        <h2>Hoy es un buen día para aprender Git</h2>
>>>>>>> holamundo2
    </body>
</html>

Debemos resolver los conflictos antes de poder hacer el merge,  por ejemplo podemos dejar el archivo holamundo.html  de la siguiente manera:

<html>
    <head>
        <title>Hola mundo</title>
    </head>
    <body>
        <h1>Hola mundo</h1>
        <h2>Hoy es un buen día para aprender Git</h2>
    </body>
</html>

Ahora lo añadimos al stage:

git add .

Y hacemos el commit:

git commit -m "Hemos resuelto el conflicto con holamundo.html"

Ahora si hacemos un git merge holamundo2 nos muestra en mensaje “Already up to date.”, esto es porque ya hemos hecho la modificación manualmente.

Con git log –graph podemos ver gráficamente como se bifurcan y se vuelven a unir las ramas:

Tags

Los Tags o etiquetas los utilizamos para nombrar a los commits que realizamos. Por ejemplo lo podemos utilizar para nombrar las diferententes versiones del proyecto y así saber en que punto comienza una versión en concreto.

Para crear una etiqueta escribimos git tag nombre_tag.

Tenemos que saber que no nos permite utilizar espacios en blanco en el nombre que le damos a la etiqueta, podemos utilizar un guión “-” o una barra baja  “_” para separar las palabras.

Por ejemplo, vamos a realizar un último cambio a nuestro archivo holamundo.html, editamos su código y lo dejamos de la siguiente manera:

<html>
    <head>
        <title>Hola mundo</title>
    </head>
    <body>
        <h1>Hola mundo</h1>
        <h2>Hoy es un buen dia para aprender Git</h2>
        <p>Con este ejemplo tenemos lista la version 1.0</p>
    </body>
</html>

Supongamos que ya tenemos una versión de nuestro proyecto preparada, por ejemplo la versión 1.0. Podemos realizar un commit y etiquetarlo para saber que en este punto esta la versión 1.0 de nuestro proyecto.

Una vez más añadimos los cambios al stage:

git add .

Y hacemos el commit:

git commit -m "Hemos añadido un párrafo a holamundo.html"

Ahora vamos a añadir una etiqueta indicando que en este punto tenemos la versión 1.0 de nuestro proyecto:

git tag version_1.0

Si lo deseamos podemos poner varias etiquetas.

Si escribimos git tag nos  muestra todas las etiquetas que hemos utilizado.

Cuando hacemos un git log vemos la etiqueta o etiquetas que hemos añadido en el ultimo commit.

Podemos utilizar el tag para identificar el commit por ejemplo si queremos volver al estado de una versión anterior en lugar de utilizar su identificador podemos utilizar su tag.

Por ejemplo vamos a añadir una linea más a nuestro código en el archivo holamundo.html:

<html>
    <head>
        <title>Hola mundo</title>
    </head>
    <body>
        <h1>Hola mundo</h1>
        <h2>Hoy es un buen día para aprender Git</h2>
        <p>Con este ejemplo tenemos lista la versión 1.0</p>
        <p>Otra línea de código</p>
    </body>
</html>

Añadimos los cambios al stage:

git add .

Y hacemos el commit:

git commit -m "Hemos añadido otra línea a holamundo.html"

Ahora podemos volver al punto en que lo teníamos en la versión 1.0 utilizando su etiqueta en lugar del identificador:

git reset --hard version_1.0

Para eliminar un tag utilizamos git tag -d nombre_de_la_etiqueta

Con git show nombre_de_etiqueta podemos ver en detalle el contenido de ese commit y la diferencia con la versión actual.

Por ejemplo en este caso si ponemos:

git show version_1.0

Obtendremos algo como esto:

Podemos etiquetar un commit anterior utilizando su identificador.

Hacemos un git log –oneline y copiamos el identificador del commit que queremos etiquetar y utilizamos el siguiente comando:

git tag nombre_tag identificador

Por ejemplo:

git tag v.0.0.1 ba94ee2

Esto es todo por hoy, con los comandos que hemos aprendido hasta ahora ya podemos manejar un repositorio en git y aprovechar las ventajas que nos ofrece esta herramienta.

En el próximo post aprenderemos a utilizar un repositorio remoto para poder tener nuestros proyectos en Github y Gitlab.

Tutorial de Git – Aprende Git y GitHub/GitLab de manera fácil, rápida y sencilla – Parte 2

En el siguiente enlace tienes el indice para acceder al resto de entradas de este tutorial:

Hola a todos, hoy vamos a continuar con el  tutorial de iniciación a Git, en el post anterior vimos como instalar Git, como crear un repositorio local, como añadir archivos al stage, como confirmar los cambios haciendo un commit y como volver a un estado anterior.

Vamos a seguir aprendiendo a utilizar git:

Obtener información sobre un comando: git help

Con git help obtenemos información sobre un comando por ejemplo si queremos obtener información sobre el comando commit escribimos lo siguiente:

git help commit

Al escribir este comando se abrirá en nuestro navegador un documento con la documentación sobre el comando que queremos consultar:

Mostrar diferencias  entre los últimos cambios del archivo sin confirmar y la última versión del archivo que hicimos commit: git diff

Vamos a volver a editar nuestro archivo holamundo.html y vamos a realizar algún cambio, por ejemplo vamos volver a poner “Adiós mundo cruel…” en el h1 y a añadir una etiqueta h2 quedando de esta manera:

<html>
    <head>
        <title>Hola mundo</title>
    </head>
    <body>
        <h1>Adios mundo cruel...</h1>
        <h2>Era broma... ¡¡¡mucho mejor hola mundo!!!</h2>
    </body>
</html>

 

Ahora si ejecutamos el comando git status veremos que nos indica que se ha modificado el archivo holamundo.html.

Si ejecutamos git diff nos muestra la diferencia del archivo actual con el contenido de ese archivo en el último commit que hemos realizado:

Añadir un único archivo

En el post anterior vimos que con git add .  añadíamos todos los archivos que habíamos modificado o se habían creado nuevos al stage a la espera de hacer un commit para confirmar el paso definitivo al repositorio, sin embargo podemos indicar a Git que pase al stage solo cierto tipo de archivos:

Si solo queremos añadir un único archivo para hacer commit en lugar de git add . utilizamos git add nombre_archivo

Por ejemplo vamos a crear un archivo nuevo en nuestro proyecto llamado holamundo.js, de momento lo dejamos en blanco, para probar nos es suficiente, y también vamos a crear otro archivo que vamos a llamar holamundo.css, de momento lo dejamos en blanco también, en este momento en la carpeta de nuestro proyecto tendremos los siguiente archivos:

Si realizamos un git status nos indicara que holamundo.html  tiene cambios  y que holamundo.css y holamundo.js no estan siendo controlados pos Git todavía.

Con git add . pasaríamos todos los archivos al stage, pero si solo queremos pasar los cambios que hemos hecho en holamundo.html  utilizaremos el siguiente comando:

git add holamundo.html

Si ahora utilizamos el comando git status veremos que holamundo.html aparece en verde y esta listo para hacer un commit, sin embargo holamundo.js y holamundo.css siguen pendientes de ser pasados al stage:

Añadir al stage una carpeta

Para añadir al stage una carpeta simplemente utilizamos git add nombre_carpeta/

Por ejemplo vamos a crear una carpeta llamada assets en nuestro proyecto:

Si ejecutamos el comando git status vemos que no aparece la  nueva carpeta que hemos creado, esto es porque git ignora las carpetas vacías, si dentro creamos un archivo que se llame por ejemplo datos.txt y después volvemos a ejecutar git status veremos que ahora si muestra la carpeta assets:

Bien, ahora mismos tenemos pendientes de pasar al stage la carpeta assets y los archivos holamundo.css y holamundo.js.

Si solo queremos pasar la carpeta assets ejecutaremos el siguiente comando:

git add assets

Añadir al stage los archivos que tengan una cierta extensión

Si solo quieres confirmar los archivos que tengan una cierta extensión por ejemplo todos los .css podemos utilizar el asterisco  “*” como comodín de la siguiente manera: 

git add *.css

En este momento falta por pasar al stage holamundo.js y el resto esta pendiente de hacer un commit para confirmar el paso:

Quitar archivos que hemos añadido al stage:

Si hemos añadido un archivo (o varios) al stage se puede indicar que se retiren del stage con git reset nombre_del_archivo.

Por ejemplo, vamos a retirar del stage el archivo holamundo.css:

git reset holamundo.css

Si ahora volvemos a ejecutar git status vemos que holamundo.css ya no esta en el stage y ahora esta pendiente de ser añadido:

Al igual que con git add, con el comando git reset también podemos indicarle carpetas o la extensión del archivo/archivos que deseamos retirar del stage.

Agregar todos los archivos al stage

Para agregar todos los archivos al stage podemos utilizar git add .,  git add -A o también git add –all

Por ejemplo si queremos añadir todos los archivos que tenemos ahora pendientes podemos escribir el siguiente comando:

git add -A

Al volver a realizar un git status podemos ver que se han añadido todos al stage y están listos para hacer un commit:

Ver el histórico de todos los commit que hemos hecho: git log

Vamos a realizar un commit de los  archivos que tenemos ahora mismo en el stage, para ello escribimos como ya sabemos el comando git commit y le ponemos un mensaje para explicar los cambios que se han hecho.

git commit -m "Hemos realizado cambios en datos.txt, holamundo.css, holamundo.html, y holamundo.js"

Con git log vemos el histórico de todos los commit que hemos hecho, te los muestra en orden inverso, es decir el último commit aparece primero.

De momento tenemos solo dos commits así que nos los mostrará todos de una vez:

Si tenemos muchos commits y no caben todos en la pantalla te muestra solo los últimos y si pulsamos  la tecla enter vamos viendo los commits anteriores, cuando llegamos al primero pone (end). Para salir antes de llegar al primero tenemos que pulsar la letra Q.

Alias

Podemos crear alias para los comandos para acortarlos.

Por ejemplo podemos hacer que en lugar de escribir git status podamos escribir git s de la siguiente manera:

git config --global alias.s "status"

Recuerda que con –global le decimos que se aplique a todos los repositorios git que tengamos.

Ahora si escribimos git s obtendremos el mismo resultado que con git status.

Renombrar un archivo: git mv

Podemos renombrar un archivo directamente desde el navegador de archivos o desde nuestro editor de código, sin embargo está bien conocer que también podemos renombrar un archivo con el comando git mv.

Vamos a renombrar el archivo holamundo.js y lo vamos a llamar adiosmundo.js:

git mv holamundo.js adiosmundo.js

Podemos observar en la carpeta de nuestro proyecto que el archivo ha cambiado de nombre:

Si ejecutamos git status obtenemos lo siguiente:

Para que el cambio se haga efectivo tenemos que ejecutar un commit:

git commit -m "Hemos renombrado el archivo holamundo.js para llamarlo adiosmundo.js"

Borrar un archivo: git rm

Para eliminar un archivo podemos utilizar el comando git rm.

Por ejemplo vamos a eliminar el archivo holamundo.css:

git rm holamundo.css

Con esto habrá desaparecido nuestro archivo.

Para hacer efectiva la eliminación volvemos a hacer un commit.

git commit -m "Hemos eliminado holamundo.css"

Todo esto está muy bien, pero ¿que pasa si nos arrepentimos de de haber eliminado el archivo?

No te preocupes, en el siguiente punto vamos a ver como volver a un estado anterior.

Volver a un estado anterior: git reset

Si ejecutamos git log vemos que después de cada commit viene un id o identificativo con una serie de números y letras, algo parecido a esto:

commit 27b6e605decfd194e4f4ec627381156e9bbadf27

Este código nos sirve para identificar el commit.

Con git log –oneline vemos los comits de una forma simplificada, el código es más corto pero también nos vale para hacer un reset, podemos utilizar cualquiera de las dos formas.

Si por ejemplo hemos eliminado un archivo y queremos volver al punto anterior a eliminarlo buscamos en el log el código identificador del commit y utilizamos git reset –soft codigo_comit  o git reset –hard codigo_commit

Con –soft no recuperamos el archivo, solamente se sitúa en el stage en el momento en que eliminamos el archivo.

Con –hard volvemos al punto anterior a eliminar el archivo y el archivo vuelve a aparecer en el lugar en el que estaba antes de ser eliminado.

Por ejemplo vamos a recuperar el archivo holamundo.css que hemos eliminado situándonos en el commit anterior a borrarlo, esto sería en el commit donde hemos renombrado  holamundo.js como adiosmundo.js, copiamos el código identificador del commit  y escribimos:

git reset --hard 6cf7d1a76c51a2875e14d19ce1ecb78017b4fd94

Recuerda que tu tendrás que poner el código correspondiente al commit donde has renombrado el archivo que será diferente al que muestro.

Una vez realizado el reset podemos ver como por arte de magia ha vuelto a aparecer el archivo holamundo.css:

Al hacer un hard reset si posteriormente ejecutamos git log vemos que en el historial de cambios ya no aparece cuando borramos el archivo:

Si ejecutamos git reflog podemos ver el historial completo de cambios incluido aquellos que hayamos revertido con reset.

Por hoy lo vamos a dejar aquí, en el siguiente post seguiremos viendo conociendo más sobre git.

 

Tutorial de Git – Aprende Git y GitHub/GitLab de manera fácil, rápida y sencilla – Parte 1

En el siguiente enlace tienes el indice para acceder al resto de entradas de este tutorial:

Hola a todos, hoy os traigo un tutorial de iniciación a Git, donde vamos a aprender como empezar a utilizar Git y también GitHub y GitLab (Hay otros pero nosotros vamos a ver estás dos) intentando que la curva de aprendizaje sea lo más suave posible y tardes el menor tiempo posible en aprender.

 

Git

 

Introducción

Hoy en día para cualquier puesto de trabajo como desarrollador te van a pedir que sepas utilizar Git. Si eres freelance también es muy importante conocer Git para llevar el control de versiones de nuestros desarrollos.

¿Que es Git?

Git, es un sistema de control de versiones creado por Linus Torvalds, conocido por iniciar y mantener el desarrollo del kernel de Linux.
Al igual que Linux, Git es  software libre.

¿Que es un sistema de control de versiones?

Un sistema de control de versiones es una herramienta utilizada para gestionar ágilmente los cambios en el código fuente de los programas y poder revertirlos.
Su propósito es llevar registro de los cambios en archivos de computadora y coordinar el trabajo que varias personas realizan sobre archivos compartidos.

Es muy común si no utilizas un sistema de control de versiones el ir guardando las diferentes versiones de nuestros proyectos en carpetas diferentes tal vez con la fecha y hora  a modo de backup.

Esto puede ser válido para proyectos pequeños que no van a tener cambios importantes, pero a la larga resulta engorroso y es fácil cometer errores y sobrescribir carpetas por error… etc,  además es mucho más complicado cuando queremos volver a un estado concreto del proyecto.

Con un sistema de control de versiones si detectamos que un cambio que hemos realizado anteriormente está generando un error podemos revertir ese cambio y volver a un estado anterior. Además podemos crear ramas para probar cosas y si funcionan estos cambios como deseamos entonces volver a fusionarlas con la rama principal.

Veremos todo esto con ejemplos prácticos.

Existen otras herramientas para el control de versiones como Mercurial, CVS,  Subversion, etc, pero sin duda la mas popular a día de hoy es Git.

Instalando Git

Lo primero que necesitamos hacer es instalar Git en nuestra computadora.

Instalar Git en Windows

Vamos a https://git-scm.com/download y descargamos la versión para nuestro sistema operativo, en este caso Windows:

Descargar Git para Windows

Una vez descargado el instalador lo ejecutamos e instalamos Git seleccionando todos los valores por defecto,  ya sabes siguiente…siguiente…, no olvides que hay que leer lo que pone antes de darle a siguiente por si acaso ;-).

Al terminar le marcamos la casilla launch git bash para que nos abra el terminal de git.

Podemos utilizar git bash o el propio cmd del sistema.

Tambien se instala una aplicación llamada git GUI que nos ofrece una interface gráfica.

Cada vez que queramos abrir el terminal de git solo tenemos que ir al  menú de inicio de Windowa  y buscar Git, entre otras aplicaciones nos aparecerá Git Bash, esa es la consola de comandos de Git y es la que vamos a utilizar.

Una vez que hemos abierto  Git Bash, para comprobar que versión de Git tenemos instalada escribimos el siguiente comando:

git --version

Si todo esta instalado correctamente veremos algo como esto:

Instalar Git en Mac

Aunque existén varias formas de instalar git en mac, mismamente desde el terminal, para hacerlo sencillo y asegurarnos de que tenemos la ultima versión estable vamos a descargar el instalador de git para mac de su página oficial. Para ello visitamos  https://git-scm.com/download y descargamos la versión para Mac OS X:

Una vez descargado damos doble click sobre el archivo y nos mostrará el instalador, pinchamos con el botón derecho sobre el archivo .pkg y le decimos que lo abra con el instalador y le damos a instalar. Nos pedirá la contraseña de usuario para poder instalarlo.

Una vez instalado desde el terminal escribimos git –version para comprobar la versión instalada.

Instalar Git en Ubuntu y derivados

Para instalar Git en ubuntu es muy sencillo, solo tenemos que seguir los siguientes pasos:

Primero actualizamos los repositorios, para ello abrimos un terminal y escribimos el siguiente comando:

sudo apt-get update

Una vez se han actualizado los repositorios instalamos git con el siguiente comando:

sudo apt-get install git

En ubuntu utilizaremos el propio terminal del sistema para trabajar con git.

Si utilizas otra distribución de linux puedes consultar como instalar git en la sección de descargas linux de la propia web de git.

Para comprobar que se ha instalado correctamente escribimos en el terminal git –version y nos mostrará la versión de git instalada.

Configurando un usuario

Una vez que tenemos instalado git lo primero que tenemos que configurar es el usuario que va a utilizar el repositorio en esta máquina, para ello debemos le vamos a indicar un nombre y una dirección de correo, esto lo hacemos con el siguiente comando desde consola:

git config --global user.name "nombre_usuario"
git config --global user.email "email_usuario"

Por ejemplo:

git config --global user.name "EduRevilla"
git config --global user.email "edu.revilla.vaquero@gmail.com"

Con git config –global -l podemos ver estos valores:

Estos datos se pueden sobrescribir volviendo a ejecutar los comandos anteriores.

El parámetro –global  indica que vamos a utilizar este usuario en todos los repositorios que utilicemos, es decir si tenemos varios proyectos gestionados por Git en nuestro ordenador estos usarán este usuario.

Si queremos utilizar otro nombre de usuario y otro email en un directorio concreto utilizaremos el comando git config pero usando el parámetro –local en lugar de –global.

Creando un repositorio en Git

Un repositorio es un sitio centralizado donde se almacena y mantiene información digital, por ejemplo todos los archivos y carpetas que componen un proyecto, y que puede estar almacenado localmente, es decir en tu propio equipo o remotamente.

Un repositorio remoto es una versión de tu proyecto que se encuentra alojado en Internet o en algún punto de la red.

Vamos a ver como crear un repositorio local con un ejemplo básico.

Vamos a crear un proyecto web, para ello creamos una carpeta en el lugar que prefiramos dentro en nuestro equipo y le llamamos por ejemplo proyectoGit1:

Entramos dentro de la carpeta que acabamos de crear y creamos un archivo que en un alarde de originalidad le vamos a llamar holamundo.html :

Editamos nuestro archivo holamundo.html y le añadimos un poco de html básico:

<html>
    <head>
        <title>Hola mundo</title>
    </head>
    <body>
        <h1>Hola mundo</h1>
    </body>
</html>

Bien, este va a ser nuestro punto de partida.

Ahora vamos a la consola de comandos y navegamos hasta la carpeta proyectoGit1 que acabamos de crear.

Una vez dentro de la carpeta proyectoGit1 vamos a crear un repositorio local con el siguiente comando:

git init

Nos mostrará un mensaje parecido a este: “Initialized empty Git repository in…” y la ruta del proyecto.

Esto creará una carpeta oculta llamada .git dentro de nuestro proyecto y es la carpeta que utilizará git para gestionar nuestro repositorio.

Las carpetas que empiezan por un punto se consideran ocultas y algunos sistemas operativos no las muestran.

Desde consola podemos ver los archivos y carpetas ocultos con el comando ls -a.

Si queremos dejar de utilizar git en nuestro proyecto solamente tenemos que eliminar la carpeta .git.

Para volver a utilizar git tendríamos que volver a ejecutar git init.

Estado de los archivos: git status

Para conocer el estado de nuestros archivos utilizamos el siguiente comando:

git status

Si ejecutamos este comando en estos momentos obtendremos lo siguiente:

Lo primero que vemos es “On branch master” esto significa que estamos en la rama principal, es la rama por defecto cuando creamos un repositorio.

Vemos en rojo holamundo.html nos avisa de que no hemos añadido ningún archivo para ser gestionado por git.

Git tiene dos procesos para gestionar nuestros archivos. Primero los tenemos que añadir a una zona intermedia conocida como stage y después tenemos que confirmar el paso  definitivo de los archivos al repositorio.

Añadir archivos: git add

Para añadir los archivos de nuestro proyecto utilizamos el siguiente comando:

git add .

“Hay que dejar un espacio entre add y el punto”

Con este comando le decimos a git que pase todos los archivos que estén sin pasar al stage.

Si ahora volvemos ejecutar el comando git status obtendremos algo como esto:

Nos informa de que no hay “commits todavía” y vemos que holamundo.html ahora aparece en verde, esto significa que holamundo.html ya se encuentra en el stage y debemos confirmarlo para que pase definitivamente al repositorio.

Confirmar los archivos: git commit

Para confirmar estos archivos y que pasen al repositorio final utilizamos en siguiente comando:

git commit -m "Commit Inicial"

Utilizamos el parámetro -m para indicarle una descripción del commit que vamos a hacer, en este caso le decimos que es el commit inicial.

Si no indicamos el parámetro -m se abrirá un editor de código de terminal (vim).
Para guardar el mensaje que escribamos pulsamos la tecla escape y escribimos :wq

Si volvemos a ejecutar el comando git status obtendremos este mensaje:

Esto significa que no hay nada para confirmar, es decir que todos los archivos se encuentran ya en el repositorio.

Ver los cambios realizados: git log

Para ver los las operaciones que hemos realizado utilizamos el siguiente comando:

git log --oneline

En estos momentos esto nos mostrará lo siguiente:

El primer conjunto de letras y números que vemos a la izquierda es el id del commit, utilizaremos este identificativo más adelante para poder volver a un estado anterior.

Después entre paréntesis nos indica que nos encontramos en la rama principal(master).

Por último nos muestra el mensaje que le pusimos al commit.

Rectificar commit: git commit –amend

Si nos hemos equivocado al escribir el mensaje al hacer el commit podemos rectificar utilizando el parametro –amend de la siguiente manera:

git commit --amend -m "Nuevo mensaje corregido para el commit"

Volver al un commit anterior: git checkout id_commit

Una de las grandes ventajas de utilizar git es que podemos volver a un estado anterior. Imaginemos que hemos realizado cambios en nuestro proyecto y nos da un error que hace que nada funcione,  no conseguimos saber que es lo que falla y queremos volver al estado anterior donde todo funcionaba, es una situación terrorífica pero bastante común. con el comando git checkout podemos volver a un estado anterior.

Para probarlo vamos a realizar cambios en nuestro archivo  holamundo.html, vamos a editarlo y a dejarlo de la siguiente manera:

<html>
    <head>
        <title>Hola mundo</title>
    </head>
    <body>
        <h1>Adiós mundo cruel...</h1>
    </body>
</html>

Bien, ahora en lugar de “Hola mundo” tenemos una etiqueta <h1> que dice “Adios mundo cruel…”.

Si ahora ejecutamos el comando git status nos avisa de que ha habido cambios en holamundo.html, por lo tanto debemos pasarlo al stage y hacer un commit, para ello tal y como hemos visto antes ejecutamos los siguientes comandos, primero lo añadimos al stage:

git add .

Y después hacemos el commit:

git commit -m "Hemos modificado holamundo.html"

Ahora si ejecutamos git log –oneline obtenemos lo siguiente:

Tenemos dos commits, el inicial y la última modificación.

Si nos hemos hemos arrepentido del último cambio que  hemos realizado podemos volver al estado anterior con el siguiente comando:

git checkout ffd325d

El valor Hexadecimal que va después de checkout es el identificador del commit al que queremos regresar, en este caso el del commit inicial.

Al ejecutar el checkout comprobaremos como nuestro archivo holamundo.html ha regresado al estado inicial, ahora vuelve a decir “Hola mundo” en lugar de “Adiós mundo cruel…”.

Si he han eliminado archivos de nuestro proyecto al volver a un commit anterior estos volverán a aparecer, al mismo tiempo si se han añadido archivos nuevos, al volver a un estado anterior estos desaparecerán. Es decir volveremos a tener una copia exacta de lo que teníamos en el momento de realizar el commit al que vamos a regresar.

Por no hacer este post demasiado largo por hoy lo dejamos aquí, en el siguiente post seguiremos aprendiendo más sobre esta maravillosa herramienta.