git add, commit y push comandos en uno?

¿Hay alguna forma de usar estos tres comandos en uno?

git add .
git commit -a -m "commit" (do not need commit message either)
git push

A veces solo cambio una letra, relleno CSS o algo así. Aún así, tengo que escribir los tres comandos para impulsar los cambios. Hay muchos proyectos donde solo soy un empujador, por lo que este comando sería increíble.

Partiendo de la respuesta de @ Gavin:

Hacer que lazygit sea una función en lugar de un alias le permite pasarle un argumento. He agregado lo siguiente a mi .bashrc (o .bash_profile si Mac):

function lazygit() {
    git add .
    git commit -a -m "$1"
    git push
}

Esto le permite proporcionar un mensaje de confirmación, como

lazygit "My commit msg"

Por supuesto, podría reforzar esto aún más aceptando aún más argumentos, como qué lugar remoto para empujar o qué rama.

Terminé agregando un alias a mi .gitconfigarchivo:

[alias]
    cmp = "!f() { git add -A && git commit -m \"$@\" && git push; }; f"

Uso: git cmp "Long commit message goes here"

Agrega todos los archivos, luego usa el comentario para el mensaje de confirmación y lo empuja hacia el origen.

Creo que es una mejor solución porque tienes control sobre el mensaje de confirmación.

El alias también se puede definir desde la línea de comandos, esto lo agrega a su .gitconfig:

git config --global alias.cmp '!f() { git add -A && git commit -m "$@" && git push; }; f'

Si bien estoy de acuerdo con Wayne Werner en sus dudas, esta es técnicamente una opción:

git config alias.acp '! git commit -a -m "commit" && git push'

Que define un alias que se ejecuta commity push. Úselo como git acp. Tenga en cuenta que tales alias de "shell" siempre se ejecutan desde la raíz de su repositorio git.

Otra opción podría ser escribir un gancho posterior a la confirmación que haga el empuje.

Ah, por cierto, de hecho se puede pasar argumentos a Shell alias. Si desea pasar un mensaje de confirmación personalizado, utilice:

git config alias.acp '! acp() { git commit -a -m "$1" && git push ; } ; acp'

(Por supuesto, ahora, tendrá que dar un mensaje de registro: git acp "My message goes here!")

Creo que podría malinterpretar el flujo de trabajo para el que se diseñó git. (Para aclarar / corregir lo que quise decir en el comentario, no necesita el git add ., ya quecommit -a generalmente tiene el mismo propósito: agregar cualquier cambio que aún no se haya organizado, si los archivos ya se han agregado)

Por lo general, harás algo como esto:

# make some changes
$ git commit -a -m "Changed something"
# make some more changes
$ git commit -a -m "Changed something else"

lavar, enjuagar, repetir, hasta que haya terminado la función X, o esté en un punto de parada, o simplemente quiera que otras personas vean lo que ha hecho. Entonces lo haces

$ git push

Git no es SVN, pero parece que estás tratando de usarlo como tal. Puede encontrar algunos de los recursos al final del artículo aquí para ser de alguna utilidad.

Lo uso en mi .bash_profile

gitpush() {
    git add .
    git commit -m "$*"
    git push
}
alias gp=gitpush

Se ejecuta como

gp A really long commit message

No olvide ejecutar source ~/.bash_profiledespués de guardar el alias.

Puede usar el script bash, establecer un alias para iniciar cualquier comando o grupo de comandos

git commit -am "your message" && git push 

Establecer como un alias en bash:

$ alias lazygit="git add .; git commit -a -m '...'; git push;";

Llámalo:

$ lazygit

(Para que este alias sea permanente, deberá incluirlo en su .bashrc o .bash_profile)

La solución más simple sería:

git commit -a -m "commit" && git push

git add ya está contenido en un parámetro de commit, pero si lo desea, puede conectarlos a todos:

git add . && git commit -a -m "commit" && git push

En Linux / Mac, esta opción práctica también debería funcionar

git commit -am "IssueNumberIAmWorkingOn --hit Enter key
> A detail here --Enter
> Another detail here --Enter
> Third line here" && git push --last Enter and it will be there

Si está trabajando en una nueva sucursal creada localmente, cambie la git pushpieza congit push -u origin branch_name

Si desea editar su mensaje de confirmación en el editor del sistema, entonces

git commit -a && git push 

abrirá el editor y una vez que guarde el mensaje, también lo empujará.

Puedes probar gitu .

Por primera vez (el nodo js debe estar instalado):

npm install -g git-upload

Después de esto:

gitu COMMIT_MSG

Para emitir esos tres comandos a la vez.

Lo bueno es que no tiene que preocuparse cuando reinstala su sistema o cuando desea hacer esto en diferentes computadoras y no es necesario modificar ningún archivo. Esto también funciona en diferentes plataformas (no solo Linux y Mac, sino también Windows bajo el símbolo del sistema como cmdy powershell) solo que tiene que instalar npmy nodejs( gitpor supuesto).

Si el archivo ya está siendo rastreado, entonces no necesita ejecutarlo git add, simplemente puede escribirgit commit -am 'your message'

Si no desea escribir un mensaje de confirmación, puede considerar hacer algo como

git commit --allow-empty-message -am ''

Este resultado : intente esto: comando simple de script uno para git add, git commit y git push

Abra su CMD en Windows y pegue esta respuesta

git commit -m "your message" . && git push origin master

Este ejemplo, la captura de pantalla de mi foto: https://i.stack.imgur.com/2IZDe.jpg

Como se menciona en esta respuesta, puede crear un alias git y asignarle un conjunto de comandos. En este caso, sería:

git config --global alias.add-com-push '!git add . && git commit -a -m "commit" && git push'

y úsalo con

git add-com-push

Escriba un pequeño script llamado gitpush.sh con las siguientes líneas y agréguelo a su directorio ~.

echo $1
git add .
git commit -m "$1"
git push

Ahora agregue un alias en ~ / .bashrc como a continuación:

alias gitpush='~/gitpush'

Ahora desde cualquier repositorio de git simplemente escriba "mensaje" de gitpush.

Yo uso un archivo por lotes:

@ECHO OFF
SET /p comment=Comment:
git add *
git commit -a -m "%comment%"
git push

Hay algunos problemas con los scripts anteriores:

shift "elimina" el parámetro $ 1, de lo contrario, "push" lo leerá y "lo entenderá mal".

Mi consejo:

git config --global alias.acpp '! git add -A && branchatu = "$ (git symbolic-ref HEAD 2> / dev / null)" && branchatu = $ {branchatu ## refs / heads /} && git commit - m "$ 1" && shift && git pull -u origin $ branchatu && git push -u origin $ branchatu '

Cuando desee un comportamiento similar a svn de git commit, use esto en sus alias git en su .gitconfig

commit = "!f() { git commit \"$@\" && git push; };f"

Si está utilizando concha de pescado (a partir de la respuesta de btse):

Guarde este archivo dentro de '~ / .config / fish / functions' como 'quickgit.fish'. Cree el directorio si no existe. '--git-dir = $ PWD / .git' Asegura que ejecutamos los comandos git contra el proyecto git donde llamamos a la función

function quickgit # This is the function name and command we call
    git --git-dir=$PWD/.git add . # Stage all unstaged files
    git --git-dir=$PWD/.git commit -a -m $argv # Commit files with the given argument as the commit message
    git --git-dir=$PWD/.git push # Push to remote
end

Reinicie el terminal, navegue hasta el proyecto, realice cambios, y ahora puede llamar a 'quickgit "mensaje de ejemplo"'. Los cambios se agregarán, confirmarán y enviarán :).

También se puede encontrar como un Gist aquí: https://gist.github.com/Abushawish/3440a6087c212bd67ce1e93f8d283a69

Ya hay muchas buenas soluciones, pero aquí hay una solución que me parece más elegante por la forma en que quiero trabajar:

Puse un script en mi camino llamado "git-put" que contiene:

#!/bin/bash
git commit "$@" && git push -u

Eso me permite correr:

git put -am "mi mensaje de confirmación"

..para agregar todos los archivos, confirmarlos y enviarlos.

(También agregué el "-u" porque me gusta hacer esto de todos modos, aunque no esté relacionado con este problema. Asegura que la rama ascendente siempre esté configurada para extraer).

Me gusta este enfoque porque también permite usar "git put" sin agregar todos los archivos (omita el "-a"), o con cualquier otra opción que quiera pasar para confirmar. Además, "poner" es un breve resumen de "push" y "commit"

Si usa VSCode, puede descargar esta extensión que le permitirá hacerlo en un atajo de teclado simple.

Si estás usando una Mac:

1. Inicie Terminal Type "cd ~ /" para ir a su carpeta de inicio

2. Escriba "touch .bash_profile" para crear su nuevo archivo.

3. Edite .bash_profile con su editor favorito (o simplemente escriba "open -e .bash_profile" para abrirlo en TextEdit).

4. Copie y pegue lo siguiente en el archivo:

function lazygit() {
    git add .
    git commit -a -m "$1"
    git push
}

Después de esto, reinicie su terminal y simplemente agregue, confirme y presione un comando fácil, por ejemplo:

lazygit "This is my commit message"

Para los usuarios de MAC VSC, la mejor configuración es:

1) presione 'shift + cmd + P' y escriba:

Shell Command: install 'code' command in PATH

Presione ENTRAR (esto instalará el comando de código para acceder fácilmente al bash_profile)

2) ahora puede ejecutar: code ~/.bash_profilepara abrir el bash_profile vacío

3) ingrese una nueva función allí:

function lazygit() {
    git add .
    git commit -m "$*"
    git push
}

4) ahora reinicie VSC

5) realice un cambio, guárdelo y escriba lazygit messagepara ejecutar los tres comandos simultáneamente

Para los usuarios de macOS:

1. Abra su Terminal o iTerm2 u otra terminal que use.

2. Mover a su carpeta de perfil de usuario con el comando ~/. Es una carpeta predeterminada para el .bash_profilearchivo:

2. Escriba nano .bash_profileEste comando abrirá el .bash_profiledocumento (o lo creará si aún no existe) en el editor de texto más fácil de usar para terminal - nano.

3. Ahora puede hacer un simple cambio en el archivo. Pegue estas líneas de código para cambiar su indicador de Terminal:

function lazygit() {
    git add .
    git commit -a -m "$1"
    git push
}

4. Ahora guarde sus cambios escribiendo ctrl + oy presione regresar para guardar. Luego salga nanoescribiendo ctrl + x.

5. Ahora necesitamos activar sus cambios. Escriba source .bash_profile(o . ~/.bash_profile) y observe su cambio rápido.

6. En iTerm2 Preferences/Profiles/General/Commandestablecido en Login Shelly Send text at startpara source ~/.bash_profile. Por lo tanto, no necesita hacerlo manualmente después de cada reinicio de macOS.

Credenciales: https://natelandau.com/my-mac-osx-bash_profile

Hice este script .sh para comando

#!/bin/sh
cd LOCALDIRECTORYNAME/  
git config --global user.email "YOURMAILADDRESS"
git config --global user.name "YOURUSERNAME"
git init
git status
git add -A && git commit -m "MASSAGEFORCOMMITS"
git push origin master

Como la pregunta no especifica qué shell, aquí está la versión de eshell basada en las respuestas anteriores. Esto va en el archivo alias de eshell, que podría estar en ~ / .emacs.d / eshell / alias. Agregué la primera parte z https://github.com/rupa/z/ que te permite cd rápidamente a un directorio , para que esto se pueda ejecutar sin importar cuál sea su directorio actual.

alias census z cens; git add .; git commit -m "fast"; git push

Agregue ~/.bash_profilepara agregar, confirmar y presionar con un comando puesto:

function g() { git commit -a -m "$*"; git push; }

Uso:

g your commit message
g your commit message 'message'

No se necesitan comillas, aunque no puede utilizar punto y coma o paréntesis en los mensajes de confirmación (se permiten comillas simples). Si desea alguno de estos, simplemente ponga comillas dobles en su mensaje, por ejemplo:

g "your commit message; (message)"

Para crear un comentario en su mensaje, haga lo siguiente:

g "your commit message:
> your note"

También hay una función para agregar y confirmar de manera similar:

function c() { git add --all; git commit -m "$*"; }

Funciona exactamente de la misma manera que gfunciona y tiene las mismas restricciones. Solo ponlo en su clugar. P.ej

c your commit message

También puede agregar un alias para empujar al control remoto:

alias p='git push'

Uso:

p

Eso equivale a 2 letras, cy las pusas mientras trabajas con tu repositorio git. O puedes usarg en lugar para hacerlo todo con una sola letra.

Lista completa de alias y funciones: https://gist.github.com/matt360/0c5765d6f0579a5aa74641bc47ae50ac

A partir de la lazygitrespuesta, la siguiente solución agrega una verificación de usuario para verificar los cambios antes de presionar. Revertirá los comandos si se cancela. Y todo eso sucederá si y solo si hay cambios en el repositorio local.

### SAFER LAZY GIT
function lazygit() {
  git add .
  if git commit -a -m "$1"; then
    read -r -p "Are you sure you want to push these changes? [y/N]} " response
    case "$response" in
      [yY][eE][sS]|[yY])
        git push
        ;;
      *)
        git reset HEAD~1 --soft
        echo "Reverted changes."
        ;;
    esac
  fi
}

Esto es perfecto para la agrupación de comandos.

Comandos de agrupamiento

{lista; } Colocar una lista de comandos entre llaves hace que la lista se ejecute en el contexto actual del shell. No se crea ninguna subshell. Se requiere la siguiente lista de punto y coma (o nueva línea).

legit(){ git add --all; git commit -m "$1"; git push origin master; }
legit 'your commit message here'

Me gusta ejecutar lo siguiente:

git commit -am "message";git push

Encontré que este yolo alias es increíble incluso enviar un comentario aleatorio al commit mientras soy flojo. Funciona muy bien fuera de la caja, así que lo hago git yoloy todos mis cambios se envían automáticamente.