Archivo de la etiqueta: tutorial git castellano

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

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

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.