git --version -----------> Saber que version tenemos

-----------------------------------------------------------------------------------
----------------------------------
En consola el anteponer -- significa que viene una palabra completa (ej: --version)
y anteponer un solo guión - (ej: -m) significa que viene una abreviatura
-----------------------------------------------------------------------------------
----------------------------------

git --help --------------> Ayuda de Git

ej: git --help config

Configuracion de usuario inicial:

---------------------------------

git config --global user.name "nombre de usuario"

git config --global user.email "correo@dominio.com"

Par averificar datos de usuario y/o modificarlos:

git config --global -e

Para modificar se apreta tecla "A" y se modifica lo necesrio. Despues para salir se
apreta ESC (escape) 1 vez, luego se ingresa por teclado los 2 puntos ":" seguido de
"w" para grabar y "q" para salir. Tambien "!" para que lo haga inmediatamente. O
sea para guardar y salir seria:
:wq!

para salir:
:q!

------------------------------------------------------------

Inicializar GIT:
----------------

git init: inicializa GIT.

git status: Da informacion sobre los commits y archivos en la rama en la que nos
encontramos y muestra archivos a los que no se les da seguimiento en rojo.

git add ./<nombre de archivo>: Definimos a que archivos se les dan seguimiento
marcandolos en verde. Con el punto agrega todos los archivos o con el nombre del
archivo en particular para seleccionar 1 solo. Si usamos git add . sube todos los
archivos al stage para seguimiento.

git reset <nombre archivo> ------> Saca del stage un archivo que no quiero agregar
al stage agregado con el add anteriormente. Si use git add . y habia 1 archivo o
carpeta a la que no queria darle seguimiento hago un git reset <nombre> y la quita

git commit -m "comentario" --------------> realiza el commit o fotografia del

momento en concreto y deja preparado para subir el proyecto. Cada commit es una
fotografia del momento actual

---------------------------- IMPORTANTE ----------------------------

git checkout -- . --------------> Reconstruye el proyecto a como estaba el ultimo

commit guardado (SOLO los archivos con seguimiento que estaban dentro del commit)

---------------------------------------------------------------------

git branch -----------> muestra todas las ramas y con asterisco en que rama estamos
posicionados

git branch -m master main --------------> cambia el nombre de la rama de master a

main

git config --global init.defaultBranch <nombreDeLaRama> -----------> Cambia de

forma GLOBAL el nombre de la rama por defecto de master a main para que siempre se
inicialice con la rama main

git commit -am "comentario" ---------------> la a es de add, añade al stage todos

los archivos QUE YA TENGAN SEGUIMIENTO y agrega el mensaje "". Esto me ahorra tener
que hacer git add . y despues el git commit, se hace todo en el commit con -am

git log -------------> muestra el log de todos los commit hechos

---------------------------- IMPORTANTE ----------------------------

Cuando necesito crear una carpeta vacia que GIT Debe mantener SI O SI entonces creo
adentro un archivo llamado .gitkeep que no contiene nada pero va a servir para que
GIT la agregue al stage y la suba

------------------------- Formas de agregar contenido con ADD

-------------------------

git add css/ --------------> Al no poner nada despues de la barra / va a sumar TODO
el contenido de la carpeta al stage

------------------------- Modificadores -------------------------

Los comandos tienen modificadores para poder ampliar o reducir informacion. Por
ejemplo git status tiene su modificador --short para que me muestre informacion mas
reducida

git status --short

------------------------------------ IMPORTANTE
------------------------------------

------------------------- Creando ALIAS para los comandos -------------------------

Puedo crear alias personalizados para poder escribir comandos que utilizo siempre
de una forma mas corta
git config --global alias.<miComandoPersonalizado> "<ComandoQueDispara>"

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

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 lg -------------> ahora dispara con este alias info resumida pero precisa del
log

------------------------------------VER MODIFICACIONES
------------------------------------

git diff ------------> veo las modificaciones entre archivo sin modificar y
modificado

Si yo hago un git add . ya no voy a ver nada con git diff porque no tiene contra
que comparar, en ese caso tengo que ejecutarlo con la siguiente bandera:

git diff --staged ----------> compara el archivo enviado al stage contra el

anterior estado

------------------------------------ COMMITS ------------------------------------

git commit -am "Instalaciones actualizadas" -----------> es la forma corta de sacar
"la foto" agregando al stage y hacer el commit. a de add y m de mensaje del commit.

Modificar el mensaje del commit si esta mal

-------------------------------------------

git commit --amend -m "nuevo_mensaje" ----------------> modifica el mensaje del

ultimo commit por uno nuevo

---------- IMPORTANTE ------------

Si ya hice el commit y modifico algo mas despues y tiene que estar adentro de ese
commit que yo ya nombre ejecuto esto para deshacer el commit y pararme en el punto
anterior al add . (esto pierde el log):

git reset --soft HEAD^ -----------> Agrega las ultimas modificaciones al commit que
acabo de crear (sin haber hecho push).

Si en cambio quiero modificar 2 commits anteriores:

git reset --soft HEAD^2

Si quiero modificar n commits anteriores:

git reset --soft HEAD^n

---------- IMPORTANTE ------------

Modificar commit con editor:

git commit --amend ------------> abre el editor. Se presiona la tecla "a" para
insertar, se borra y escribe lo que se necesita y se presiona ESC y despues para
salir :wq!

git reset --soft 52fe493 ---------------> el HASH que es el numero hexa es el punto
exacto al que me quiero mover para poder volver a escribir el commit en caso de
querer añadir modificaciones al commit que hice

git reset --mixed <hash> ------------------> vuelve al commit indicado sacando TODO
del stage. Esto no es destructivo ya que deja pendiente las modificaciones que se
hicieron hasta el momento.

git reset --hard <hash> ------------------> vuelve al commit indicado sacando TODO
del stage. Es destructino, no mantiene NINGUNA modificacion que se haya hecho hasta
ese punto, vuelve todo atras hasta ese punto.

---------- RECUPERAR DATOS ------------

git reflog ---------------------> contiene un log de referencias de todo lo que se

hizo en orden cronologico. Con este comando recupero el HASH al que me quiero
desplazar y luego hago:

git reset --hard <hash_recuperado>

CAMBIAR NOMBRE SIN PERDER LOG:

git mv <archivo.extencion> <archivo_nuevonombre.extencion>

De esta forma lo mueve al mismo lugar cambiando el nombre y GIT mantiene el log del
archivo mal nombrado y del renombre. Si se hace git log se ve que perduran los 2
movimientos

ELIMINAR ARCHIVO:

git rm <archivo>

Hacer esto sigue manteniendo el archivo en el stage. Para decirle a GIT que marque
como eliminado ese archivo hay que introducir un commit, de esa forma lo elimina
del stage

------------------------------------ IMPORTANTE
------------------------------------

GIT REFLOG ---------------------> muestra historial COMPLETO de cambios hasta

eliminados

------------------------------------ IMPORTANTE
------------------------------------

-----------------------------------------------------------------------------------
--------------------
------------------------------------------------ RAMAS
------------------------------------------------
-----------------------------------------------------------------------------------
--------------------

git branch rama-villanos --------------------> crea una nuevarama llamada rama-

villanos

git branch ------------> me muestra todas las ramas y marca con * en que rama estoy
posicionado

git checkout rama-villanos ------------> Me muevo a la rama rama-villanos

------------------------------------ MERGE ------------------------------------

Para hacer el merge se debe estar en la rama que se quiere mantener como principal
y desde la cual se van a llamar a los cambios de otra rama. Ejemplo si tengo main
por un lado, rama1 y rama2 y quiero hacer merge de la rama2 HACIA main tengo que
pararme primero en main (git checkout main) y desde ahi hacer un git merge rama2

git merge <nombre_rama> ------------> Une la rama <nombre_rama> a la rama sobre la

que estoy parado

---------------------------- Eliminar RAMAS ----------------------------

git branch -d rama-villanos -----------------> borra la rama seleccionada

Si hay cambios sin unir a ninguna rama y queremos borrarla de manera forzada:

git branch -d rama-villanos -f

Para crear una rama Y A LA VEZ moverme a esa rama:

git checkout -b <nombre_rama>

------------------------------------ IMPORTANTE
------------------------------------

git reflog --------------> ME MUESTRA TODO EL HISTORIAL DE COMMITS POR MAS QUE SE
ELIMINEN

------------------------------------ IMPORTANTE
------------------------------------
---------------------------- TAGS ----------------------------
Se usan por lo general para versionar la aplicacion en los momentos de crear los
ejecutables en el tiempo

git tag <nombre_que_deseo>

git tag --------------> veo todos los tags que se crearon

Para borrar un tag

------------------

git tag -d <nombre_del_tag>

Para versionado
---------------

git tag -a v1.0.0 -m "Version 1.0.0 lista" ---------> el -a es de anotacion para

el numero de version y el -m para dejar un mensaje al crearlo.

versiones: va.b.c
a: cambios importantes o mayores en la aplicacion, version mayor y puede romper con
la aplicacion anterior
b: estos son añadidos de nuevas funcionalidades, actualizacion de un paquete o
libreria
c: arreglos de bugs, arreglos menores pero de soluciones de errores o fallos

Añadir TAG a commit existente:

------------------------------

git tag -a v0.1.0 de470ed -m "Version Alpha de nuestra app" --------------> el HASH
del commit va al final

para ver mas info sobre el tag en particular:

--------------------------------------------
git show v0.1.0 ----------> al final va el numero de version de tag. Aca veo quien
lo creo, que comentario tiene y los cambios que se habian hecho en ese punto

SI QUIERO HACER PUSH DEL TAG:

git push --tags