Pregunta ¿Cómo nombrar y recuperar un alijo por nombre en git?


Siempre tuve la impresión de que podías dar un nombre a un escondite haciendo git stash save stashname, que luego podrías aplicar haciendo git stash apply stashname. Pero parece que en este caso todo lo que sucede es que stashname se usará como la descripción del alijo.

¿No hay forma de nombrar realmente un alijo? Si no, ¿qué recomendarías para lograr una funcionalidad equivalente? Esencialmente tengo un pequeño alijo que me gustaría aplicar periódicamente, pero no quiero tener que cazar siempre git stash list cuál es su número de escondite real.


927
2018-06-29 21:33


origen


Respuestas:


En realidad, puede encontrar el alijo por nombre usando la sintaxis de expresión regular de git para direccionar objetos:

stash^{/<regex>}
:/<regex>

Por ejemplo, al guardar su alijo con un nombre para guardar:

git stash save "guacamole sauce WIP"

... puedes usar una expresión regular para abordar ese alijo:

git stash apply stash^{/guacamo}

Esto aplicará el alijo más joven que coincida con la expresión regular guacamo. De esta forma, no tienes que saber en qué número está el alijo en la pila, solo tienes que saber su nombre. No hay sintaxis de terser para esto, pero puede crear un alias en su .gitconfig archivo:

[alias]
sshow = "!f() { git stash show stash^{/$*} -p; }; f"
sapply = "!f() { git stash apply stash^{/$*}; }; f"

Puedes usar git sapply <regex> para aplicar ese alijo (sin dejar caer).
 Puedes usar git sshow <regex> para mostrar: archivos modificados, inserciones y eliminaciones

EDITAR: Apoyos para esta respuesta StackOverflow sobre cómo usar argumentos de bash en alias de git.

EDICION 2: Esta respuesta solía contener drop y list alias, pero desde entonces los eliminé, ya que drop requiere el stash@{n} sintaxis mientras list no filtró los escondites en absoluto. Si alguien sabe cómo resolver un escondite SHA-1 hash a un escondite ref, entonces podría implementar los otros comandos también.

EDIT 3: Por isyiSugerencia He agregado un indicador de parche para mostrar el contenido del alijo cuando se muestra uno.


1147
2017-07-27 13:17



Así es como lo haces:

git stash save "my_stash"

donde "my_stash" es el nombre del escondite ...

Algunas cosas más útiles que debe saber: Todos los stashes se almacenan en una pila. Escribir :

git stash list

Esto listará todos tus escondites.

Para aplicar un alijo y eliminarlo de la pila de alijo, puede dar,

git stash pop stash@{n}

Para aplicar un alijo y mantenerlo en la pila de alijo, escriba:

git stash apply stash@{n}

Donde n en el índice del escondido cambia.


321
2018-03-04 08:18



Puedes convertir un alijo en una rama si crees que es lo suficientemente importante:

git stash branch <branchname> [<stash>]

de la página man:

Esto crea y verifica una nueva rama llamada <branchname> a partir de la confirmación en la que se creó originalmente el <stash>, aplica los cambios registrados en <stash> al nuevo árbol de trabajo e índice, luego descarta el <stash> si eso termina con éxito Cuando no se proporciona <stash>, se aplica el último.

Esto es útil si la rama en la que ejecutó git stash save ha cambiado lo suficiente como para que git stash apply falle debido a conflictos. Dado que el alijo se aplica sobre la confirmación que era HEAD en el momento en que se ejecutó git stash, restaura el estado originalmente oculto sin conflictos.

Luego puede volver a establecer la base de esta nueva rama en algún otro lugar que sea un descendiente de donde estaba cuando escondió.


64
2018-06-29 22:34



Los mapas no son para ser cosas permanentes como tú quieres. Probablemente te sirvas mejor usando etiquetas en commits. Construye lo que quieras esconder. Haga un compromiso de eso. Crea una etiqueta para esa confirmación. A continuación, deshaga su rama hacia HEAD^. Ahora, cuando quieras volver a aplicar ese alijo, puedes usar git cherry-pick -n tagname (-n es --no-commit)


30
2018-06-29 21:39



git stash save es obsoleto ahora, en cambio, puedes usar git stash push -m "message" 

Puedes realizar de esta manera:

git stash push -m "message" 

donde "mensaje" es tu nombre de alijo ...


15
2018-03-29 15:08



Si solo está buscando una forma ligera de guardar algunos o todos sus cambios de copia de trabajo actuales y luego volver a aplicarlos a voluntad, considere un archivo de parche:

# save your working copy changes
git diff > some.patch

# re-apply it later
git apply some.patch

De vez en cuando me pregunto si debería usar escondites para esto y luego veo cosas como la locura anterior y estoy contento con lo que estoy haciendo :)


12
2017-11-10 16:06



Alias

sapply = "!f() { git stash apply \"$(git stash list | awk -F: --posix -vpat=\"$*\" \"$ 0 ~ pat {print $ 1; exit}\")\"; }; f"

Uso

git sapply "<regex>"

  • compatible con Git para Windows

Editar: me apegué a mi solución original, pero veo por qué la mayoría preferiría la versión de Etan Reisner (arriba). Entonces solo para el registro:

sapply = "!f() { git stash apply \"$(git stash list | grep -E \"$*\" | awk \"{ print $ 1; }\" | sed -n \"s/://;1p\")\"; }; f"

7
2017-11-26 22:51



Esta respuesta le debe mucho a Klemen Slavič. Acabo de comentar la respuesta aceptada, pero aún no tengo suficientes representantes :(

También puede agregar un alias de git para encontrar el alijo ref y usarlo en otros alias para mostrar, aplicar, soltar, etc.

[alias]
    sgrep = "!f() { ref=$(git --no-pager stash list | grep "$1" | cut -d: -f1 | head -n1); echo ${ref:-<no_match>}; }; f"
    sshow = "!f() { git stash show $(git sgrep "$1") -p; }; f"
    sapply = "!f() { git stash apply $(git sgrep "$1"); }; f"
    sdrop = "!f() { git stash drop $(git sgrep "$1"); }; f"

Tenga en cuenta que el motivo de la ref=$( ... ); echo ${ref:-<no_match>}; el patrón es para que no se devuelva una cadena en blanco, lo que provocaría sshow, sapply y sdrop para apuntar al último escondite en lugar de fallar como cabría esperar.


5
2018-01-11 01:30



Alias Esta podría ser una sintaxis más directa para sistemas tipo Unix sin necesidad de encapsular en una función. Agregue lo siguiente a ~ / .gitconfig en [alias]

sshow = !sh -c 'git stash show stash^{/$*} -p' -
sapply = !sh -c 'git stash apply stash^{/$*}' -
ssave = !sh -c 'git stash save "${1}"' -

Uso:     sapply regex

Ejemplo:     git sshow MySecretStash

El guión al final dice tomar entrada de la entrada estándar.


3
2017-08-22 17:00



Tengo estas dos funciones en mi .zshrc archivo:

function gitstash() {
    git stash push -m "zsh_stash_name_$1"
}

function gitstashapply() {
    git stash apply $(git stash list | grep "zsh_stash_name_$1" | cut -d: -f1)
}

Utilizándolos de esta manera:

gitstash nice

gitstashapply nice

2
2018-06-06 18:53



Para todo, además de la creación de alijo, propongo otra solución al presentar fzf como una dependencia. Recomiende tomarse 5 minutos de su tiempo y conocerlo, ya que es sobre todo un gran refuerzo de productividad.

De todos modos, un extracto relacionado de su página de ejemplos ofreciendo búsqueda oculta. Es muy fácil cambiar el sciptlet para agregar funcionalidad adicional (como la aplicación oculta o la caída):

fstash() {
    local out q k sha
    while out=$(
            git stash list --pretty="%C(yellow)%h %>(14)%Cgreen%cr %C(blue)%gs" |
            fzf --ansi --no-sort --query="$q" --print-query \
                --expect=ctrl-d,ctrl-b); do
        mapfile -t out <<< "$out"
        q="${out[0]}"
        k="${out[1]}"
        sha="${out[-1]}"
        sha="${sha%% *}"
        [[ -z "$sha" ]] && continue
        if [[ "$k" == 'ctrl-d' ]]; then
            git diff $sha
        elif [[ "$k" == 'ctrl-b' ]]; then
            git stash branch "stash-$sha" $sha
            break;
        else
            git stash show -p $sha
        fi
    done
}

1
2017-09-10 11:58