Tutorial Git desde cero: Crea, comparte y colabora sin miedo

Qué es Git

Comenzaremos respondiendo a esta pregunta, ¿qué es Git y para qué sirve?

Git es uno de los programas de software más utilizados en la actualidad en el ámbito del desarrollo.

Si te preguntas qué es y para qué sirve Git, podríamos decir que se trata de una herramienta de control de versiones (VCS) de código abierto. Gracias a este, se pueden gestionar las diferentes versiones por las que pasará el código de tus proyectos en los diferentes momentos de su creación tanto si son individuales o en equipo.

¿Para qué se utiliza el control de versiones? Principalmente para el desarrollo de software.

¿Y cómo funciona? Muy sencillo, este se encarga de almacenar una copia de todos los cambios realizados en los archivos de tus proyectos en un repositorio, lo que permite ver su evolución y volver a versiones anteriores en caso que sea necesario.

Pero entre los numerosos programas que cumplen esta función, ¿por qué elegir Git? ¿Qué lo diferencia de los demás?

Importancia de Git en el control de versiones

Entre las diferentes características que hacen destacar a Git entre su competencia encontramos:

• La configuración de su modelo de repositorio, siendo este compatible con diferentes protocolos de transferencia cómo son HTTP (HyperText Transfer Protocol), FTP (File Transfer Protocol) o SSH (Secure Shell); y sistemas.

• Es un sistema de control distribuido, lo que permite que cada usuario pueda tener una copia completa de su repositorio en su propio sistema. Lo que proporciona flexibilidad e independencia para gestionar el trabajo.

• Su velocidad y rendimiento no se limitan únicamente a pequeños proyectos, sino que también se ajusta perfectamente a otros más grandes.
  Garantiza la integridad de los datos almacenados en el repositorio, por lo que cada archivo y cambio realizado en este tendrá una firma única siendo fácilmente detectable cualquier alteración, previniendo así posibles pérdidas de datos.

• Facilita la gestión de ramas de trabajo, esto permite crear una nueva rama separada de la principal, en la que podrás realizar los diferentes cambios sin afectar al proyecto y finalmente fusionarla a la original. Esto facilita el desarrollo en paralelo, permite experimentar sin riesgos y tener mayor eficiencia en el trabajo realizado.

Ahora que ya conoces las ventajas de Git, ¿te interesa implementarlo en tu día a día? Si es así, te dejamos los pasos necesarios para aprender Git desde cero, desde su instalación hasta los primeros pasos.

Instalación de Git

A continuación, te mostramos las pautas a seguir y los comandos Git que debes utilizar para su instalación

Guía de instalación de Git en Windows

En el caso de Windows, la instalación es más sencilla. Te dejamos los pasos por aquí:

1. Descarga el paquete de instalación de Git para la versión de Windows que utilices.
2. Una vez iniciado el instalador, se mostrará en tu pantalla el asistente de configuración de Git. Aquí, los pasos a seguir son simples, selecciona la opción “next” y “finish” para completar el proceso y ya lo tendrías.

Guía de instalación de Git en Linux

Si tu sistema es Linux, ¡tienes suerte!, la mayoría de dispositivos que tienen integrados este sistema operativo suelen tener instalados Git. Para comprobar si es así, escribe en tu shell este comando: git --version

En caso afirmativo, podrás ver un mensaje en el que te indique cuál es la última versión con la que cuentas.

Si finalmente no cuentas con este software, según la distribución con la que cuentes, debes seguir unos pasos u otros.

En el caso de que tu distribución sea Ubuntu / Debian / Linux Mint, debes hacer lo siguiente:

1. Abre tu shell.
2. Una vez abierto, instala Git haciendo uso de apt-get:

$ sudo apt-get update
$ sudo apt-get install git

En caso de que cuentes con Fedora, el procedimiento es este:

1. Abre tu shell.
2. Una vez abierto, instala Git, esta vez usando “dfn” (aunque en versiones más antiguas debe usarse “yum”)

$ sudo dnf install git o bien $ sudo yum install git

Guía de instalación de Git en macOS

Si en tu caso, tienes un sistema operativo macOS, hay formas diferentes de instalarlo, pero la más fácil es la siguiente:

1. Descarga el instalador de la aplicación que mejor se ajuste a la versión del sistema de tu dispositivo.
2. Completa la descarga con las instrucciones del instalador.

Configuración Inicial de Git

Antes de comenzar a explicaros cómo usar Git, debemos poner el software a punto para obtener su mayor rendimiento.

Verificación de la instalación

Una vez creas que la instalación se ha llevado a cabo, debes verificarlo de la siguiente forma introduciendo el siguiente comando en terminal: git --version

Una vez tengamos el “sí” por parte de nuestro dispositivo, solo quedaría un pasito más para poder empezar a desarrollar tus futuros proyectos.

Configuración de usuario

Aunque tras la instalación de Git creas que ya puedes empezar a utilizarlo, primero, hay que hacer una última configuración inicial, con el fin de informar a Git quiénes somos y que tenga constancia de nuestro email, ya que así es como podrá firmar cualquier cambio que realicemos en el código de nuestros proyectos. Para ello, tendrás que lanzar el siguiente comando:

git config --global user.name "Tu nombre"
git config --global user.email "tu_email@example.com"

Creando tu primer repositorio Git

Para empezar a utilizar Git, lo primero que debes de hacer es crear un repositorio, y aquí te explicaremos cómo hacerlo.

Iniciar un repositorio

Para crear nuestro repositorio, el primer paso sería iniciarlo, ¿y cómo lo hacemos? A continuación, te lo explicamos.

Este proceso es necesario para comunicar a Git que empiece a llevar un control sobre los cambios que se llevarán a cabo desde ahora.

Para ello, simplemente debes usar el siguiente comando: git init

Al ejecutarlo en nuestro dispositivo, hará que se cree un nuevo subdirectorio en tu directorio de trabajo actual; creándose al mismo tiempo una nueva rama principal de tu proyecto.

Cada proyecto lo tendrás guardado en una carpeta distinta y repositorio independiente, es por eso importante realizar esta operación de inicio de repositorio únicamente al principio de cada proyecto que quieras crear.

Una vez realizado este procedimiento, podrás ver que se ha creado una carpeta llamada “.git” dentro del proyecto en el que te encuentres, aunque en ocasiones también se encuentra oculta. Pero no debes borrar ni acceder de forma directa a su contenido, ya que la interacción con estos se hará siempre a través de comandos.

Primer commit

Cuando hablamos de commit, nos referimos a la copia que se hace del proyecto en un momento determinado y guardarlo en tu repositorio; tú puedes elegir cuándo hacerlo y qué cambios quieres incluir en él.

Para hacerlo, debes prepara aquellos cambios que quieras guardar antes de llevar a cabo el commit. Estos quedan en una zona llamada “zona Index” o “Staging Area”, donde estarán temporalmente mientras se eligen todos aquellos ficheros que quieras incluir en el commit. Para ello, utilizarás el comando: git add

Vamos a ver un ejemplo para que sea más sencillo entenderlo. Si tenemos un archivo llamado, por ejemplo, “la234.py” el cuál has modificado y ahora quieres incluirlo en el commit que vas a realizar, haces lo siguiente: git add la234.py

Si quieres incluir todos los archivos modificados y no solo uno, se utilizará el siguiente comando: git add

El punto final del comando es importante, ya que este será el que indique que se quiere almacenar todos esos archivos en el repositorio que has creado.

Antes de hacer el commit, para comprobar que los ficheros que has incluido, lo han hecho correctamente, se lanza el siguiente comando: git status

Una vez que todos los cambios están preparados en la zona de index y quieres hacer el commit. Se debe lanzar el siguiente comando. git commit -m

En el caso de que quieras dejar un mensaje en el commit que describa de qué se trata, solo debes escribir el título en el comando. Por ejemplo, el cambio que has hecho consiste en un proceso realizado para el registro de usuarios. Pues se indicaría de la siguiente forma:

git commit -m “Nueva función de registro”

Una vez realizada la acción, se abrirá un editor de texto para solicitar un mensaje de confirmación junto con aquellos cambios que se han incluido y que quieres guardar en el repositorio.

Manejo básico de Git

Aquí podrás ver los comandos de Git esenciales, que necesitas para dar tus primeros pasos.

Trabajando con commits

A parte de los comandos de commits que hemos mencionado en el apartado anterior, existen otros con diversas funcionalidades y que son básicos para el uso de Git:

• git log: este comando es utilizado para ver los diferentes commits que tiene tu proyecto, y con el que conseguiremos la siguiente información: autor, fecha y mensaje del commit.
• git revert: este comando es utilizado para revertir un commit. Se suele usar seguido del identificador del commit que deseas deshacer (nombre que le has puesto).
• git commit –aemend: es utilizado para editar el mensaje de un commit o editar los archivos que este contiene.
• git reset: elimina los cambios realizados aun cuando no se ha llevado a cabo el commit.
• git checkout: para descartar cambios antes de llevar a cabo el “commit”, cuándo el archivo con cambios se encuentra aún en el “staging area”.

Uso de ramas

Una rama (también conocida como branch), es una línea de desarrollo independiente. Estas son muy útiles, ya que permite que los desarrolladores puedan trabajar dentro de diferentes características, al mismo tiempo que experimentan nuevas funcionalidades sin miedo a afectar al trabajo original.

Es importante mencionar, que encontrarás diferentes ramas, siendo la principal la denominada como “máster”

Aquí, te explicamos los pasos básicos para que aprendas a cómo trabajar con ellas:

1. Para poder comprobar en qué rama del proyecto te encuentras, bastará con escribir el siguiente comando: git branch
2. Para crear ramas, debes poner el siguiente comando que hemos mencionado antes, junto con el nombre que le queramos dar a la rama. Por ejemplo, si la queremos llamar “rama 2”, sería así: git branch rama 2
3. Si lo que quieres es comprobar las diferentes ramas que tiene el proyecto de forma más detallada, con utilizar el siguiente comando tendrás esta información: git show-branch
4. Si lo que te interesa es cambiar a una rama ya existente, aplicando el ejemplo que hemos utilizado en uno de los puntos anteriores, sería algo así: git checkout rama 2
5. En el caso que quieras eliminar una rama, te recomendamos usar este comando, ya que es más seguro y evitará posibles pérdidas de código. Para que sea más sencillo, nos volveremos a basar en el ejemplo anterior: git branch -d rama 2

Con estos pasos, podrás moverte de forma básica en la creación y desarrollo de nuevas ramas.

Fusión de código y resolución de conflictos

Cómo hemos explicado antes, se pueden crear diferentes ramas de un mismo proyecto, pero también se pueden fusionar ramas externas, aquí podrás ver cómo hacerlo y te explicaremos los posibles errores que podrás encontrar en el proceso.

Merge vs rebase

El uso de ramas es interesante, cómo ya habíamos dicho antes, porque te puede permitir experimentar diferentes procesos sin afectar el trabajo principal o el de otros compañeros, pero ¿cómo puedes fusionar aquellos cambios que has implementado en la rama secundaria a la principal?, para ello tenemos el comando “merge”.

Para ello, primero tendrás que encontrarte en la rama principal o “main”, una vez nos encontramos ahí, debemos de utilizar el comando “merge” con la rama que queremos fusionar.

Al igual que ocurría cuando lanzábamos el comando “commit”, necesitarás añadir un mensaje.

Por lo que el proceso sería de la siguiente forma, utilizando el ejemplo anterior:

1. Primero no moveremos a la rama principal: git checkout master
2. Luego comprobaremos que nos encontramos en la rama principal, con el comando: git branch
3. Luego fusionaremos la rama secundaria a la principal, al mismo tiempo que añadimos la información que creamos que es relevante: git merge rama 2 -m “mensaje que queremos añadir”

Una vez que hagamos este proceso haríamos “commit”, para almacenar los cambios realizados.

Estrategias básicas para resolver conflictos

Cuando trabajamos con Git, nos podemos encontrar con dos conflictos básicos:

• Qué Git no inicie la fusión que queremos realizar: Esto ocurre si Git no identifica que haya cambios en el directorio de trabajo o proyecto en el que se esté trabajando, es decir, que hay cambios pendientes por guardar antes de que se realice la fusión.
• Qué Git falle durante la fusión: Cuando esto ocurre es debido a que hay un conflicto entre la rama local que se crea y una rama que se está fusionando, en este caso, entra en el conflicto el código de otro desarrollador.

¿Cómo puedes identificar de qué tipo de error se trata? Para cada uno de estos casos, aparecerá un mensaje:

• Error 1: Entry ‘fileName’ not uptodate. Cannot merge. (Changes in working directory)
• Error 2: Entry ‘fileName’ would be overwritten by merge. Cannot merge. (Changes in staging area)

¿Qué puedes hacer en cada uno de estos casos?

• Error 1: puedes utilizar los comandos: git checkout, git commit o git reset
• Error 2: puedes utilizar los comandos git reset o git merge –abort

Trabajando con repositorios remotos

¿Quieres saber cómo trabajar con otros colaboradores y cómo compartir tus repositorios en la nube? En este apartado te explicaremos cómo.

Conexión a un repositorio remoto

Todo el proceso que hemos visto ahora lo hemos enfocado a la creación de repositorios locales, pero ¿sabías que puedes obtener acceso a otros repositorios en línea desarrollados por otras personas y desde los cuáles puedes trabajar nuevas funcionalidades?

Una de los repositorios remotos más conocidos y usualmente el más utilizado es GitHub.

Los repositorios remotos siempre vendrán dados en forma de URL.

El primer paso a realizar cuando queremos trabajar con un repositorio remoto es crearlo y después clonarlo en nuestro directorio o espacio de trabajo local, para ello utilizaremos lo siguiente:

git clone <url que hemos copiado>

Una vez realizados los cambios qué queramos dentro de este, es donde entran en juego los comandos “push” y “pull” .

Push y pull

Una vez que tenemos los cambios realizados y queremos enviarlos al repositorio remoto, utilizaremos el comando “git push” lo que hará que podamos ver que se han añadido los datos que queremos a nuestro repositorio remoto.

En el caso del comando “git pull” es útil, cuándo trabajamos de forma colaborativa con otros desarrolladores, de esta forma, cuándo lo lanzamos en nuestra terminal, conseguiremos los datos del repositorio remoto, en los que podamos realizar los cambios o las fusiones necesarias.

Conclusiones

Cómo sabemos, el trabajo en equipo es esencial para el futuro laboral, siendo una de las habilidades más demandadas por las empresas.

Pero para ello debemos aprender a utilizar las herramientas para obtener los mejores resultados.

En el caso de Diseño, el sistema de control de versiones con Git será tu solución.

Aquí te hemos podido enseñar los primeros pasos, pero tu aprendizaje en Git sólo acaba de empezar.

Si quieres sacarle el máximo partido a esta herramienta, te dejo por aquí el curso de Git desde cero de OpenWebinars.

¡Empieza a observar las ventajas de usar Git en tus próximos proyectos!