git add, commit e push comandos em um?

Existe alguma maneira de usar esses três comandos em um?

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

Às vezes, estou mudando apenas uma letra, preenchimento CSS ou algo assim. Ainda assim, tenho que escrever todos os três comandos para fazer as alterações. Existem muitos projetos em que sou apenas um empurrador, então esse comando seria incrível!

Aproveitando a resposta de @ Gavin:

Tornar o lazygit uma função em vez de um alias permite passar um argumento para ele. Adicionei o seguinte ao meu .bashrc (ou .bash_profile se Mac):

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

Isso permite que você forneça uma mensagem de confirmação, como

lazygit "My commit msg"

É claro que você poderia reforçar isso ainda mais, aceitando ainda mais argumentos, como em qual lugar remoto para onde empurrar ou em que ramo.

Acabei adicionando um alias ao meu .gitconfigarquivo:

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

Uso: git cmp "Long commit message goes here"

Adiciona todos os arquivos, depois usa o comentário para a mensagem de confirmação e a envia até a origem.

Eu acho que é uma solução melhor porque você tem controle sobre qual é a mensagem de confirmação.

O alias também pode ser definido na linha de comando; isso inclui o seu .gitconfig:

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

Embora eu concorde com Wayne Werner sobre suas dúvidas, esta é tecnicamente uma opção:

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

Que define um alias que é executado commite push. Use-o como git acp. Esteja ciente de que esses aliases "shell" são sempre executados a partir da raiz do seu repositório git.

Outra opção pode ser escrever um gancho pós-confirmação que faça o push.

Ah, a propósito, você realmente pode passar argumentos para aliases de shell. Se você deseja passar uma mensagem de confirmação personalizada, use:

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

(É claro que, agora, você terá que dar uma mensagem de commit: git acp "My message goes here!")

Eu acho que você pode entender mal o fluxo de trabalho para o qual o git foi projetado. (Para esclarecer / corrigir o que eu quis dizer no comentário, você não precisa do git add ., poiscommit -a geralmente serve para o mesmo objetivo - adicionar quaisquer alterações que ainda não tenham sido preparadas, se os arquivos já tiverem sido adicionados)

Normalmente, você fará algo assim:

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

lave, enxágue, repita, até concluir o recurso X, ou estar em um ponto de parada ou desejar que outras pessoas vejam o que você fez. Então você faz

$ git push

O Git não é SVN - mas parece que você está tentando usá-lo como tal. Você pode encontrar alguns dos recursos no final do artigo aqui de alguma utilidade.

Eu uso isso no meu .bash_profile

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

Ele executa como

gp A really long commit message

Não se esqueça de executar source ~/.bash_profiledepois de salvar o alias.

Você pode usar o script bash, definir alias para iniciar qualquer comando ou grupo de comandos

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

Defina como um alias no bash:

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

Chame-o:

$ lazygit

(Para tornar esse alias permanente, você deve incluí-lo no seu .bashrc ou .bash_profile)

A solução mais simples seria:

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

git add já está contido no parâmetro -a commit, mas se você quiser, pode conectar todos eles:

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

No Linux / Mac, essa opção muito prática também deve 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

Se você estiver trabalhando em um nova ramificação criada localmente, altere ogit push peça comgit push -u origin branch_name

Se você deseja editar sua mensagem de confirmação no editor do sistema,

git commit -a && git push 

abrirá o editor e, após salvar a mensagem, ela também será enviada.

Você pode tentar gitu .

Pela primeira vez (o nó js deve ser instalado):

npm install -g git-upload

Depois disso:

gitu COMMIT_MSG

Para emitir esses três comandos ao mesmo tempo.

O bom é que você não precisa se preocupar quando reinstalar o sistema ou quando quiser fazer isso em computadores diferentes e nenhuma modificação de arquivo é necessária. Isso também funciona em plataformas diferentes (não apenas Linux e Mac, mas também no Windows sob prompt de comando como cmde powershell), apenas que você precisa instalar npme nodejs(é gitclaro).

Se o arquivo já estiver sendo rastreado, você não precisará executar git add, basta escrevergit commit -am 'your message'

Se você não quiser escrever uma mensagem de confirmação, considere fazer algo como

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

Resultado - Tente o seguinte: Comando simples de script um para git add, git commit e git push

Abra seu CMD no Windows e cole esta resposta

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

Este exemplo, minha captura de tela de imagem: https://i.stack.imgur.com/2IZDe.jpg

Conforme mencionado nesta resposta, você pode criar um alias do git e atribuir um conjunto de comandos para ele. Nesse caso, seria:

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

e use-o com

git add-com-push

Escreva um pequeno script chamado gitpush.sh com as linhas abaixo e adicione-o ao seu diretório ~.

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

Agora adicione um alias em ~ / .bashrc como abaixo:

alias gitpush='~/gitpush'

Agora, a partir de qualquer repositório git, escreva gitpush "message".

Eu uso um arquivo em lote:

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

Existem alguns problemas com os scripts acima:

shift "remove" o parâmetro $ 1, caso contrário, "push" irá lê-lo e "entendê-lo mal".

Minha dica:

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

Quando você quiser um comportamento semelhante ao svn do git commit, use isso nos aliases do git no seu .gitconfig

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

Se você estiver usando casca de peixe (com base na resposta da btse):

Salve este arquivo em '~ / .config / fish / functions' como 'quickgit.fish'. Crie o diretório se ele não existir. '--git-dir = $ PWD / .git' Garante que executamos os comandos git no projeto git em que chamamos a função

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 o terminal, navegue para o projeto, faça alterações e agora você pode chamar 'quickgit "example message"'. As alterações serão agora adicionadas, confirmadas e enviadas por push :).

Também pode ser encontrado como um Gist aqui: https://gist.github.com/Abushawish/3440a6087c212bd67ce1e93f8d283a69

Já existem muitas boas soluções, mas aqui está uma solução que acho mais elegante para a maneira como quero trabalhar:

Eu coloquei um script no meu caminho chamado "git-put" que contém:

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

Isso me permite executar:

git put -am "minha mensagem de confirmação"

..para adicionar todos os arquivos, enviá-los e enviá-los.

(Também adicionei o "-u" porque, de qualquer maneira, gosto de fazer isso, mesmo que não esteja relacionado a esse problema. Ele garante que o ramo upstream esteja sempre configurado para puxar.)

Eu gosto dessa abordagem porque ela também permite usar o "git put" sem adicionar todos os arquivos (pule o "-a") ou com outras opções que eu queira passar para confirmar. Além disso, "put" é um pequeno portmanteau de "push" e "commit"

Se você usa o VSCode, pode fazer o download desta extensão, que permitirá fazer isso em um simples atalho de teclado.

Se você estiver usando um Mac:

1. Inicie o Terminal Digite "cd ~ /" para ir para a sua pasta pessoal

2. Digite "touch .bash_profile" para criar seu novo arquivo.

3. Edite .bash_profile com seu editor favorito (ou você pode simplesmente digitar "open -e .bash_profile" para abri-lo no TextEdit).

4. Copie e cole o abaixo no arquivo:

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

Depois disso, reinicie o seu terminal e simplesmente adicione, confirme e pressione um comando fácil, por exemplo:

lazygit "This is my commit message"

Para usuários do MAC VSC, a melhor configuração é:

1) pressione 'shift + cmd + P' e digite:

Shell Command: install 'code' command in PATH

Pressione ENTER (isso instalará o comando de código para chegar facilmente ao bash_profile)

2) agora você pode executar: code ~/.bash_profilepara abrir o bash_profile vazio

3) insira uma nova função:

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

4) agora reinicie o VSC

5) faça uma alteração, salve-a e digite lazygit messagepara executar os três comandos simultaneamente

Para os usuários do macOS:

1. Abra o seu Terminal ou iTerm2 ou outro terminal que você usa.

2. Mover para pasta de perfil de usuário com o comando ~/. É uma pasta padrão para o .bash_profilearquivo:

2. Digite nano .bash_profileEste comando abrirá o .bash_profiledocumento (ou o criará, se ele ainda não existir), da maneira mais fácil de usar o editor de texto para o terminal - nano.

3. Agora você pode fazer uma simples alteração no arquivo. Cole estas linhas de código para alterar o prompt do Terminal:

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

4. Agora salve suas alterações digitando ctrl + oe pressione Enter para salvar. Então saia nanodigitando ctrl + x.

5. Agora precisamos ativar suas alterações. Digite source .bash_profile(ou . ~/.bash_profile) e observe sua alteração imediata.

6. No iTerm2, Preferences/Profiles/General/Commanddefina para Login Shelle Send text at startpara source ~/.bash_profile. Portanto, você não precisa fazer isso manualmente após cada reinicialização do macOS.

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

Eu fiz 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 a pergunta não especifica qual shell, eis a versão eshell com base nas respostas anteriores. Isso acontece no arquivo eshell alias, que pode estar em ~ / .emacs.d / eshell / alias. Adicionei a primeira parte z https://github.com/rupa/z/, que permite que você faça um cd rapidamente em um diretório , para que isso possa ser executado, independentemente do diretório atual.

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

Adicione ~/.bash_profilepara adicionar, confirmar e pressionar com um comando:

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

Uso:

g your commit message
g your commit message 'message'

Não são necessárias aspas, embora você não possa usar ponto-e-vírgula ou parênteses em suas mensagens de confirmação (aspas simples são permitidas). Se você quiser alguma dessas opções, basta colocar aspas duplas na sua mensagem, por exemplo:

g "your commit message; (message)"

Para criar um comentário em sua mensagem, faça:

g "your commit message:
> your note"

Há também uma função para adicionar e confirmar de maneira semelhante:

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

Funciona exatamente da mesma maneira que gfunciona e tem as mesmas restrições. Basta colocar cem seu lugar. Por exemplo

c your commit message

Você também pode adicionar um alias para enviar para o controle remoto:

alias p='git push'

Uso:

p

Isso equivale a 2 letras, ce pvocê usa enquanto trabalha com seu repositório git. Ou você pode usarg para fazer tudo com apenas uma letra.

Lista completa de aliases e funções: https://gist.github.com/matt360/0c5765d6f0579a5aa74641bc47ae50ac

Com base na lazygitresposta, a solução a seguir adiciona uma verificação do usuário para verificar as alterações antes de enviar por push. Ele reverterá os comandos se cancelado. E tudo isso acontecerá se e somente se houver alterações no repositório 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
}

Isso é perfeito para agrupamento de comandos.

Comandos de agrupamento

{ Lista; } Colocar uma lista de comandos entre chaves faz com que a lista seja executada no contexto atual do shell. Nenhum subshell é criado. É necessário o ponto e vírgula (ou nova linha) a seguir.

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

Eu gosto de executar o seguinte:

git commit -am "message";git push

Achei esse yolo alias incrível mesmo enviar um comentário aleatório para o commit enquanto eu estava sendo preguiçoso. Funciona muito bem fora da caixa, então eu apenas faço git yoloe todas as minhas alterações são enviadas automaticamente.