Come evitare di digitare "git" all'inizio di ogni comando Git?

Mi chiedo se c'è un modo per evitare di dover digitare la parola gitall'inizio di ogni comando Git.

Sarebbe bello se ci fosse un modo per usare il gitcomando solo una volta all'inizio dopo aver aperto un prompt dei comandi per entrare in "Modalità Git" .

Per esempio:

git>

Dopo di che ogni comando che digitiamo viene interpretato di default come un comando Git.

In un modo simile a come utilizziamo la shell MySQL per scrivere i comandi del database:

mysql>

Questo mi eviterà di dover scrivere gitcentinaia di volte al giorno.

NOTA: sto usando git-bash, su Windows.

Potresti provare Gitsh . Dal loro readme:

Il gitshprogramma è una shell interattiva per git. Dall'interno gitshpuoi emettere qualsiasi comando git, anche usando i tuoi alias e configurazione locali.

• I comandi Git tendono ad arrivare in gruppi. Evita di digitare gitpiù e più volte eseguendoli in una shell git dedicata:

sh$ gitsh
gitsh% status
gitsh% add .
gitsh% commit -m "Ship it!"
gitsh% push
gitsh% ctrl-d
sh$

O dai un'occhiata agli altri progetti collegati lì:

• git-sh - Una shell bash personalizzata con un prompt Git, alias e completamento.
• gitsh - Una semplice shell Git scritta in Perl.
• repl - Avvolge qualsiasi programma con sottocomandi in un REPL.

Nota: non l'ho usato da solo.

Un one-liner Perl che farà questo:

perl -nE 'BEGIN {print "git > "} system "git $_"; print "git > "'

Questo eseguirà qualunque cosa tu digiti, con il prefisso git . E continuerà a farlo fino a quando non colpisci ^D.

Questo non è esattamente quello che stai chiedendo, ma potresti impostare alcuni alias di shell nei tuoi ~/.bashrccomandi Git che usi più frequentemente:

alias commit='git commit'
alias checkout='git checkout'
...

Si noti inoltre che è possibile creare alias all'interno di Git stesso:

git config --global alias.ci commit
git config --global alias.co checkout
...

Ciò consente di digitare git cianziché git commite così via.

Sono un grande fan dell'uso degli alias in ~ / .bash_profile per il mio GitBash. Se segui questo approccio, ecco alcuni dei miei preferiti:

# git
alias gw='git whatchanged'
alias gg='git grep -n -C8'
alias ggi='git grep -i -n -C8'
alias gb='git branch'
alias gbd='git branch -D'
alias gba='git branch -a'
alias gc='git checkout'
alias gcp='git cherry-pick'
alias gfo='git fetch origin'
alias s='git status'
alias gmom='git merge origin/master'
alias grom='git rebase origin/master'
alias gpom='git pull origin master'
alias pplog='git log --oneline --graph --decorate'

Usa il tuo editor.

Digita il comando come commitdal tuo editor preferito come vs code e sii più efficiente con git:

Oppure digita gitper ottenere tutti i comandi:

Un mio amico ha realizzato un piccolo script bash che lo compie. Si chiama Replify .

$ replify git
Initialized REPL for [git]
git> init
Initialized empty Git repository in /your/directory/here/.git/

git> remote add origin https://your-url/repo.git

git> checkout -b new-branch
Switched to a new branch 'new-branch'

git> push

Ecco un altro modo. Inoltre non è proprio quello che mi è stato chiesto, ma lo sto usando da un po 'di tempo ed è abbastanza carino. Aggiungi la seguente riga al tuo ~/.bashrc:

complete -E -W git

Ora premendo Tab al prompt di Bash vuoto si digiterà "git".

So che questa è una risposta molto tardiva, ma questa domanda mi ha davvero colpito perché ho avuto a che fare con questo tipo di ripetizione da un po 'di tempo.

Non sono sicuro di te ma sinceramente non voglio (ripeto NON VOGLIO ) creare alias per ogni gitcomando, quindi ho scritto uno script Python chiamato NoGit per risolvere questo problema:

#!/usr/bin/env python
import sys, os, signal, atexit, readline, subprocess

commands, stop, history_file = [], False, os.path.join(os.getcwd(), "git.history")

def run_commands():
  stop = True
  for cmd in commands:
    command = ["git" if not cmd.startswith("git ") else ""]
    command = [cmd] if command[0] == "" else [command[0], cmd]
    subprocess.Popen(command).communicate()
    commands = []

def signal_handler(sig, frame):
  run_commands()
  sys.exit(0)

try:
  readline.read_history_file(history_file)
  signal.signal(signal.SIGINT, signal_handler)

  while True:
    if stop == True:
      break
    command = input("git> ")
    if command == "%undo":
      commands.pop()
    elif command == "%run":
      run_commands()
    elif command == "%exit":
      sys.exit(0)
    else:
      commands += [cmd.strip() for cmd in command.split(";")]

  signal.pause()
  readline.set_history_length(-1)
except IOError:
  pass

atexit.register(readline.write_history_file, history_file)

NoGit è un semplice script Python per evitare la ripetizione non necessaria della parola chiave "git".

Documentazione:

• il %undocomando rimuove l'ultimo comando dallo stack
• il %runcomando esegue i comandi nello stack e cancella lo stack
• il %exit comando chiude la CLI senza fare nulla
• premere ctr+cequivale a correre%run; %exit
• lo script salva i comandi che sono stati eseguiti su un file chiamato git.history nella stessa cartella dello script
• puoi aggiungere più comandi in una riga usando un punto e virgola
• puoi usare la parola chiave gitall'inizio del comando e lo script non la duplicherà ( eg: git init non diventa git git init)

Comandi di esempio:

1. init
2. add .
3. stage .
4. commit -m "inital commit"
5. %run; %exit

Informazioni aggiuntive (per utenti Linux):

Se lo desideri, puoi rimuovere l' .pyestensione e convertirla in un eseguibile utilizzando:

mv ./git.py ./git
chmod +x ./git

Quindi invece di chiamare lo script in questo modo:

python3 git.py

Avresti eseguito questo invece:

./git

Informazioni aggiuntive (per i più pigri):

Se sei pigro e non vuoi scrivere a, ./puoi spostare questo script nella tua /bin/cartella e creare un alias per questo.

Se sei davvero molto pigro, usa i seguenti comandi:

sudo cp ./git /bin/nogit
sudo chmod +x /bin/nogit
alias nogit='/bin/nogit'

Se sei davvero, davvero, molto pigro, copia e incolla il seguente one-liner:

sudo cp ./git /bin/nogit && sudo chmod +x /bin/nogit && alias nogit='/bin/nogit'

Se la tua pigrizia ha raggiunto livelli precedentemente sconosciuti all'umanità, ecco una versione più compatta dello stesso one-liner:

sudo cp ./git /bin/nogit;sudo chmod +x /bin/nogit;alias nogit='/bin/nogit'

In bocca al lupo.

Un altro approccio che funzionerà con qualsiasi comando: usa Ctrl + R (reverse-i-search).

La ricerca inversa i consente di cercare nella cronologia dei comandi. Ripeti Ctrl + R dopo aver premuto la stringa di ricerca per ripetere la ricerca più indietro con la stessa stringa.

Devi solo digitare un comando una volta, quindi puoi richiamare quel comando da qualsiasi sottostringa del comando. Nella maggior parte dei casi, puoi richiamare interi comandi molto lunghi e le loro varie varianti con solo due o tre lettere di ricerca ben posizionate. Non sono necessarie preconfigurazioni oltre all'utilizzo della shell normalmente ed è autoadattativo rispetto al modo in cui è stata utilizzata la shell, è sufficiente digitare il comando completo una volta e i comandi verranno automaticamente aggiunti alla cronologia dei comandi.

• git commit --amend: <Ctrl+R>am
• git pull: <Ctrl+R>pu
• git rebase --rebase-merges -i --onto origin/develop origin/develop feature/blue-header: <Ctrl+R>blu
• git rebase --abort: <Ctrl-R>ab
• git rebase --continue: <Ctrl-R>con
• docker-compose stop && git pull && make && docker-compose up -d: <Ctrl-R>up
• eccetera

Inoltre, Ctrl-R funziona non solo su bash, ma molti programmi che usano la libreria readline (e ce ne sono molti), come Python shell, IPython, mysql shell, psql shell, irb (ruby), ecc.

Nel tuo esempio, lo confronti con un prompt di MySql. Il modo in cui funziona è che inizia un processo MySql e tu dai i tuoi comandi a quel processo. Come tale, perché non scrivere qualcosa di simile nella tua lingua preferita? Ecco un semplice esempio in C ++:

#include <iostream>
#include <cstdlib>

int main(int argc, char *argv[]){
    while(true){
        std::cout << "git> ";
        std::cout.flush();
        std::string command;
        std::getline(std::cin, command);
        if(command == "exit") break;
        std::system("git " + command);
    }

    return 0;
}

Nota che l'ho appena scritto dalla memoria e che non l'ho verificato con un compilatore. Potrebbero esserci banali errori di sintassi.

Per le cose di base, puoi fare:

function ggit(){ while true; do printf 'git> '; read; eval git $REPLY; done }

git> status
On branch master
Your branch is ahead of 'origin/master' by 1 commit.
  (use "git push" to publish your local commits)

Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    deleted:    yarn.lock

no changes added to commit (use "git add" and/or "git commit -a")
git> add .
git> status
On branch master
Your branch is ahead of 'origin/master' by 1 commit.
  (use "git push" to publish your local commits)

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    deleted:    yarn.lock

git>

Esci con ctrl + c

Quando ho usato Windows 7 con Conemu, ho aggiunto quanto segue al mio script di avvio dell'ambiente di sviluppo:

doskey g=git $*

Con questo, potrei semplicemente usare il gcomando invece di digitare git. L'ultima volta che ho provato con Windows 10 e Conemu, non ha funzionato, penso che ci sia un bug, ma vale la pena provare.

Usa un editor di parentesi, è facile usare il tuo codice e comandi git, ha anche molte funzionalità.

Nell'angolo in alto a destra viene utilizzata la seconda icona binoculare per installare le estensioni.

Cerca estensione brackets git come l'immagine sopra e installala.

Di nuovo nell'angolo in alto a destra verrà mostrata la quarta icona, quindi basta fare clic e vedere le modifiche come nell'immagine sopra.

Se si desidera installare parentesi, utilizzare i comandi seguenti:

sudo add-apt-repository ppa:webupd8team/brackets
sudo apt-get update
sudo apt-get install brackets

Per ulteriori informazioni, puoi leggere: Come installare l'Editor di codice parentesi in Ubuntu e Linux Mint su Ubuntupit .