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

Reconstruir commits en Git con amend

40/43
Recursos

Remendar un commit con amend puede modificar el commit más reciente (enmendar) en la misma rama. Lo ejecutamos así:

git add -A # Para hacer uso de amend los archivos deben de estar en staging
git commit --amend # Remendar último commit

Este comando sirve para agregar archivos nuevos o actualizar el commit anterior y no generar commits innecesarios. También es una forma sencilla de editar o agregar comentarios al commit anterior porque abrirá la consola para editar este commit anterior.

Atención

Usar amend es una mala práctica, sobre todo cuando ya se ha hecho push o pull al repositorio remoto. Al momento de hacer amend con algún commit que esté en remoto, va a generar un conflicto que se va a arreglar haciendo un commit adicional y se perderá el beneficio del amend.

Aporte creado por: David Behar.

Aportes 316

Preguntas 23

Ordenar por:

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

Me parce genial este comando y un homenaje al gran freddier

Apuntes! ✌

Espero les sirvan …

el commit --amend es muy util, pero hay que tener cuidado en algunos casos, como en el caso de que el commit que quieras enmendar lo hayas pusheado al repositorio remoto, entonces quieras enmendar un commit que esta en remoto.

Así como en el caso de cherry-pick y rebase, hay que usarlo con cuidado porque modificará la historia de tu repositorio.

Digamos que haces un cambio al archivo a.txt y haces un commit.

Luego subes ese commit al repositorio haciendo push.

Pero se te olvido agregar cambios a ese commit y quieres enmendarlo.

Haces un git --amend y en la historia de tu repositorio local, pareciera que no ha pasado nada: enmendaste tu commit.

Pero resulta que en el repositorio remoto eso no ha ocurrido, ese git --amend no tuvo lugar en el repositorio remoto, y al hacer git status te mostrará un error así:

Your branch and 'origin/master' have diverged,
and have 1 and 1 different commits each, respectively.
  (use "git pull" to merge the remote branch into yours)

y al momento de hacer push para sobreescribirlo, te aparecerá este error:

 ! [rejected]        master -> master (non-fast-forward)
error: failed to push some refs to '[email protected]:luisxxor/hyperblog-1.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Y tendrás que hacer git pull para mergear los cambios de tu repositorio remoto y finalmente hacer push. Es decir, se puede hacer, pero sería contraproducente, porque la idea del amend era enmendar un sólo commit y no generar commits adicionales, pero el resultado de continuar haciendolo en éste caso es que tienes:

  1. El primer commit
  2. El commit enmendado
  3. Y el commit del merge

tl:dr

Es una mala práctica enmendar un commit que ya ha sido pusheado al repositorio remoto.

Remendar un commit

Puede modificar el commit más reciente (enmendar) en la misma rama ejecutando:

git add -A # Para hacer uso de ammend los archivos deben de estar en staging
git commit --amend # Remendar último commit

Este comando sirve para agregar archivos nuevos o actualizar el commit anterior y no generar commits innecesarios.
.
También es una forma sencilla de editar o agregar comentarios al commit anterior porque abrirá la consola para editar el commit anterior.
.
Nota: Es una mala práctica hacer ammend de un commit que ya ha sido pusheado o pulleado del repositorio remoto, al momento de hacer ammend con algún commit que esté en remoto va a generar un conflicto que se va a arreglar haciendo un commit adicional y se perderá el beneficio del ammend.

jajajajajaja freddy me mata de risa XD

Y así, con git amend nadie sabe ese error tonto que cometiste y aquí nunca pasó nada 😎

si el caso es que únicamente olvidamos incluir archivos al commit y el mensaje que habíamos ingresado estaba bien, también podríamos ejecutar el siguiente comando:

git commit --amend --no-edit

Con el --no-edit además de todo lo que significa el --amend estamos diciéndole a git que utilice el mensaje que ya habíamos ingresado.

git commit --amend “antes de que el chino se comiera la sopa de murcielago”

Mis apuntes de esta lección.

Reconstrucción de Commits

Si el último commit que hicimos tenía un error, por ejemplo de ortografía o quizá se nos olvidó agregar algo al código de ese commit podemos darle solución con el siguiente comando.

→ Modificar el mensaje del commit más reciente.

$ git commit --amend

→ Modificar el commit más reciente y su mensaje en la misma línea.

$ git commit --amend -m

Recordar que -m permite escribir un mensaje desde la línea de comandos sin tener que abrir un editor.

→ Modificar el commit sin modificar el mensaje de dicho commit.

$ git commit --amend --no-edit

El indicador --no-edit permite hacer correcciones el el código sin modificar el mensaje original.

Este comando es una manera práctica de modificar la información más reciente de nuestro repositorio.

No utilizar --amend para reconstruir commits que ya se encuentran en el repositorio remoto. Esto sería una mala práctica.

wow git --amend me hubiese ahorrado muchos commit en el pasado

$git commit --amend y AMEN ! jajajaja

![](

git commit --amend
Salvando vidas desde que nos lo enseñó el señor Freddy.

Apuntes 😅

Cuando se te olvida modificar algo y ya mandaste el commit y no querías que se fuera sin esa modificación, debes hacer lo siguiente:

  1. Hacer lo que se te olvidó.
  2. Es importante añadirlo con un: git add [archivo_modificado]
  3. git commit --amend

Muy buen comando antes de esta clase yo ya lo explicaba la dos formas .
git commit --amend --no-edit "Para editar solo el mensaje del commit"
git commit --amend "Para editar el commit los archivos y el mensaje "

Recomiendo usar, para evitarse algunos bugs de git:

git commit --amend -m "Descripción del commit"

Llevo 2 minutos de video, creo que freddy aun no dice que esto es una mala practica, pero estoy casi seguro deque es una mala practica
Por que todas las cosas divertidas son malas practicas? 😦

****************
****Remendar****
****************

git commit --amend (coloca los cambios en el útimo commit realizado)

****************
****Remendar****
****************```

Es my inteligente usar ammend en vez de hacer varios commits que se titulen “Arreglando error del commit anterior”, como me ha pasado leyendo proyectos de Git de compañeros. Muy buen comando y muy buena herramienta.
Para realizar el comando después de haber hecho un commit “incompleto” se deben realizar los cambios pertinentes, añadirlos y remendar esto, de la siguiente manera:

$git add _archivo_ (Se añade el archivo a Staging Area)
$git commit --ammend (Se remienda el commit añadiendo los cambios al último commit)

Y listo, uno revisa el commit y como si no hubiera pasado nada.

Y que pasa si quieres ajustar algo en un commit QUE NO ES EL ULTIMO ENVIADO?
en ese caso siempre es posible hacer un rebase interactivo

git rebase -i

Con el rebase interactivo, podemos borrar commits que queramos descartar, modificar el mensaje de un commit o incluso agregar o modificar cambios realizados en un commit aunque hayamos realizado varios commits mas recientes en el mismo branch.

Para realizar un rebase interactivo pueden utilizar el siguiente comando

git rebase -i $(git merge-base $(git branch --show-current) master)

utilizamos $() para imprimir en la consola de git “variables” que podemos obtener con ciertos comandos.

en el comando anterior, git merge-base nos va a indicar el punto exacto donde se creo la bifurcacion en nuestra historia (el punto exacto donde creamos la rama), para eso le vamos a dar el nombre de la rama en la que estamos actualmente (usando git branch --show-current se hace automaticamente por si acaso no nos acordamos) y la rama principal de nuestro repositorio, en este caso: master.

de esta forma, ejecutando ese comando es como si hicieramos: git rebase -i <hash del commit>

una vez ejecutado ese codigo, vamos a entrar en un dialogo similar a cuando debemos crear el mensaje para un commit nuevo. (un dialogo de VIM) en el dialogo podremos ver una lista con todos los commits que tenemos en nuestra rama y un mensaje donde se describen todas las opciones que tenemos.

Para editar un commit, basta con presionar la tecla i para entrar en modo edicion (igual que al crear el mensaje de un commit) y editar el texto del commit que queremos modificar.

como bien explico Freddy en un episodio, todo el texto que tenga un simbolo # significa que esta comentado, en el dialogo de vim veremos que nuestros commits aparecen todos comentados (con un simbolo #) esto es porque nosotros debemos eliminar el # y agregar la opcion que queramos ejecutar sobre ese commit.

por ejemplo, si tenemos un commit asi

#12345ABC "commit de ejemplo"

si queremos editar el contenido de este commit, debemos editar el texto del dialogo y hacer algo asi:

edit 12345ABC "commit de ejemplo"

luego de eso presionamos escape y salimos del dialogo como explica Freddy,
si te parece complicado tambien puedes salir de vim tecleando :wq (dos puntos + w + q)

al hacer esto, en nuestra consola nuestro head va a estar ubicado en el commit 12345ABC siguiendo con el ejemplo, ahora podemos ir a nuestro editor y realizar los cambios que queramos en el archivo.

una vez finalizados los cambios, debemos guardar los cambios en el stage haciendo git add como normalmente, y luego ingresar el comando git rebase --continue

ya para finalizar, al haber ingresado el rebase continue, veremos un dialogo de confirmacion, salimos del dialogo de la forma que explica Freddy o tecleando :wq y listo, nuestro commit quedo oficialmente modificado.

si en este momento hacemos git push, git nos va a arrojar un error. por que? porque nosotros acabamos de sobreescribir la historia, esto quiere decir que la historia de nuestro repositorio local es diferente a la del repositorio remoto.

como se soluciona? sencillo, debes forzar al repositorio remoto a que tome tus cambios.
esto lo hacemos con:
git push --force

una vez hecho esto habremos modificado exitosamente un commit sin necesidad de ensuciar la historia de nuestro repositorio.

esta tecnica puede ayudarte un sinfin de veces a salir de apuros o agregar cambios de ultimo momento sin hacer commits innecesarios, pero como todo, debes utilizarla con mucho cuidado ya que puedes causar problemas si la aplicas de la manera erronea.

saludos y espero les sirva el tip!!

Si se nos olvidó agregar unos cambio en el commit anterior, o algo en el mensaje del commit.
usaremos (git commit --amend).
En le historial de commit, se vera como solo un commit, el cual sera la fusion entre el nuevo y el anterior.

En el caso de que el commit ya se haya enviado al repositorio, y lo vamos a enmendar en local para luego subirlo, debemos usar el comando git push --force origin master para que se pueda subir el commit arreglado.

este comando les puede ser util deja ver las ramas y su ultimo commit
git commit -v
espero les sirva

Esto me va ahorrar muchas cosas jajaja no tenía conocimiento de eso. It’s nice

🐱‍💻 git commit --amend permite modificar la confirmación más reciente que realizamos.

Jajaja de haber sabido esto antes...

Tambien se puede usar para el caso en que nos equivocamos en lo que colocamos en el mensaje del commit, pero sin adicionar o modificar ningun otro archivo?

Freddy salvándonos de un despido desde tiempos inmemorables 😄

esto tambien es una mala practica? es que ya no estoy seguro de cuales son buenas y cuales malas… existe un libro o lectura adicional de buenas y malas practicas en git?

-git commit --amend = remienda los cambios es decir los cambios del primer commit los va a pegar al commit anterior

Es común equivocarnos en nuestro mensaje de commit, cosa que también podemos remendar con el subcomando --amend

git commit --amend -m "Mensaje nuevo"

La combinación que me ayudo 👌
Justo ahora estaba trabajando en un proyecto y me paso lo siguiente, utilice el comando git commit -am y luego git status y me di cuenta que solo realizo el commit de los archivos que estaban siendo rastreado pero no de los nuevos 😮🤨, así que realice nuevamente un git add . y un git commit ahora tenía dos commit del mismo tema separados, claro que pude haber realizado git commit --amend pero en ese momento se me escapo, así que lo que hice fue lo siguiente.

git reflog (para ver mi historial de cambios)
git reset --soft HEAD~2 (retrocedí dos commit dejando todo en memoria)
git add y git commit (guardando todos mis cambios en un solo commit)

Espero y les sirva la combinación

Una vez hecho el commit, se hace el cambios faltantes, se hace UN ADD de ese archivo y luego el comando --amend. Inserta esos cambios al commit hecho y nos evita hacer un nuevo commit y quedar como tontos.

git commit --ammend “2020 new version 😃”

ojalá hubiera sabido el comando hace como 8 videos cuando hice 6 commits corrigiendo el mismo .gitignore jajajaj

Esta creo que puede ser una de las mejores jajajjaajaja 🤘🏽🤘🏽

La pregunta importante, es buena práctica o no? estoy traumado desde el git cherry-píck :'v

Por fiiin ya no voy a tener que disculparme de nuevo con el jefe por enviar tantos commits corregidos xD como necesitaba este comando!!! xD

Como que me huele a mala práctica

Si hiciste el push antes de hacer el amend y aunque lo hagas despues y hagas el push si se mostrara como otro commit ,osea mmend es util antes de haber hecho el push

Tengan en cuenta que esto solo funciona si NO se ha hecho git push aun

Lo uso mucho cuando tengo errores en el mensaje del último commit. No se necesita hacer ningún cambio en los archivos del proyecto para poder utilizarlo.

Concluimos que ** Git Commit --Ammend** es buena práctica, porque Freddy no dijo nada a lo último como en la clase pasada 🦁

Practicando en otros proyecto siempre me paso eso y nunca supe de la existencia de --amend

Y si se envió al servidor remoto?

Con el comando git commit --amend podemos agrupar el commit actual con el commit anterior. Al final solo se verá solo un commit en la historia.

Si ya se hizo el push al repositorio remoto
Seguir los pasos del video y:
git push --force origin <rama-a-empujar>

No ha pasado nada de nada XD
Pero ejecutas ´git reflog´ y él lo sabe todo jajaja

Apuntes 😄

git commit --amend 
"a mi relacion toxica de 5 años " ;(

Mi historial de comando mi rpimer dia de trabajo
git commit --amend
git commit --amend
git commit --amend
git commit --amend
git commit --amend
git commit --amend
git commit --amend
git commit --amend
git commit --amend
git commit --amend
git commit --amend
xdddddd

# Tengo que cambiar el texto de header y el color del footer
# cambio el texto
$ git commit -am "Cambio al texto y al color"

# Ahhh! la embarré, me falto el color del footer
# cambio el color del footer
$ git add css/estilos.css
$ git commit --amend

# verifico que nadie se va a dar cuenta jaja
$ git log --oneline

Creo que me hubiera ayudado mucho saber esto en las primeras clases. No creo ser el único que se haya equivocado al seguir los pasos de cada una de ellas.

git amend: modifica un commit en caso de error
sintaxis:
git add archivo_cambiado: es importante cuando haces amend
git commit --amend: pega los cambios hechos al commit anterior

Esto me pasó algunas veces, necesito amend en mi vida 😄

amen…d

git commit -m “Cambios malos"
git commit --amend
"yo no fui fue pepe”

comando muy util que me va ahorra dolores de cabeza!!

Es mejor el git commit --ammend que hacer un git reset --soft y luego reescribir el commit.

Bendito sea amend. jaja

Git commit --amend no crea un nuevo commit, se fusiona con el commit anterior y te da la posibilidad de reescribir el mensaje.

Jajaja haber sabido esto antes jajaja en varias ocasiones hice commits demas…

Espero no tener que enviar muchos commits remendados…

Cuantos commits innecesarios he hecho, gracias por esto.

Creo que hay un detalle que se puede malinterpretar en esta clase, Minuto 1:46 "Los cambios que hice me los va a pegar al commit anterior, no va a crear un commit nuevo".… sí, pero no, entiendo el punto de freddy, y lo que dice es desde es desde cierta perspectiva, correcto, en la historia (git log) pareciese que eso pasa, pero siendo mas exactos en realidad sí se crea un commit nuevo que reemplaza al anterior, git nunca sobre escribe un commit, siempre crea nuevos commit.

Para comprobar, luego de hacer un amend, ejecuten git reflog y podrán observar que el commit del amend es un commit totalmente nuevo con un identificador diferente, y antes de este podrán encontrar el commit anterior que fue reemplazado (ese que ya no aparece con git log). Sería bueno considerar en la pregunta del examen algo que especifique que están hablando del historial que aparece al ejecutar git log, no del historial completo de git, pues eso cambia el sentido de la idea, porque como tal el commit que se agrega sí es nuevo.

Aqui desde produccion usando --amend :v
Ustedes no vieron nada.

este comando les reduce los pasos de “add .” y le agrega un nuevo mensaje si quieneren

git commit --amend -am "mensaje"

Pasos para arreglar una embarrada (En Git):

  1. Sentirte mal por haber olvidado el cambio o cometido el error.
  2. Hacer el arreglo, modificación u edición correspondiente.
  3. Guardar la modificación.
  4. agregar el cambio a staging con git add nombrearchivo
    5)git commit --amend
    6)cambiar nombre commit si deseas.
    7)dejar de llorar.

Consejo vital:

Si ya la embarraron en el commit, no envien push hasta arreglar el problema.

Otro opción en caso de haber usado push es usar:

git push -f origin master

y reemplaza con el remoto, pero como siempre hay que tener cuidado.

Después de dos clases de esto es esto es Git clean pero es mala práctica, esto es cherry-pick pero es mala práctica …

Aquí Freddy sólo dijo aquí nadie sabe nada y no vamos a mencionar esto nunca más

En caso de ya haber pusheado a origin el commit al que se hace amend.

git push -u origin +nombredelarama

Este comando lo que hace es borrar la rama remota y crearla nuevamente con el commit reconstruido con amend.

Notese el signo + en el nombre de la rama. Es el que le indica a Github de que debe borrar la rama que tiene alojada y crearla nuevamente; a partir de la que estamos enviando con el push, incluyendo el commit modificado con amend.

si hubiese sabido de amend al inicio del curso. No hubiese llegado hasta aqui con 65 commit en mi repositorio hahaha

  • Si no quieres hacer siempre un $git add antes del amend, puedes poner:
$git commit -a --amend

Epa… ¿Esto no es cambiar la historia?
Si es positivo, ¿es mala práctica?
Hay Tabla! 🏏

git commit -am “Comentario”

Se olvido hacer algún cambio y se hizo el commit, se debe usar amend “enmendar”.

  • Que se debe hacer ?

Se realiza actualización del proyecto y se hace el nuevo commit con amend al final de la siguiente manera:

  1. Se debe añadir el archivo que falto por actualizar (En el caso del video se olvido actualizar el footer), una vez actualizado se debe añadir (git add rutaDelArchivo)
  2. git status para comprobar que el archivo fue añadido
  3. git commit --amend para unir todo el trabajo realizado
  4. listo

Si hubiera sabido esto hace tiempo, me pude haber ahorrado un montón de commits repetidos xD

Mis apuntes
si se genera un commit, pero faltan algunos cambios:

  1. generar cambios hechos
  2. realizar ‘git add archivo’
  3. git commit --ammend -> copia los cambios hechos al ultimo commit
  • Supongamos que debemos modificar dos archivos, por alguna razón se nos olvida esto y solo modificamos uno y hacemos un commit con los cambios incompletos.
  • Para corregir esto tenemos que ir al archivo que nos falto y modificarlo, una vez guardados los cambios es muy importante hacer un git add al archivo modificado para añadir los cambios.
  • Por ultimo ejecutaremos git commit --amend el cual nos desplegara un editor de texto por si queremos modificar el mensaje del commit.

Ya veo como no se puede ocultar los pequeños errores y no pasar un rato incomodo, claro esta tienes q darte cuenta antes de q te diga oye se te olvido algo … (y te sonrojes).

Notes

Amend

The git commit --amend command is a convenient way to modify the most recent commit. It lets you combine staged changes with the previous commit instead of creating an entirely new commit. It can also be used to simply edit the previous commit message without changing its snapshot.

https://www.atlassian.com/git/tutorials/rewriting-history#git-commit–amend

  • Before you do the amend, you most stage the changes

Commands

  • Rectify the changes or the message of the last commit

    git commit --amend
    
  • Only modify the changes but not the message

    git commit --amend --no-edit
    

Cuando se quiere adicionar un cambio a un commit previo:

  1. Agregar a staging el fichero modificado con git add nameOfFile
  2. Adicionar cambio a commit previo con git commit --amend -m “NewMessage”. Ambos cambios se fusionan en commit previo.

Para poner el mensaje de una vez pueden usar:

git commit --amend -m "aquí_pones_tu_mensaje"

Tambien podemos poner el mensaje directamente

git commit --amend -m "nuestro bonito mensaje"

Hubiera deseado ver esta clase al principio ajajaja

muy bueno.

Gracias, necesitaba un comando como este.

Es útil usarlo para no tener commits porque si y porque no

este fue el que mas me gusto

git commit --amend` toca más archivos de los necesarios

Modifique los archivos A, B y C.
Confirme las modificaciones con git commit.
Compila el proyecto, de modo que la compilación esté actualizada.
Realice una modificación de seguimiento/corrección solo en el archivo A.
Ejecute git commit -a --amend (o git commit --amend path/to/A)
Reconstruir el proyecto de forma incremental.
  • Ahora, dado que solo modifiqué el archivo A desde la última vez que lo compilé, esperaría que solo se reconstruya el archivo A, pero lo que invariablemente veo es que todo A, B y C (es decir, todos los archivos tocados por la confirmación completa) se reconstruyen.

Me parece que git commit --amend es touchtocando / superando las últimas marcas de tiempo modificadas de cada uno de A, B y C, aunque solo estoy agregando una modificación de A para la confirmación.

Pero com $ git reflog todo siempre sale a la luz!

No se ustedes pero este señor merita el premio al mejor profesor de platzi, sus clases son super divertidas.

Wuaoo!! Este curso está de lo mejor.

No se imaginan la cantidad de veces que he necesitado este comando jajaja ahora si a enmendar de la forma correcta 😉

Amen Freddy tambien para tí.

Se puede hacer git commit --amend a mi vida??

Es broma, es broma.

Así se remiendan los commits!! git commit --amend