Table of contents

Curso de GIT

Introducción a GIT

Es un sistema de control de versiones distribuido, que permite llevar un control de los cambios en los archivos de un proyecto.

El pilar de GIT es el repositorio, que es una carpeta que almacena los archivos de un proyecto y su historial de cambios.

Cada repositorio tiene al menos una rama principal, que es una línea de tiempo de los cambios en los archivos.

Estados en GIT

• modificado (modified): Archivo modificado pero no ha sido guardado en el repositorio.
• preparado (staged): Archivo modificado y marcado como preparado. Listo para ser guardado en el repositorio.Esta accion recibe el nombre de add.
• confirmado (commited): Archivo guardado en el repositorio. Esta accion recibe el nombre de commit.

Configuración y ayuda

Ver la versión de git

git --version

Ver la version de git, con un - podemos utilizar la abreviatura de los comandos.

git -v

Definimos el nombre

git config --global user.name "Nombre"

Definimos el email

git config --global user.email "email"

Definir nombre de la rama principal por defecto a main

git config --global init.defaultBranch main

Listamos la configuración de git

git config --global -l

Editamos la configuración de git

git config --globar -e

Muestra la configuración de git en el sistema, local y global.

git config -l --show-scope

Muestra la ayuda de git

git help

Muestra la ayuda de un comando en específico

git help config

Primeros comandos

Inicializa un repositorio y crea la carpeta .git

git init

Muestra el estado del repositorio

git status

Muestra el estado del repositorio de forma resumida

git status -s

Trabajando con el seguimiento de archivos.

Agrega archivos al stage

git add <nombre_archivo>

Agrega todos los archivos al stage

git add .

Agrega archivos al stage con un comodín

git add *.html

Quita un archivo del stage

git reset <nombre_archivo>

Guarda los archivos en el repositorio, tienen que estar en el stage.

git commit -m "Mensaje"

Por defecto git no hace seguimiento a carpetas vacias, para que lo haga se debe crear el archivo .gitkeep dentro de la carpeta y añadirlo al stage.

.gitkeep

Guarda todos archivos en el repositorio, siempre que esten en seguimiento.

git commit -am "Mensaje"

Modifica el último commit. Nos llevará al editor de texto desde donde podremos modificar el mensaje y ver información del commit.

git commit --amend

Modifica el mensaje del último commit.

git commit --amend -m "Mensaje"

Para sacar del stage un archivo

git reset HEAD ARCHIVO-A-UNSTAGE

Quita el ultimo commit. Detrás del HEAD^ se puede poner el número de commits que se quieren quitar. También se puede poner el hash del commit. Hay que tener en cuenta las banderas, soft mantiene los cambios en el área de preparación, mixed los quita del área de preparación pero los mantiene en el directorio de trabajo, y hard elimina los cambios tanto del área de
preparación como del directorio de trabajo.

git reset --soft HEAD^

Ver las diferencias entre archivos.

git diff

Para excluir archivos del seguimiento de git, se debe crear un archivo .gitignore y añadir los archivos que se quieren excluir.

.gitignore

Trajando con el historial.

Muestra el detalle de un commit.

git show <hash>

Muestra el historial de commits.

git log

Muestra el historial de commits de forma resumida.

git log --oneline -> Muestra el historial de commits de forma resumida.

Con el comando reflog podemos ver el historial de sucesos de git. Muy útil para saber que ha pasado en el repositorio.

git reflog

Trajando con el Stash.

El Stash es una carpeta temporal donde se almacenan los cambios que se han realizado en el repositorio, pero que no se han confirmado aún. Cuando lo lancemos todo el working directory se guardará en el Stash, y GIT nos situará en el último commit que se haya realizado. Si nos acostumbramos a trabajar en ramas cuando creemos una nueva feature, el trabajo con el Stash no se suele utilizar.

Para guardar los cambios en el Stash.

git stash

Para guardar los cambios en el Stash con un mensaje.

git stash save "Mensaje"

Para restaurar los cambios del Stash.

git stash pop

Para restaurar los cambios del Stash y no los borrar del Stash.

git stash pop --index

Para ver el Stash.

git stash list

Para ver el Stash de forma resumida.

git stash list --oneline

Para ver el Stash de forma detallada.

git stash list --verbose

Para ver el Stash de forma resumida y detallada.

git stash list --oneline --verbose

Trabajando con ramas.

Tenemos que tener en cuenta posibles tipos de union (Merge) que tenemos en GIT.

• Union automática: Este es el tipo de fusión más común y básico en Git. Se crea un nuevo commit de fusión que combina los cambios de la rama de origen a la rama destino. Git intenta fusionar automáticamente los cambios, pero si hay conflictos, te pedirá que los resuelvas manualmente antes de completar la fusión.

• Fast-forward: Esta es una forma simplificada de fusión que ocurre cuando la rama que se está fusionando no tiene divergencias significativas con respecto a la rama de destino. En lugar de crear un nuevo commit de fusión, Git simplemente mueve el puntero de la rama de destino al commit más reciente de la rama que se está fusionando. Esto hace que el historial de confirmaciones sea lineal y no se crea un commit de fusión adicional.

Para cambiar de rama.

git switch <nombre_rama>

Para crear una rama.

git branch <nombre_rama>

Para cambiar el nombre de la rama

git branch -m <nombre_rama> <nuevo_nombre>

Para crear una rama y cambiar a ella.

git switch -c <nombre_rama>
git checkout -b <nombre_rama>

Para ver las ramas.

git branch

Para ver las ramas de forma verbosa.

git branch -v

Para ver todas las ramas, locales y remotas.

git branch -a

Para ver todas las ramas remotas.

git branch -r

Para borrar una rama.

git branch -d <nombre_rama>

Para borrar una rama remota.

git push origin -d <nombre_rama>

Para unir las ramas. A tener en cuenta es que siempre nos pondremos en la rama de destino para realizar la union.

git merge <nombre_rama>

Ver diferencias entre ramas.

git diff <nombre_rama> <nombre_rama>

Si ponemos las rama de destino nos la compara con la rama actual.

git diff <rama_destino>

Trabajando con los repositorios remotos

Para ver los repositorios remotos.

git remote -v

Para agregar un repositorio remoto.

git remote add <nombre_repositorio> <url_repositorio>

Para subir los cambios al repositorio remoto.

git push <nombre_repositorio> <nombre_rama>

Para descargarse los últimos cambios del repositorio remoto.

git pull

Para descargarse todos los cambios del repositorio remoto y no solo los de la rama actual.

git pull -a

Para descargarse las referencias remotas (historial de commits) pero no los archivos.

git fetch

Para descargar las referencias remotas y borrar las que ya no existen en el repositorio remoto.

git fetch -p

Alias

git config --global alias.lg "log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)' --all"

git config --global alias.s "status --short --branch"

SOS

Restaura el sistema de archivos al último commit

git checkout -- .