Primeros pasos con Git - El mejor sistema de versiones y manual de git
Primeros pasos con Git - El mejor sistema de versiones y manual de git

 

GIT es un gestor de versiones imprescindible para cualquier programador. Si queremos conservar y tener de forma ordenada cada uno de los cambios y mejoras de nuestro proyecto, debemos usarlo sin duda. En este artículo, en forma de manual quisiera mostrarte los primeros pasos en GIT.

 

Tabla de contenidos - Git Manual - Primeros pasos con el mejor sistema de versiones

 

 

¿Qué es Git?

Git es un sistema de versiones para desarrolladores. Sirve para casi cualquier proyecto, es compatible con la mayoría de plataformas. Además lo puedes usar en cualquier SO, Windows, Linux, Mac... En resumen, si tú proyecto tiene código, puedes usarlo. Es más, deberías usarlo.

 

Empezar con Git

Lo primero que debemos hacer es instalar Git, si usamos Windows el siguiente enlace te servirá para descargarlo, además puedes instalar su consola o agregar los comandos para que puedas usarlos desde la consola de Windows. Si usas Linux puedes instalarlo desde el repositorio. Git, como he comentado antes, está disponible para cualquier plataforma, ya sea Windows, Linux o Mac. También hay interface gráficas para usar Git, también las veremos en este artículo.

Descargar Git para Windows

 

Órdenes básicas para Git

Para iniciar un repositorio de Git, debemos situarnos en la carpeta raíz de nuestro proyecto. Inicializar el repositorio con Git, luego añadir el origin, que será el recurso, normalmente online, de nuestro proyecto. Donde subiremos los cambios, hay repositorios gratuitos, como Bitbucket.

 

Ahora vamos a ver un ejemplo de como inicializar nuestro proyecto con Git, mediante comandos. Por ejemplo:

 

git init

git remote add origin https://miguelgomezsa@bitbucket.org/miguelgomezsa/my-web.git git pull origin master

mkdir /path/to/your/project

 

Añadir exclusiones .gitignore

Si queremos que ciertos archivos, como por ejemplo las imágenes, no se añadan a nuestro repositorio, lo que tenemos que hacer es añadirlas al archivo .gitignore. Como os muestro a continuación:

 

application/cache/*!application/cache/index.html!application/cache/.htaccess

img/*

!application/config/config.php

!application/config/database.php

 

Opciones de Git, necesarias para el día a día

Ahora veremos algunos comandos útiles de Git, está bien conocerlos, aunque podemos valernos de la interface gráfica para todo.

 

  • git fetch

Descarga los cambios realizados en el repositorio remoto.

 

  • git merge <nombre_rama>

Impacta en la rama en la que te encuentras parado, los cambios realizados en la rama “nombre_rama”.

 

  • git pull

Unifica los comandos fetch y merge en un único comando.

 

  • git commit -am "<mensaje>"

El más común de los comandos de Git. Confirma los cambios realizados. El “mensaje” generalmente se usa para asociar al commit una breve descripción de los cambios realizados.

 

  • git push origin <nombre_rama>

Sube la rama “nombre_rama” al servidor remoto.

 

  • git status

Muestra el estado actual de la rama, como los cambios que hay sin commitear.

 

  • git add <nombre_archivo>

Comienza a trackear el archivo “nombre_archivo”.

 

  • git checkout -b <nombre_rama_nueva>:¡

Crea una rama a partir de la que te encuentres parado con el nombre “nombre_rama_nueva”, y luego salta sobre la rama nueva, por lo que quedas parado en esta última.

 

  • git checkout -t origin/<nombre_rama>

Si existe una rama remota de nombre “nombre_rama”, al ejecutar este comando se crea una rama local con el nombre “nombre_rama” para hacer un seguimiento de la rama remota con el mismo nombre.

 

  • git branch

Lista todas las ramas locales.

 

  • git branch -a

Lista todas las ramas locales y remotas.

 

  • git branch -d <nombre_rama>

Elimina la rama local con el nombre “nombre_rama”.

 

  • git push origin <nombre_rama>

Commitea los cambios desde el branch local origin al branch “nombre_rama”.

 

  • git remote prune origin

Actualiza tu repositorio remoto en caso que algún otro desarrollador haya eliminado alguna rama remota.

 

  • git reset --hard HEAD

Elimina los cambios realizados que aún no se hayan hecho commit.

 

  • git revert <hash_commit>

Revierte el commit realizado, identificado por el “hash_commit”.

 

  •  git clone /path/to/repository 

Clonar o hacer checkout a un repositorio: este comando crea una copia local del repositorio, si utilizas un servidor remoto, ejecuta: git clone username@host:/path/to/repository

 

  • git push -f --set-upstream origin master

A veces ocurre que quieres subir cosas a master y machacar lo que haya en remoto. Esto puede ocurrir porque te esté dando el siguiente error: fatal: refusing to merge unrelated histories Muy común al crear nuevos repositorios o juntar códigos que no tienen mucho que ver entre ellos. Sería un git push origin master forzado.

 

  • git log o git log --since="10 days" o mejor aún -> git log -5 --pretty=oneline para que sea más legible

Muestra los últimos cambios realizados, muy útil para saber qué commit tenemos en producción por ejemplo.

 

  • git checkout -b release/v2021-03-26
  • git tag V2021-03-26

Crear una "Release". Cuando tenemos una versión en firme y subida en producción es una buena práctica crear una nueva rama y etiquetarla. Esta práctica viene muy bien para localizar versiones finales subidas a PRO.

 

Buenas prácticas con Git

Cada desarrollador o equipo de desarrollo puede hacer uso de Git de la forma que le parezca mas conveniente. Sin embargo una buena práctica sería usar al menos 2 ramas: Master y Development. ¿Obvio verdad?

 

  • Master o rama maestra: Como su nombre puede indicar, es la rama principal. Contiene el repositorio que se encuentra publicado en producción, por lo que debe estar siempre estable.
  • Development o desarrollo: Es una rama derivada de la maestra. Se podría decir que es la rama más actualizada, con los últimos cambios. Normalmente es la anterior a producción. Todas las nuevas funcionalidades se desarrollan sobre esta o sub ramas. Y luego se integran (merge) con master.

No olvidemos que se pueden usar tantas ramas como se deseen. A fin de tener un repositorio ordenado. A veces se puede llegar a crear una rama diferente por cada desarrollador, o por cada módulo o funcionalidad nueva.

 

Flujo de trabajo

Tu repositorio local esta compuesto por tres "árboles" administrados por git. El primero es tu Directorio de trabajo que contiene los archivos, el segundo es el Index que actua como una zona intermedia, y el último es el HEAD que apunta al último commit realizado.

Add & commit

Puedes registrar cambios (añadirlos al Index) usando git add <filename> para añadir un archivo ó git add . -A para añadirlo todo Este es el primer paso en el flujo de trabajo básico. Para hacer commit a estos cambios usa git commit -m "Commit message" Ahora el archivo esta incluido en el HEAD, pero aún no en tu repositorio remoto.

Eliminar archivos de Git, lo contrario a Add & commit

Al igual que se pueden registrar, también podemos eliminarlos del repositorio. Esto no lo elimina del sistema de archivos, solo del repositorio. 

 git rm --cached <filename>

Enviar cambios

Tus cambios están ahora en el HEAD de tu copia local. Para enviar estos cambios a tu repositorio remoto ejecuta git push origin master. Reemplaza master por la rama a la que quieres enviar tus cambios. Si no has clonado un repositorio ya existente y quieres conectar tu repositorio local a un repositorio remoto, usa git remote add origin <server> Ahora podrás subir tus cambios al repositorio remoto seleccionado.

Ramas o branch

Las ramas en Git son utilizadas para desarrollar funcionalidades separadas unas de otras. La rama master es la rama "por defecto" cuando creas un repositorio. Crea nuevas ramas durante el desarrollo y fusiónalas a la rama principal cuando termines.

Actualiza y fusionar

Para actualizar tu repositorio local al commit más actual, ejecuta git pull en tu directorio de trabajo para descargar y mezclar los cambios remotos. Para fusionar otra rama a tu rama activa (por ejemplo master), utiliza git merge <branch> en ambos casos git intentará fusionar automáticamente los cambios. Desafortunadamente, no siempre será posible y se podrán producir conflictos. Tú eres responsable de fusionar esos conflictos manualmente al editar los archivos mostrados por git. Después de modificarlos, necesitas marcarlos como fusionados con git add <filename> Antes de fusionar los cambios, puedes revisarlos usando git diff <source_branch> <target_branch>

  

Reemplazar cambios locales

En caso de que hagas algo mal (lo que seguramente nunca suceda ;) puedes reemplazar cambios locales usando el comando git checkout -- <filename>Este comando reemplaza los cambios en tu directorio de trabajo con el último contenido de HEAD. Los cambios que ya han sido agregados al Index, así como también los nuevos archivos, se mantendrán sin cambio.

Por otro lado, si quieres deshacer todos los cambios locales y commits, puedes traer la última versión del servidor y apuntar a tu copia local principal de esta forma git fetch origin git reset --hard origin/master

 

Enlaces y  Recursos para Git

Clientes gráficos para Git

  • GitX (L) (OSX, open source)
  • Tower (OSX y Windows)
  • Source Tree (OSX y Windows free)
  • GitHub for Mac (OSX, free)

 Lo más usados son: SourceTree y yo, personalmente uso SubliMerge:

Sublimerge

Otras guías y manuales para Git

  • Git Community Book
  • Pro Git
  • Think like a git
  • GitHub Help
  • A Visual Git Guide

  

Otro aliado de cualquier desarrollador y de Git -> Composer

Si usas Git por comandos como yo, también te vendrán bien estos comandos de Composer, yo los dejo aquí a modo de memorandum. Estoy seguro de que también puede servirte a ti.

Algunos turcos de Composer

Drop All Tables & Migrate

The migrate:fresh command will drop all tables from the database and then execute the migratecommand:

php artisan migrate:fresh

php artisan migrate:fresh --seed

 

- CUANDO SE VA A EJECUTAR UN PROYECTO DESCARGADO DEL GIT
composer update --no-scripts

 

- CREAR UNA MIGRACIÓN
php artisan make:migration create_users_table

 

- FORZAR MIGRACIÓN
php artisan migrate:fresh

 

- FORZAR MIGRACIÓN CONCRETA
php artisan migrate --path=/database\migrations\2019_01_17_124844_create_log_table.php

 

- CREARUN SEED
php artisan make:seeder TemplatesTableSeeder

 

- INCLUIR SEED EN EL FICHERO DatabaseSeeder.php

DB::table('templates')->delete();
.....
$this->command->info('Creando Templates');
$this->call('TemplatesTableSeeder');


- ACTUALIZARLAS CLASES DESPUES DE CREAR EL SEED
composer dump-autoload

 

- CREARUN MODELO CON MIGRACIÓN Y CONTROLADOR
php artisan make:model -mc Templates

 

- FORZAR UN SEED
php artisan db:seed --class=TemplatesTableSeeder

 

- ACTUALIZAR SEED E INCORPORAR LOS NUEVOS
composer dump-autoload

 

- REAR UN RESOURCE
php artisan make:resource "../../Modules/Templates/Resources/Views/Templates"

 

- CREAR MODULOS
php artisan make:module Templates

 

- CREAR MODELO DENTRO DE UN MÓDULO
php artisan make:model "Modules/Templates/Model/Template"

 

- CREAR UN CONTROLADOR DENTRO DE UN MÓDULO
php artisan make:controller "../../Modules/Templates/Http/Controllers/TemplatesController" --resource

 

 

 

¿Y tú, todavía no usas Git?

Si aún te quedan dudas puedes dejarlas en los comentarios.