Como evito digitar "git" no início de cada comando do Git?

Gostaria de saber se há uma maneira de evitar ter que digitar a palavra git no início de cada comando do Git.

Seria bom se houvesse uma maneira de usar o gitcomando apenas uma vez no início, depois de abrir um prompt de comando para entrar no "modo Git" .

Por exemplo:

git>

Após o qual todo comando digitado é interpretado por padrão como um comando Git.

De maneira semelhante à forma como usamos o shell do MySQL para escrever comandos no banco de dados:

mysql>

Isso me impedirá de digitar gitcentenas de vezes por dia.

NOTA: Estou usando git-bash, no Windows.

Você pode tentar o gitsh . De seu leia-me:

O gitshprograma é um shell interativo para o git. De dentro, gitshvocê pode emitir qualquer comando git, mesmo usando seus aliases e configurações locais.

• Os comandos Git tendem a aparecer em grupos. Evite digitar gitrepetidamente, executando-os em um shell git dedicado:

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

Ou dê uma olhada nos outros projetos vinculados lá:

• git-sh - Um shell bash personalizado com um prompt, aliases e conclusão do Git.
• gitsh - Um shell Git simples escrito em Perl.
• repl - quebra qualquer programa com subcomandos em um REPL.

Nota: Não usei isso sozinho.

Um one-liner Perl que fará isso:

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

Isso executará o que você digitar, com o prefixo git. E continuará fazendo isso até você bater ^D.

Não é exatamente isso que você está pedindo, mas você pode configurar alguns aliases de shell nos ~/.bashrccomandos Git que você usa com mais freqüência:

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

Observe também que você pode criar aliases no próprio Git:

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

Isso permite que você digite em git civez de git commite assim por diante.

Eu sou um grande fã de usar aliases em ~ / .bash_profile para o meu GitBash. Se você seguir essa abordagem, aqui estão alguns dos meus favoritos:

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

Use seu editor.

Digite o comando como commitem seu editor favorito, como código vs, e seja mais eficiente com o git:

Ou digite gitpara obter todos os comandos:

Um amigo meu fez um pequeno script do bash que faz isso. Chama-se 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

Aqui está outro caminho. Também não foi exatamente o que foi solicitado, mas eu o uso há algum tempo e é muito bom. Adicione a seguinte linha ao seu ~/.bashrc:

complete -E -W git

Agora, pressionando Tab em um prompt vazio do Bash, digite "git".

Sei que essa é uma resposta muito tardia, mas essa pergunta realmente me chamou a atenção porque estou lidando com esse tipo de repetição há um bom tempo.

Não tenho certeza de você, mas sinceramente não (repito NÃO ) quero criar aliases para cada gitcomando, então escrevi um script python chamado NoGit para resolver esse 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 é um script python simples para evitar a repetição desnecessária da palavra-chave "git".

Documentação:

• o %undocomando remove o último comando da pilha
• o %runcomando executa os comandos na pilha e limpa a pilha
• o %exitcomando fecha a CLI sem fazer nada
• pressionar ctr+cé o mesmo que correr%run; %exit
• o script salva comandos que foram executados em um arquivo chamado git.historyna mesma pasta que o script
• você pode adicionar vários comandos em uma linha usando um ponto-e-vírgula
• você pode usar a palavra-chave gitno início do comando e o script não a duplicará (por exemplo git init , não se torna git git init)

Comandos de exemplo:

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

Informações adicionais (para usuários do Linux):

Se você quiser, pode remover a .pyextensão e convertê-la em um executável usando:

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

Então, em vez de chamar o script assim:

python3 git.py

Você executaria isso:

./git

Informações adicionais (para pessoas preguiçosas):

Se você é preguiçoso e não deseja digitar um ./, mova esse script para sua /bin/pasta e crie um alias para ele.

Se você é realmente muito preguiçoso, use os seguintes comandos:

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

Se você é realmente muito, muito preguiçoso, copie e cole a seguinte linha:

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

Se sua preguiça atingiu níveis anteriormente desconhecidos para a humanidade, aqui está uma versão mais compacta da mesma linha:

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

Boa sorte.

Outra abordagem que funcionará com qualquer comando: use Ctrl + R (pesquisa reversa-i).

A pesquisa inversa-i permite pesquisar seu histórico de comandos. Repita Ctrl + R depois de pressionar sua sequência de pesquisa para repetir a pesquisa ainda mais com a mesma sequência.

Você só precisa digitar um comando uma vez, para recuperar esse comando a partir de qualquer substring do comando. Na maioria dos casos, você pode recuperar comandos muito longos e suas diversas variantes com apenas duas a três letras de pesquisa bem posicionadas. Nenhuma pré-configuração é necessária além do uso normal do shell e é auto-adaptável à forma como você usou o shell, basta digitar o comando completo uma vez e os comandos serão automaticamente adicionados ao seu histórico de comandos.

• 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
• etc

Além disso, o Ctrl-R funciona não apenas no bash, mas em muitos programas que usam a biblioteca readline (e existem muitos), como shell Python, IPython, shell mysql, shell psql, irb (ruby), etc.

No seu exemplo, você o compara com um prompt do MySql. A maneira que funciona é que um processo MySql é iniciado e você fornece seus comandos para esse processo. Como tal, por que não escrever algo semelhante no seu idioma de escolha? Aqui está um exemplo simples em 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;
}

Observe que acabei de escrever isso de memória e que não o verifiquei com um compilador. Pode haver erros de sintaxe triviais.

Para coisas básicas, você pode fazer:

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>

Sair com ctrl + c

Quando usei o Windows 7 com o Conemu, adicionei o seguinte ao meu script de inicialização do ambiente de desenvolvimento:

doskey g=git $*

Com isso, eu poderia apenas usar o gcomando em vez de digitar git. A última vez que tentei com o Windows 10 e o Conemu, não funcionou, acho que há um bug, mas vale a pena tentar.

Use um editor de colchetes, é fácil usar seus comandos code e git, também possui muitos recursos.

No canto superior direito, o segundo ícone binocular é usado para instalar extensões.

Procure a extensão brackets gitcomo a imagem acima e instale-a.

Novamente, no canto superior direito, o quarto ícone será exibido; basta clicar e ver as alterações, como na imagem acima.

Se você deseja instalar colchetes, use os seguintes comandos:

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

Para obter mais informações, você pode ler: Como instalar o Brackets Code Editor no Ubuntu e Linux Mint no Ubuntupit .