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

Git Reset y Reflog: úsese en caso de emergencia

39/43
Recursos

Git guarda todos los cambios aunque decidas borrarlos, al borrar un cambio lo que estás haciendo sólo es actualizar la punta del branch, para gestionar éstas puntas existe un mecanismo llamado registros de referencia o reflogs…La gestión de estos cambios es mediante los hash’es de referencia (o ref) que son apuntadores a los commits…Los recoges registran cuándo se actualizaron las referencias de Git en el repositorio local (sólo en el local), por lo que si deseas ver cómo has modificado la historia puedes utilizar el comando:

git reflog

Muchos comandos de Git aceptan un parámetro para especificar una referencia o “ref”, que es un puntero a una confirmación sobre todo los comandos:

  • git checkout Puedes moverte sin realizar ningún cambio al commit exacto de la ref

    git checkout eff544f
    
    
  • git reset: Hará que el último commit sea el pasado por la ref, usar este comando sólo si sabes exactamente qué estás haciendo

    git reset --hard eff544f # Perderá todo lo que se encuentra en staging y en el Working directory y se moverá el head al commit eff544f
    git reset --soft eff544f # Te recuperará todos los cambios que tengas diferentes al commit eff544f, los agregará al staging area y moverá el head al commit eff544f
    
    
  • git merge: Puedes hacer merge de un commit en específico, funciona igual que con una branch, pero te hace el merge del estado específico del commit mandado

    git checkout master
    git merge eff544f # Fusionará en un nuevo commit la historia de master con el momento específico en el que vive
    

¿Qué pasa cuando todo se rompe y no sabemos qué está pasando? Con git reset HashDelHEAD nos devolveremos al estado en que el proyecto funcionaba.

  • git reset --soft HashDelHEAD te mantiene lo que tengas en staging ahí.
  • git reset --hard HashDelHEAD resetea absolutamente todo incluyendo lo que tengas en staging.

Atención

git reset es una mala práctica, no deberías usarlo en ningún momento. Debe ser nuestro último recurso.

Aporte creado por: David Behar.

Aportes 427

Preguntas 56

Ordenar por:

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

Git nunca olvida, git reflog

Git guarda todos los cambios aunque decidas borrarlos, al borrar un cambio lo que estás haciendo sólo es actualizar la punta del branch, para gestionar éstas puntas existe un mecanismo llamado registros de referencia o reflogs.
.
La gestión de estos cambios es mediante los hash’es de referencia (o ref) que son apuntadores a los commits.
.
Los recoges registran cuándo se actualizaron las referencias de Git en el repositorio local (sólo en el local), por lo que si deseas ver cómo has modificado la historia puedes utilizar el comando:

git reflog

Muchos comandos de Git aceptan un parámetro para especificar una referencia o “ref”, que es un puntero a una confirmación sobre todo los comandos:

  • git checkout Puedes moverte sin realizar ningún cambio al commit exacto de la ref

    git checkout eff544f
    
  • git reset: Hará que el último commit sea el pasado por la ref, usar este comando sólo si sabes exactamente qué estás haciendo

    git reset --hard eff544f # Perderá todo lo que se encuentra en staging y en el Working directory y se moverá el head al commit eff544f
    git reset --soft eff544f # Te recuperará todos los cambios que tengas diferentes al commit eff544f, los agregará al staging area y moverá el head al commit eff544f
    
  • git merge: Puedes hacer merge de un commit en específico, funciona igual que con una branch, pero te hace el merge del estado específico del commit mandado

    git checkout master
    git merge eff544f # Fusionará en un nuevo commit la historia de master con el momento específico en el que vive eff544f
    

Freddy son las 3:43 AM y estoy vienod el video a esta hora porque hace 40 minutos hice un merge que genero conflicto y se sobreescribio mis cambios en un intento de recuperara el trabajo con VS2019 lo que hice fue borrar todo.
No sabe como le agradezco esta clase, de verdad pensé que había perdido el trabajo de mas de 30 horas seguidas todo el fin de semana con su festivo incluido, justo 6 horas antes de tener que entregarlo.
Esta es la clase que por mucho me ha ayudado a que no fuera la peor semana de este año.
Mil Millones de Gracias , de verdad, creo que se nota mi agradecimiento, estaba realmente desesperanzado

git reset --HARD <antes de que el chino se comiera la sopa de murcielago>

==Antepenúltimo aporte de este curso! 😃 ==

Existe una extension para vscode llamada Git Graph es muy buena para visualizar el arbol de manera grafica

Flanders!!, porque borraste todo…

Cuando haces un git commit --amend cuando la cagaste y pensaste que tu jefe no se enteraría:

Cuando te enteras de que existe el git reflog:

Saludos!
Sam Martínez( ̄﹃ ̄)

Cabecera queda eliminada porque se le hace reset a master, para recuperar cabecera podemos conseguir el commit con reflog e usar

git checkout -b cabecera "commit id"

git reset --HARD Antes de conocerla a ella

Freddy viendo cómo uso git reset --hard a lo loco porque YOLO.
Jk.

Reflog

Los registros de referencia también llamados reflogs son una funcionalidad de git que registra todos los eventos del repositorio. Cada vez que el extremo de tu rama se actualiza por cualquier motivo, se añade una nueva entrada a este registro.

→ Mostrar el registro.

$ git reflog

→ Mostrar el registro relativo a la fecha especificada.

$ git reflog --relative-date

Reset

Este comando borra toda la información de nuestra rama hasta el punto que le especifiquemos. La invocación predeterminada tiene argumentos implícitos, como lo detallo a continuación:

→ Invocación predeterminada del comando

$ git reset

→ Invocación con sus argumentos implícitos.

$ git reset --mixed HEAD

En vez de HEAD, se puede usar cualquier HASH de commit de git.

Además del argumento --mixed tenemos otros dos que son --hard y --soft.

Ahora, detallando un poco cada uno de los argumentos tendríamos lo siguiente:

  1. --hard → Esta es la opción más peligrosa aunque es la que se usa más frecuentemente. Con esta opción todo el trabajo que se encuentra en el staged se pierde y la cabecera de nuestro repositorio apuntará al commit indicado olvidándose de todo lo que sucedió después de ese commit.
  2. --mixed → Este es el modo de funcionamiento predeterminado. Se actualizan los punteros del repositorio y todos los cambios que se hayan deshecho en el índice del entorno de ensayo e mueven al directorio de trabajo.
  3. --soft → En esta opción a diferencia de la primera todo lo que estaba en el staged se conserva, únicamente actualiza la cabecera del repositorio al commit indicado.

Git reflog lo sabe todo…

Visual studio code fue hecho con el amor de una madre. ☺️

Para los que se les perdio la rama cabecera solo ejecuten git checkout cabecera, luego git checkout master de nuevo y git branch ahí ya aparece cabecera de nuevo.

Yo viendo con reflog todos los reset que había hecho antes de llegar a la clase de los reset xd

Es increible como Git guarda absolutamente todo lo que hicimos en nuestro repositorio. Incluso luego de hacer un git reset --hard, podemos volver al momento exacto antes de hacerlo.
Un dato interesante es que tu reflog nunca será igual al de otra persona, aún cuando esa persona esté trabajando en el mismo proyecto que tú. La razón es que Git solamente sube al servidor (GitHub por ejemplo) las referencias que se puedan acceder directamente. Es decir, cuando estamos haciendo un push no estamos mandando el reflog, el reflog solo vive en nuestra máquina, y el servidor tiene su propio reflog. Por lo tanto, Git no es un sistema de opias de seguridad, hacer un push no es hacer una copia de seguridad al repositorio.

Cuando el pinche bug no se puede solucionar!!! xD

¿Qué pasó ayer? Parte 4

¿Cómo hago eso con mi vida?

Para recuperar una rama que haya sido eliminada necesitamos el hash ultimo commit hecho en dicha rama. Para eso usamos git reflog. Buscamos el hash y lo copiamos.

Ya habiendo obtenido el hash lo que hacemos sera volver a crear la rama pero le agregamos el hash al final.

	git checkout -b cabecera hash_del_utlimo_commit_de_cabecera

Un momento… Minuto 5:25, el branch cabecera no volvió!!

No pude recuperar mi rama cabecera con Git reset --hard 😦

Visual Studio Code fue hecho con el amor de una madre 😄

Hola a todos, fui anotando todos los comandos del curso y los agrupé en categorías y como no podía ser de otra forma, los subí a GitHub, seria genial, que ustedes añadiesen los comandos que quisieran y/o sus propias descripciones con un pull requests
https://github.com/SuKuShaing/ComandosDeGit.git

Jajaja me gusta la forma de enseñar de Freddy, con sus actuaciones es original y hace la clase dinámica y entretenida, se aprende mejor la verdad, pase en unos pocos días de saber nada de Git a entenderle y usarlo sin problemas.

Apuntes 😄

el git reset si te devuelve al commit si hiciste algo mal en local, pero se debe usar como ultimo recurso, si el repositorio esta en la nube (github, gitlab, bitbucket, etc.) es mejor volver a clonar el repo, o pedirle a algún colaborador si existe en el proyecto que haga un push de sus cambios y hacer nosotros un pull, recordemos que son repositorios distribuidos.

así que git reset con --soft o --hard se puede hacer pero cuando ya no consigamos solución como el ultimo, recurso de después de hacer todo lo posible.

Falto mencionar que si cambias o eliminas un archivo ignorado no lo recuperas con git reset asi no más. Buena clase.

Bueno pero la rama cabecera ya se perdio, no vi que se recuperara. =/

Yo cuando freddy borró la rama cabecera

git reflog nos devuelve un histórico de las instrucciones que ejecutamos en un repositorio.

nooo frediee no quiero ver mas…

–cuando fredy te da buenos recursos pero te dice que son malas practicas jjjaa !

Como trabaje todo este tiempo sin Git y Github estas herramientas nos dan superpoderes.

Una pregunta, entonces si por error yo envio por ejemplo mi archivo .env con todas las claves de mi base de datos y api keys y estas cosas,
como hago para eliminar estos datos de la historia de mi repositorio? , según lo que dices esto es imposible ?

Cual es la diferencia de usar entre git reset --hard o --soft+ el commit y
git reset --hard o --soft + HEAD{0}

*******************************************************************************
****************Git Reset y Reflog: Úsese en caso de emergencia****************
*******************************************************************************

git reflog (Permite ver el log completo)

git reset HEAD@{2}

git RESET --hard 9ea6558

*******************************************************************************
****************Git Reset y Reflog: Úsese en caso de emergencia****************
*******************************************************************************

Úsese solo cuando nos hagamos bolita y lloremos en un rincón

Podemos hacer una copia del log por si algun dia necesitamos recuperar algo con:

git reflog > nombrearchivo.txt

nunca escriban codigo mientras estan borrachos… los puede obligar al dia siguiente a utilizar el git reset --hard

jajajajjajaja como me reí, Freddy debería tener más cursos

git reflog es el ojo de sauron. que atraviesa las sombras y la piel.

Freddie para los premios Oscar xD

haha me encanta la alegria de como enseñas

Gracias git reset --hard

OMG esto si me va a servir 😅🤘

Git reflog es como el norte nunca olvida 😃

Por si alguien olvido arbolito se escribe así:

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

ojala hubiera un git reset para tu corazon despues de que ella te rompiera el corazon XD

esto tal vez les sea de utilidad:

pasa que si nosotros metemos un commit al remoto que NO queremos que este allí, podemos sacarlo de esta manera … (desde consola y no por github)
hacer un reset --hard a la versión anterior al envio del archivo.
hacer un commit origin master -f ( f = fuerza el envio )

aqui encontraran mas info

https://www.campusmvp.es/recursos/post/como-eliminar-el-ultimo-commit-de-git-en-el-repositorio-de-origen-p-ej-github.aspx

Una anécdota que me voy a llevar de este curso es que por mas que tenga que entregar eso si tengo que dormir lo haré… XD

Cabecera sigue donde ha estado toda la vida

Ah! Es que nunca estuvo. Todo fue una mentira x’D

Si usan el powershell de windows, cuando hagan git reset [email protected]{0} deben encerrarlo en comillas git reset “[email protected]{0}” ya que puede dar error.

Excelente clase, de verdad me sorprendo mucho en como han pensado los comandos los creadores para todas las situaciones que se puedan presentar usando Git. 🙂

En mac no sirve git reset --HARD [commit] ya que al parecer tiene conflictos con las letras mayusculas, en este caso seria git reset --hard [commit] para restaurar determinado commit

Git Reset y Reflog: úsese en caso de emergencia
git reflog, Aquí se ve todo sin importar que hayas eliminado cosas o hayas hecho daños y hecho commits, una vez aquí podemos coger el ultimo HEAD donde todo estaba bien y podemos hacer un git reset.

git reset --soft, este mantiene lo que sea que tengamos en staging, a lo que le hayamos dado add, lo que todavia este pendiente de un commit.
git reset --hard, y este nos resetea todo.

git reset lo que hace es volvernos a traer esa posición donde estuvimos antes.

El comando reset es peligroso porque cuando hacemos un reset HARD es como si estuviéramos reseteando toda la historia, esta es una mala practica y no debería usarse sino hasta cuando algo realmente se rompe

aca mi pregunta interezante… recuerdo que en un proyecto hace un tiempo lanzamos un reset… solo experimentando… despues seguimos trabajando… revisando dicho proyecto seguimos avanzando hasta que llegue a esta clase y probe el reflog… y en realidad la parte donde aparece ese RESET me la “skipea”, es decir la pasa por alto por que son muchos logs. existe alguna forma de ver realmente el log completo?

dejo captura

git reset NO recupera ramas.

En conclusión NADA, pero NADA se pierde con GIT!

En git reflog está la verdad...

git reflog es el que da las pistas para resolver el crimen que cometiste jaja

Estos códigos me hubieran sido utiles a mitad del curso jejej

Hace dos calses se me fue al carajo todo, yo viendo este video 😃

git reflog, trae todos los cambios y nunca olvida.

git reset, debería ser utilizado en casos muy estrictos.

Amo reír con el estilo de Freddy.

Tssss git NUNCA OLVIDA!!!

Normalmente, en entornos de desarrollo, no se utiliza el git reset --soft si no que se hace un --hard y es razón de ello, la corrección de errores, reseteando todo radicalmente.

git reflog seria como un detective, descubre a los rebase a los amed por ahi que parecian que nunca estuvieron cuando se hacia git log jaja

La clase más divertida de todo Platzi me parece.

Eso no sería estar dormido, eso sería tener 15 cervezas encima jajajajaja

GIT REFLOG es como tu conciencia 💀👽👹

De mis videos favoritos 😄😄

ya casi terminamos el cursoooo

Tengo una duda, que tal si ese commit ya se le hizo un push y esta en el remoto?
¿puedo darle RESET en local y despues hacer push?

Hay que recordar que git reset permite viajar al pasado pero no volver al futuro 😄

++git reflog++ sirve para ver todo los que hemos hecho y desecho en el repositorio. Es importante ya que nos mostrara el id de la cabecera a la que queremos regresar.

Como así que git es mi exnovia?

Dios bendiga al REFLOG ❤️

A alguien mas le da miedito hacer ese tipo de experimentos de borrar todo o eliminar archivos, me resisto hacerlos porque siento que nunca volveré a verlos ajjajajaj

Que loco es Fredy, pero así es como se aprende

Puse en el comando de “git reset --hard” en mayusculas la palabra “HARD” y justo checo los archivos y no estaba blogpost, casi me muero del susto HAHAH

El git reset --HARD serviria si por ejemplo ya subí el repositorio a GitHub?, como seria eso?, tendriaa que hacer el reset y luego hacer Push?

Para llevar acabo un reset, primero tendríamos que poner: git reset hash de la cabeza, eso nos lleva momentos antes de hacer el último commit que está adelante. Luego un git reset --hard id commit para restaurar todo en su lugar.

esto no tiene que ver con esta clase, pero mi alias arbolito desaparecio, por que? D:

¿Verdad que $git reflog no te permite recuperar ramas?
En el video freddy eliminó cabecera, pero no la recuperó con $git reset --hard

¿Alguien sabe como recuperar ramas borradas?

cuando eliminas una rama no se elimina completamente si esta en un repositorio remoto. debido a que la rama se puede rastrear por el origen remoto

Git Reset y Reflog: úsese en caso de emergencia

Sin importar que la hayas cagado de formas inconmensurables, hay un comando que recuerda todo, git reflog. Este comando permite localizar ramas aunque estas se hayan borrado, commits, etc.

git reflog

Con este comando se busca el último HEAD donde todo estaba bien y se copia el identificador de dicho HEAD (ejemplo: [email protected]{4}).

A continuación se hace un git reset para deshacer los errores.

Hay dos tipos de git reset:

  • git reset --HARD: resetea todo sin conservar nada del staging area. Por lo general es el que más se usa en casos de emergencia.
  • git reset --SOFT: conserva los archivos que esten en el staging area
git reset --HARD [email protected]{4} # Retorna el estado del proyecto al HEAD especificado
git reset --HARD hash # También puede recibir un hash por parámetro

Hacer esto se considera como una mala práctica por lo que sólo debe usarse n casos de emergencia. Git reset no borra el registro que queda en git reflog

En mi opinion el comando: git reset --HARD nos vamos a llevar muy bien

git reset --HARD = bite za dusto

(jojo referencia)

  • git reflog Encontramos la historia de los cambios realizados con los archivos en git, como las ramas o archivos eliminados

jajaja por qué asta ahora me entero de esto?

$git reflog es vida
$git reflog es amor

git reflog: Muestra una lista de toda la historia de commits, cada uno con su hash y HEAD

git reflog par ver todos los cambios en la historia