Archivo de la etiqueta: git status

Tutorial de Git – Aprende Git y GitHub/GitLab de manera f√°cil, r√°pida y sencilla – Parte 6

Hola a todos:

En los post anteriores hemos aprendido a utilizar Git como repositorio local y también GitHub como repositorio remoto.

Tras la compra de GitHub por parte de Microsoft hubo desarrolladores que recelosos del papel que pueda jugar Microsoft  con el futuro de GitHub decidieron migrar sus repositorios a GitLab.

Hoy vamos a iniciarnos en esta plataforma:

Al igual que GitHub, Gitlab es un servicio web de control de versiones y desarrollo de software colaborativo basado en Git.

GitLab nació en 2011 como un proyecto dentro de GitHub convirtiéndose en una alternativa a este.

Fue escrito por los programadores ucranianos Dmitriy Zaporozhets y Valery Sizov en el lenguaje de programación Ruby

GitLab tiene la ventaja que permite tener repositorios privados en la versión gratuita.

Lo primero que tenemos que hacer para utilizar gitLab es crearnos una cuenta, para ello vamos a la página de GitLab: https://gitlab.com   y pinchamos en

Seleccionamos la pesta√Īa Register¬†y rellenamos los campos del formulario antes de pulsar el bot√≥n Register:

Una vez enviado el formulario te llegar√° un email a la cuenta de correo que has indicado para que confirmes tu cuenta pinchando en el enlace.

Una vez confirmada tu cuenta ya podemos empezar.

Al logearte en GitLab la primera vez veremos una pantalla como esta:

Podemos crear un proyecto, explorar proyectos publicos al igual que en GitHub y crear un grupo para gestionar un proyecto colaborativo.

Vamos a crear un nuevo proyecto, por lo tanto seleccionamos Create a proyect:

Al proyecto le vamos a llamar holamundo para no perder las buenas costumbres.

Podemos poner una descripci√≥n del proyecto si queremos y seleccionamos el tipo de repositorio que queramos: Private(privado), Internal (interno) o Public (p√ļblico).

Si queremos que sea un proyecto que solo nosotros podamos ver lo dejamos en Private.

Por √ļltimo accionamos el bot√≥n Create project y ya tendremos nuestro repositorio creado.

Si  nos desplazamos por la página hacia abajo veremos que al igual que en GitHub nos muestra los comandos que tenemos que ejecutar para sincronizar este repositorio con un proyecto en nuestro ordenador.

Primero tenemos que configurar nuestro usuario y nuestro email con git config  si no lo hemos hecho.

Como nosotros ya tenemos nuestro repositorio holamundo en nuestro ordenador ya hemos configurado el usuario.

Tenemos tres posibilidades:

Crear un nuevo repositorio vacío, utilizar una carpeta donde ya tengamos un proyecto pero que no esté gestionado todavía por git, o utilizar un repositorio local que ya esté gestionado por git.

En este caso ya tenemos nuestro proyecto holamundo que ya est√° siendo gestionado por Git y adem√°s lo tenemos asociado remotamente a GitHub.

Tenemos que seguir por lo tanto los pasos que indica en “Existing Git repository“.

Lo primero que tenemos que hacer es situarnos en la consola de comandos dentro de la carpeta de nuestro proyecto.

Ahora renombramos el origin y lo llamamos old-origin, recordad que en origin ahora estaba definido la url de nuestro proyecto en GirHub:

git remote rename origin old-origin

Ahora tenemos que indicar que el origin va a ser la dirección de nuestro proyecto en Gitlab:

git remote add origin https://gitlab.com/tu_usuario/holamundo.git

Recuerda poner la url que indique en tu caso, con tu usuario.

Ahora¬† nos indica que realicemos un push -u origin –all:

git push -u origin --all

Al ejecutar este comando nos pedir√° usuario y contrase√Īa. Debemos poner nuestro usuario y contrase√Īa de GitLab:

Una vez logeados comenzara a subir los archivos de nuestro repositorio.

Por √ļltimo nos indica que introduzcamos el siguiente comando:

git push -u origin --tags

Con esto ya tendremos todo sincronizado, si refrescamos la p√°gina de nuestro repositorio en GitLab vemos que aparecen todos los archivos de nuestro proyecto holamundo:

 

El uso que podemos hacer de GitLab es muy similar al de GitHub.

Si queremos clonar un repositorio de Gitlab en nuestro ordenador solo tenemos que copiar la url de nuestro proyecto y  utilizar el comando git clone como vimos en la parte de GitHub por ejemplo.

Vamos ha hacer una prueba:

Primero vamos a crear una carpeta en nuestro equipo donde clonaremos el repositorio, la llamaremos por ejemplo HolaMundoGitLab:

Ahora copiamos la url de nuestro repositorio en GitLab:

Ahora desde el terminal nos situamos en la carpeta que acabamos de crear y al igual que haríamos con un repositorio de GitHub utilizamos el siguiente comando:

git clone https://gitlab.com/reviblog/holamundo.git

Al hacer esto  dentro de nuestra carpeta se habrá creado la carpeta holamundo con el contenido de nuestro repositorio.

Fork

Al igual que GitHub, GitLab nos permite hacer un fork de un repositorio, como vimos en GitHub, un fork es una copia exacta de un repositorio para poder hacer modificaciones del repositorio original sin afectar a este.

En GitLab tambien 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 GitLab te da la opci√≥n de explorar repositorios p√ļblicos:

Seleccionamos un proyecto publico que nos interese y para tener una copia en nustra cuenta de GitLab solo tenemos que pulsar el botón fork:

Nos pedir√° que seleccionemos el namespace para hacer un fork del proyecto:

Seleccionamos el nuestro y después de unos segundos o algo más de tiempo dependiendo de la envergadura del proyecto tendremos una copia exacta que podemos modificar a nuestro antojo:

Al igual que en GitHub podemos hacer un pull request para solicitar la integración de los cambios que hayamos realizado en el proyecto original, en GiLab debemos solicitar un Merge request.

En el men√ļ lateral izquierdo encontraremos la opci√≥n para realizar un Merge Request:

Después debemos seleccionar la rama donde queremos hacer el merge:

Despu√©s pulsamos en el bot√≥n “Compare branches and continue” y se mostrar√° un formulario donde podemos describir el merge que vamos a realizar.

Una vez rellenado el formulario pulsamos en el bot√≥n “Submit merge request”¬†para enviar la petici√≥n.

Wiki

Gitlab nos provee tambi√©n de una Wiki donde podemos documentar nuestro proyecto y a√Īadir toda la informaci√≥n que consideremos relevante al respecto.
Desde el men√ļ lateral izquierdo podemos acceder a la Wiki y crear nuestra primera p√°gina:

A√Īadir miembros al proyecto

Podemos invitar a otros usuarios a participar en nuestro proyecto, por ejemplo si somos un equipo de varias personas trabajando en un proyecto se puede autorizar a diferentes usuarios para que puedan acceder a el.

Para ello en el men√ļ lateral de la izquierda en la parte de abajo selecionamos Settings -> Members:

Al empezar a escribir el nombre del usuario en el campo Select members to invite aparecerán sugerencias de usuarios que coincidan con lo que estamos escribiendo hasta que veamos en usuario que nos interesa.

Después en  Choose a role permission seleccionamos el tipo de rol que va a tener el usuario, pudiendo elegir entre Guest, Reporter, Developer y Maintainer.

Dependiendo del tipo de rol el usuario tendr√° diferentes permisos respecto al repositorio:

Action Guest Reporter Developer Maintainer Owner
Create new issue ‚úď ‚úď ‚úď ‚úď ‚úď
Create confidential issue ‚úď ‚úď ‚úď ‚úď ‚úď
View confidential issues (‚úď) ‚úď ‚úď ‚úď ‚úď
Leave comments ‚úď ‚úď ‚úď ‚úď ‚úď
See related issues ‚úď ‚úď ‚úď ‚úď ‚úď
See a list of jobs ‚úď ‚úď ‚úď ‚úď ‚úď
See a job log ‚úď ‚úď ‚úď ‚úď ‚úď
Download and browse job artifacts ‚úď ‚úď ‚úď ‚úď ‚úď
View wiki pages ‚úď ‚úď ‚úď ‚úď ‚úď
Pull project code ‚úď ‚úď ‚úď ‚úď
Download project ‚úď ‚úď ‚úď ‚úď
Assign issues ‚úď ‚úď ‚úď ‚úď
Assign merge requests ‚úď ‚úď ‚úď
Label issues and merge requests ‚úď ‚úď ‚úď ‚úď
Create code snippets ‚úď ‚úď ‚úď ‚úď
Manage issue tracker ‚úď ‚úď ‚úď ‚úď
Manage labels ‚úď ‚úď ‚úď ‚úď
See a commit status ‚úď ‚úď ‚úď ‚úď
See a container registry ‚úď ‚úď ‚úď ‚úď
See environments ‚úď ‚úď ‚úď ‚úď
See a list of merge requests ‚úď ‚úď ‚úď ‚úď
Manage related issues [STARTER] ‚úď ‚úď ‚úď ‚úď
Lock issue discussions ‚úď ‚úď ‚úď ‚úď
Lock merge request discussions ‚úď ‚úď ‚úď
Create new environments ‚úď ‚úď ‚úď
Stop environments ‚úď ‚úď ‚úď
Manage/Accept merge requests ‚úď ‚úď ‚úď
Create new merge request ‚úď ‚úď ‚úď
Create new branches ‚úď ‚úď ‚úď
Push to non-protected branches ‚úď ‚úď ‚úď
Force push to non-protected branches ‚úď ‚úď ‚úď
Remove non-protected branches ‚úď ‚úď ‚úď
Add tags ‚úď ‚úď ‚úď
Write a wiki ‚úď ‚úď ‚úď
Cancel and retry jobs ‚úď ‚úď ‚úď
Create or update commit status ‚úď ‚úď ‚úď
Update a container registry ‚úď ‚úď ‚úď
Remove a container registry image ‚úď ‚úď ‚úď
Create/edit/delete project milestones ‚úď ‚úď ‚úď
Use environment terminals ‚úď ‚úď
Add new team members ‚úď ‚úď
Push to protected branches ‚úď ‚úď
Enable/disable branch protection ‚úď ‚úď
Turn on/off protected branch push for devs ‚úď ‚úď
Enable/disable tag protections ‚úď ‚úď
Rewrite/remove Git tags ‚úď ‚úď
Edit project ‚úď ‚úď
Add deploy keys to project ‚úď ‚úď
Configure project hooks ‚úď ‚úď
Manage Runners ‚úď ‚úď
Manage job triggers ‚úď ‚úď
Manage variables ‚úď ‚úď
Manage GitLab Pages ‚úď ‚úď
Manage GitLab Pages domains and certificates ‚úď ‚úď
Remove GitLab Pages ‚úď
Manage clusters ‚úď ‚úď
Edit comments (posted by any user) ‚úď ‚úď
Switch visibility level ‚úď
Transfer project to another namespace ‚úď
Remove project ‚úď
Delete issues ‚úď
Remove pages ‚úď
Force push to protected branches
Remove protected branches
View project Audit Events ‚úď ‚úď

Esta tabla esta sacada de la documentación oficial de gitlab, para saber más sobre los permisos de usuario puedes visitar el siguiente link: https://gitlab.com/help/user/permissions

Eliminar un repositorio

Si queremos eliminar un repositorio debemos acceder en el men√ļ lateral izquierdo y seleccionar Settings – General¬†¬†y en General project¬†pulsar el bot√≥n Expand

En General project nos desplazamos hasta el final de la página y en Advanced pulsamos el botón Expand. Nos desplazamos una vez más hasta el final de la página para encontrar el botón Remove project.

Al pulsar el botón Remove project nos pide introducir el nombre del proyecto para confirmar la eliminación.

Conclusión:

A lo largo de este tutorial hemos aprendido a utilizar Git para crear nuestros repositorios locales y llevar un control de versiones a través de esta potente herramienta. También hemos visto como trabajar con repositorios remotos con una introducción a dos de las plataformas basadas en Git mas utilizadas, GitHub y GitLab.

Espero que os sea de utilidad.

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

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

En el siguiente enlace tienes el índice 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.

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

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 enlace tienes el índice para acceder al resto de entradas de este tutorial:

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

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

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.

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

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 y¬†¬†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.

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