Introducción a Git

1

¿Por qué usar un sistema de control de versiones como Git?

2

¿Qué es Git?

3

Instalando Git y GitBash en Windows

4

Instalando Git en OSX

5

Instalando Git en Linux

6

Editores de código, archivos binarios y de texto plano

7

Introducción a la terminal y línea de comandos

Comandos básicos en Git

8

Crea un repositorio de Git y haz tu primer commit

9

Analizar cambios en los archivos de tu proyecto con Git

10

¿Qué es el staging y los repositorios? Ciclo básico de trabajo en Git

11

¿Qué es branch (rama) y cómo funciona un Merge en Git?

12

Volver en el tiempo en nuestro repositorio utilizando reset y checkout

13

Git reset vs. Git rm

Flujo de trabajo básico en Git

14

Flujo de trabajo básico con un repositorio remoto

15

Introducción a las ramas o branches de Git

16

Fusión de ramas con Git merge

17

Resolución de conflictos al hacer un merge

Trabajando con repositorios remotos en GitHub

18

Cambios en GitHub: de master a main

19

Uso de GitHub

20

Cómo funcionan las llaves públicas y privadas

21

Configura tus llaves SSH en local

22

Conexión a GitHub con SSH

23

Tags y versiones en Git y GitHub

24

Manejo de ramas en GitHub

25

Configurar múltiples colaboradores en un repositorio de GitHub

Flujos de trabajo profesionales

26

Flujo de trabajo profesional: Haciendo merge de ramas de desarrollo a master

27

Flujo de trabajo profesional con Pull requests

28

Utilizando Pull Requests en GitHub

29

Creando un Fork, contribuyendo a un repositorio

30

Haciendo deployment a un servidor

31

Hazme un pull request

32

Ignorar archivos en el repositorio con .gitignore

33

Readme.md es una excelente práctica

34

Tu sitio web público con GitHub Pages

Multiples entornos de trabajo en Git

35

Git Rebase: reorganizando el trabajo realizado

36

Git Stash: Guardar cambios en memoria y recuperarlos después

37

Git Clean: limpiar tu proyecto de archivos no deseados

38

Git cherry-pick: traer commits viejos al head de un branch

Comandos de Git para casos de emergencia

39

Git Reset y Reflog: úsese en caso de emergencia

40

Reconstruir commits en Git con amend

41

Buscar en archivos y commits de Git con Grep y log

Bonus sobre Git y Github

42

Comandos y recursos colaborativos en Git y GitHub

43

Tu futuro con Git y GitHub

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Tags y versiones en Git y GitHub

23/43
Recursos

Los tags o etiquetas nos permiten asignar versiones a los commits con cambios más importantes o significativos de nuestro proyecto.

Comandos para trabajar con etiquetas:

  • Crear un nuevo tag y asignarlo a un commit: git tag -a nombre-del-tag id-del-commit.
  • Borrar un tag en el repositorio local: git tag -d nombre-del-tag.
  • Listar los tags de nuestro repositorio local: git tag o git show-ref --tags.
  • Publicar un tag en el repositorio remoto: git push origin --tags.
  • Borrar un tag del repositorio remoto: git tag -d nombre-del-tag y git push origin :refs/tags/nombre-del-tag.

Para generar un comando complejo con varios comandos de una forma optimizada, utilizamos conjuntos de sentencias conocidas como alias.

Cómo aregar un alias solo para git

  • Para un proyecto:
git config alias.arbolito "log --all --graph --decorate --oneline"
  • Global:
git config --global alias.arbolito "log --all --graph --decorate --oneline"
  • Para correrlo:
git arbolito

Aporte creado por: Jorge Sarabia

Aportes 578

Preguntas 107

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Ejecutan este comando en la terminal y queda guardado en los alias pero de git. con esto se puede ejecutar cada que se escribe git superlog

git config --global alias.superlog "log --graph --abbrev-commit --decorate --date=relative --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"

Apuntes 😃

La minilección sobre alias de Freddy me hizo recordar a este memazo:
(NO LO INTENTES EN CASA, mejor busca su significado si no entiendes).

También se puede agregar un alias solo para git:
Para un proyecto:
git config alias.arbolito "log --all --graph --decorate --oneline"

Global:
git config --global alias.arbolito "log --all --graph --decorate --oneline"

Para correrlo:
git arbolito

git push origin :refs/tags/nombretags -> Para eliminar tags en el repo remoto

git log --all: Muestra toda la historia de commits de nuestro proyecto
git log --all --graph: Además de mostrar la historia de commits muestra gráficamente las ramas
git log --all --graph --decorate --oneline: Muestra la historia de commits y ramas de manera compacta
git tag -a nombre-del-tag -m “Mensaje del tag” id-del-commit: Creamos un tag y asignarlo a un commit
git tag: Muestra la lista de todos los tag
git show-ref --tags: Muestra la lista de tags y a que commits están asignados
git push origin --tags: Envía un tag a un repositorio remoto
git tag -d nombre-del-tag: Borra un tag en el repositorio local
git push origin :refs/tags/nombre-del-tag: Borra un tag en el repositorio remoto

El comando que utilizó Freddy solo sirve para crear un alias temporal, estará vigente mientras no se cierre la terminal. El comando de ALIAS que uso Freddy solo funcionara de forma temporal mientras la terminal siga abierta si no de lo contrario al volverla abrir se perderá el ALIAS, en mi caso en macOS tengo que agregarlo al archivo .zshrc (estoy usando en shell ZSH no el Bash que viene por defecto). Por lo general esta en ~/.zshrc hay que modificarlo con cualquier editor y colocar al final el ALIAS que se quiera agregar (para que sea mas facil ubicar los ALIAS) por ejemplo:
alias arbolito=git log --all --graph --decorate --oneline
y listo ahora tendrás configurado ese ALIAS de forma global 😉👍🏻 Y podremos seguir agregando todos los que quieras.

Aqui mi aporte 😄

Uso de Alias
alias nombre=‘codigo’ aqui se le asigna a la variable nombre el codigo que queremos resumir, por ejemplo alias arbolito="git log --all --graph --decorate --oneline"
unalias nombre sirve para borrar un alias creado

Listado de todas Tags disponibles

git tag enumera todas las etiquetas disponibles
search tags sirve para buscar versiones especificas y si se usa * nos mostrara todas las subversiones por ejemplo git tag -l “v1.8.5*”

Crear, borrar y empujar Tags en GIT

git tag tagName Esto creará una tag local con el estado actual de la rama en la que se encuentra
git tag -d tagName Borrar un tag en el repositorio local
git tag tagName idCommit Esto creará una tag local con el identificador de la rama en la que se encuentra.
git push origin :refs/tags/tagName Borrar un tag del repositorio remoto

Empuje un commit en GIT

git push origin tagName Empuje una etiqueta individual
git push origin --tags Empuje todas las etiquetas a la vez

Pueden conocer todo los alias disponible escribiendo el comando alias.

El comando que utilizó Freddy solo sirve para crear un alias temporal, estará vigente mientras no se cierre la terminal.

Si queremos que el alias sea permanente, debemos buscar un archivo llamado .bashrc si usas bash en la terminal (Por defecto en todas las distros Linux) o buscar un .zshrc si tienes una shell zsh (instalada en mac), por lo general este archivo está oculto en nuestra carpeta principal.

Ahora para hacer el alias permanente debemos agregar al final del archivo el mismo comando que utilizó Freddy
alias arbolito=git log --all --graph --decorate --oneline, guardas el archivo y listo, ya está permanente el alias.
Se pueden agregar al archivo tantos como queramos.

Si quieren eliminar el alias el comando es

unalias nombre-del-alias

¡Hola!
Aquí comparto mis notas de la clase:

  • Se pueden crear alias: alias nombre="comando git"

    Los TAGS son realmenta utiles en Github.

  • Crear un nuevo TAG:
    Se crea con la siguiente estructura: git tag -a nombre-del-tag -m “mensaje / comentarios” id-del-commit
    Ejemplo:

  • El comando git tag nos muestra los tags existentes:

  • Referencias de los tags con el comando git show-ref --tags

  • Empujar a nuestro repositorio en Github los tags que creamos:

  • Se pueden checar los tags creados en Github en el repositorio en cuestión:

  • Borrat tags desde la consola en Git: git tag -d "nombre del tag"
    Ejemplo:

  • Borrar referencia allá en el origen (Github) conectado con nuestra referencia: git push origin :refs tags/nombreTag
    Ejemplo:

Este es el arbol que yo uso! Lo tengo con el alias de slog (superlog):

Para llamarlo, he creado el alias slog en git. De esta manera, lo llamo con git slog
Si quieren copiarselo, pueden usar este comando para agregarlo a su configuracion:

$git config --global alias.ALIAS "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

En donde dice alias.ALIAS, cambian el ALIAS por el nombre que le quieran poner. De esa manera lo pueden llamar en la consola con git ALIAS

😃

En linux pueden usar alias para facilitar el uso de los comandos: Los alias son variables como ~.

Éstos son mis alias para git:

# alias para git
alias gta='git add .'
alias gtc='git commit -m'
alias gts='git status'
alias gtl='git log'
alias ggraph='git log --all --graph --decorate --oneline'
alias gtp='git pull origin'
alias gtb='git branch'
alias gtck='git checkout'

Yo trate de crear un alias global con git config --global alias-[nombreAlias] “comando”, pero no me funciono, aunque no da error al crearlo al llamarlo decía que no había un comando asignado, googlee un poco y encontre que se puede añadir los alias directamente en el archivo .gitconfig (esta en el home) y este si que funciona. entonces lo que hare es ir copiando los alias a un documento aparte para tener esto de respaldo y cuando necesite configurar de nuevo el git usar git en otro equipo, puede copiar mis alias y trabajar mas comodamente… debo decir que yo ya he trabajado con git desde hace un tiempo, pero como dice Freddy en el primer video me habia conformado con hacer pull y push, este curso es… geniall

Según la página oficial de Git en la sección de Alias, el comando para guardar un alias y que no se borre cuando se reinicia la máquina es:

git config --global alias.NOMBRE_ALIAS 'COMANDO_DEL_ALIAS'

Entonces el ejemplo que utiliza Freddy sería así:

git config --global alias.arbol 'log --all --graph --oneline'

Espero les sirva.

Muy buena explicación

git log
git log --all
git log --all --graph
git log --all --graph --decorate --oneline
alias arbolito="git log --all --graph --decorate --oneline"
git tag -a v0.1 -m "Resultado de las primeras clases del curso" 9f98e8f
git tag
git show-ref --tags
git status
git pull origin master
git push origin --tags
git tag
git tag -d Dormido
git pull origin master
git push origin :refs/tags/Dormido

Asi como recomendacion general, es bueno colocar la ‘v’ del tag en mayuscula, o sea, V0.1

chicos les recuerdo que si quieren tener un ALIAS PERMANENTE en windows ejecuten los siguientes comandos que aparecen en esta pagina web:
https://styde.net/alias-de-comandos-para-la-consola-windowslinuxmac/

Para los que no les funcione lo del alias por alguna razon:
git config –global alias.[ElAliasQueLeQuierasColocar] ‘log –all –oneline –graph –decorate’

Y para ejecutarlo: git [ElAliasQueColocasteAnteriormente]
Ejemplo: git config --global alias.arbolito 'log --all --oneline --graph --decorate’
Y al ejecutarlo: git arbolito

Excelente explicación, Git es súper interesante, los tag son muy usados para los despliegues, ayudan a devolverse fácil de versión de una aplicación. Acá hay un artículo de la página oficial de Git en donde trabajan con Tags, para quién guste leerlo.

**********************************
***************TAGS***************
**********************************

git log --all(Muesta toda la historia)
git log --all --graph (Muestra toda la historia con la ineracción de las ramas)
git log --all --graph --decorate --oneline
alias arbolito="git log --all --graph --decorate --oneline"(forma de alias en linux)

git tag -a v0.1 -m "apendiendo tags en git" (hash del commit) (crear un tag)
git show-ref --tags

git push origin --tags (enviar los tags al repositorio remoto)
git tag -d v0.1   && $ git push origin :refs/tags/v0.1 (Borrar tags)


**********************************
***************TAGS***************
**********************************```

Las etiquetas o tags son identificadores que podemos asignar a ciertos puntos del historial de commits de nuestro proyecto. Se usan para dar nombres de versiones a nuestro proyecto (Por ejemplo v1.0).

Creando un tag en Git:

git tag -a <version-o-release> -m "<mensaje-explicativo>" <commit-de-tu-tag>

Ver referencia de los commits a los que están conectados mi tags:

git show-ref --tags

Enviando tags al repo remoto: Posterior a un git pull (Como buena práctica) ejecutamos:

git push origin --tags

Borrando un tag de mi repo local:

git tag -d <nombre-de-tu-tag>

Enviándole a GitHub la información de tu tag eliminado:

git push origin :refs/tags/<tu-etiqueta>


De esta forma se puede guardar el alias de forma global. En este caso “lg” seria el “arbolito” que hizo Freddy en el ejemplo.

Para dejar los alias para siempre yo coloque la siguiente linea
git config --global alias.arbolito “log --oneline --decorate --all --graph”

Y me funciono perfecto…

Crear un Tag
git tag -a NOMBRETAG -m “COMENTARIO” IDCOMID/HASH
Saber que commit tiene cada Tag
git show-ref --tags

Subir Tag a GitHub (Primero debe estar creado):

  1. Verificar que se tengan los cambios en nuestro repositorio:
    git pull origin master
  2. Eviar Tag a Github:
    git push origin --tags

Borrar Tags:
En local: git tag -d NOMBRETAG
Borrar Tag de GitHub: git push origin :refs/tags/NOMBRETAG

Comando para ver los commits (id) de manera mas simple:
git log --all --graph --decorate --oneline
Para guardarlo dentro de un alias:
alias arbolito=“git log --all --graph --decorate --oneline”

Comandos aprendidos en la clase:

  • alias: se usa para resumir los comandos que nos de flojera escribir, se usa así: alias nombre_de_alias=“git log --all --graph --decorate --oneline”

  • git tag: se usa para crear tags, versiones o referencias en tu proyecto, se suele usar de esta forma: git tag -a v0.1 -m “versión 0.1 del archivo” 4b0d564
    también podemos usar -b para borrar algún tag, escribiendo git tag -b nombre_del_tag.
    ese último es lo que aparece cuando hacemos un commit.

  • git tag: con este sabemos que tags tenemos

  • git show-ref --tags: nos muestra el tag que está asignado al commit en el que tenemos el tag

  • git push origin --tags: nos enía los tags que tenemos en el local al repositorio remoto

  • git push origin :refs/tags/nombre_del_tag: nada que decir, borramos los tags del repositorio remoto jaja

Aca les dejo un SuperLog que me enseño el sensei Mike Nieva

git log --graph --abbrev-commit --decorate --date=relative --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

Más fácil usar “git push origin --delete nombre_tag”, comando que también sirve para borrar ramas en remoto

yo también lo llamé arbolito 😂

los alias creados, de la manera que muestra Freddy, son temporales
para crearlos con tiempo indefinido hay que ponerlos en un archivo del sistema, acá hay un tutorial:
https://www.youtube.com/watch?v=UynEQk52pMk

¡LOS ALIAS SON UNA HERRAMIENTA MUY ÚTIL PERO CADA QUE INICIO GIT BASH YA NO ESTÁN!!
Si quieres agregar un alias y que permanezca guardado para tus futuras sesiones sigue estos pasos:

  1. Crea un archivo en HOME llamado .bashrc Puedes hacerlo desde linea de comandos con touch .bashrc (recuerda que debe ser en HOME, asi que no esta de más dar un cd ~)
  2. Por defecto, Git te creara otros archivos (o yo no me habia dado cuenta que existieran antes de hacer el paso 1😅 ): .bash_profile y .bash_history
  3. Entras al editor de texto VIM, a Visual studio code o directo en boc de notas del archivo .bash_profile y agregas el siguiente texto:
alias arbolito='git log --all --graph --decorate --oneline'
alias ver='ls -lh'

O cualquier alias que quieras agregar para tu comodidad.

  1. Guardas el archivo.
  2. Prueba en git bash y disfruta

😎🤙

Excelente clase, cada vez le estoy perdiendo el miedo a la consola, y es tan gratificante que cuando realizo el ejercicio con mis propias notas después de ver el vídeo, me salga sin problemas.

Tags y versiones en Git y GitHub
Para aprender a hacer tags o versiones del proyecto debemos de revisar la historia de nuestro proyecto
git log --all Nos muestra todo lo hecho históricamente (ya que en ocasiones no nos muestra todo dependiendo de qué branches han ocurrido)

git log --all --graph Este nos muestra de una forma visual como han funcionado las ramas

git log --all --graph --decorate --oneline Este nos muestra todo mucho más comprimido

alias arbolito=“git log --all --graph --decorate --oneline” Esto nos permite llamar este comando solo escribiendo ‘arbolito’ en git.

Para crear la version de nuestro proyecto primero mostramos el arbol, copiamos el hash del commit al cual queremos nombrar como versión y luego escribir el siguiente comando git tag -a v0.1 -m “Resultado de las primeras clases del curso” #examplehash.

Al escribir git tag nos muestra la lista de todos los tags, pero la forma de saber a que hash o a que commit esta conectado un tag es con git show-ref --tags y al hacer esto nos muestra primero el commit y luego el tag al que esta asignado.

git push origin --tags Esto significa que vamos a empujarle a origin (nuestro repositorio en github) los tags que creamos

git tag -d exampletag Este nos permite borrar un tag

La razón por la cual el tag no se borra de github al hacer un git push origin --tags cuando ya hemos eliminado el tag es porque los tags se pueden usar como releases (es la forma en que categorizas que algo esta listo) aunque lo borremos internamente tiende a quedar en github.

La manera especial para borrarlo de github es con git push origin :refs/tags/exampletagtodelete esto es una sintaxis interna que borra la referencia en mi repositorio conectado con nuestra referencia de cuando borramos el tag.

MIS NOTAS
Como sistema de control de versiones, Git nos deja ver los estados por los que han pasado sus archivos de manera global (no de un archivo concreto) y con un tag podemos etiquetar el estado del repositorio completo, algo que se suele hacer cuando sale una nueva versión del software. El desarrollador es el que determina las versiones y se recomienda asignarlas un valor semántico.

Podemos dividirlas en tres categorías: mayor, menor y pequeño ajuste. Por ejemplo, si comenzamos el proyecto con una versión 0.0.1 y realizamos un cambio en el que la funcionalidad es la misma y no cambia la interfaz, lo que se aconseja es versionarlo a la 0.0.2. Si cambia la funcionalidad, pero es totalmente compatible con la anterior, podemos pasar de la 1.0.0 a la 1.1.0. Pero si los cambios que realicemos no son compatibles con la versión anterior y cambia considerablemente, el número a utilizar deberá de ser más relevante y podemos, por ejemplo, pasar de una versión 1.1.5 a una 2.0.0.
Espero que les guste y cualquier cosa me comentan si me falto o me pase de alto algo que no halla visto

Para ver el funcionamiento de las ramas / branches:

$ git log --all --graph 
//también 
$ git log --all --graph --decorate--oneline
// truco de Linux:
//					 I──Comando
//					V
$ alias _________="_________"
//     ^──Nombre que quieras para el comando	

Para crear un tag:

  1. Copiar el hash del commit que queramos:
$ git tag -a ___________ -m "___________" _________
//		    ^──Nombre del tag			^──Hash

Para enviar nuestros tags al repositorio de GitHub:

1. $ git pull origin master
2. $ git push origin --tags

Para eliminar tags del repositorio local:

$ git tag -d _________
//			^──Nombre del tag que se quiere borrar

Para eliminar tags del repositorio remoto:

  1. Hacer paso anterior
$ git push origin :remote/tags/________________
//						^──Nombre del tag que se quiere eliminar
  • git log --all --graph --decorate --oneline = muestra el historias de repositorio peor decorando y comprimiendo todo
  • alias NOMBRE_DEL_ALIAS = “AQUI VA TODO EL CODIGO DE GIT”
  • git tag -a nombre-del-tag id-del-commit. = Crear un nuevo tag y asignarlo a un commit.
  • git tag -d nombre-del-tag = Borrar un tag en el repositorio local.
  • git tag o git show-refs --tags = Listar los tags de nuestro repositorio local.
  • git push origin --tags = Publicar un tag en el repositorio remoto.
  • git tag -d NOMBRE_DEL_TAG = Ellmina el tag de manera local
  • git push origin :refs/tags/nombre-del-tag = Borrar un tag del repositorio remoto.

📌 git tag permite tener un nombre que apunta a un commit, esto marcar un punto específico en la historia de un repositorio.

Los alias sólo permanecen creados en una sesión. Si cerramos la terminal y abrimos otra, este anterior alias no funcionará. Para que se queden almacenados hay que modificar el ** .bashrc ** y escribir el alias ahí. Si usas otra shell, en mi caso Zsh, deberás modificar el archivo ** .zshrc **.

Puedes encontrar estos archivos en el directorio Home de tu Sistema operativo.

En Git, una etiqueta o tag sirve básicamente como una rama firmada que no permuta, es decir, siempre se mantiene inalterable. Sencillamente es una cadena arbitraria que apunta a un commit específico. Puede decirse que un tag es un nombre que puedes usar para marcar un punto específico en la historia de un repositorio.
https://www.genbeta.com/desarrollo/tags-con-git

Comparto este post en inglés para configurar los alias (arbolito) y mantenerlos en la consola.
https://kurtdowswell.com/software-development/git-bash-aliases/
Espero que a alguien le sirva!
Nunca pares de aprender!

Para profundizar en los alias de git https://styde.net/crear-alias-de-comandos-con-git/

Les dejo un alias para que no escriban tanto:

alias push="git pull origin master; git push origin master"
alias push-tags=“git pull origin master; git push origin --tags”

😄

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

Por si están interesados en un super arbolito, un post de stackoverflow

Pretty git branch graphs

TODO SOBRE LOS ‘ALIASES’ 😃 😃
Hola, si han tenido problemas con los alias, espero que mi aporte los ayude.
Al crear un alias en Linux, el alias se crea de forma temporal, así que al terminar la sesión o cambiar de terminal, el alias deja de existir. Para crear alias persistentes, podemos seguir esta referencia.

# CREAR ALIAS 'TEMPORAL'
alias nombreAlias="comandos"

# EJEMPLO (crear comm!t más rápido)
alias comino="git commit -a"
# CREAR ALIAS PERMANENTE
# Dentro del directorio del usuario (~), buscamos el archivo .bashrc y lo abrimos con nuestro editor de preferencia
# Agregamos hasta el final del archivo el alias que queremos crear

# MIS ALIAS PERSONALIZADOS
alias nombreAlias="codigo"

# EJEMPLO
alias aguas="git log --all --graph --decorate --oneline"
# CREAR ALIAS EN ARCHIVO INDEPENDIENTE
# El archivo .bashrc ubicado en el directorio del usuario (~) incluye una línea que verifica si un archivo llamado .bash_aliases existe.
# Creamos el archivo .bash_aliases en la misma carpeta (~), y enel agregamos nuestros alias personalizados.



# Platiquemos de lo que gusten por telegram :D
# @ mauriicioreyes
# ¡Saludos, nunca paren de aprender!

Mi lista de alias para git:

alias ga='git add'
alias gaa='git add .'
alias gaaa='git add --all'
alias gau='git add --update'
alias gb='git branch'
alias gbd='git branch --delete'
alias gc='git commit'
alias gcm='git commit --message'
alias gcam='git commit -am'
alias gcaam='git commit --amend -am'
alias gcf='git commit --fixup'
alias gco='git checkout'
alias gcob='git checkout -b'
alias gcom='git checkout master'
alias gd="git diff -- . ':!*.min.js' ':!*.min.css' ':!*.min-rtl.css'"
alias gda='git diff HEAD'
alias gi='git init'
alias glg='git log --graph --oneline --decorate --all'
alias gld='git log --pretty=format:"%h %ad %s" --date=short --all'
alias gm='git merge'
alias gmn='git merge --no-ff'
alias gma='git merge --abort'
alias gmc='git merge --continue'
alias gpu='git pull origin'
alias gpr='git pull --rebase'
alias gpo='git push origin'
alias gpof='git push origin --force'
alias gr='git rebase'
alias gs='git status'
alias gss='git status --short'
alias gst='git stash'
alias gsta='git stash apply'
alias gstd='git stash drop'
alias gstl='git stash list'
alias gstp='git stash pop'
alias gsts='git stash save'
alias grs='git reset --soft'
alias grh='git reset --hard'
alias grsuo='git remote set-url origin'
alias gcue='git config user.email'
alias gcl='git clone'
alias grao='git remote add origin'
<h3>Tags y versiones en Git y GitHub</h3>
  • git log --all: Muestra todos los commits sin excepción.

    • git log --all --graph: Muestra los commits de una manera más gráfica.
    • git log --all --graph --decorate --oneline: Muestra los commits de manera gráfica y comprimido.
  • alias nombre = "comando": Le crea un alias o apodo al comando para que con pocas palabras o que nos acordemos más fácil del comando.
    Para que el alias sea permanente lo debes añadir a tu archivo de terminal que puede ser:

    • Bash → ~/.bashrc
    • ZSH → ~/.zshrc
    • Fish → ~/.config/fish/config.fish

    Si no has configurado personalizado la terminal lo más seguro es que el archivo sea Bash.

Los tag so

  • git tag -a nombre -m "mensaje" código commit: Crea un tag, lo normal es que en el nombre se coloque v. y el número.
  • git tag: Muestra los tags que hay.
    • git show-ref --tags: Muestra los tags especificando el commit.
  • git push origin --tags: Envía los tags al repositorio remoto.
  • git tag -d nombre: Elimina el tag nombrado en local.
  • git push origin :refs/tags/nombre: Elimina el tag nombrado en el repositorio remoto.

Para los que no se les guarda su alias, les comparto los pasos que realicé:

1) NOS VAMOS AL SIGUIENTE ARCHIVO:

Se encuentra en su disco local C, en la carpeta de Users, entran a su usuario y ahí pueden encontrar el archivo con nombre .gitconfig

C:\Users\maryf\.gitconfig 
  1. ABRIMOS EL ARCHIVO Y AGREGAMOS LA SIGUIENTE LINEA
[alias]
arbolito = log --all --graph --decorate --oneline

3) GUARDAMOS LOS CAMBIOS Y EJECUTAMOS EN LA CONSOLA

 git arbolito

Y LISTO, SALUDOS.

El comando alias me hizo por fin darme cuenta que tenemos super poderes

Cual es la forma para buscar con el teclado los comandos ya puestos anteriormente para no tener que volver a escribirlos?

Al crear alias como lo hizo Fredy, los mismos no se guardan al cerrar la consola. Para crear alias que no se borren debemos ir al archivo de configuracion de nuestra termina, por lo general esta en el home; si usas bash el archivo se llama .bashrc, si por el contrario usas zsh el archivo se llama .zshrc. Solo debes usar un editor de texto, en mi caso uso nano quedaria entonces: nano .zshrc <br>
Una vez allí, escoges un lugar del archivo en el cual crear todos tus alias, sigues los pasos que uso fredy para crearlo y listo. Reinicias la consola y ya tendras tus alias para siempre!

git pull sirve para traer todo lo que hay en nuestro repositorio remoto. pero si mi repositorio local es mas avanzado que el remoto, ¿hacer un pull borraría los avances de mi repositorio loca?

Para los que estamos utilizando bash (en windows), la forma mas fácil de colocar alias y que estos no se pierdan al cerrar la consola es:

  • en la ruta home ( ~ ) procedemos a editar el archivo .bashrc
vim .bashrc
  • al final del todo colocamos el alias
alias arbolito="git log --graph --decorate --oneline"
  • guardamos el documento cerramos la consola

  • abrimos nuevamente la consola y listo

  • ya funciona nuestro alias.

Para los que tienen dudas sobre los alias aquí esta un pequeño aporte.

Alias

Los alias dentro de git nos permiten crear shorcuts de nuestros comandos más usados. Por ejemplo para obtener un log del repositorio que me permita ver los movimientos entre ramas de forma gráfica deberíamos de usar este comando.

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

Pero al ser un comando muy largo de escribir y posiblemente difícil de recordar podemos asignarle un alias de la siguiente manera.

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

Y con esto la próxima vez que deseemos obtener los logs de esa forma sólo tendremos que escribir en nuestra terminal:

$ git lg

Bastante interesante la creación de alias.

Para remover un alias, podemos usar

unalias [nombreDelAlias]

Ejemplo:

unalias arbolito

Si por otro lado, queremos editar este alias para que tenga otro comando, basta con usar el mismo proceso de alias

alias arbolito='ls -l'

Muy interesante, no conocía el concepto “alias”

Con el comando ‘alias’ o ‘alias -p’ listamos los alias creados temporalmente.

Comparto la documentacion de git log ! para que lo chequeen , existen muchas variantes para personalizar el historial de nuestros commits .
https://git-scm.com/docs/git-log

Les dejo un enlace de como pueden crear los aliases ya sean temporales o permanentes en Ubuntu. Sirve para los que instalen la terminal de Ubuntu en Windows gracias a WSL.

https://ubunlog.com/alias-temporales-permanentes-comandos/

Ejecuta solo unas vez en tu terminal
usalo con el comando: git lg
😃

git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative" 

tú git con super poderes!!!

Si usan mac y estan usando oh-my-zsh en su terminal o iterm, para dejar permanente el alias (por que se va cuando cierran la terminal), busquen en su directorio home el archivo oculto (Shift + CMD + . ) .zshrc y ahi agregan alias arbolito=“git log --all --graph --decorate --oneline” guardan y listo ya pueden usar “arbolito” o lo que decidan poner, ademas de agregar mas alias, uno por linea.

Si al crear un tag nos equivocamos con la referencia del commit podemos ejecutar el siguiente comando.

Por ejemplo, si el tag 0.5 pertenece al commit cm_001, pero queremos que el tag haga referencia al commit cm_002 entonces sería

$ git tag -a 0.5 -fm 'Mensaje…' cm_002

Traer lo que hay en internet (git pull origin master) antes de mandar (git push origin master) es una buena práctica.

El comando de Freddy para evitar la fatiga de crear un tag errado:

git tag -a dormido -m 'pohas sadfkhsdf loarepol' <hash_commit>

😂😂😂

recuerden no dejar espacios entre el nombre del alias y el comando alias

 arbolito="git log --all --graph --decorate --oneline"

los alias ahorran mucho tiempo es muy importante saber que son muy personales y solo funcionan en tu área de trabajo local

Arbolito de navidad! je

para escribir un alias es:
alias nombreAlias=“los comandos que queramos que sean nuestros alias”

Ejemplo:
alias arbolito=“git log --all --graph --decorate --oneline”

Crear un Tag:
1.Copiar el Hash.
2.Poner el siguiente comando:
git tag -a “Nombre de la version” -m “Mensaje” “Pegar el Hash” + Enter
comandos utilizados en la clase:
1.git show-ref --tags : Sirve para saber a que commit esta relacionado el tag creado
2.git tag : para ver los tags creados.
3.git tag -d : para borrar un tag internamente.
4.git push origin :refs/tags/“nombre del tag” : borra el tag de la interfaz de github.

Espero les sirve mi aporte. A seguir aprendiendo. 😄

No hizo pull antes de hacer ese push :'(

Me gustó mucho este hack de los alias para abreviar comandos, y aún más el uso de los tagas. A la par del curso también he estado leyedo el libro oficial de git en su página para complementar las prácticas.

Dejo por aquí la sección especifica de etiquetado:
https://git-scm.com/book/es/v2/Fundamentos-de-Git-Etiquetado

Carpe diem:
Si estas en linux, edita el archivo .bashrc que está en la raíz del directorio de usuario (es decir, home) y agrega al final lo siguiente:

`#GIT
alias gpsom="git push origin master"
alias gplom="git pull origin master"
alias gs="git status"
alias gb="git branch"
alias gsht=“git log --all --graph --decorate --oneline”

alias gch="git checkout"
alias gcm="git commit -am "
`
Son los alias de los comandos más utilizados hasta esta parte del curso, es necesario notar que los alias no están pensado que utilicen parámetros, para ello linux tiene preparado las funciones, de hecho casi todo lo que uno escribe en la terminal son llamadas a funciones. Los dos últimos alias tienen argumentos porque lellos pueden manejar sólo uno y al final, por tanto un alias para hacer, por ejemplo, un “git hard reset” está contraindicado.
Saluti,
Fabricio
P.D: Para que los cambios en bashrc tomen efecto sólo debes reiniciar la terminal. Puede ser que tu shell no tome la configuración de bash, en cuyo caso debes editar el archivo particular de esa shell. IO utilizo TILIX (muy recomendado) que toma la configuración de bash.

He aquí el ejemplo del sistema de control de versiones, el uso de tags es la buena práctica de documentar.
Resumen de la clase:

$git tag -a _name_ _commitHash_(Crea el tag de nombre name para el commit de numero hash commitHash)
$ git tag -d _name_ (Borra el tag del repositorio local)
$git tag (Muestra el nombre de los tags que hemos creado)
$git push origin --tags (Sube los tags al repositorio remoto)
$git push origin :refs/tags/_name_ (Elimina del repositorio remoto al tag _name_)

que notable lo del alias arbolito jeje

Adjunto mis apuntes. Espero que a alguien le sirva.

Tags.

Visualizar el historia de cambios
$ git log --all --graph

Crear nuevo tag.
git tag -a v0.1 -m “Resultado de las primeras clases del curso” 5100998

Visualizar tags
$ git tags

Visualizar a que commit esta relacionado al tag
$ git show-ref --tags

Mandar tags a GitHub
$ git push origin master --tags

Matar tag
$ git tag -d v0.1

Para eliminar tag definitivamente
$ git push origin master :refs/tags/v0.1

Para cada acción siempre hay que realizar un pull para traer datos (buena practica) y push para mandar los tags realizados.

Lo mejor de la clase:

Pohas sadfkhsdf loarepol

A mi el alias no me funciono,tuve que probar con otro comando,se los dejo por si les sirve:

git config --global alias.arbolito 'log --all --graph --decorate --oneline'

**Esta es la extensíon que puedes agregar para visualizar las ramas en VSCode:
** Git Graph extension for Visual Studio Code

para guardar el alias en linux hagan lo siguiente:

 cd $HOME && code .bashrc

les va a salir una ventana de vscode, ahi se dirigen a:

crean su alias y se dirigen a la terminal y ponen el siguiente comando :

bash

y ya les quedara funcionado el alias que ustedes quieran

La forma definitiva de poder usar el alias para siempre sin usar comandos para activarlos, es modificando el archivo zshrc o bashrc. Solo vayan al home, y escriban “code .bashrc” o “code .zshrc” dependiendo de cual usen ustedes. Una vez dentro, se van al final del archivo y escriben un comentario para separar sus alias del resto del archivo, y luego ponen el alias. Algo así:

SI queremos ver el historial acompañado de los gráficos en terminal ejecutamos:
.

Y si queremos ver el historial acompañado de los graficos pero desde VSCode debemos instalar la extension Git Graph y se va a ver de esta manera:

Comandos✍🏻

📌 Crear un nuevo tag y asignarlo a un commit: .

git tag -a [nombre-del-tag] -m [mensaje] [id-del-commit]

📌 Listar los tags localmente

Ver lista de tags: git tag
Ver lista de tags y susreferencias: git show-ref --tags

📌 Ver el hash del commit donde se creo el tag

git show nombretag

📌 Borrar un tag localmente

git tag -d [nombre-del-tag]

📌 Enviar tag el repositorio remoto:

git push origin --tags

📌 Borrar un tag del repositorio remoto

git tag -d [nombre-del-tag] y git push origin :refs/tags/nombre-del-tag

Notas 📒

✏️ Tags

Son utilizados normalmente para marcar una versión del proyecto. Son útiles para visualizar el avance del proyecto. Si se desea se puede hacer un checkout a una versión.

✏️ Volver a una versión

Se ejecuta git show-ref --tags para ver el hash del tag
Después se hace un git checkout hash

había una cosa que me frustraba cada vez que usaba git log.
cuando me encontraba con la palabra (FIN) al final del todos los registros y No poeia escribir ningún comando, terminaba cerrando el bash actual y abriendo otro.

afortunadamente me di cuenta que era tan simple, solo tenia que presionar la telca:

q

para salir del registro de log.
Saludos espero que a los principiantes como yo les sirva!

Buenas tardes compañeros les vuelvo a compartir mis apuntes, que cada vez son más y lo que falta, vamos a l a mitad del curso, lo seguiré compartiendo conforme le vaya agregando más información, espero les sea de apoyo, a seguir aprendiendo 😎💪

Notes de GIT


Comandos de GIT

Flujo de Git:

Inicializa un repositorio
Considera que es necesario estar en el directorio donde se va a crear el repositorio de git.
git init

Verificar el estado de los archivos
Permite conocer el estatus de los diferentes archivos: nuevos, modificados, eliminados. Mostrará los archivos de diferentes colores según el estatus de los archivos. De color rojo (archivos nuevos, eliminados y modificados), color verde (archivos en área de preparación).

git status

Añadir archivos al área de preparación
Mueve el estatus de los archivos del área local al área de preparación, se puede hacer de forma individual especificando ruta y nombre del archivo:

git add _nombre_archivo_

Y también se puede hacer utilizado un punto (.), con esto pasara todos los archivos a los que no se les está dando seguimiento.

git add .

Incluso se puede hacer utilizando los comodines para seleccionar determinados archivos según su extensión, por ejemplo, el siguiente comando solo agregara los archivos con extensión HTML que no se les esté dando seguimiento:
git add *.html

Sacar archivos del área de preparación
Al ser un área de preparación podremos sacar algún archivo de esta área y regresarlo al área local, para eso se hace con el comando:

git rm --cached _nombre_archivo_

Las diferentes áreas de Git

  • Área Local (Working directory)
    Es el directorio de tu computadora. Los archivos en esta área están untracked.
  • Área de Preparación (Staging area)
    Es área de preparación y se colocan los archivos que se confirmarán para ser guardados en el repositorio. Si lo deseamos se pueden regresar al área local. Los archivos en esta área están tracked.
  • Repositorio de Git (Git Repository)
    Es cuando ya se han guardado en la base de datos de git y forman parte de un punto en la historia del proyecto.

Configurar nombre y correo:
Antes de poder realizar commits en nuestro repositorio será necesario configurar el nombre y correo, ya que en cada commit Git agrega esta información.

Los comandos para poder consultar y realizar estas configuraciones son:

Para mostrar la ayuda para la opción config
git config

Muestra la lista de configuraciones
git config --list

Muestra los directorios en donde se encuentra guardada las diferentes configuraciones (son configuraciones avanzadas):
git config --list --show-origin

Configurar el nombre
git config --list --global user.name "_nombre_"

Configurar el nombre
git config --list --global user.email "_email_"

Guardar una versión de nuestros archivos
Este permite guardar en la base de datos de git una versión en el tiempo de nuestros archivos, es como sacarle una fotografía la cual podemos regresar a ver en cualquier momento en el tiempo, se hace con el siguiente comando:

git commit -m "_mensaje_"

Si se hace solo sin el parámetro -m “mensaje”, lo que hará git es abrirnos una ventana con el editor configurado para redactar el mensaje de una mejor manera:

git commit


Formas de listar Commits Git:

En cualquier momento podemos consultar la historia de uno de los archivos o de nuestro proyecto de Git, es decir listar de diferentes formas todos los commits realizados durante la historia de nuestro proyecto.

El listado puede mostrar información relevante como sería: la rama en la que nos encontramos, quien los realizo, el hash identificador único de cada commit, fecha y hora, así como el mensaje que identifica cada commit.
Para un archivo específico:

git log _nombre_archivo

Para todo los commits del proyecto:

git log

Hay diferentes opciones para mostrar la lista de commits con git log entre esas variaciones están:

Mostar en una sola línea cada commit:

git log --oneline

Mostar estadísticas en cada commit:

git log --stat

Muestra donde se encuentra el head point en el log:

git log --decorate

Pero si combinamos las siguientes flags tendremos una visualización más precisa de como ha evolucionado nuestro proyecto, es decir podemos visualizar de forma gráfica como se ven las ramas y en qué puntos se han fusionado a la rama principal:

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

Hay otro comando que muestra absolutamente todos los commit de nuestro proyecto, incluso cuando volvimos atrás en el tiempo con --rest --hard, este comando es:

git reflog

Consultar con más detalle la historia de un archivo
Mostrará todo los que muestra el comando git log pero también nos mostrará las versiones que existen de este archivo, así como también mostrara de color rojo lo que se ha eliminado y de color verde lo que se ha agregado.

git show _nombre_archivo_


Viajar en el Tiempo en tu proyecto de Git:

En git podemos movernos hacia cualquier punto en el tiempo de nuestro proyecto (commit), esto se puede usando el reset, pero hay 2 tipos: --hard y --soft:
El reset –hard eliminará todos los commits posteriores al punto en que nos regresamos.
El reset –soft eliminará todos los commits posteriores al punto en que nos regresamos, pero respeta todo lo que está en el área de preparación.

git reset _hash_commit_ --rest | --hard

Otra forma de movernos en el tiempo es utilizando el comando “checkout”, con este podemos hacerlo para todos los archivos o solo para un archivo en específico:

git checkout _hash_commit_


Branchs y Merge:

Branch (ramas)
Las ramas permiten trabajar de forma paralela en nuestro proyecto y de esta forma tener más control sobre lo que se agregar al master o rama principal.

Podemos consultar las ramas (muestra todas las ramas que existen en nuestro proyecto) y es con el siguiente comando:

git branch

Al crear una rama con el siguiente comando solo la crea, pero no nos cambia a la nueva rama, para que lo tengas en cuenta:

git branch _nombre_rama_

Otra forma de crear una rama y al mismo tiempo cambiarnos a esa nueva rama es con el siguiente comando:

git checkout -b _nombre_rama_

Para cambiarnos a otra rama en nuestro proyecto usamos:

git checkout _nombre_rama_a_cambiarnos_

Merges (fusiones de Ramas)
Para fucionar ramas (merge) es importante considerar desde donde estamos haciendo el merge, ya que si la hacemos de forma inversa podemos perder cambios importantes, solo considera que la rama en donde estemos parados será la rama que recibiera los cambios de la otra rama, por ejemplo, si tenesmo nuestra rama master y una rama llamada new-feature y queremos añadir esa nueva característica a master, por lo que debemos movernos a master y ahí hacer el merge hacia la rama new-feature. Para hacer un merge usamos el siguiente comando:

git merge _nombre_rama_a_fucionar_


Repositorios Remotos (GitHub):

Existe repositorios remotos como serían GitHub, GitLab, Atlassian Bitbucket, GitKraken entre otros, el más utilizado y conocido es GitHub.

Para poder subir nuestro código a cualquier repositorio antes mencionado es necesario crear un repositorio remoto en nuestro proyecto con el siguiente comando:

git remote add origin _url_del_repositorio_remoto_

La _url_del_repositorio_remoto_ la obtenemos desde el repositorio que estemos utilizando de cualquiera de las opciones antes mencionadas.

Para consultar los repositorios remotos que tenemos agregados a nuestro proyecto usamos el siguiente comando:

git remote

Para obtener más información sobre estos repositorios remotos usamos el comando:

git remote -v

Git Push y Git Pull
Para subir nuestro proyecto al repositorio remoto que acabamos de crear usamos el comando:

git push origin main

Cuando creamos el repositorio y a este le agregamos por ejemplo el readme o el .gitignore o el archivo de la licencia al el git push origin main nos mostrara un error, en el cual nos menciona que el repositorio remoto incluye trabajo (otros archivos) que no tenemos en nuestro repositorio local, por lo que nos pide primero integrar los cambios del repositorio remoto lo cual se hacer con el siguientes comando:

git pull origin main

Pero nos mostrara una advertencia ya que requerimos de una parámetro para que nos permita fusionar la rama main del repositorio remoto con nuestra rama main de nuestro repositorio local, para eso ejecutamos el siguiente comando:

git pull origin main --allow-unrelated-histories

Nos solicitara ingresar un mensaje al commit que crea Git para hacer el merge, ahora debemos ejecutar nuevamente el comendo

git pull origin main


Crear y configurar llave SSH en GitHub:

Primero necesitamos crear una llave SSH en nuestro equipo la cual consta de 2 archivos: id_rsa y id_rsa.pub la primera es la llave privada la cual nunca se debe compartir y se quedara siempre en el equipo en el que se configura, y la segunda es la llave publica la cual se puede compartir para poder establecer la comunicación por medio de SSH.

Para crear la llave SSH en nuestro equipo (Windows 10) usamos el siguiente comando:

ssh-keygen -t rsa -b 4096 -C "_correo_electronico_de_GitHub"

Al dar Enter preguntara lo siguiente:

  1. Solicita la ruta donde se guardará la llave SSH, es recomendable dejar la que nos pone por defecto.
  2. Solicita especificar una frase, esta sería como una contraseña que tendríamos que ingresar cada vez que usamos la llave, ya quedará a tu consideración ingresar una o no, si deseas no ingresar esta contraseña solo hacemos Enter.
    Algo a tener en cuenta es que cuando ingresas la contraseña no visualizaras nada pero si se está capturando.
  3. Solicita repetir la contraseña, si la dejamos en blanco presionamos Enter, pero si ingresaste una contraseña hay que ingresarla exactamente igual.
  4. Con esto se crea la llave SSH, la cual es un directorio con 2 archivos: id_rsa y id_rsa.pub
  5. Verificamos que el servidor SSH este encendido, se hace con el comando:
    eval $(ssh-agent -s)
    El cual debe mostrar un Pid y un número, esto quiere decir que el servidor SSH está funcionando correctamente.
  6. Ahora agregamos la llave, para eso debemos estar en la raíz de nuestro home y se hace con el comando:
    ssh-add ~/.ssh/id_rsa

Para cambiar la url de un repositorio remoto, esto se podría utilizar cuando tenemos configurado hacer git push y git pull con protocolo HTTPS, pero si queremos cambiarlo para hacerlo con SSH, entonces ejecutamos los siguientes comandos:
Primero visualizamos los repositorios remotos:

git remote -v

Nos mostrara uno para fetch y otro para push por lo regular se hace para los 2 y se cambia con este comando:

git remote set-url origin _url_ssh_del_repositorio_remoto_


Tags y Releases

Los Tag nos sirven para identificar puntos relevantes en la evolución de nuestro proyecto, ya que estos puntos se pueden considerar como un numero de versión especifica.

Para crear un tag se hace de la siguiente forma:
git tag -a v_numero_version_ -m "_mensaje_del_tag_" _hash_commit_

Ejemplo de un Tag:

git tag -a v_0.1 -m "Versión Beta" 5dg23k

También podemos consultar los Tags que hemos creado con el comando:
git tag

Para saber el hash del commit al que hace referencia el Tag es con el comando:
git show-ref --tags

También podemos enviar al repositorio remoto (origin) los tags que hemos creado, se hacen de la siguiente forma:
git push origin --tags

Para eliminar un tag en Local se hace con el comando:
git tag -d _nombre_tag_a_eliminar_

Pero hay un detalle cuando eliminamos un tag en local que anteriormente habíamos subidos al repositorio remoto, este no se elimina del repositorio remoto, este se tiene que eliminar con un comando especial:
git push origin :refs/tags/_nombre_tag_a_eliminar_


Lecturas Complementarias

Git reset VS Git rm

Estos son comando con utilidades diferente:

Git rm
Este comando permite eliminar archivos de Git sin eliminar su historial del sistema de versiones, es decir si en un futuro necesitamos recuperar ese archivo solo debemos viajar en el tiempo y recuperarlo con el último commit antes de borrarlo. Este comando no debe usarse así nomás, debe usarse con un flag ya que hay 2 forma de utilizarlo:

Con la flag --cached Elimina los archivos de nuestro repositorio local y del área de preparación (staging), pero los mantiene en nuestro disco duro, es decir le dice a Git que deje de trackear el historial de cambios de este o estos archivos y pasara al status untracked.

git rm --cached _nombre_archivo_

Con la flag --force Elimina los archivos de Git y del disco duro, pero como Git guarda todo hay forma de poderlo recuperar, pero es necesario utilizar comandos avanzados.

git rm --force _nombre_archivo_

Git reset
Este comando nos ayuda a volver en el tiempo (pero no como git checkout el cual nos permite ir, mirar, pasear y volver), es decir con git reset volvemos al pasado sin la posibilidad de volver al futuro. Este comando es muy peligroso y debemos usarlo solo en caso de emergencia.

Existe 2 formas de usar git reset:

Con el argumento --soft borra todo el historial y los registros de Git pero guardamos los cambios que tengamos en el área de preparación, así podremos aplicar las últimas actualizaciones a un nuevo commit.

git reset --soft

Con el argumento --hard Borra absolutamente todo, absolutamente todo, toda la información de los commits y del área de preparación también borra su historial.

git reset --hard

Y también tenemos este comando que nos permite sacra los archivos del área de preparación, NO los borra, si no que los pone en estatus untraked.

git reset HEAD

desde la carpeta raíz (recuerda que está indicada por un virgulilla al final de la ruta) puedes escribir el siguiente código, el cual te dirige a VScode donde, entre otras cosas, encontrarás los alias que tienes activos

code .bashrc

Verás algo parecido a esto y ahí puedes agregar cuantos alias quieras

# some more ls aliases
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'
alias c='clear'
alias arbol='git log --all --graph --decorate --oneline'

Para guardarlos y que te funcionen donde desees, guardas los cambios que hayas realizado en VScode y te diriges a la terminal, allí actualizas el bash nuevamente en tu carpeta raíz, y ¡todo listo.!

bash 

Buena clase

Los proyectos de codigo abierto por lo general tienen versiones v1,v2, hasta que dicen hasta aqui llego el proyecto y eso es lo que voy a enviar.

  1. Necesitamos ver la historia del proyecto. Con git log.
  2. git log --all nos va a mostrar todo.
  3. git log --all --graph te muestra unas rayitas de como han funcionado las ramas de una manera mas o menos visual
  4. $ git log --all --graph --decorate --oneline muestra todo mucho mas comprimido
  5. le vamos a hacer un alias colocamos entre comillas el comando. y antes le colocas alias arbolito"comando–’’
  6. Ir a la clase de terminal y linea de comando donde nos aprendo a guardar los alias en el documento base
  7. vamos a crear un tag(etiqueta)
  8. copiamos el hash del commit
  9. git tag -a v0.1 -m “Resultado de las primeras clases del curso” + hash
  10. git tag (te muestra la lista de todos los tags)
  11. la forma de saber a que commit esta conectado un tag es con git show-ref --tags
  12. mirar la historia con history
  13. esos cambios debemos enviarlos al repo en github
  14. con git pull origin main
  15. luego el git push origin --tags
  16. podemos verlos en github al dar click en branchs
  17. Que hacer con tags errados: borrar el tag (git tag -d dormido)
  18. hacemos pull y push nuevamente para guardar los cambios

A nivel Github un tag comprime toda la version de nuestro codigo hasta el hash que le indicamos:

eliminar un tag de forma remota :: git push origin :refs/tags/nombre_del_tag

Los tags o etiquetas nos permiten asignar versiones a los commits con cambios más importantes o significativos de nuestro proyecto.

Les comparto el comando del aporte más votado pero más corto. Esto porque descubrí que con los argumentos --graph y --format y --all bastan. Además agregue que después del autor aparezca entre paréntesis el correo.

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

NOTA IMPORTANTE:
Los alías viven en memoria RAM del programa, cuando se sería la terminal deja de existir, hay otra forma de guardar estos alias de forma permanente.

Desconocía por completo que existen los Tags!. Ahora me queda mas claro

Mis apuntes:
git log -> revision de la historia

  flags ->
      --all -> revision de TODA la historia.
     flags ->
          --grap -> revision de toda la historia de forma grafica mostrando las graficamente las ramas y la informacion de git log.
      	  flags ->
              --decorate --oneline -> muestra un resumen con el ID commit, comentario y muestra graficamente la historia de las ramas con una linea.

git tag -> muestra los tags en el repositorio local.

  flags ->
      -a nombreTag -m "comentario" idCommit -> creacion de etiqueta en el commit realizado.
  	    flags->
  	        -a -> agrega el nombre al tag. Usualmente se coloca en el nombreTag = v0.1
  	        -m -> crea un comentario para el tag.
      -d nombreTag -> (d=delete)eliminar tag

NOTA: los tags no son cambios, pero en el repositorio repositorio es importante para dejar referencias de las versiones y acciones hechas en el momento por el programador actual.

git push origin :refs/tags/nombreTag -> borrar el tag en el repositorio remoto.

git show-ref --tags -> mirar el ID commit y el nombre del tag.

git push origin --tags -> enviara los tags creados al repositorio remoto.

NOTA: Envios del repositorio local al remoto:

  1. realizar un git pull:
    git pull origin main.
  2. Enviar cambios:
    git push origin main
    Enviar tags:
    git push origin --tags.

Configuracion de los alias ->
git config --global alias.nombreAlias -> crear un alias llamdo nombreAlias, se ejecuta ‘git nombreAlias’

  EJEMPLO
  git config --global alias.superlog "log --graph --abbrev-commit --decorate --date=relative --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 --unset alias.nombreAlias -> eliminar un alias.

	NOTA: si por alguna razon no funciona, utilizas realizar el cambio en el usuario o home en el archivo .gitconfig
	EJEMPLO: 
[alias]
	superlog = log --graph --abbrev-commit --decorate --date=relative --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

Gracias a CristianTovar, arturopanama y AlejoCm en este aporte vi la info aqui https://platzi.com/comentario/594183/