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 Stash: Guardar cambios en memoria y recuperarlos después

36/43
Recursos

El stashed nos sirve para guardar cambios para después, Es una lista de estados que nos guarda algunos cambios que hicimos en Staging para poder cambiar de rama sin perder el trabajo que todavía no guardamos en un commit

Ésto es especialmente útil porque hay veces que no se permite cambiar de rama, ésto porque tenemos cambios sin guardar, no siempre es un cambio lo suficientemente bueno como para hacer un commit, pero no queremos perder ese código en el que estuvimos trabajando.

El stashed nos permite cambiar de ramas, hacer cambios, trabajar en otras cosas y, más adelante, retomar el trabajo con los archivos que teníamos en Staging, pero que podemos recuperar, ya que los guardamos en el Stash.

git stash

El comando git stash guarda el trabajo actual del Staging en una lista diseñada para ser temporal llamada Stash, para que pueda ser recuperado en el futuro.

Para agregar los cambios al stash se utiliza el comando:

git stash

Podemos poner un mensaje en el stash, para asi diferenciarlos en git stash list por si tenemos varios elementos en el stash. Ésto con:

git stash save "mensaje identificador del elemento del stashed"

Obtener elelmentos del stash

El stashed se comporta como una Stack de datos comportándose de manera tipo LIFO (del inglés Last In, First Out, «último en entrar, primero en salir»), así podemos acceder al método pop.

El método pop recuperará y sacará de la lista el último estado del stashed y lo insertará en el staging area, por lo que es importante saber en qué branch te encuentras para poder recuperarlo, ya que el stash será agnóstico a la rama o estado en el que te encuentres. Siempre recuperará los cambios que hiciste en el lugar que lo llamas.

Para recuperar los últimos cambios desde el stash a tu staging area utiliza el comando:

git stash pop

Para aplicar los cambios de un stash específico y eliminarlo del stash:

git stash pop stash@{<num_stash>}

Para retomar los cambios de una posición específica del Stash puedes utilizar el comando:

git stash apply [email protected]{<num_stash>}

Donde el <num_stash> lo obtienes desden el git stash list

Listado de elementos en el stash

Para ver la lista de cambios guardados en Stash y así poder recuperarlos o hacer algo con ellos podemos utilizar el comando:

git stash list

Retomar los cambios de una posición específica del Stash || Aplica los cambios de un stash específico

Crear una rama con el stash

Para crear una rama y aplicar el stash más reciente podemos utilizar el comando

git stash branch <nombre_de_la_rama>

Si deseas crear una rama y aplicar un stash específico (obtenido desde git stash list) puedes utilizar el comando:

git stash branch nombre_de_rama stash@{<num_stash>}

Al utilizar estos comandos crearás una rama con el nombre <nombre_de_la_rama>, te pasarás a ella y tendrás el stash especificado en tu staging area.

Eliminar elementos del stash

Para eliminar los cambios más recientes dentro del stash (el elemento 0), podemos utilizar el comando:

git stash drop

Pero si, en cambio, conoces el índice del stash que quieres borrar (mediante git stash list) puedes utilizar el comando:

git stash drop [email protected]{<num_stash>}

Donde el <num_stash> es el índice del cambio guardado.

Si, en cambio, deseas eliminar todos los elementos del stash, puedes utilizar:

git stash clear

Consideraciones:

  • El cambio más reciente (al crear un stash) SIEMPRE recibe el valor 0 y los que estaban antes aumentan su valor.
  • Al crear un stash tomará los archivos que han sido modificados y eliminados. Para que tome un archivo creado es necesario agregarlo al Staging Area con git add [nombre_archivo] con la intención de que git tenga un seguimiento de ese archivo, o también utilizando el comando git stash -u (que guardará en el stash los archivos que no estén en el staging).
  • Al aplicar un stash este no se elimina, es buena práctica eliminarlo.

Aporte creado por: David Behar.

Aportes 366

Preguntas 43

Ordenar por:

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

Stashed:

El stashed nos sirve para guardar cambios para después, Es una lista de estados que nos guarda algunos cambios que hicimos en Staging para poder cambiar de rama sin perder el trabajo que todavía no guardamos en un commit

Ésto es especialmente útil porque hay veces que no se permite cambiar de rama, ésto porque porque tenemos cambios sin guardar, no siempre es un cambio lo suficientemente bueno como para hacer un commit, pero no queremos perder ese código en el que estuvimos trabajando.

El stashed nos permite cambiar de ramas, hacer cambios, trabajar en otras cosas y, más adelante, retomar el trabajo con los archivos que teníamos en Staging pero que podemos recuperar ya que los guardamos en el Stash.

git stash

El comando git stash guarda el trabajo actual del Staging en una lista diseñada para ser temporal llamada Stash, para que pueda ser recuperado en el futuro.

Para agregar los cambios al stash se utiliza el comando:

git stash

Podemos poner un mensaje en el stash, para asi diferenciarlos en git stash list por si tenemos varios elementos en el stash. Ésto con:

git stash save "mensaje identificador del elemento del stashed"

Obtener elelmentos del stash

El stashed se comporta como una Stack de datos comportándose de manera tipo LIFO (del inglés Last In, First Out, «último en entrar, primero en salir»), así podemos acceder al método pop.

El método pop recuperará y sacará de la lista el último estado del stashed y lo insertará en el staging area, por lo que es importante saber en qué branch te encuentras para poder recuperarlo, ya que el stash será agnóstico a la rama o estado en el que te encuentres, siempre recuperará los cambios que hiciste en el lugar que lo llamas.

Para recuperar los últimos cambios desde el stash a tu staging area utiliza el comando:

git stash pop

Para aplicar los cambios de un stash específico y eliminarlo del stash:

git stash pop [email protected]{<num_stash>}

Para retomar los cambios de una posición específica del Stash puedes utilizar el comando:

git stash apply [email protected]{<num_stash>}

Donde el <num_stash> lo obtienes desden el git stash list

Listado de elementos en el stash

Para ver la lista de cambios guardados en Stash y así poder recuperarlos o hacer algo con ellos podemos utilizar el comando:

git stash list

Retomar los cambios de una posición específica del Stash || Aplica los cambios de un stash específico

Crear una rama con el stash

Para crear una rama y aplicar el stash mas reciente podemos utilizar el comando

git stash branch <nombre_de_la_rama>

Si deseas crear una rama y aplicar un stash específico (obtenido desde git stash list) puedes utilizar el comando:

git stash branch nombre_de_rama [email protected]{<num_stash>}

Al utilizar estos comandos crearás una rama con el nombre <nombre_de_la_rama>, te pasarás a ella y tendrás el stash especificado en tu staging area.

Eliminar elementos del stash

Para eliminar los cambios más recientes dentro del stash (el elemento 0), podemos utilizar el comando:

git stash drop

Pero si en cambio conoces el índice del stash que quieres borrar (mediante git stash list) puedes utilizar el comando:

git stash drop [email protected]{<num_stash>}

Donde el <num_stash> es el índice del cambio guardado.

Si en cambio deseas eliminar todos los elementos del stash, puedes utilizar:

git stash clear

Consideraciones:

  • El cambio más reciente (al crear un stash) SIEMPRE recibe el valor 0 y los que estaban antes aumentan su valor.
  • Al crear un stash tomará los archivos que han sido modificados y eliminados. Para que tome un archivo creado es necesario agregarlo al Staging Area con git add [nombre_archivo] con la intención de que git tenga un seguimiento de ese archivo, o también utilizando el comando git stash -u (que guardará en el stash los archivos que no estén en el staging).
  • Al aplicar un stash este no se elimina, es buena práctica eliminarlo.

git stash : Guarda el trabajo actual de manera temporal. (Archivos modificados o eliminados)
git stash -u : Crea un stash con todos los archivos. (Añadiendo los creados Untracked)
git stash save “mensaje” : Crea un stash con el mensaje especificado.
git stash list : Permite visualizar todos los stash existentes.
git stash clear : Elimina todos los stash existentes.
git stash drop : Elimina el stash más reciente. El que tiene num_stash=0.
git stash drop [email protected]{num_stash} : Elimina un stash específico.
git stash apply : Aplica el stash más reciente. El que tiene num_stash=0.
git stash apply [email protected]{num_stash} : Aplica los cambios de un stash específico.
git stash pop : Aplica el stash más reciente y lo elimina. El que tiene num_stash=0.
git stash pop [email protected]{num_stash} : Aplica los cambios de un stash específico y elimina lo stash.
git stash branch nombre_de_rama : Crea una rama y aplica el stash mas reciente.
git stash branch nombre_de_rama [email protected]{num_stash} : Crea una rama y aplica el stash especificado.

Consideraciones:

  • El cambio más reciente (al crear un stash) SIEMPRE recibe el valor 0 y los que estaban antes aumentan su valor.
  • Al crear un stash tomará los archivos que han sido modificados y eliminados. Para que tome un archivo creado es necesario agregarlo al Staging Area con git add [nombre_archivo] con la intención de que git tenga un seguimiento de ese archivo, o también utilizando el comando git stash -u.
  • Al aplicar un stash este no se elimina, es buena práctica eliminarlo.

Aquí mis apuntes de Git Stash!

Git stash es como decirle a un cambio “No, no avances quedate conmigo un rato que yo te digo qué hacer”.

-git stash: “Vení acá un segundo.”

-git stash drop: Lo matas (F)

-git stash pop: Volvé a donde estabas (el cambio post-commit vuelve al archivo)

-git stash list: “Mira usuario, ese es el cambio que tengo guardado.”

-git stash branch x: “Andá a esa rama de ahí. No al master porque no te quieren ahí por ahora 😭”

VSCode tiene una extensión para visualizar ramas: Git Graph.

![](

  • git stash : Guardamos un estado temporal

  • git stash list : vemos la lista de stash que tenemos

  • git stash pop : restablecemos el estado que teniamos guardado

  • git stash branch (nombre de la rama ) : despues de haber creado un stash en memoria podemos crear una nueva rama con se cambio que esta en stash

  • git stash drop : borramos un stash ya guardado

Si hacemos

git stash save "aqui va un mensaje para identificar el stash"

Podemos poner mensaje al stash, por si tenemos varios y asi diferenciarlos en git stash list.

De igual manera para llamar a un stash en particular y aplicarlo

git stash apply [email protected]{numero del stash}

El numero del stash lo podemos ver en la lista de stash

Excelente explicación y si es un comando muy usado, hay una opción que acabo de leerla en la documentación oficial que me parece interesante y es el

git stash --patch

En donde el git te va mostrando la diferencia de cada uno de los archivos y te va preguntando que si lo quieres guardar en el stash. Es como mantener en memoria no todos los archivos modificados, pero si algunos de ellos y uno decide cuales.

git stash = guarda los cambios en memoria cuando no quieres hacer un commit aun
git stash save “mensaje” = guarda un stach con mensaje
git stash list = lista de todos stash
git stash pop = trae de vuelta los cambios que teniamos guardados en el ultimo stash
git stash apply [email protected]{n} = trae el stash que necesites con indicar su numero dentro de las llaves
git stash drop = borra el ultimo stash
git stash clear = borra todos los stash

GIT STASH

  • git stash = guarda los cambios que se han hecho al archivo (cambios en ustasged)

  • git stash list = muestra los stash disponibles (los cambios guardados)

  • git stash pop = te lanza el ultimo stash que guardaste y lo borra de la lista de stash

  • git stash pop indiceDelStash = te lanza el stash selececcionado por le indice // los stash se guardan desde arriba hacia abajo (lista) por lo tanto el ultimo stash guardado siempre sera del indice 0

  • git stash apply indice(opcional) = hace los mismo que git pop, pero no borra el stash seleccionado

  • git stash drop = elimina el ultimo stash agregado (stash indice 0)

  • git stash branch nombreDeLaRama = crea una nueva rama con el ultimo stash agregado // se necesita un stash guardado anteriormente //si nos vamos a otra rama el stash seguira en staging, no se sobreesriben con el checkout, es como si fuera un staging global

  • git stash branch nombreDeLaRama indiceDelStash = crea una nueva rama con el stash seleccionado por el indice

Git stash == ctrl + z
  • git stash Guarda los cambios temporalmente
  • git stash list Muestra la lista de cambios temporales
  • git stash pop Saca los cambios temporales y regresa los cambios al directorio de trabajo
  • git stash drop Elimina los cambios temporales

Guardar los cambios y ponerlos en una rama

  • git stash branch english-version Coloca el stash en una rama

Tan bonito que es el git stash ❤️

Otro comando útil es: git stash apply [email protected]{0} así pueden seleccionar cual stash aplicar de todos los que se hayan guardado.

Pueden ver un poquito más sobre como funciona en este link

Apuntes locos 😅

 <git stash>  Guarda los cambios en memoria

<git stash list> Muestra la lista de  los cambios que se han guardado

<git stash pop> Muestra los cambios

<git stash branch [rama]>  Lleva los cambios a una nueva rama

<git stash drop> Borra los cambios guardados en stash



  

Se pueden tener varios stash a partir de un mismo commit:

Y el comando stash pop también sirve para seleccionar alguno de estos:

$ git stash pop [email protected]{1}

Hay que tener en cuenta que al hacer esto, hay un traslado de stash en git stash list y el que era el [email protected]{2} pasa a ser [email protected]{1}

Y para ver la diferencia entre el stash y el último commit sin tener que seleccionarlo con pop se puede usar git stash show.
Por ejemplo con el [email protected]{2}

> git stash show -p [email protected]{2}

git stash:
guarda los cambios de manera temporal y regresa al commit anterior; desde alli puedes moverte entre ramas para recuperar informacion desde esta; tambien puede ser util para hacer experimentos rapidos.
Comandos:
git stash: crea el estash
git stash list: lista de stash creados
git stash drop: elimina el stash
git stash pop: abre el stash en la rama actual
git stash branch nombre_rama: guarda el stash en nobre_rama
Nota: recuerda regresar a la rama original antes de quitar el stash

Comandos de la clase

  1. Para guardar los cambios realizados en memoria: git stash
  2. Para ver lo guardado en memoria: git stash list
  3. Para obtener lo guardado en memoria: git stash pop
  4. Para agregar los cambios almacenados en memoria y ubicarlos en la rama “nameBranch”: git stash branch “nameBranch”
  5. Para eliminar los cambios almacenados en memoría: git stash drop

git stash: Guarda los cambios en memoria.
git stash list: Muestra la lista de todos los stash que tengamos guardados.
git stash branch nombre_rama: Crea una nueva rama y envía todos los cambios allá.
git stash drop: Borra los cambios guardados en stash.
git stash pop: Muestra los cambios guardados en stash, también podemos mostrar los cambios de un stash determinado usando su índice que nos muestra el git stash list "git stash pop [email protected]{1} " siendo el índice {0} el último stash guardado.

Nota:“No se puede colocar los cambios de dos o más stash al mismo tiempo, antes debemos hacer commit del primer stash”

Mi resumen de esta clase 😄

## 1- Stasheando cambios

Para stashear estos cambios, simplemente ejecuta git stash sin ningún argumento.

git stash

Esto tomará tanto tus cambios en el área de espera como los que no están en el área de espera, grabandolos internamente, y luego limpiando el directorio de trabajo. Esto te da la oportunidad de cambiarte a una nueva rama y desarrollar nuevas características sin preocuparte de que tu commit parcial vaya a estropear algo.

## 2- Re-aplicando cambios stasheados

Cuando estás listo para volver a tu trabajo incompleto, corre el siguiente comando para re-aplicar los cambios stasheados:

git stash pop

El conjunto más reciente de cambios stasheados aparecerá en el directorio de trabajo y puedes continuar exactamente donde te habías quedado. Es todo lo que hay que hacer.

Les dejo otros comandos super útiles:

  • $ git stash show: muestra los cambios registrados en el stash. (Es muy parecido a git log --stat).

  • $ git stash show -p: este parámetro -p hace que el funcionamiento sea paerecido a un git diff, solo que refiriendose al stash.

  • $ git stash apply: funciona igual que git stash pop, solo que en lugar de borrar el stash, lo sigue almacenando. Esto es util por ejemplo si queremos conservar una especie de “historia”, o simplemente no queremos eliminarlo.

  • $ git stash clear: borra todos los stash, para no tener que borrarlos uno por uno.


Algunos datos importantes:

  • Podemos tener decenas de stash, incluso de distintas ramas, solo que hay que tener en cuenta que git los guarda “de arriba hacia abajo”, es decir, que el ultimo stash se llamará [email protected]{0} o el stash número 0 (compruébalo por tí mismo con git stash list).

  • Teniendo en cuenta lo anterior, se puede decir que todos los comandos explicados en este comentario hacen referencia al [email protected]{0}, que no es más que el último stash realizado. Lo interesante es que obviamente podemos cambiar esa referencia. Dicho de otro manera, podemos hacer “git stash show nombreStash”, “git stash show -p nombreStash”, “git apply nombreStash”, etc, etc.

No vi este truco adicional en los otros aportes, entonces lo pongo.
Crear un stash quita los cambios, ¿pero qué pasa si los quiero conservar y simplemente usar el stash como un “copiado de portapapeles”?
Para crear un stash sin perder los cambios:

  1. Agregar a staging los archivos con los cambios que me interesan
  2. Realizar git stash --keep-index

Diariamente trabajo en un equipo muy dinámico, muchas veces debo salir de mis tareas para atacar un bug o fix que tiene prioridad y sobretodo cuando estas trabajando en nuevos features donde ya has agregado muchas lineas de código se vuelve un poco complicado (si no existiera git stash) para hacer esa pausa, irte a otra rama para solucionar el bug y luego volver a tu rama anterior y restaurar el estado en el que estabas, quizas se puede pensar que basta con hacer un git add . y comitearlo todo, pero en mi caso prefiero hacer los commit bien organizado seleccionando solo las lineas modificadas asi también contribuyo a que mi Code Reviewer tenga mejor visión de los cambios que hice. Para ello confirmo los cambios con la herramienta git gui que ya viene instalada con git al igual que gitk.

La utilidad de Stash es impresionantes para el manejo fluido de un proyecto en términos del movimiento entre ramas. El resumen de la clase en términos de comandos es:

$git stash (Guarda los cambios hechos en la rama actual)
$git stash list (Muestra los lugares temporales que han sido guardados)
$git stash pop (Devuelve los cambios stasheadosmás recientes en la rama actual)
$git stas branch _ramaS_ (Envía los cambios y se mueve a la ramaS)
$git stash drop (Elimina el lugar temporal de guardado más reciente)

Espero que les ayude.

Algo importante a recalcar es que estamos hablando de una lista de “stash”, por lo que al ejecutar el comando en repetidas ocasiones vas agregando a la lista de “stash”. Esto se comporta como una Pila de estructura de datos, por eso hay comandos normalmente conocidos como pop.
Más información en la Documentación oficial

No es como un ctrl + z ?


Git Stash


git stash (crea un stash)
git stash list (lista los stash)
git stash pop (carga el stash)
git stash branch english-version (Crear una rama con el stash)
git stash drop (borrar un stash)


Git Stash


Si realizas cambios, no les haces commit e intentas cambiar de rama; git es tan smart que te dice:

error: Your local changes to the following files would be overwritten by checkout:
	Most used commands in Git.txt
Please commit your changes or stash them before you switch branches.
Aborting

Traducción:
Hey! no seas silly o le haces commit o stash, pero no puedo permitirte que pierdas tus avances!! 😉

Gracias Git

yeiiiii! ya no tendré que hacer una copia de mis archivos para poder cambiarme de branch jajaja

Algo similar me pasó en un proyecto personal:
Tenía que realizar dos historias de usuario, en cada una debía modificar una sola clase. Dos ramas para dos clases.
Había terminado la primer historia, y como la segunda era muuuy parecida. Quería ver cómo hice la primera para replicarla.
Estando en la segunda rama, apliqué el comando

git checkout <commit_de_primer_rama> <documento>

Con “tomas prestada” esa version del primer archivo, sin cambiar de rama.
Lo importante es recordar devolver esa version, o de lo contrario git tomará como que editaste el primer archivo, también en la segunda historia.

Imaginen la escena de Avengers Endgame, donde Bruce va con The Ancient One: Prestame la gema, hago mis cosas; y cuando termine, te la regreso.

git stash == Ctrl + z

git stash almacena temporalmente los cambios que realizamos en el código en el que trabajamos.

Creo que este es uno de los codigos mas importantes para mi, abre una ventana de oportunidades para hacer muchas cosas.

madre mia willy!
y yo aqui creando ramas a lo loco para probar una sola cosa.

Para los que usan linux y no saben como tener la interfaz grafica (gitk) usen: sudo apt-get install git-gui gitk

Tip: Yo uso varias computadora:
1 en el trabajo
1 lap cuando estoy en otro lugar
1 de escritorio
Entonces guardo mis cambios locales en un archivo con el comando
$ git diff --cached > changes.patch
o
los cambios que deje en el stash
$ git stash show “[email protected]{0}” -p > changes.patch

el archivo changes.patch lo comparto en mi google driver
y cuando estoy en mi computadora lo unico que realizo es aplicar las modificaciones
$git apply changes.patch
o si quiero revertir los cambios
$ git apply changes.patch --reverse
Espero que sea de utilidad así puedes guardar tus cambios en un archivo y después aplicarlos en otro lado.

Git Stash es una forma útil de mantener mis cambios en temporal y poder moverme entre ramas.

  • Para guardar cambios temporalmente: git stash
  • Para ver los cambios en stash: git stash -list
  • Para mover los cambios en stash a una rama: git stash branch <nombre de rama>
  • Para borrar cambios en stash: git stash -drop

Como se puede ver en la consolas cuando Freddy utiliza git stash list abajo se muestran los “stashes” hechos y con un identificador:

[email protected]{0}: WIP on master: 255ddd1
[email protected]{1}: WIP on master: 255ddd1

Es el 0 y el 1 después de [email protected], esto es importante por que el comando git stash drop elimina el último cambio hecho, pero también se le puede especificar el identificador, por ejemplo git stash drop 1, esto también ocurre con el comando git stash pop asi que es útil para mostrar un stash especifico. Para eliminar todos los cambios hechos se utiliza git stash clear

Encontré esta página que explica con ejemplos el Git Stash, https://www.cspsprotocol.com/git-stash-command/

Una manera util de nombrar a los stash cuando se tiene demasiados o solamente quieres distinguir cada stash es con el comando:

git stash push -m "my_stash"

Si se desea hacer varios “Stash” y al mismo tiempo dejar un recordatorio para diferenciarlos, se usa el comando Git stash save <“Mensaje”>.
Al momento de usar el git stash list se muestran todos los stash con su id ([email protected]{0}) y un mensaje. Para volver a aplicar algún cambio específico guardado en la lista de stash se usa git stash pop <StashId>.

git stast pop = git stash apply + git stash drop

Git stash es el Ctrl Z de Git

Git stash es bueno para probar algo rapido

`git stash` guarda solo los archivos que estén dentro del stage index

Con mi desorden al parecer git stash va a ser mi pan de cada día

como aportación importante les comento que se pueden guardar muchos stash al mismo tiempo y con le codigo que poseen se pueden tomar los que uno desea, eso se logra adicionando a los comandos aquí dados en la clase el código del stash

Git Stash ¿de qué se trata?
Se trata de un comando que “congela” el estado en el que se encuentra el proyecto en un momento determinado, con todos los cambios que tenemos a “sin comitear”, y lo guarda en una pila provisional brindando la posibilidad de poder recuperarlo más adelante. Siguiendo con nuestro ejemplo, lo que haríamos es guardar los cambios que hemos hecho con git stash, esto deja el working tree limpio y nos permite cambiar de rama sin problema. Una vez solucionado el bug, volveríamos a nuestra rama y recuperaríamos nuestros cambios con git stash apply.

Comandos vistos en esta clase:

- git stash = guarda temporalmente el último commit de la rama actual.

- git stash list = muestra el último stash realizado.

- git stash pop = carga el último stash realizado en la rama actual.

- git stash branch nombre_rama = guarda el último stash en una nueva rama. Después se debe hacer commit desde la nueva rama creada.

- git stash = se puede usar también para recuperar el último commit de la rama actual, en caso de haber cometido errores. Es como una especie de ctrl+z de git.

- git stash drop = borra el último stash realizado.

Para mas informacion puedes acceder a este link

Stash: Sirve para guardar los cambios actuales, y regresar a un punto antes de los cambios que hayan roto tu programa.

*Guarda en estado temporal los cambios.
Git stash

*Lista los stash
Git stash list

*Carga el estado de stash
Git stash pop

*Crea una nueva rama con el stash que tengamos guardado
git stash branch ‘nombre de la rama’

*Borra lo que tengas en stash,
Git stash drop

  • El comando $ git stash nos permite guardar temporalmente los cambios que no han sido guardados en un commit.
    -En caso de haber cometido algún error, o que en medio de nuestro trabajo deseamos ir a alguna rama sin perder los cambios sin necesidad de hacer commit este comando nos es muy útil.
  • Una vez guardados temporalmente los datos podemos decidir entre borrar los cambios, crear una rama y mandar esos cambios ahí, o volverlos a traer en caso de ser necesario.
  • NOTA: No se puede colocar el contenido de dos stash sin antes haber hecho commit del primero.
  • git stash
  • git stash list
  • git stash pop

--------------------------- stash--------------------------------
Es la forma temporal en que dejamos los archivos en staging para poder cambiarse de rama sin perde lo cambio que fueramos hecho

git stash: es otro de los limbos, como el staging area. Para agregar los cambios estos deben estar en el staging area.
git stash list: nos muestra la lista de stash que tengamos.
git stash drop : nos permite borrar un stash.
git stash apply: aplicamos el último cambio.
git stash pop: aplicamos el último cambio.
git stash branch +nombre de rama nueva : es para poner la informacion del stash una nueva rama automatica

git stash Es una forma útil de tener en temporal los cambios para poder moverse entre ramas y luego poder recuperar esos cambios.

Bien eso de usar stash cuando se lleva mucho trabajo adelantado sin hacer commits y se necesitan datos de otra rama. En vez de ir a GitHub para tener todo el entorno listo, mejor hacer git stash y luego**_ checkout_** hacia otra rama.

Relacioné a stash con una cápsula.
Esta cápsula o Stash sirve para guardar un cambio dentro del archivo

$ git stash

y puedes liberar el cambio con

$ git stash pop

También te permite liberar el cambio en un branch o rama con:

$ git stash branch **nombre del branch o rama**

y finalmente eliminar la capsula con:

$ git stash drop

liberando el cambio guardado.💚

Freddy en la ultima parte del video dijo: ‘chereve aprenderlo pero no creo necesitarlo’ lo mismo pense hace 2 años cuando vi por primera vez el curso, ahora que ya estoy en cosas mucho mas avanzadas, aquí estoy de regreso para ver como se usa git stash… Bastante sabio el hombre.

que bello es el comando stash

git stash -m "mensaje"  //Si quieres añadir un mensaje más descriptivo para saber qué es lo que has hecho.  

Resumen de la clase
Hice cambio a la rama master, tengo que irme a una rama anterior pero aun no quiero hacerle commit a las modificaciones.
Las quiero guardar en otro lugar
-git stash//guarda los cambios
-git stash list//work in process
Ahora me muevo en la rama
Es mejor regresar a la rama principal y luego ahí quitar el stash
-git stash pop//para obtener lo guardado

También podemos guardar cambios y llevarlos a otra rama.
Primero: git stash
Segundo: git stash branch version-ingles

si hicimos cambios que no deseamos conservarm podemos usar git stash y luego:
git stash drop// para borrar lo grabado

Para crear una rama y aplicar el stash mas reciente podemos utilizar el comando
git stash branch <nombre_de_la_rama>
Si deseas crear una rama y aplicar un stash específico (obtenido desde git stash list) puedes utilizar el comando:
git stash branch nombre_de_rama [email protected]{<num_stash>}

Git Stash: Guardar cambios en memoria y recuperarlos después
En ocasiones realizamos ciertos cambios en nuestro proyecto, pero no queremos hacer un commit todavía y para estas ocasiones especiales existe un comando de git muy útil: Stash. Stash nos permite guardar nuestros cambios en un lugar sin tener que hacer un commit y nos lleva de vuelta al ultimo commit.
Podemos tener varias versiones de nuestro proyecto en Stash
Existen ciertos comandos que considero que son muy útiles:
• git stash: guarda los cambios realizados a partir del último commit
• git stash save “mensaje”: tiene la misma función que git stash, pero nos permite colocar un mensaje para poder identificarlo más fácil.
• git stash list: nos muestra todos los stash que tenemos, cada stash tiene un identificador y cada que agregamos un nuevo stash todos los demás se recorren una posición y el nuevo toma el valor del índice 0.
• git stash pop: nos trae devuelta los cambios del stash mas reciente, el del índice 0 y también lo elimina
• git stash drop: elimina el stash mas reciente, el que se encuentra en el índice 0, hay que tener cuidado de no confundirlo con pop ya que drop únicamente lo elimina y no nos trae los cambios devuelta.
• git stash apply: nos trae devuelta los cambios del último stash, pero no lo elimina, es muy parecido al comando git stash pop pero la diferencia que tiene con este es que al usar apply el stash sigue ahí mientras que en pop si se elimina.
• git stash branch nombre_de_la_rama: crea una nueva rama y aplica los cambios del stash mas reciente
A cada uno de los últimos cuatro comandos mencionados (pop, drop, apply, branch) se les puede indicar el índice de un stash en especifico para ejecutarse sobre este, solamente se tiene que agregar el final [email protected]{indice_stash}
Ejemplos:
• git stash pop [email protected]{1}
• git stash drop [email protected]{2}
• git stash apply [email protected]{3}
• git stash branch nombre_de_la_rama [email protected]{4}
Me gustaría añadir que en muchos de los aportes de mis compañeros fueron de gran utilidad para comprender mejor como funciona stash y sobre todo las diversas aplicaciones que tiene este comando 😎

lo entendí como control + Z a grande rasgos

Excelente explicación master!

GIT-STASH mi contribución:
Stash nos permite mantener cambios en nuestros archivos sin tener la necesidad de hacer un commit o una nueva rama tenemos estos comandos para ellos:
git stash
git stash list: Aparecen los cambios que hicimos.
gist stash pop: muestra los cambios de modificación como un estado.
git stash branch nombrerama: crea una nueva rama con tu modificacion.
git stash drop: borra la modificación que hiciste.

Stash: Guardar cambios en memoria y recuperarlos después

  • Hacer cambios, querer regresar depues pero sin tener que hacer commits todavia

  • Se revierten los cambios, y los guarda en el stash

  • Los podemos ver con stash list

  • Con stash pop regresamos lo que tenemos del stash al ambiente de trabajo

  • Con stash drop, podemos eliminar lo que existe en el

Buena práctica siempre hacer git pull

esta cool el stash creo que lo aplicare a partir de ahora…

Esto es verdaderamente útil, pensé que ya sabía gran parte por tomar el anterior curso. Pero nunca he usado git stash y en entornos reales de trabajo ayuda mucho.

Pregunta de examen
¿Cómo colocar stash en una rama?
https://platzi.com/clases/1557-git-github/19984-stash/?time=229

  • git stash = guardar cambios en memoria para poder moverse entre ramas
    -git stash list = lista los cambios guardados en memoria.
    -git stash pop = haber el stach que se tenia antes de cambiar a la rama
  • git stash branch NOMBRE_DE_LA_RAMA = se crea una rama con el stash guardado
  • git stash drop = eliminamos el stash

Quise hacer una rama con un stash, pero no me acordé que debía ejecutarse primero el stash. Me puse a improvisar comandos y resulté agregándolos al stage. ¿Qué debería hacer en ese caso para sacarlos de stage y poderlos poner en stash?

Me gustó mucho este comando, puede ayudar a resolver descuidos o momentos de desconcentración y realizar cambios no deseados en otras ramas. 🙂

Muy util, ya tengo pensado muchos casos de usos.

Este es un comando muy utilizado en el caso de que estén trabajando en una tarea en especifico del proyecto y se encuentran en una rama que hace referencia a esa tarea, pero resulta que surgió un bug en la rama que hace referencia a producción y tienes que cambiarte rápidamente de rama a solucionarlo pero no quieres committear porque aun no terminas tu tarea entonces haces un git stash mientras vas a solucionar el problema en prod y luego vuelves a tu rama de la tarea.

Que gran ayuda la de git stash

git stash, guarda en memoria; si por error se apaga el equipo o cierro el cierro el git, pierdo el stash?

Usar stash para almacenar cambios de manera temporal, sin realizar add o commit directamente a la rama.

Una herramienta muy interesante para realizar pruebas.

git stash
git stash list
git stash pop
git stash branch english-version
git stash drop

Y como dijio Freddy “Lo vas a necesitar” Lo necesité hahahah
Está genial poder regresar a los cursos que ya hiciste y entender mas a profundidad su contenido
Love Platzi!!

$git stash 
  • Guarda (en stash-> que es una lista temporal) los cambios realizados para que se puedan recuperar en el futuro.
$git stash apply
  • Aplica cambios pero los mantiene en nuestra lista (stash).
$git stash pop
  • Aplica cambios pero los elimina de nuetra lista (stash).

Git stash es demasiado bueno para creerlo!

print("Aprendiendo Git Stash");

Muy importante ese tal git stash

git permite guardar varios cambios desde diferentes ramas

git stash drop solo elimina el último cambio realizado (es decir el primero de la lista, como una pila), pero git stash clear borra toda la lista

Con ese último comentario que hizo Freddy creo que él nos lee la mente. jajajaja

¿Por cuánto tiempo puedo tener ese cambio en stash?
Supongo que mientras se apaga el equipo ¿O no?

Cada clase, git es mas hermoso. Ahora con un ctrl+z

Maravilloso, super entendible.

Resumen:
¿Qué pasa si estoy trabajando en master, tengo unos arreglos en proceso y resulta que debo ir a otra rama urgentemente a trabajar alguna solución? No quiero hacer commit aún porque no he terminado, pero cuando termine el otro arreglo sí necesito recuperar donde iba en master para continuar:

Para eso uso git stash:

# Estoy en master trabajando
# Debo ir urgentemente al branch footer a hacer un arreglo pero tengo cambios en master sin terminar.
# Uso git stash para dejar los cambios en memoria
$ git stash

# Compruebo que se hizo el stash
$ git stash list

# Voy a footer y hago lo que se requiere
$ git checkout footer
# Si es necesario hago el commit del caso
$ git commit -am "Arreglo que era urgente"

# Vuelvo a master
$ git checkout master

# Ya en master traigo el trabajo en donde iba
$ git stash pop

# Ya puedo continuar

También es posible crear una rama con el stash o borrar el stash:

# Para crear una nueva rama con el stash
$ git stash branch english-version

# Para borrar un stash
$ git stash drop

pasos:
haces cambios (como lo hizo en master)
haces git stash
git stash list (para verificar)
git stash branch (nombre de la nueva rama) ----> cambia de rama en automatico.
git commit -am "msj"
listo puedes volver a tu version original con un git checkout

excelente herramienta !!
así evitaremos tantos commits innecesarios

Es básicamente el Ctrl+Z de git