Git tag y versiones en Github

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 😃

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 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

git push origin :refs/tags/nombretags -> Para eliminar tags en el repo 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.

Pueden conocer todo los alias disponible escribiendo el comando alias.

Si quieren eliminar el alias el comando es

unalias nombre-del-alias

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

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'

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.

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.

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

😃

¡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:
  

  

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

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

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

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

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>

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/

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”

**********************************
***************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***************
**********************************```

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.

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

yo también lo llamé arbolito 😂

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

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.

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

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

😎🤙

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.

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

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…

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

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

• 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.

que notable lo del alias arbolito jeje

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 alguien quiere guardar sus “alias” permanentemente tienes que dirigirte a tu HOME y con ls -a buscar un archivo llamado “.bashrc”, una vez encontrado lo puedes abrir con “code .bashrc” y dentro de tu archivo en vscode escribir:
alias [El nombre que le quieras poner]=" lo que quieras que haga".
Despues de eso solo tienes que cerrar y abrir tu bash y listo

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

Lo mejor de la clase:

Pohas sadfkhsdf loarepol

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

Esto toma sentido una vez que trabajas en un proyecto

Para quienes usen ubuntu (Entre otras distribuciones) y usen bash. Puede editar el archivo .bashrc que se encuentra en el home y al final agregan el alias, yo lo hice de esta manera:
alias glog=“git log --all --graph --decorate --oneline”

Para crear un alias permanente en Ubuntu,

puedes agregarlo al archivo .bashrc ubicado en tu directorio personal. Este archivo se ejecuta cada vez que abres una nueva terminal, por lo que cualquier alias que agregues en este archivo estarán disponibles cada vez que abras una nueva sesión de terminal.

Para agregar un alias al archivo .bashrc, sigue estos pasos:

1. Abre una terminal y escribe el siguiente comando para abrir el archivo .bashrc con el editor de texto nano:

   nano ~/.bashrc
   

2. Busca una línea en blanco o al final del archivo y agrega el siguiente código para crear tu alias:

   alias nombre_del_alias='comando_a_ejecutar'
   

   Reemplaza nombre_del_alias con el nombre que deseas darle a tu alias y comando_a_ejecutar con el comando que deseas ejecutar cuando se use el alias.

3. Guarda y cierra el archivo .bashrc presionando Ctrl + X, seguido de Y para guardar los cambios y Enter para confirmar el nombre del archivo.

4. Finalmente, para que el alias se active en la sesión actual de la terminal, ejecuta el siguiente comando:

   source ~/.bashrc
   

   Este comando carga los cambios realizados en el archivo .bashrc en la sesión actual de la terminal.

A partir de ahora, cada vez que abras una nueva sesión de terminal, tu alias estará disponible y no se borrará después de reiniciar tu computadora.

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

“A Dog” = git log --all --decorate --oneline --graph

Para listar los tags con sus mensajes:

git tag -n

v0.01           Ticker
v0.03           BMP280 I2C
v0.04           OLED Display
v0.05           WiFi
v0.06           WebServer
v0.07           Accelerometer
v0.08           Gyroscope README
v0.09           Magnetometer
v0.10           Angles
v0.11           Battery

Alias

• Son shorthand que se para reemplazar todo un bloque de código

Alias temporales

1. Crea un alias dentro de la instancia de la consola (al cerrar la consola se pierde el alias)
   alias git-grafico="comando"

Alias de globales

1. Crear o modificar el archivo “.bashrc” Ubicado en la carpeta Home ~
2. Dentro del archivo al final de todo agregar la misma sintaxis para crear alias temporales
   alias git-grafico="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"
3. Guardar y listo.

Para ver los tags que hicimos y sus mensajes:

$git tag -n

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'

• 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.

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'

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_)

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.

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

Aquí las ideas principales de esta lección :

Los proyectos de código tienen versiones específicas, llamadas “releases”.
Se puede revisar la historia del proyecto utilizando el comando “git log”.
El comando “git log --all” muestra todos los commits históricos del proyecto.
El comando “git log --graph” muestra una representación gráfica de las ramas del proyecto.
Es posible crear alias para comandos largos utilizando el comando “alias” en Linux.
Se pueden crear tags en un commit específico utilizando el comando “git tag -a [nombre del tag] -m [mensaje]”.
Los tags son útiles para marcar versiones específicas del proyecto y se pueden mostrar en plataformas como GitHub.
Los tags se pueden enviar al repositorio remoto utilizando el comando “git push --tags”.
Se pueden listar los tags existentes utilizando el comando “git tag”.
Se pueden borrar tags utilizando el comando “git tag -d [nombre del tag]”.
Para borrar un tag en el repositorio remoto, se utiliza el comando “git push origin :refs/tags/[nombre del tag]”.

Git Aliases

Los “alias” en Git, son una manera de crear accesos directos a comandos personalizados par Git. Puedes usarlos para ahorrar tiempo y escribir, creando comandos más cortos para los comandos de Git de uso común, o para crear comandos personalizados que realizan una serie de operaciones en Git.
.
Para crear un alias de Git, debes usar el comando git config con la opción alias.<alias_name>. Luego, pones el comando Git que desea asociar con ese alias.
.
Ejemplo:
git config --global alias.co checkout
.
Esto crea un alias llamado “co” que se asigna al comando “chaeckout” y para usarlo debes escribir git co. Podemos crear alias para cualquier comando de Git, incluyendo scripts o comandos personalizados como git log --all --graph --decorate --oneline.
.

Git tag

Las etiquetas, son referencias estáticas a puntos específicos en la historia de Git, como confirmaciones (commits) importantes o versiones de un lanzamiento. Son útiles para marcar versiones importantes en el proyecto, crear puntos de control o para crear una versión estable y rastrear el progreso del proyecto.
.
Git soporta dos tipos diferentes de etiquetas, etiquetas con anotaciones y etiquetas ligeras. Las etiquetas ligeras y las etiquetas anotadas difieren en la cantidad de metadatos que almacenan. Una buena práctica es considerar las etiquetas anotadas como públicas, y las etiquetas ligeras como privadas. Las etiquetas anotadas almacenan metadatos adicionales, como el nombre, el correo electrónico y la fecha del autor de la etiqueta. Se trata de datos importantes para una publicación. Las etiquetas ligeras son esencialmente “marcadores” de una confirmación, son únicamente un nombre y un puntero a una confirmación, útiles para crear enlaces rápidos a confirmaciones relevantes.
.
Para crear etiquetas ligeras, usamos el comando: git tag <tag_name>. Si queremos crear una etiqueta anotada, usamos el siguiente comando: git tag -a <tag_name>. También podemos agregar un mensaje descriptivo agregando al final -m “description.
.
Para ver la información detallada de una etiqueta, utilizamos git show <tag_name>. Para ver las etiquetas que hemos creado, usamos git tag o git show-ref --tags. También podemos eliminar etiquetas por medio de git tag -d <tag_name>.
.
Por último, podemos utilizar los siguientes comandos para administrar las etiquetas:

• Publicar un tag en el repositorio remoto:
  git push <remote> --tags
• Borrar un tag del repositorio local y remoto:
  git tag -d <tag_name>
git push<remote> :refs/tags/<tag_name>

3:05 lo que hace Freddy para pasar de un comando a otro es darle click a la flecha hacia arriba

ALIAS PERSONALIZADOS

En Git, los alias personalizados son atajos que se pueden crear para comandos de Git más largos o complejos. Los alias personalizados pueden ayudar a ahorrar tiempo y hacer que el uso de Git sea más fácil y conveniente.

Hay dos formas de crear alias personalizados en Git:

1. Utilizando el comando git config:

   Puede utilizar el comando git config para crear alias personalizados que se apliquen globalmente en todos los repositorios de Git en su sistema. Para crear un alias personalizado, puede ejecutar el siguiente comando en la terminal de Git:

   git config --global alias.[nombre-del-alias] [comando-de-git]
   

   Por ejemplo, si desea crear un alias personalizado para el comando git status llamado st, puede ejecutar el siguiente comando:

   git config --global alias.st status
   

   Ahora, cada vez que escriba git st en la terminal, Git ejecutará el comando git status.

2. Utilizando la sintaxis de alias de la terminal:

   También puede crear alias personalizados utilizando la sintaxis de alias de la terminal en la sesión actual. Para crear un alias personalizado utilizando esta sintaxis, puede ejecutar el siguiente comando en la terminal de Git:

   alias [nombre-del-alias]="[comandos-de-git]"
   

   Por ejemplo, si desea crear un alias personalizado para la serie de comandos git add . && git commit -m "Algun mensaje" && git push llamado acp, puede ejecutar el siguiente comando:

   alias acp="git add . && git commit -m 'Algun mensaje' && git push"
   

   Ahora, cada vez que escriba acp en la terminal de Git, Git ejecutará la serie de comandos definidos en el alias personalizado.

Es importante tener en cuenta que los alias personalizados creados utilizando la sintaxis de alias de la terminal son temporales y solo están disponibles en la sesión actual de la terminal. Para crear alias permanentes que se apliquen globalmente en todos los repositorios de Git en su sistema, debe utilizar el comando git config como se muestra en el primer método.

creo que seria bueno esplicar que hace y para que sirve un tag, antes mandar los comandos asi porque si