Git Bash

Para ver la versión:

git --version

Para ver las opciones:

git --help o git -h

Ruta donde estamos:

pwd

Crear carpetas:

mkdir "Hello Git"

Entrar al directorio:

cd "Hello Git" o cd Hello\ Git

Para abrir la carpeta / proyecto con VC:

.code

Configurar GIT:

git config --global user.name "AsnoaPanda"

git config --global user.email "[email protected]"

Crear un archivo:

touch hellogit.py (extensión python)

Ver si está Git funcionando y ponerlo en el proyecto:

 git init --> Se lanza desde terminal en el directorio.

** Siempre tener los directorios que se vean los directorios ocultos.

Se verá una carpeta .git y archivos dentro. Aquí se indica que se está creando un repositorio de
GIT y se trabaja con un gestor de versiones.

Ahora en la terminal, se ve que pone : (master). Se le puede llamar rama main también a la
rama principal.
Se podría cambiar el nombre de la rama principal con:

git config --global init.defaultBranch <name>

o con:

git branch -m main

RAMAS
Git tiene el concepto de ramas.
Las ramas permiten a los desarrolladores trabajar en diferentes características, solucionar
problemas o mejoras de forma paralela sin interferir en el trabajo de otros. Cada rama contiene
una copia completa del repositorio con su historial de commits.

Las ramas son útiles en el desarrollo de software por las siguientes razones:

1. Desarrollo paralelo: Varias personas pueden trabajar en diferentes partes del proyecto al
mismo tiempo sin afectarse mutuamente.
2. Experimentación: Puedes crear una rama para probar nuevas características o realizar
cambios sin afectar la rama principal. Si los cambios no funcionan, simplemente puedes
descartar la rama sin afectar el código principal.
3. Versionado: Las ramas pueden utilizarse para mantener diferentes versiones del software.
Por ejemplo, puedes tener una rama para la versión de desarrollo y otra para la versión
de producción.
4. Solución de problemas: Puedes crear una rama para abordar un problema específico o
una solicitud de extracción (pull request) sin afectar el código principal hasta que esté listo
para su revisión y fusión.
5. Colaboración: Cuando colaboras con otros desarrolladores en un proyecto, cada uno
puede trabajar en su propia rama y luego fusionar los cambios en la rama principal
cuando estén listos.

Crear una rama:

 git branch nombreRama

Para ver las ramas:

git branch

Para movernos entre ramas:

git checkout nombre_de_tu_rama

Si quiero ver el status del proyecto:

git status

Para versionar los archivos, que es como hacer una fotografía de nuestro fichero:

git add nombreArchivo.java

Para lanzar la fotografía del código (commit):

git commit -m "Este es mi primer commit"

SIEMPRE hay que meter comentarios en commit.

Y saldrá --> create mode 100644 hellogit.py
Este es un hash del fichero.

Para ver si se ha lanzado:

git log

Si se crea otro archivo y queremos hacer otra fotografía:

git add hellogit2.py

 git commit -m "Este es mi segundo commit"

//Comprovamos:
git log

Ahora tendríamos 2 ficheros:

main --> primera rama con hellogit.py --> Segunda rama con hellogit.py y hellogit2.py

Ahora podría moverme por las ramas para ir viendo que hay en cada uno.
Si modificamos uno:

git status

Nos dice que hay una modificación de uno de los archivos ( o de los que se hayan modificado).

Para borrar los cambios y volver a como lo teníamos antes:

git checkout hellogit2.py

No situaremos en un punto concreto. Es para cuando no he hecho la fotografía. Por ejemplo:

print("Holi")

No me gusta y quiero volver a cómo lo tenía antes, pues uso git chekout. Esto sirve siempre y
cuando no haya hecho git commit de esta modificación.

Para borrar una fotografía:

git reset

Y nos saldrá el archivo que podemos tocar.

Hacemos otro cambio:

print("Hago cambios")

Ahora lo guardamos:

git add hellogit.py

Y ahora commit:

git commit -m "He actualizado este archivo"

git log

Para ver el listado de otra manera:

git log --graph #Lo veríamos como una rama

git log --graph --pretty=oneline #Todo seguido en una línea

git log --graph --decorate --all --oneline

Git Alias

git config --global alias.tree "log --graph --decorate --all --oneline"

Y en el fichero de configuración, sale el alias.

GitGnore

git status
//Vemos un fichero .DS_Store (es temporal que se autoregenera)
touch .gitignore //Archivo oculto de git ignore y lo veremos en rojo en
nuestro proyecto. No se tendrán en cuenta. Se crea en la raiz del proyecto.
//Aquí meteremos lo que no queremos subir.
**/.DS_Store --> Le indicamos que cualquier fichero con este nombre vaya a git
a la fotografía. Esto lo escribimos en Visual Studio Code.

Ahora se ve .gitignore y lo podemos añadir como fotografía:

git add .gitignore

git commit -m "Se añade el .gitignore"
git statuts --> Ya no hay nada que comitear.

El árbol de trabajo ya está limpio.

Rama, esto significa que ahora mismo tenemos diferentes ramas porque hemos hecho
diferentes commits. Siempre estamos en la parte final de la rama. Sin olvidar que
podemos ver en otras ramas anteriores.
En VSC:

print("New hello git with changes")

Para ver las diferencias :

git diff

Y nos muestra las diferencias entre el fichero original fotografiado y lo que hemos cambiado sin
llegar a realizar la fotografía.

Recordemos, el git log nos dice todos los ficheros que tenemos guardados. Y si queremos
volver a una rama anterior?

git checkout + hash de la fotografía

Nos dará error porque hay cambios. Y eso lo vemos con git status. Si queremos ver el fichero.

git checkout nombre del fichero

Volvemos a hacer :

git checkout + hash

Y ahora vamos al fichero y vemos que se "han perdido" los otros archivos que teníamos. Y es
porque hemos vuelto a la rama anterior.
Si queremos volver a la rama final:

git chechout HEAD

git log

Nos indica que la cabeza (HEAD) es donde nos encontramos ahora. El puntero es el primer
commit. Pero si queremos ir al final de la rama:

git chechout + hash del final

Y si hacemos git tree, veremos que el HEAD ha cambiado y vuelven los ficheros que habían
desaparecido.

GIT RESET HARD

 git tree ( es el alias para ver el git log )
//Veríamos las ID para movernos entre ellos.

El reset nos permite volver atrás, pero si nos equivocamos y queremos volver atrás y eliminar
dos commits.

git reset --hard + ID de donde queremos volver

//Nos dirá que la cabeza es ese ID.

Desaparece todo lo que hemos hecho hasta delante desde el ID.

Si ahora queremos recuperar el hard:

git reflog

Y nos sale el historial completo que hemos hecho en git y sale todo lo que hemos hecho.
Veremos también el último ID.

git chechkout + id que queremos volver

git tree
//Vemos que la cabecera ha vuelto al final de la rama.

git checkout main

//Volvemos hacia atrás otra vez. No estamos logrando llegar al punto.

git reset --hard + id de la cabeza final

git log
git tree
//Estamos al final otra vez.

Reseteando de nuevo el commit que hemos borrado, volvemos de nuevo adelante y hacia
atrás.

GIT TAG
Sirve para hacer referencia a algo o etiquetar:

git tag clase_1

git log //Y vemos HEAD -> main, tag:clase_1

Ahora este punto, tiene un nombre identificativo.

 git tree // Vemos el tag también

Creamos un nuevo fichero llamado hellogit3.py

git statuts
git add . //añade todo lo que tengamos pendiente
git status //Vemos el nuevo fichero añadido
git commit -m "Este es mi quinto commmit"

Ahora tenemos un nuevo fichero con un ID asociado y el head pasa a esta rama. Se mueve el
head y el main pero no el tag.

git tags //Nos sale el listado de tags.

git chechkout tags/clase_1
git tree //Nos hemos movido al tag sin necesidad de saber el ID.

Esto establece flujos de navegación.

git checkout main // Volvemos al final de nuevo

GIT BRANCH y GIT SWITCH

A nivel de comandos, git usa el concepto de branch. Hasta ahora hemos estado con la
rama main.

Cuando queremos hacer algo que no tiene sentido hacer en la rama donde nos encontramos.

git branch login //Con el nombre de la rama que queremos.

git tree //El head sigue apuntando igual.
git switch login //Cambiamos a la rama login. Lo veremos en el bash.
git tree //Veremos head -> login

Esta rama irá paralela al anterior commit. Tendremos un nuevo flujo de trabajo.
Ahora podremos trabajar en un flujo distinto.
Creamos un nuevo fichero llamado login.py y codeamos lo que queremos.

git add .
git commit -m "Login"
git status

Ahora tenemos un nuevo commit en la rama login.

Si hacemos git log o git tree podemos ver el nuevo commit.

git switch main //Volvemos a la rama main

Ahora el HEAD cambia al fichero último de la rama main.

GIT MERGE
Los equipos han seguido trabajando, pero quiero saber qué hace el otro equipo. Para ver
compatibilidades entre ramas.
 git merge main //Nos pide un commit

Y en la rama loggin, vemos actualizados los ficheros de la rama main cuando abrimos el
proyecto en VSC.

git log // Vemos el merge de main into login

CONFLICTOS EN GIT
Si hacemos un merge y vemos que pone conflicto con una cruz roja. Esto pasa cuando
ambos han tocado el mismo fichero y la misma línea de código. Si se tocan líneas
diferentes, no hay problema, pero cuando se toca la misma línea de código.
En el editor veremos los conflictos entre los cambios.
Se borra los cambios que no queremos o que están mal.

git commit -m "Corrección conflicto"

git status //Sale como otra vez modificado
git add .
git commit -m "Correción conflicto"
git status //En verde correctamente
git log //Esta todo con la corrección

GIT STASH

git stash // Hacer un commit de una manera temporal que queda reflejado en tu
local pero no afecta al árbol

git stash list //Veo lo que tengo en los stash

Podemos ahora cambiar de rama con:

git switch main //Hago lo que quiero en main

Y ahora para recuperar lo que hemos guardado con stash:

git stash pop // Y lo recuperamos y nos avisa de cambios.

REINTEGRACIÓN DE RAMAS DE GIT

Si ahora queremos juntar las ramas:

git switch main

git diff login //Nos sirve para ver que hay de nuevo en la rama login.
git merge login // En la rama main, ahora veremos el fichero del login
git status // Nos dice que está todo correcto
git checkout main
git status
git checkout login.py //Vuelvo a dejarlo como estaba.
git switch login //Volvemos a la rama login.
git add .
git commit -m "Modificiado el login.py"
git siwtch main // Volvemos al main
git merge login //Ahora nos dice que no hay errores.
git status
git add .
git commit -m "Mergeado el main y el login"

ELIMINACIÓN DE RAMAS
Una vez una rama cumple su función y queremos eliminarla:

git branch -d login

Ahora nos cargamos la rama llamada login.

 git branch

git reflog //Vemos todo lo que hemos hecho y los ID.

git checkout + id
git tree //Sale que la rama borrada aparece al hacer el checkout.
git checkout main
git tree

Pero si hacemos un switch, no podremos ir a la rama pero si podemos ir con los checkout.