git aggiungere, commit e push comandi in uno?

C'è un modo per usare questi tre comandi in uno?

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

A volte sto cambiando solo una lettera, imbottitura CSS o qualcosa del genere. Tuttavia, devo scrivere tutti e tre i comandi per inviare le modifiche. Ci sono molti progetti in cui sono solo uno spacciatore, quindi questo comando sarebbe fantastico!

Partendo dalla risposta di @ Gavin:

Rendere lazygit una funzione anziché un alias ti consente di passare un argomento. Ho aggiunto quanto segue al mio .bashrc (o .bash_profile se Mac):

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

Ciò consente di fornire un messaggio di commit, ad esempio

lazygit "My commit msg"

Ovviamente potresti rinforzarlo ancora di più accettando ancora più argomenti, come in quale luogo remoto dove spingere o in quale ramo.

Ho finito per aggiungere un alias al mio .gitconfigfile:

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

Uso: git cmp "Long commit message goes here"

Aggiunge tutti i file, quindi utilizza il commento per il messaggio di commit e lo spinge fino all'origine.

Penso che sia una soluzione migliore perché hai il controllo su quale sia il messaggio di commit.

L'alias può anche essere definito dalla riga di comando, questo lo aggiunge al tuo .gitconfig:

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

Mentre sono d'accordo con Wayne Werner sui suoi dubbi, questa è tecnicamente un'opzione:

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

Che definisce un alias che viene eseguito commite push. Usalo come git acp. Si noti che tali alias "shell" vengono sempre eseguiti dalla radice del repository git.

Un'altra opzione potrebbe essere quella di scrivere un hook post-commit che esegua il push.

Oh, a proposito, è infatti possibile passare gli argomenti a Shell alias. Se si desidera passare un messaggio di commit personalizzato, utilizzare invece:

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

(Naturalmente, ora, è necessario dare un messaggio di commit: git acp "My message goes here!")

Penso che potresti fraintendere il flusso di lavoro per cui Git è stato progettato. (Per chiarire / correggere ciò che intendevo nel commento, non è necessario git add ., poiché di commit -asolito ha lo stesso scopo: aggiungere eventuali modifiche che non sono ancora state messe in scena, se i file sono già stati aggiunti)

In genere fai qualcosa del genere:

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

lavati, risciacqua, ripeti fino a quando non hai terminato la funzione X, o sei a un punto di arresto o vuoi solo che altre persone vedano quello che hai fatto. Allora lo fai

$ git push

Git non è SVN, ma sembra che tu stia cercando di usarlo come tale. Si potrebbe trovare alcune delle risorse alla fine di questo articolo qui per essere di qualche utilità.

Lo uso nel mio .bash_profile

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

Esegue come

gp A really long commit message

Non dimenticare di eseguire source ~/.bash_profiledopo aver salvato l'alias.

È possibile utilizzare lo script bash, impostare l'alias per avviare qualsiasi comando o gruppo di comandi

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

Imposta come alias in bash:

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

Chiamalo:

$ lazygit

(Per rendere permanente questo alias, dovresti includerlo nel tuo .bashrc o .bash_profile)

La soluzione più semplice sarebbe quella di:

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

git add è già contenuto in -a parametro di commit, ma se vuoi puoi connetterli tutti:

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

In Linux / Mac, anche questa opzione molto pratica dovrebbe funzionare

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 stai lavorando su un nuovo ramo creato localmente, cambia il git pushpezzo congit push -u origin branch_name

Se vuoi modificare il tuo messaggio di commit nell'editor di sistema, allora

git commit -a && git push 

aprirà l'editor e una volta salvato il messaggio lo spingerà anche.

Puoi provare Gitu .

Per la prima volta (il nodo js deve essere installato):

npm install -g git-upload

Dopo di che:

gitu COMMIT_MSG

Per emettere quei tre comandi contemporaneamente.

La cosa buona è che non devi preoccuparti quando reinstalli il tuo sistema o quando vuoi farlo su computer diversi e non è necessaria alcuna modifica ai file. Questo funziona anche su piattaforme diverse (non solo Linux e Mac, ma anche Windows al prompt dei comandi come cmde powershell) solo che devi installare npme nodejs( gitovviamente).

Se il file è già in fase di tracciamento, non è necessario eseguirlo git add, è possibile semplicemente scriveregit commit -am 'your message'

Se non vuoi scrivere un messaggio di commit, potresti prendere in considerazione l'idea di fare qualcosa del genere

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

Questo risultato - Prova questo: comando semplice script one per git add, git commit e git push

Apri il tuo CMD su Windows e incolla questa risposta

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

Questo esempio è il mio screenshot: https://i.stack.imgur.com/2IZDe.jpg

Come menzionato in questa risposta, è possibile creare un alias git e assegnare un set di comandi per esso. In questo caso, sarebbe:

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

e usalo con

git add-com-push

Scrivi un piccolo script chiamato gitpush.sh con le righe sottostanti e aggiungilo alla tua directory ~.

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

Ora aggiungi un alias in ~ / .bashrc come di seguito:

alias gitpush='~/gitpush'

Ora da qualsiasi repository git basta scrivere gitpush "messaggio".

Uso un file batch:

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

Ci sono alcuni problemi con gli script sopra:

shift "rimuove" il parametro $ 1, altrimenti "push" lo leggerà e "lo fraintenderà".

Il mio consiglio:

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 '

Quando vuoi un comportamento simile a svn di git commit, usa questo nei tuoi alias git nel tuo .gitconfig

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

Se stai usando il guscio di pesce (basandoti sulla risposta di Btse):

Salvare questo file in '~ / .config / fish / Functions' come 'quickgit.fish'. Creare la directory se non esiste. '--git-dir = $ PWD / .git' Assicura di eseguire i comandi git sul progetto git dove abbiamo chiamato la funzione

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

Riavvia il terminale, passa al progetto, apporta le modifiche e ora puoi chiamare "quickgit" esempio di messaggio "'. Le modifiche verranno ora aggiunte, confermate e inviate :).

Puoi anche trovarlo come Gist qui: https://gist.github.com/Abushawish/3440a6087c212bd67ce1e93f8d283a69

Esistono già molte buone soluzioni, ma ecco una soluzione che trovo più elegante per il modo in cui voglio lavorare:

Ho inserito uno script nel mio percorso chiamato "git-put" che contiene:

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

Questo mi permette di correre:

git put -am "il mio messaggio di commit"

..per aggiungere tutti i file, impegnarli e inviarli.

(Ho anche aggiunto "-u" perché mi piace farlo comunque, anche se non è correlato a questo problema. Garantisce che il ramo upstream sia sempre impostato per il pull.)

Mi piace questo approccio perché permette anche di usare "git put" senza aggiungere tutti i file (salta "-a"), o con qualsiasi altra opzione che potrei voler passare per eseguire il commit. Inoltre, "put" è un breve portmanteau di "push" e "commit"

Se usi VSCode, puoi scaricare questa estensione che ti permetterà di farlo in una semplice scorciatoia da tastiera.

Se stai usando un Mac:

1. Avviare il Terminale Digitare "cd ~ /" per accedere alla cartella principale

2. Digita "touch .bash_profile" per creare il tuo nuovo file.

3. Modifica .bash_profile con il tuo editor preferito (oppure puoi semplicemente digitare "open -e .bash_profile" per aprirlo in TextEdit).

4. Copia e incolla quanto segue nel file:

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

Successivamente, riavvia il tuo terminale e aggiungi semplicemente, esegui il commit e invia un semplice comando, ad esempio:

lazygit "This is my commit message"

Per gli utenti MAC VSC la migliore configurazione è:

1) premi 'shift + cmd + P' e digita:

Shell Command: install 'code' command in PATH

Premi INVIO (questo installerà il comando code per arrivare facilmente al bash_profile)

2) ora puoi eseguire: code ~/.bash_profileper aprire il bash_profile vuoto

3) inserisci una nuova funzione lì dentro:

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

4) ora riavvia VSC

5) apportare una modifica, salvarla e digitare lazygit messageper eseguire contemporaneamente i tre comandi

Per gli utenti macOS:

1. Apri il tuo Terminale o iTerm2 o un altro terminale che usi.

2. Passare alla cartella del profilo utente con il comando ~/. È una cartella predefinita per il .bash_profilefile:

2. Tipo nano .bash_profileQuesto comando aprirà il .bash_profiledocumento (o lo creerà se non esiste già) nell'editor di testo più semplice da usare per il terminale - nano.

3. Ora puoi apportare una semplice modifica al file. Incolla queste righe di codice per modificare il prompt del Terminale:

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

4. Ora salva le modifiche digitando ctrl + oe premi Invio per salvare. Quindi uscire nanodigitando ctrl + x.

5. Ora dobbiamo attivare le tue modifiche. Digita source .bash_profile(o . ~/.bash_profile) e guarda il tuo cambiamento rapido.

6. In iTerm2 Preferences/Profiles/General/Commandimpostare su Login Shelle Send text at startsu source ~/.bash_profile. Quindi non è necessario farlo manualmente dopo ogni riavvio di macOS.

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

Ho fatto questo script .sh per il 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

Poiché la domanda non specifica quale shell, ecco la versione di eshell basata sulle risposte precedenti. Questo va nel file alias eshell, che potrebbe essere in ~ / .emacs.d / eshell / alias Ho aggiunto la prima parte z https://github.com/rupa/z/ che ti consente di eseguire rapidamente il cd in una directory , in modo che questo possa essere eseguito indipendentemente dalla directory corrente.

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

Aggiungi ~/.bash_profileper aggiungere, confermare e spingere con un solo comando:

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

Uso:

g your commit message
g your commit message 'message'

Non sono necessarie virgolette anche se non è possibile utilizzare punti e virgola o parentesi nei messaggi di commit (sono consentite virgolette singole). Se vuoi uno di questi semplicemente inserisci due virgolette nel tuo messaggio, ad esempio:

g "your commit message; (message)"

Per creare un commento nel tuo messaggio, procedi come segue:

g "your commit message:
> your note"

C'è anche una funzione per aggiungere e impegnare in modo simile:

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

Funziona esattamente allo stesso modo di quella gfunzione e ha gli stessi vincoli. Basta mettere cinvece. Per esempio

c your commit message

Puoi anche aggiungere un alias per l'invio al telecomando:

alias p='git push'

Uso:

p

Ciò equivale a 2 lettere ce plo usi mentre lavori con il tuo repository git. Oppure puoi usare ginvece per fare tutto con una sola lettera.

Elenco completo di alias e funzioni: https://gist.github.com/matt360/0c5765d6f0579a5aa74641bc47ae50ac

Costruendo la lazygitrisposta, la seguente soluzione aggiunge un controllo utente per verificare le modifiche prima di inviare. Ripristinerà i comandi se annullato. E tutto ciò accadrà se e solo se ci sono cambiamenti nel repository locale.

### 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
}

Questo è perfetto per il raggruppamento dei comandi.

Comandi di raggruppamento

{ elenco; } Posizionando un elenco di comandi tra parentesi graffe, l'elenco verrà eseguito nel contesto della shell corrente. Non viene creata alcuna subshell. È richiesto il seguente punto e virgola (o newline).

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

Mi piace eseguire quanto segue:

git commit -am "message";git push

Ho trovato sorprendente questo yolo alias anche per inviare un commento casuale al commit mentre sono pigro. Funziona davvero bene fuori dalla scatola, quindi lo faccio git yoloe tutte le mie modifiche vengono inviate automaticamente.