¿Cuál es el equivalente Git de los comandos TFS shelve/unshelve? cherry-pick?

Question

Descubrí que los comandos shelve / unshelve en TFS son muy útiles y fáciles de usar. ¿Cuál es el equivalente en Git?

aquí está el escenario en TFS:

• Hice cambios en el maletero
• Guardo: el conjunto de cambios se guarda en el servidor (con una etiqueta) y recupero la fuente antes de los cambios
• Yo trabajo en el maletero
• Alguien puede unshelve: obtener el cambio establecido en su espacio de trabajo

Sé que hay un comando llamado cherry-pick pero no estoy seguro del flujo de trabajo y si se ajusta a la necesidad.

Answer 1

Lo que quieres hacer se logra con una vieja y simple ramificación en git.

De una buena respuesta de por JaredPar :

Estanterías es una forma de guardar todos los cambios en su caja sin registrarse. Los cambios se mantienen en el servidor.

Esto es análogo a comprometerse con una sucursal y empujarla a un servidor en git.

Cómo hacerlo:

Supongamos que está trabajando en la rama "maestra" y decide implementar la característica X. Tiene un buen comienzo, pero luego su jefe le dice que la característica Y necesita implementarse tan pronto como sea posible. Phil en el cubo siguiente sobre voluntarios para terminar la característica X mientras que sí tienes Y. Esto es lo que haces:

Cree una nueva sucursal y cambie a ella:

$ git checkout -b feature-x

Confirme sus cambios:

$ git add filethatyouchanged.cc
$ git commit -m ''partial implementation of feature X''

Presiónalo en un servidor que Phil pueda ver:

$ git push origin feature-x

Vuelve a la rama principal (que no ha cambiado):

$ git checkout master

Es posible que también desee crear proactivamente una nueva rama para la característica Y:

$ git checkout -b feature-y

Phil ahora puede desplegar su trabajo de característica X y continuar donde lo dejó:

phil$ git fetch origin
phil$ git checkout -t origin/feature-x

Answer 2

git stash es un poco similar, excepto que está limitado a tu árbol de trabajo.

En un DVCS, para lograr ese tipo de flujo de trabajo, necesita:

• comprometa sus cambios actuales en una nueva rama
• Verifique la sucursal original donde puede continuar, sin ninguno de los cambios que ha introducido (pero se ha comprometido en la nueva sucursal)
• empujar esa nueva rama a un repositorio simple
• permite que otro desarrollador tire de esa nueva rama y la fusione con su rama actual.

Otra forma sería dejar que el otro desarrollador busque su sucursal (donde se ha comprometido ese conjunto especial de cambios), y seleccionarla con precisión , pero eso no se recomienda, porque las confirmaciones seleccionadas son difíciles de seguir .

Answer 3

Lo que describes es similar a git stash , excepto que con git tienes tu propio repositorio (no solo uno en un servidor), solo tú puedes recuperar ese cambio.

La idea general es:

# do some stuff
vim foo/bar.c
# stash away your changes
git stash

# do some other things...

# retrieve your changes
git stash pop

Si desea que otra persona tenga acceso a este conjunto de cambios, le recomendamos enviarlo a una sucursal activa:

# make yourself a branch
git checkout -b temp-featureA
# commit to it
git add foo/bar.c; git commit

# now you push this branch (or they could just fetch straight from you)
git push origin temp-featureA


# Now, in someone else''s repo:
# Fetch updates
git fetch origin
# Make a branch tracking the remote branch
git branch temp-featureA origin/temp-featureA

# Either check it out:
git checkout temp-featureA
# or cherry-pick it, to apply the changes somewhere else:
git cherry-pick temp-featureA
# or, if it''s multiple commits, rebase it!
git rebase --onto my-branch start-of-featureA temp-featureA