Guía Completa de Git y GitHub para Principiantes

Git y GitHub son herramientas fundamentales en el mundo del desarrollo de software moderno. Si eres nuevo en la programación o simplemente quieres mejorar tu flujo de trabajo, esta guía te llevará paso a paso a través de los conceptos básicos de Git para principiantes hasta técnicas más avanzadas.

Aprenderás cómo usar Git para controlar versiones de tus proyectos y cómo colaborar eficazmente con otros desarrolladores utilizando GitHub.

Índice

1. Introducción a Git y GitHub
2. Instalación y Configuración
3. Conceptos Básicos de Git
4. Comandos Esenciales de Git
5. Trabajando con Ramas
6. Ignorando archivos y carpetas
7. Introducción a GitHub
8. Conectando Git y GitHub
9. Colaboración en GitHub
10. Resolución de Conflictos
11. Buenas Prácticas
12. Herramientas Visuales
13. Conclusión y Próximos Pasos

1. Introducción a Git y GitHub

¿Qué es Git?

Git es un sistema de control de versiones distribuido, creado por Linus Torvalds en 2005. Imagina que estás escribiendo un libro y quieres guardar cada borrador como una versión diferente. Git hace exactamente eso con tu código, permitiéndote guardar «instantáneas» de tu proyecto en diferentes puntos del tiempo.

¿Qué es GitHub?

GitHub es una plataforma en línea que utiliza Git como su sistema de control de versiones subyacente. Piensa en GitHub como una red social para programadores, donde puedes almacenar tus proyectos, colaborar con otros, y descubrir código interesante de todo el mundo.

2. Instalación y Configuración

Instalando Git en tu sistema

Para instalar Git:

1. Ve a https://git-scm.com/downloads
2. Descarga la versión para tu sistema operativo (Windows, macOS, Linux)
3. Sigue las instrucciones del instalador

Configuración inicial de Git

git config --global user.name "Tu Nombre"
git config --global user.email "[email protected]"

git config –list

Esto es importante porque Git usa esta información en cada commit que haces.

3. Conceptos Básicos de Git

4. Comandos Esenciales de Git

git init

Este comando inicializa un nuevo repositorio Git en tu directorio actual:

git init

Este comando va a iniciar un repositorio local en nuestro equipo. Podemos comprobar que dentro del directorio de nuestro proyecto se ha creado un directorio oculto llamado ‘.git’.

git add

git add nombrearchivo.txt

git add nombrearchivo.txt otroarchivo.txt

git add .

git commit

git commit -m "Descripción de los cambios realizados"

git commit -m "Descripción de los cambios realizados" -a

git commit

git config -global core.editor 'code --wait'

Posteriormente, para obtener el nombre de los archivos que fueron «comiteados» (-r añade también los directorios):

git ls-tree -r -name-only identificador

git status

Muestra el estado actual de tu repositorio:

git status

Tenemos una variante de git status que nos muestra el estado actual en un estilo corto (short):

git status --short

git status -s

Para ver la información de un archivo que ha sido «comiteado»:

git show nombrearchivo.extension

Eliminación y restauración de archivos (restore, checkout, reset)

Imaginemos que se ha eliminado un archivo (llamado archivo.txt) en nuestra área de trabajo. Para que los cambios se vean reflejados en nuestro repositorio, debemos ejecutar los siguientes comandos:

git status

Si queremos que el archivo borrado se borre del staging y del repositorio:

git add archivo.txt
git commit -m 'Eliminando archivo.txt'

git restore archivo.txt

git reset --hard

git checkout archivo.txt

git config --global core.abbrev 5

Ver las diferencias entre commits o archivos

Diferencias entre el área de preparación (el staging) y que ha sido «comiteado»:

git diff --staged

Para obtener las diferencias entre dos commits usamos los identificadores

git diff 4427b 9ccc3

Si sólo quiero saber el nombre de los ficheros que habían sido modificados:

git diff --name-only 4427b 9ccc3

Si quiero ver el contenido que ha cambiado:

git diff --word-diff 4427b 9ccc3

git log

Muestra el historial de commits:

git log

Podemos ver esta misma información en formato reducido:

git log --oneline

Ejemplos de uso con commit y reset

Imaginemos que hemos realizado un commit pero que queremos deshacerlo por cualquier motivo:

git commit --amend

Se nos abre el fichero COMMINT_EDITMSG. En él podemos modificar el mensaje del último commit por ejemplo.

Si además de querer modificar el texto del mensaje del commit quisiéramos agregar más ficheros o cambios de los mismos, haríamos el git add de los ficheros agregados o modificados y posteriormente lanzaríamos el comando anterior.

git add ficheronuevo.txt ficheromodificado.txt
git commit --amend

Ahora supongamos que tenemos 5 commits realizados y queremos deshacer el último. Para ello, realizado el siguiente comando:

git reset --soft 45a55

Primero hemos obtenido los hash de los commits para saber a cuál movernos. Queremos ir al penúltimo, por lo que necesitamos su código hash abreviado, que en este caso es el 45a55. Para ver los hash hemos usado el comando git log –oneline.

Ahora imaginemos que queremos ir n commits hacia atrás en el pasado. El comando a usar sería el siguiente:

git reset --soft head~n #siendo n el número de commits que queremos retroceder

Si detrás de la virgulilla (~) no agregamos ningún número, por defecto es 1.

Si usamos –soft los archivos que estaban en staging se mantienen, y los que habían en el commit posterior que no estaban en el commit anterior, se copian al staging. 

Si usamos –mixed los archivos que estaban en staging desaparecen, pero en el área de trabajo no se modifica nada.

Si usamos –hard, mueve el puntero HEAD de un commit a otro y se modifican todos los ficheros a como estaban en ese commit (se descartan todos los cambios que hubieran). Lo que hay en el área de trabajo y en staging se modifican igualmente.

5. Trabajando con Ramas

Obtener información sobre Ramas

Saber las ramas que tenemos y en cuál estamos posicionados:

git branch

Ver todas las ramas que tenemos tanto en local como en los repositorios remotos:

git branch -a

Crear y cambiar entre ramas

git branch nueva-caracteristica

git checkout nueva-caracteristica

git checkout -b nueva-caracteristica

git checkout es la forma antigua y en desuso, ahora se usa git switch, que es la forma actual y recomendada.

Borrado y Renombrado de Ramas

git branch -d nombre-rama

git branch -m modificar-texto

git branch -m modificar-dev modificar-texto

Fusionar ramas (merge)

Para fusionar los cambios de una rama a otra:

git checkout main
git merge nueva-caracteristica

Ejemplo de fusión de ramas

Supongamos que tenemos un proyecto en la rama master y queremos realizar una nueva característica (feature). Para ello, creamos una nueva rama y nos movemos a ella (git switch -c nueva-caracteristica). Una vez que hemos realizado los cambios en nuestro proyecto, agregamos al staging (git add .) y posteriormente hacemos el commit de la rama (git commit -m «Nueva característica agregada»).

Ahora, ¿cómo fusionamos los cambios de nuestra rama con master?

1. Nos posicionamos sobre la rama en la que vamos a fusionar, en nuestro caso master (git switch master).
2. Ahora fusionamos la rama que queremos sobre la master (git merge nueva-caracterísitca).

# Creamos nuestra nueva rama llamada nueva-característica y nos posicionamos en ella
git switch -c nueva-caracteristica

# Una vez que hemos realizado la tarea, agregadmos a staging y hacemos el commit
git add .
git commit -m "Nueva característica agregada"

# Ahora nos posicionamos sobre la rama master
git switch master

# Por último, realizamos la fusión de la rama sobre master
git merge nueva-característica

NOTA: la rama nueva-característica sigue existiendo

Si quisiéramos deshacer el merge por cualquier motivo, debemos localizar el Identificador del commit anterior y volver a él con el comando git reset –hard identificador_numérico

Si ahora quisiéramos borrar la rama nueva-característica, simplemente lanzamos el comando:

git branch -d nueva-característica

Podemos comprobar que aunque se haya borrado la rama, los cambios permanecen en master porque han sido fusionados.

Git log usando ramas

Anteriormente vimos cómo podíamos ver los commits, pero si estábamos en master y teníamos una rama que contenía más commits que master, desde master no podíamos ver los commits con el comando git log –online. Para solventar esto, le agregamos –all al final, tal que así:

git log --oneline --all

Si queremos verlo un poco más gráfico (con las ramas dibujadas) sería así:

git log --oneline --all --graph

Y para agregar una marca de tiempo que nos indica hace cuánto tiempo se hicieron los commits:

git log --oneline --all --graph --pretty=format:"%C(auto)%h%d %s %C(black)%C(bold)%cr"

6. Ignorando archivos y carpetas

.gitignore

Creamos un archivo llamado «.gitignore» en el cual vamos a agregar todos los archivos y directorios que queremos que no se añadan a la hora de subirlos al staging y el posterior comiteado. 

Para obviar varios archivos, por ejemplo todos los archivos de tipo txt, usamos el carácter comodín «*», creando una línea en nuestro .gitignore que sea:

# Este archivo es .gitignore
# Todo lo que se agrega a él será obviado tanto para subirlo al stage como al commit

*.txt

Si quisiéramos crear una excepción y que se suba el fichero readme.txt, lo haríamos así:

# Este archivo es .gitignore
# Todo lo que se agrega a él será obviado tanto para subirlo al stage como al commit

*.txt
!readme.txt # El símbolo de cierre de exclamación es la negación

Si queremos ignorar un directorio:

copia/ # Se ignora el directorio copia y todos sus elementos que contiene

Si queremos obviar aquellos archivos que terminan con la palabra «copia» y de tipo txt:

*copia.txt

.gitignore global

Imaginemos que queremos tener un fichero .gitignore global para que cualquier nuevo proyecto que creemos lo herede.

Creamos nuestro archivo nuevo llamado por ejemplo .gitignore_global. Abrimos en la consola GitBash y escribimos el siguiente comando:

git config --global core.excludesfile ruta/al/fichero/.git_ignore_global

NOTA: Si queremos que un proyecto no herede de este .gitignore, le creamos uno local.

7. Introducción a GitHub

Creación de una cuenta

1. Ve a https://github.com
2. Haz clic en «Sign Up»
3. Sigue las instrucciones para crear tu cuenta

Crear un repositorio en GitHub

1. Inicia sesión en GitHub
2. Haz clic en el botón «+» en la esquina superior derecha
3. Selecciona «New repository»
4. Completa la información del repositorio y haz clic en «Create repository»

8. Conectando Git y GitHub

Clonar un repositorio

Para copiar un repositorio de GitHub a tu computadora:

git clone https://github.com/usuario/nombre-repositorio.git

Push y Pull

Para enviar tus cambios locales a GitHub:

git push origin main

Para obtener los últimos cambios de GitHub:

git pull origin main

9. Colaboración en GitHub

Forks

Un fork es una copia de un repositorio en tu cuenta de GitHub. Para hacer un fork, visita el repositorio en GitHub y haz clic en el botón «Fork».

Pull Requests

Un Pull Request (PR) es una solicitud para fusionar los cambios de tu fork al repositorio original:

1. Haz tus cambios en una rama de tu fork
2. Ve a la página del repositorio original en GitHub
3. Haz clic en «Pull requests» y luego en «New pull request»
4. Selecciona tu rama y describe tus cambios
5. Haz clic en «Create pull request»

10. Resolución de Conflictos

Identificar conflictos

Git te avisará de conflictos cuando intentes fusionar ramas con cambios incompatibles.

Resolver conflictos manualmente

1. Abre los archivos con conflictos
2. Busca las secciones marcadas con <<<<<<<, =======, y >>>>>>>
3. Edita el archivo para resolver el conflicto
4. Guarda el archivo y haz un nuevo commit

Si se pulsa sobre:

• Accept Current Change: nos quedamos con la parte de arriba coloreada en verde.
• Accept Incoming Change: nos quedamos con la parte de abajo, coloreada en azul.
• Accept Both Changes: suma el resultado de las dos opciones.
• Compare Changes: nos permite comparar con más detalles los cambios.

Visual Studio Code nos brinda una opción con un botón que nos aparece más abajo que pone: » Resolve in Merge Editor «.

Si por lo que sea no le hemos dado a finalizar la fusión, en nuestro prompt de GitBash veríamos que en lugar de mostrarnos que estamos en master, nos pondría (master|MERGING).

Para terminar de realizar la fusión desde la consola, escribimos:

git merge --continue

11. Buenas Prácticas

Escribir buenos mensajes de commit

• Sé conciso pero descriptivo
• Usa el imperativo: «Añade función» en lugar de «Añadida función»
• Limita la primera línea a 50 caracteres

Uso de .gitignore

Crea un archivo .gitignore en la raíz de tu proyecto para especificar archivos que Git debe ignorar, como archivos de configuración local o directorios de dependencias.

12. Herramientas Visuales

GitHub Desktop

GitHub Desktop es una aplicación que proporciona una interfaz gráfica para Git y GitHub, ideal para principiantes.

Extensiones de Git para editores de código

Muchos editores de código como Visual Studio Code tienen extensiones de Git integradas que facilitan el uso de Git directamente desde el editor.

13. Conclusión y Próximos Pasos

Dominar el control de versiones es un proceso continuo, pero con esta guía de Git y GitHub para Principiantes has dado tus primeros pasos importantes.

Recuerda que la práctica es clave: cuanto más uses estas herramientas, más cómodo te sentirás con ellas. No temas cometer errores; Git está diseñado para ayudarte a recuperarte de ellos.

A medida que avances, explora características más avanzadas como el rebase, los hooks de Git, y las acciones de GitHub. Estas herramientas no solo mejorarán tu flujo de trabajo personal, sino que también te harán un colaborador más valioso en proyectos de código abierto y equipos de desarrollo.

Recuerda siempre que Git y GitHub son herramientas poderosas que pueden parecer complejas al principio, pero con tiempo y práctica, se convertirán en una parte natural e indispensable de tu proceso de desarrollo.

Sigue aprendiendo con Maníaco Digital

En este artículo quiero mencionar a Lucas Dalto, pues gracias a unos de sus cursos he podido compartir este artículo con todos vosotros.
Puedes ver su vídeo en el siguiente enlace: Curso de GIT desde CERO (Completo)

Si te ha gustado este artículo y quieres más, no dudes en visitar el siguiente enlace: BLOG