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

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Comandos y recursos colaborativos en Git y GitHub

42/43
Recursos

A continuación veremos una lista de comandos colaborativos para facilitar el trabajo remoto en GitHub:

  • git shortlog -sn: muestra cuantos commit han hecho cada miembro del equipo.
  • git shortlog -sn --all: muestra cuantos commit han hecho cada miembro del equipo, hasta los que han sido eliminados.
  • git shortlog -sn --all --no-merge: muestra cuantos commit ha hecho cada miembro, quitando los eliminados sin los merges.
  • git blame ARCHIVO: muestra quien hizo cada cosa línea por línea.
  • git COMANDO --help:muestra como funciona el comando.
  • git blame ARCHIVO -Llinea_inicial,linea_final: muestra quien hizo cada cosa línea por línea, indicándole desde qué línea ver. Ejemplo -L35,50.
  • git branch -r: se muestran todas las ramas remotas.
  • git branch -a: se muestran todas las ramas, tanto locales como remotas.

Aporte creado por: Juan Sebastián Rodriguez.

Aportes 242

Preguntas 17

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

  • git shortlog -sn = muestra cuantos commit han hecho cada miembros del equipo.
  • git shortlog -sn --all = muestra cuantos commit han hecho cada miembros del equipo hasta los que han sido eliminado
  • git shortlog -sn --all --no-merge = muestra cuantos commit han hecho cada miembros quitando los eliminados sin los merges
  • git blame ARCHIVO = muestra quien hizo cada cosa linea por linea
  • git COMANDO --help = muestra como funciona el comando.
  • git blame ARCHIVO -Llinea_inicial,linea_final= muestra quien hizo cada cosa linea por linea indicándole desde que linea ver ejemplo -L35,50
  • **git branch -r **= se muestran todas las ramas remotas
  • git branch -a = se muestran todas las ramas tanto locales como remotas

Apunte Final

Ha sido un curso muy muy útil e interesante!

NOTAS CLASE:

  • git shortlog: Ver cuantos commits a hecho los miembros del equipo
  • git shortlog -sn: Las personas que han hecho ciertos commits
  • git shortlog -sn --all: Todos los commits (también los borrados)
  • git shortlog -sn --all --no-merges: muestra las estadisticas de los comigs del repositorio donde estoy
  • git config --global alias.stats “shortlog -sn --all --no-merges”: configura el comando “shortlog -sn --all --no-merges” en un Alias en las configuraciones globales de git del pc
  • git blame -c blogpost.html: Muestra quien ha hecho cambios en dicho archivo identado
  • git blame --help: Muestra en el navegador el uso del comando
  • git blame archivo -L 35, 60 -c: Muestra quien escribio el codigo con informacion de la linea 35 a la 60, EJ: git blame css/estilos.css -L 35, 60 -c
  • git branch -r: Muestra las Ramas remotas de GitHub
  • git branch -a: Muestra todas las Ramas del repo y remotas de GitHub

Les comparto mis anotaciones de este curso:

Algunos comandos vistos en la clase:

  • git shortlog: cuántos commits ha hecho cada miembro del equipo.
    git shortlog -sn: muestra las personas que han hecho ciertos commits, junto con la cantidad.
  • git shortlog -sn --all: incluye todos los commits, incluso los borrados.
  • git shortlog -sn --all --no-merges: todos los commits sin incluir los merges.
  • git config --global alias.nombre “sentencia”. Para añadir un alias. Ej: git config --global alias.stats “shortlog -sn --all --no-merges”.
  • git comando --help: para conocer cómo funciona un comando.
  • git branch -r: ramas del repositorio remoto.
  • git branch -a: ramas locales y remotas.

Acá mis apuntes de esta clase![](

  • git shotlog: Muestra la descripción de los commits y la cantidad por cada persona

  • git shortlog --sn: Muestra la cantidad de commits por cada persona

  • git shortlog --sn --all --no-merges: Muestra la cantidad de commit sin incluir los merge

  • git config --global alias.stasts "git shortlog --sn --all --no-merges": Agregamos un alias de manera global en git

  • git blame file.ext Vemos líneas por línea quien ha hecho los cambios

  • git blame -C file.ext Muestra de una ejor forma las modificaciones realizadas línea por línea

  • git command --help Muestra la documentación para ese comando.

  • git blame file.ext -L35,60 Muestra los cambios realizados desde la línea 35 hasta 60

  • git branch -r Muestra el listado de ramas remotas (Las que están el el servidor)

  • git branch -a Muestra todas las ramas, las del repositorio local y las del reposotorio remoto

git config --global user.name “nombre”: Configurar Nombre que salen en los commits.

git config --global user.email [email protected]: Configurar Email.

git config --global color.ui true: Marco de colores para los comando.
git help: Muestra una lista con los comandos más utilizados en GIT.

git init: Podemos ejecutar ese comando para crear localmente un repositorio con GIT y así utilizar todo el funcionamiento que GIT ofrece. Basta con estar ubicados dentro de la carpeta donde tenemos nuestro proyecto y ejecutar el comando. Cuando agreguemos archivos y un commit, se va a crear el branch master por defecto.

git add + path: Agrega al repositorio los archivos que indiquemos.

git add : Añadimos todos los archivos para el commit.

git add –A: Agrega al repositorio TODOS los archivos y carpetas que estén en nuestro proyecto, los cuales GIT no está siguiendo.

git commit -m “mensaje” + archivos: Hace commit a los archivos que indiquemos, de esta manera quedan guardados nuestras modificaciones.

git commit -am “mensaje”: Hace commit de los archivos que han sido modificados y GIT los está siguiendo.

git checkout -b NombreDeBranch: Crea un nuevo branch y automaticamente GIT se cambia al branch creado, clonando el branch desde donde ejecutamos el comando.

git branch: Nos muestra una lista de los branches que existen en nuestro repositorio.

git checkout NombreDeBranch: Sirve para moverse entre branches, en este caso vamos al branch que indicamos en el comando.

git merge NombreDeBranch: Hace un merge entre dos branches, en este caso la dirección del merge sería entre el branch que indiquemos en el comando, y el branch donde estémos ubicados.

git status: Nos indica el estado del repositorio, por ejemplo cuales están modificados, cuales no están siendo seguidos por GIT, entre otras características.

git clone URL/name.git NombreProyecto: Clona un proyecto de git en la carpeta NombreProyecto.

git push origin NombreDeBranch: Luego de que hicimos un git commit, si estamos trabajando remotamente, este comando va a subir los archivos al repositorio remoto, específicamente al branch que indiquemos.

git pull origin NombreDeBranch: Hace una actualización en nuestro branch local, desde un branch remoto que indicamos en el comando.

git tag : Muestra una lista de todos los tags.

git tag -a <verison> - m “esta es la versión x” : Crea un nuevo tags.

Comandos adicionales:
git shortlog commits de cada mienbro del equipo
git shortlog -sn numero de commits por miembro
git shortlog -sn --all incluye los commits borrados
git shortlog -sn --all --no-merges excluye los merges
git blame archivo muestra quien modifico el archivo (por lineas)
git blame archivo -c: indenta mejor la informacion
git blame archivo -Li,f: muestra solo las lineas que estan entre i-f
git branch -r ver ramas remotas
git branch -a ver todas las ramas (remotos/locales)

Utilidades gitHub:
Panel insights
pulse merge/pull request/ issues/historia de contribuciones
contributors contribuidores del proyecto
comunity readme, codigo de conducta, licencias, etc
trafic: trafico del proyecto
commits historia de commits
code frecuency codigo añadido/borrado
dependency graph uso de otras librerias
alerts alertas de gitHub
network historia de contribucion de los colaboradores
forks muestra los forks del proyectos

  • git shortlog => Ver cuantos commits a hecho los miembros del equipo
    git shortlog -sn => Las personas que han hecho ciertos commits
    git shortlog -sn --all => Todos los commits (también los borrados)
    git shortlog -sn --all --no-merges
    git config --global alias.stats “shortlog -sn --all --no-merges”

git blame -c index.js => quien ha hecho cambios en dicho archivo
git blame --help

git branch -r => Ramas remotas en el servidor

Me siento superman con este curso!



************************************
************Alias en Git************
************************************

git short log (Ver commits realizados por persona)
git shortlog -sn (¿cuantas veces han realizado commits, cada persona?)
git shortlog -sn --all (detalle de absolutamente todos los commits)


git config --global alias.stats "shortlog -sn --all --no-merges" (alias)

************************************
************Alias en Git************
************************************

**************************************************************
**********************Detalle de cambios**********************
**************************************************************

git blame blogpost.html -c (Sobre un archivo)
git blame --help
git blame css/estilos.css -L35,58

**************************************************************
**********************Detalle de cambios**********************
**************************************************************

*******************************************
*************Ver ramas remotas*************
*******************************************

git branch -r
git branch -a


*******************************************
*************Ver ramas remotas*************```

La nueva version de este curso es el doble de completa del anterior

  • git shortlog -sn = muestra cuantos commit han hecho cada miembros del equipo.
  • git shortlog -sn --all = muestra cuantos commit han hecho cada miembros del equipo hasta los que han sido eliminado y merges.
  • git shortlog -sn --all = muestra cuantos commit han hecho cada miembros quitando los eliminados y los merges

-git blame ARCHIVO = muestra quien hizo cada cosa linea por linea
-git COMANDO --help = muestra como funciona el comando.
-git blame ARCHIVO -Llinea_inicial,linea_final= muestra quien hizo cada cosa linea por linea indicándole desde que linea ver ejemplo -L35,50
-git branch -r = se muestran todas las ramas remotas
-git branch -a = se muestran todas las ramas tanto locales como remotas

Auque aprendi git y github con Leonidas. Freddy le hizo un excelente update a este curso. Muchas gracias.

ese git blame es el que te delata.

Algunos comandos a los que se le pueden crear alias
Mostrar commits de forma compacta y colores, git ls
git log --pretty=format:"%C(yellow)%h%Cred%d\ %Creset%s%Cblue\ [%cn]"

Listar commits y ficheros modificados, git ll
git log --pretty=format:"%C(yellow)%h%Cred%d\ %Creset%s%Cblue\ [%cn]"

Fuente: El baul del programador

Apuntes 😄
Despues de 2 meses y medio recién acabo el curso 😅

Les dejo este alias, a mi se me hace una forma muy útil de usar el git log visualmente con fechas relativas:

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" 

Saludos! Si quieren ver mas alias de git sobre el programador que menciona Freddy al inicio Harry Roberts aqui esta su articulo.

Notas de Clase

*Para saber cuantos commit ha echo cada mienbreo del equipo, Ejecutamos el comando
git shortlog

*Mostrar solo las personas que han echo commit
git shortlog -sn

  • Mostrar todos los commit incluso los borrados
    git shortlog -sn --all

*No incluir las merge
git shortlog -sn --all --no-merges

*Crear un comando
git config --global alias.stats “shortlog -sn --all --no-merges”

*Si queremos saber quien hizo que, Ejecutamos el comando

git blame -c blogpost.html

  • Si queremos saber en detalle quien modifico una linea de código, Ejecutamos el siguiente comando
    git blame css/estilos.css –L35,53 –c

*Si queremos mirar las ramas locales y remotas, Ejecutamos el comando
git branch -a

Consejo: instalen “Git lens” como extensión para Vscode. Van a poder usar git de una forma mas visual. Por ejemplo: automáticamente te muestra en cada linea quien fue el último que la modificó, como con git blame.

Los alias de git son una caracteristica muy personalizable, es capaz de ejecutar comandos de consola, no se limita unicamente a comandos propios de git.
De igual manera podemos encadenar la ejecución de comandos creados o no por nosotros, les dejo este artículo muy interesante al respecto y lo explica de manera muy practica y sencilla

Han pasado 84 años y fredy no hace los merge que tanto prometio

Los animo a que continuamente estén haciendo git comando --help. De esa forma aprenderán demasiadas cosas muy interesantes!!

Ésta clase me hizo despertar el interés por la comunidad de proyectos Open Source 🤔

## SHORTCUT COLABORATIVOS

  • git shortlog: cuántos commits ha hecho cada miembro del equipo.git shortlog -sn: muestra las personas que han hecho ciertos commits, junto con la cantidad.
  • git shortlog -sn --all: incluye todos los commits, incluso los borrados.
  • git shortlog -sn --all --no-merges: todos los commits sin incluir los merges.
  • git config --global alias.nombre “sentencia”. Para añadir un alias. Ej: git config --global alias.stats “shortlog -sn --all --no-merges”.
  • git comando --help: para conocer cómo funciona un comando.
  • git branch -r: ramas del repositorio remoto.
  • git branch -a: ramas locales y remotas.

Hola, recopile algunos comandos del video, espero que les sirvan:

short log :

Lo que ha hecho cada uno de los miembros del equipo -> ($ git shortlog -sn)
Muestra todos los commits incluso los que han sido borrados -> ($ git shortlog -sn --all)
No muestra los merges -> ($ git shortlog -sn --all --no-merges)

Crear Comandos Globales :

Crea un comando global -> git config --global alias.Nombre comando "Comando"
Ej -> git config --global alias.stats “shortlog -sn --all --no-merges”

git Blame :

Sirve para ver historial de modificaciones y quien hizo “Que” ($ git blame)
Si usas ($ git blame css/estilos.css -L35,53) puedes ver el historial de modificaciones solo de esas lineas
Para mejor formato -> ($ git blame css/estilos.css -L35,53 -c)

Para ver ramas remotas ($ git branch -r)
Para ver todas las ramas locales/remotas ($ git branch -a)

- ¿Cómo podemos crear alias a los comandos internamente en git?
o Con el comando git config --global alias.nombre-alias “comando”

- ¿Para qué nos sirve el comando git shortlog?
o Cuenta muestra los commits que hayan hecho los contribuyentes de repositorio
 git shortlog -sn = muestra el número de comits de cada uno de los contribuyentes.
 git shorlog -sn --all = Muestra la cantidad de commits incluyendo los borrados de cada uno de los contribuyentes
 git shorlog -sn --all --no-merges = Muestra la cantidad de commits sin incluir los merge de cada uno de los contribuyentes.


- ¿Para qué nos sirve el comando git blame archivo?
o Para ver quien hizo los cambios en el archivo especificado
 git blame -c archivo = identa mejor la información del comando git blame.
 git blame archivo L#-línea,#línea = permite saber que persona hizo los cambios en el archivo en ese rango de líneas que se especifica.
 git blame archivo L#-línea,#línea = lo mismo que el anterior pero identa mejor la información.

- ¿Cómo podemos saber cómo funciona cualquier comando de Git?
o Con el comando git comando --help. Esto abre el manual del comando.

- ¿Cómo podemos ver las ramas remotas?
o Con el comando git branch -r

- ¿Cómo podemos ver todas las ramas incluyendo las locales y remotas?
o Con el comando git branch -a

Excelente clase, muy valiosa

git shortlog -sn
git shortlog -sn --all
git shortlog -sn --all --no-merges

git config --global alias.stats “shortlog -sn --all --no-merges”

git blame (archivo) -L35,50
git blame --help

git branch -r /ramas servidos
git branch -a /todas

github
en Insigths vemos las stadisticas

git shortlog -sn Nos muestra el número de commit por cada colaborador.
git shortlog -sn --all Nos muestra el número de commit por cada colaborador incluidos los eliminados.
git shortlog -sn --all --no-merges Nos muestra el número de commit por cada colaborador incluidos los eliminados pero que no incluya los merge

git config --global alias.<nombre> “comando(s)_git” Definir un alias en git. Ejemplo:
git config --global alias.stats "git shortlog -sn --all --no-merges"
Despues solo ejecutamos
git stats
git blame <nombre_archivo> Para lograr identificar quien realizo alguna acción en el archivo.
git blame -c <nombre_archivo> Para lograr identificar quien realizo alguna acción en el archivo incluyendo identación para mayor claridad
git blame <nombre_archivo> -L#i,#f Identificamos quien modifica algo por última vez desde un rango de líneas. La línea inicial (L#i) y línea final (L#f)

me gustó esta clase, empece en nivel 0 y salgo con bastantes conocimientos

Buen Curso 💚 💚

ahora siento que tengo un super poder

En caso que deseen borrar el alias, pueden escribir el siguiente comando:

git config --global --unset alias._nombreAlias_

Git y GitHub profesional
⭐️⭐️⭐️⭐️⭐️

Demasiado completo el curso, platzi es aprendizaje online de verdad!

Visual studio te permite ver quien hizo que cambio y hace cuanto tiempo sin tener que usar git blame

Para crear alias en su git local:

git config --global alias.stats "comando a realizar sin el git adelante"

stats es el nombre del alias que estoy creando
Despues solo queda usar:

git stats

y ejecuta el comando que pusieron entre comillas. Recuerden no ponerle el git adelante cuando escriben el comando entre comillas

En las preguntas hay un error que le sucede a un par de personas al ejecutar el alias creado y es el siguiente:

expansion ofalias'stats' failed; 'git' is nota git command

Este problema se da por lo siguiente:

Cuando se crea un alias de git al usar el comando que usa Freddy :

git config --global alias.<nombre_alias> "<comando>"

En la parte <comando> es muy importante que no pongan la palabra git.

Me explico con el ejemplo de Freddy:

git config --global alias.stats “shortlog -sn --all --no-merges”

al crear el alias stats lo que están diciéndole a git es: git cuando yo te diga la palabra stats debes sustituirla por lo siguiente: shortlog -sn --all --no-merges.

El error que sale es porque seguramente al crear el alias se pone la palabra git. Algo así:

git config --global alias.stats “git shortlog -sn --all --no-merges”

Por esa razón cuando ponen git stats, git sustituye stats por “git shortlog -sn --all --no-merges” y lo que está intentando ejecutar la consola es:

git git shortlog -sn --all --no-merges

Por lo que git no entiende el segundo git y saca ese error.

En conclusión, cuando creen un alias de git no pases entre las comillas del comando la palabra git. 😄

Comandos

git shortlog: Nos muestra un resumen de lo que ha hecho cada miembro del equipo

Modificadores

-sn: Nos muestra el número de commits realizados por persona 

    git shortlog-sn 

-all: Nos añade información extra y si lo combinamos con el modificador -sn nos dice todos los commits realizados por las personas (incluso si fueron borrados) 

    git shortlog --sn --all  

    git shortlog –all 

--no-merges: le indica que no nos incluya los merges en el resultado 

    git shortlog --sn --all --no-merges 

    git shortlog --no-merges 

Creación de alias

Se hace al configurar nuestro git de manera global (config –global)

git config –global alias.NombreDelAlias “NuestroComando”

Nota: El nuevo comando no debe incluir la palabra “git”

Git blame: Nos muestra quien hizo que

Modificadores

-c identa de mejor manera nuestro resultado (le añade sangría) 

    git blame -c 

-L nos dice quien modifico el contenido de un archivo en ciertas lineas, línea por línea 

    git blame camioAlArchivo –LNumInicioLinea,NumFinalLinea 

Para entender el funcionamiento de un comando se puede hacer con el modificador –help

 git comando –help 

 git blame –help 

Modificadores de git branch

-a: Nos muestra todas nuestras ramas las locales y las remotas. 

    git branch -a 

-r: nos muestra las ramas remotas 

    git branch -r 

Compañerxs,

les dejo el link de mis notas del curso. Por favor sean libres de compartirlas y si ven que se puede mejorar o algun error, por favor me avisan.

Exitos!!!

https://www.notion.so/Git-y-Github-2854e4a1542342dd9029bd92645761a2

Comandos y recursos colaborativos en Git y GitHub
git shortlog, nos muestra un log por persona de lo que ha hecho cada uno de los miembros del equipo.

git shortlog -sn, Muestra cuantos commit han hecho cada miembros del equipo.

git shortlog -sn --all , Muestra cuantos commit han hecho cada miembros del equipo incluso los que han sido eliminados

git shortlog -sn --all --no-merge, Muestra cuantos commit han hecho cada miembros quitando los eliminados sin los merges.

git config --global alias.stats “shortlog -sn --all --no-merges”, nos permite setear stats como un lias para el comando entre comillas

git blame -c #archivo, nos permite saber quien hizo qué en el archivo seleccionado.
git #comando --help, Nos abre en el navegador el manual que vive dentro de nuestra pc de como funciona el comando.

git branch -r, Con este vemos las ramas remotas, las ramas que están en nuestro servidor en github.

git branch -a, Este nos permite ver todas las ramas, en blanco las locales y en rojo las remotas, de esta manera siempre sabemos que ramas existen y a cuales les falta hacerles push

git blame css/estilos.css -L35,53, nos permite ver como cambiaron específicamente estas líneas y quien lo hizo

digitando

<git help -a> 

“Tienes todo este contenido como ayuda”

Comandos de Porcelana principales

  • add: Agrega contenido de carpetas al índice
  • am: Aplicar una serie de parches de un mailbox
  • archive: Crear un archivo o archivos de un árbol nombrado
  • bisect: Use la búsqueda binaria para encontrar el commit que introdujo el bug
  • branch: Lista, crea, o borra ramas
  • bundle: Mover objetos y referencias por archivo
  • checkout: Cambia ramas o restaura los archivos de tu árbol de trabajo
  • cherry-pick: Aplica los cambios introducidos por algunos commits existentes
  • citool: Opción gráfica a git-commit
  • clean: Remueve archivos del árbol de trabajo no rastreados
  • clone: Clona un repositorio dentro de un nuevo directorio
  • commit: Graba los cambios en tu repositorio
  • describe: Dar a un objeto un nombre legible por humanos basado en una referencia disponible
  • diff: Muestra los cambios entre commits, commit y árbol de trabajo, etc
  • fetch: Descarga objetos y referencias de otro repositorio
  • format-patch: Prepara parches para ser enviados por e-mail
  • gc: Limpia archivos innecesarios y optimiza el repositorio local
  • gitk: El navegador de repositorio Git
  • grep: Imprime las líneas que concuerdan con el patron
  • gui: Una interfaz gráfica portátil para Git
  • init: Crea un repositorio de Git vacío o reinicia el que ya existe
  • log: Muestra los logs de los commits
  • merge: Junta dos o más historiales de desarrollo juntos
  • mv: Mueve o cambia el nombre a archivos, directorios o enlaces simbólicos
  • notes: Agrega o inspecciona objetos nota
  • pull: Realiza un fetch e integra con otro repositorio o rama local
  • push: Actualiza referencias remotas junto con sus objetos asociados
  • range-diff: Compara dos rangos de commits (por ejemplo dos versions de un branch)
  • rebase: Vuelve a aplicar commits en la punta de otra rama
  • reset: Reinicia el HEAD actual a un estado especifico
  • restore: Restaurar archivos de árboles de trabajo
  • revert: Revierte algunos commits existentes
  • rm: Borra archivos del árbol de trabajo y del índice
  • shortlog: Resumir la salida ‘git log’
  • show: Muestra varios tipos de objetos
  • sparse-checkout: Inicializa y modifica el sparse-checkout
  • stash: Poner en un stash los cambios en un directorio de trabajo sucio de todas maneras
  • status: Muestra el estado del árbol de trabajo
  • submodule: Inicializa, actualiza o inspecciona submódulos
  • switch: Cambiar branches
  • tag: Crea, lista, borra o verifica un tag de objeto firmado con GPG
  • worktree: Gestiona múltiples árboles de trabajo

Comandos auxiliares / Manipuladores

  • config: Configurar repositorio u opciones globales
  • fast-export: Exportador de data Git
  • fast-import: Backend para importadores de data de Git rápidos
  • filter-branch: Reescribir ramas
  • mergetool: Ejecuta las herramientas de fusión de resolución de conflictos para resolver conflictos de fusión
  • pack-refs: Empaqueta heads y tags para un acceso eficiente al repositorio
  • prune: Limpia todos los objetos no alcanzables de la base de datos de objetos
  • reflog: Gestionar información de reflog
  • remote: Gestiona un conjunto de repositorios rastreados
  • repack: Empaquetar objetos no empaquetados en un repositorio
  • replace: Crea, lista, borra referencias para reemplazar objetos

Comandos auxiliares / Interrogadores

  • annotate: Anotar líneas de archivo con información de commit
  • blame: Mostrar qué revisión y autor modificaron al último cada línea de un archivo
  • count-objects: Contar número de objetos no empaquetados y su consumo en disco
  • difftool: Mostrar cambios usando herramientas de diff comunes
  • fsck: Verifica la conectividad y disponibilidad de los objetos en la base de datos
  • gitweb: Interfaz web Git (interfaz web para repositorios Git)
  • help: Mostrar información sobre Git
  • instaweb: Buscar instantáneamente tu repositorio de trabajo en gitweb
  • merge-tree: Mostrar fusión de tres vías sin tocar el índice
  • rerere: Reutilizar la resolución registrada de fusiones conflictivas
  • show-branch: Mostrar ramas y sus commits
  • verify-commit: Verificar firma GPG de commits
  • verify-tag: Verifica la firma GPG de etiquetas
  • whatchanged: Muestra logs con las diferencias que cada commit introduce

Interactuando con Otros

  • archimport: Importar un repositorio GNU Arch en Git
  • cvsexportcommit: Exporta un commit único a CVS checkout
  • cvsimport: Salva tus datos de otro SCM que la gente adora odiar
  • cvsserver: Un servidor emulador de CVS para Git
  • imap-send: Enviar una colección de parches de stdin a una carpeta IMAP
  • p4: Importar desde y enviar a repositorios Perforce
  • quiltimport: Aplica un parche quilt en la rama actual
  • request-pull: Genera un resumen de cambios pendientes
  • send-email: Envía una colección de parches como e-mails
  • svn: Operación bidireccional entre un repositorio Subversion y Git

Comandos de bajo nivel / Manipuladores

  • apply: Aplicar un parche a archivos y/o el índice
  • checkout-index: Copiar archivos del índice al árbol de trabajo
  • commit-graph: Escribe y verifica los archivos de Git commit-graph
  • commit-tree: Crea un nuevo objeto commit
  • hash-object: Computa ID de objeto y, opcionalmente, crea un blob de un archivo
  • index-pack: Constuye un archivo de índice para un archivo empaquetado existente
  • merge-file: Ejecuta una fusión de tres vías en un archivo
  • merge-index: Ejecuta una fusión para archivos que la necesitan
  • mktag: Crea un objeto tag
  • mktree: Construir un objeto árbol de un texto en formato ls-tree
  • multi-pack-index: Escribe y verifica archivos multi-pack-index
  • pack-objects: Crea un archivo de objetos empaquetados
  • prune-packed: Remover objetos extra que ya están en archivos empaquetados
  • read-tree: Lee información del ábol en el índice
  • symbolic-ref: Lee, modifica y borra referencias simbólicas
  • unpack-objects: Desempaqueta objetos de un archivo empaquetado
  • update-index: Registra contenidos de archivos en el árbol de trabajo al índice
  • update-ref: Actualiza el nombre del objeto almacenado en una referencia de forma segura
  • write-tree: Crea un objeto árbol del índice actual

Comandos de bajo nivel / Interrogadores

  • cat-file: Proveer contenido o tipo y tamaño de información para objetos de repositorio
  • cherry: Encuentra commits que faltan aplicar en upstream
  • diff-files: Compara archivos del árbol de trabajo y del índice
  • diff-index: Compara un árbol con el árbol de trabajo o índice
  • diff-tree: Compara el contenido y el modo de blobs encontrados a través de dos objetos de árbol
  • for-each-ref: Información de output en cada ref
  • get-tar-commit-id: Extrae el ID de commit de un archivo creado usando git-archive
  • ls-files: Muestra información sobre archivos in el índice y el árbol de trabajo
  • ls-remote: Lista referencias en un repositorio remoto
  • ls-tree: Lista los contenidos de un objeto árbol
  • merge-base: Encuentra un ancestro común bueno para una posible fusión
  • name-rev: Encontrar nombres simbólicos para revs dados
  • pack-redundant: Encuentra archivos empaquetados de manera redundante
  • rev-list: Lista objetos commit en orden cronológico inverso
  • rev-parse: Seleccionar y masajear los parámetros
  • show-index: Mostrar el índice de archivo empaquetado
  • show-ref: Listar referencias en el repositorio local
  • unpack-file: Crea un archivo temporal con contenidos de un blob
  • var: Mostrar una variable lógica de Git
  • verify-pack: Valida archivos Git empaquetados

Comandos de bajo nivel / Sincronización de repositorios

  • daemon: Un servidor realmente simple para repositorios Git
  • fetch-pack: Descarga objetos faltantes de otro repositorio
  • http-backend: Implementación de lado de servidor de Git por HTTP
  • send-pack: Empujar objetos por protocolo Git a otro repositorio
  • update-server-info: Actualiza el archivo de información auxiliar para ayudar a los servidores dumb

Comandos de bajo nivel / Auxiliares internos

  • check-attr: Mostrar información de gitattributes
  • check-ignore: Debug a gitignore / excluir archivos
  • check-mailmap: Mostrar nombres canónicos y direcciones de correo de contactos
  • check-ref-format: Asegura que un nombre de referencia esté bien formado
  • column: Mostrar data en columnas
  • credential: Obtener y guardar credenciales de usuario
  • credential-cache: Auxiliar para almacenar temporalmente claves en memoria
  • credential-store: Auxiliar para guardar credenciales en disco
  • fmt-merge-msg: Produce un mensaje de commit para fusión
  • interpret-trailers: Agregar o analizar información estructurada en mensajes de commit
  • mailinfo: Extraer parche y autoría de un único mensaje de e-mail
  • mailsplit: Programa divisor de mbox simple de UNIX
  • merge-one-file: El programa de ayuda estándar para usar con git-merge-index
  • patch-id: Calcular ID único para un parche
  • sh-i18n: El código de configuración i18n de Git para scripts de shell
  • sh-setup: Código de configuración de script de shell común de Git
  • stripspace: Eliminar el espacio en blanco innecesario

Buenas tardes quisiera compartir mis apuntes sobre el curso de git y github, espero les ayude https://drive.google.com/file/d/1J0UYNGxActY5_tU18_-Yqj-BnUkotoVV/view?usp=sharing

“Esto es útil como gráficos nerds que a nosotros nos gustan” ❤️

Un curso increíble, amo Platzi

Otra forma de crear un alias, tomando como referencia 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.stats 'shortlog -sn --all --no-merges'

Espero les sirva.

la extención git lens en vs code muestra un quién modificó cada linea al pararte sobre ella

https://marketplace.visualstudio.com/items?itemName=eamodio.gitlens

Realmente estoy muy impresionado con lo avanzado que es este curso y todo lo que aprendí en muy poco tiempo!

git shortlog -sn para mostrar solo la cantidad de commits por persona y no solo los commits, ordenado de mayor a menor.

Con la extension de vs code:

  • GitLens — Git supercharged.

Se puede ver el blame, la fecha y la descripcion del commit de cada linea solo estando posicionada en ella, ademas de muchas otra funciones, es muy util, espero les sirva!

comandos adicionales que ayudan a la administración del git

Crear alias dentro de Git
git config —global alias.MiAlias “linea de commando"
Ejemplo:
git config --global alias.MiAlias "shortlog -sn —al —no-merges”

Creación y uso de alias local de git

Cuando hacemos un pull, estamos trayendo la historia del repositorio remoto.

[]([https://platzi.com/tutoriales/1557-git-github/4221-como-guardar-para-siempre-un-alias-en-linux-y-gitbash/](por si a alguien se le borró el alias cuando cerró la consola xD aca la solución) me pasó con arbolito y me dije wtf, ahora quería guardar otro y me pasó igual xD bash loquillo :v

  • Summarizes git log output in a format suitable for inclusion in release announcements. Each commit will be grouped by author and title.

    git shortlog
    

    -n: Sort output according to the number of commits per author instead of author alphabetic order.

    -s: Suppress commit description and provide a commit count summary only.

    -e: Shows the email

    --all: Shows all the commits, even the deleted ones

    --no-merges: it does not include merges

    -L<initial-line>,<final-line>:

    https://git-scm.com/docs/git-shortlog

  • Show what revision and author last modified each line of a file

    git blame <file>
    
  • See the remote branches

    git branch -r
    
  • See all the branches including local and remote

    git branch -a
    

Fue un curso el cual me tomo mucho tiempo, la verdad me encanto cada clase que estuve aqui.

Para asignar un alias $ git config --global alias.stats “shortlog -sn --all --no-merges”

git blame

🎈 git blame permite rastrear cambios de un archivo, quien realizo el cambio en el repositorio.

Creo que el comando que más me gustó fue git blame xD Es como tener el poder y verlo todo y ver quién hace qué, ¡Es increíble!

Excelente Clase

Interesante

Excelente!

Excelente todas las útilidades que tiene github para ayudarnos en todo momento. 🙂

Genial esos comandos 😄

Verdaderamente ha sido un curso super completo!

oh dios, esto me servira cuando me hechen la culpa de algo que no hice :'v

Jaja, el amable recordatorio de blame

Hola.
Acá la lista de comandos vistos en este curso: https://github.com/Pirris-Salas/GitCommands
Saludos

Me acabo de enamorar de github Insights 💚💚💚

Cuando coloco git <comando> --help, abre un archivo html en vs, no en el navegador, alguien sabe que puedo hacer ?

Ve sus ramas actuales

git branch 

para ver ramas remotas es

git branch  -r

Importante saber, para que funcione el git blame deben tener el nombre del archivo y la extensión ejemplo: git blame blogpost .html, git blame RPGGAME .PY y asi

Puse todos los comandos del curso en un excel, a quien le sirva se lo dejo aquí

Creo que esta clase la guardare para un futuro!!

$ git shortlog
$ git shortlog -sn
$ git shortlog -sn --all
$ git shortlog -sn --all --no-merges
$ git config --global alias.stats "shortlog -sn --all --no-merges"
$ git blame archivo.extension
$ git blame -c archivo.extension
$ git comandoDeGit --help
$ git blame archivo.extension -Linicio,final
$ git blame archivo.extension -Linicio,final -c
$ git branch -r
$ git branch -a

Notas 📒

✏️ Estadísticas de commits

Muestra los commits de cada colaborador git shortlog

Muestra en orden el número de commits de cada colaboradorgit shortlog -sn donde s muestra únicamente los nombres y n ordena el resultado.

Igual que el anterior pero también cuenta los commits eliminados git shortlog -sn --all

Igual que el anterior menos los commits hechos en los merges git shortlog -sn --all --no-merges

✏️ Agregar Alias

git config --global alias.tuAlias "el comando"

✏️ Ver responsables de cada cambio de un archivo

Ver responsables git blame archivo

Ver responsables con mejor formato git blame archivo -c

Ver responsables con un rango de líneas git blame -L24,45 archivo

✏️ Ver ramas remotas

Ramas remotas git branch -r

Todas las ramas (remotas y locales)git branch -a

Creando un alias e invocandolo

¡Apuntes!
Esta clase vio:

  1. Comandos para consultar lo realizado (commits) por cada miembro
  2. Comando para consultar quién es el encargado de determinadas líneas del código
  3. Comando para consultar las ramas (tanto remotas como locales)
  4. Como guardar los alias para que sirvan con git únicamente

Esta clase, en resumidas cuentas, abordó tres comandos utilizados comunmente en Git y GitHub, cuya finalidad es agilizar ciertos procesos y servir de herramientas para mejorar el funcionamiento de proyectos colaborativos. Adicional a esto se dio el comando específico para guardar alias en Git

  1. Para consultar lo realizado por el resto del equipo (en término de commits) se utiliza
git shortlog

Es el comando general y me muestra todos los cambios

git shortlog -sn

Me lo muestra por personas (es mucho más conciso)

git shortlog -sn --all

Me muestra todos los commits (aún los eliminados)

git shortlog -sn --all --no-merge

Parecido al anterior, pero me excluye los merges.

  1. Cuando es necesario consultar la autoría de determinadas líneas de código se usa
git blame nombre_documento -La, b

Aquí, se consulta en "nombre_documento, las autorias de las lineas entre a y b.

  1. La consulta de ramas con git branch, permite tambien la consulta de las ramas del remoto y de todas en general.
git branch -r

me muestra las ramas del remoto

git branch -a

me muestra las ramas en general (local y remoto).

  1. Por último, para crear un alias específico para git, se usa el siguiente comando
git config --global alias.nombre_nuevo_comando "comando_a_ejecutar"

/************* BONUS SOBRE GIT Y GITHUB *********/

/ clase 42 --> Mas comandos /

git shortlog -sn --all --no-merges
    [git config --global alias.stats "shortlog -sn --all --no-merges"]
--> Muestra cuantos commit hizo cada colaborador.

git blame [directorio] -L35,40 --> Muestra de quien y cual fueron los cambios
                                    en esas líneas.

git branch -r --> Ves ramas remotas.
           -a --> Ves todas.

github > insight --> Estadisticas.

echaron a anita

Comandos y recursos colaborativos en Git y GitHub
Algunos comandos útiles a la hora de trabajar de manera colaborativa:
• git shortlog: nos muestra un log por persona de lo que ha hecho cada miembro del proyecto
• git shortlog -sn: nos muestra cuantos commits ha hecho cada miembro del equipo
• git shortlog -sn --all: nos muestra cuantos commits ha hecho cada miembro del equipo incluso los que han sido borrados.
• git shortlog -sn –all –no-merges: nos muestra cuantos commits ha hecho cada miembro del equipo sin contar los merges
• git blame <archivo>: nos muestra quien escribió cada línea del proyecto
• git blame -c <archivo>: nos muestra lo mismo que blame, pero con una mejor identación.
• git blame <archivo> L<línea inicial>,<línea final>: nos muestra únicamente quien escribió las líneas que le estamos indicando.
• git branch -r: muestra las ramas que se encuentran en nuestro repositorio remoto.
• git branch -a: nos muestra todas nuestras ramas, las locales y las remotas.
Para añadir un alias a git lo que tenemos que hacer es ejecutar el siguiente comando:
git config –global alias.<nombre del alias> “<comando que queremos guardar dentro del alias>”

++git branch -a++ muestra tanto las ramas locales como las remotas

++git branch -r++ para ver las ramas remotas

++git blame ARCHIVO -Linea_inicial,linea_final++ muestra quien hizo cada cosa linea por linea indicándole desde que linea ver ejemplo git blame nombre-del_archivo -L35,50

++git blame --help++ nos muestra el manual del comando blame. Esto se puede replicar para cualquier comando de git.

++git blame -c nombre_del_archivo++ para saber quien realizo cambios al archivo. Nos mostrara que linea cambio y quien fue quien la realizo. Con una mejor identacion

++git blame nombre_del_archivo++ para saber quien realizo cambios al archivo. Nos mostrara que linea cambio y quien fue quien la realizo.

++git shortlog -sn --all --no-merge++ muestra todos los commit hechos y eliminados menos los merge

++git shortlog -sn --all++ muestra todos los commits por usuario incluso los que se borraron

++git shortlog -sn++ Cuantos commit han hecho por usuario