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

190

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.

Noturno
fonte
87
Para aqueles que votaram para fechar com base no fato de serem fora do tópico, leia o texto no qual você está clicando: "Perguntas sobre hardware e software de computação geral são fora do tópico para o Stack Overflow, a menos que envolvam diretamente ferramentas usadas principalmente para programação . " Git é uma ferramenta usada por programadores. Como evidenciado pelo fato de ter sua própria tag neste site.
JBentley
5
Por que você está digitando tanto "git"? Seu IDE deve ter integrações poderosas do vcs disponíveis ao pressionar uma tecla. Você sim digitar "git pull" 50 vezes por dia, ou ctrl-t ... parada ser um guerreiro linha de comando quando você não precisa ser;)
vikingsteve
8
@vikingsteve Praticamente toda a ajuda e sabedoria do git são fornecidas em termos de linha de comando.
Ed Randall
6
@vikingsteve Estou digitando muito porque é mais rápido. Digito ~ 100wpm, mais se estiver intimamente familiarizado com as teclas pressionadas, como estou com o Git; comparado a clicar em GUIs, é apenas mais fácil. Seu IDE favorito pode ter atalhos de teclado. Isso é legal para você. Por que eu perderia tempo aprendendo-os quando <M-Tab> git blah <CR> já está na minha memória muscular?
Fund Monica's Lawsuit
3
Deve haver uma "esta pergunta deve ser encerrada porque o usuário está fazendo uma pergunta que não faz sentido" - como eu entendi o que você está perguntando, mas como o shell saberá que você deseja inserir um "não começando com" comando git "se realmente havia uma maneira de fazer isso.
user3728501

Respostas:

190

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.

alfunx
fonte
22
resmungar ... repl(1)não é um REPL. Não avalia nem imprime nada. Ele executa programas.
Kevin
11
@ Kevin Ele lê as solicitações do usuário, avalia a solicitação do usuário (executando um programa) e imprime a saída do programa. Isso também é o que as conchas fazem.
Yakk - Adam Nevraumont
2
@ Yakk-AdamNevraumont: Não, certamente não "imprime a saída do programa". Ele conecta o stdout do programa ao terminal e, em seguida, o programa imprime sua própria saída - exceto que o stdout do programa já está conectado ao terminal (herdado automaticamente pelo fork()/ exec()), portanto, repl(1)nem faz isso .
Kevin
6
@Kevin Entendo sua opinião, no entanto, a definição estrita de um REPL excluiria a maioria dos intérpretes “REPL” em vários idiomas. Somente em linguagens funcionais puras você pode garantir que a avaliação não tenha efeitos colaterais, mas mesmo em Haskell, o "REPL" GHCi também aceitará IOações e executá-las incluindo efeitos colaterais, como impressão na tela conectada ao terminal.
leftaroundabout
2
@ Kevin replnão é um REPL autônomo; é um meio de criar um sistema REPL no qual replé apenas o componente interativo. Isto é Justo?
Kyle Strand
116

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.


fonte
6
Isso realmente é mais parecido com o que o OP está pedindo e em um pacote muito leve!
Ruohola
2
Isso seria perfeito se funcionasse com o readline, mas infelizmente não funciona (não surpreendentemente, pois isso é estritamente um hack nas -nebandeiras do Perl ).
Konrad Rudolph
11
@KonradRudolphperl -MTerm::ReadLine -E '$n = Term::ReadLine -> new ("git"); while ($_ = $n -> readline ("git > ")) {system "git $_"}'
57

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.

Thomas
fonte
7
A desvantagem dessa abordagem é que um alias separado precisaria ser criado para cada comando Git.
Tim Biegeleisen 8/06/19
22
Somente para os mais usados. Quero dizer, com que frequência você usa git hash-objectou git interpret-trailers? Só estou oferecendo isso como uma alternativa, porque, até onde eu sei, o que a pergunta está pedindo realmente não existe.
Thomas
15
Além de cifor commiteu também uso um apelido de shell gpara git, isso reduz a maior parte da digitação e permite que eu permaneça no meu shell preferido.
rkta
32

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'
JacobIRR
fonte
3
where's commit: P
qwr 10/06/19
14
Eu não incluem commitou pushdesde que eu quero alguns segundos extra (enquanto digitação) para ter certeza que eu não estou destruindo algo
JacobIRR
3
O commit e o push não devem destruir nada, a menos que você use o push forçado. Mas tento usar o status git de antemão.
QWR
1
foi o que fiz também, +1. Embora eu estou tentado a experimentar gitsh como outras respostas mencionado
CoffeeTableEspresso
1
@CoffeeTableEspresso Eu respeito o fato de que você reconhece que algumas teclas são a diferença entre salvar atualizações e destruir um projeto.
LogicalBranch
31

Use seu editor.

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

insira a descrição da imagem aqui

Ou digite gitpara obter todos os comandos:

insira a descrição da imagem aqui

prosti
fonte
13
Estou surpreso com todos esses votos negativos. Esta não é uma resposta terrível para as pessoas que usam IDEs que suportam esses recursos.
Glen Pierce
4
Acho que as pessoas votaram menos porque nem todo mundo usa / gosta do código VS. De qualquer forma, acho que é uma solução decente, portanto, +1 de mim.
LogicalBranch
4
@LogicalBranch, as pessoas geralmente usam o git na linha de comando, e eu estou ciente disso, mas o suporte ao git dentro de alguns editores existe e vale a pena tentar.
Prosti19:
1
Eu não gosto desta resposta porque nem todo mundo usa código VS (eu pessoalmente não gosto), mas não diminuirei o voto porque esta é uma boa solução para pessoas que o usam.
CoffeeTableEspresso
1
@CoffeeTableEspresso, se você estiver usando sublime, existe um plugin chamado gitsavvy , e assim por diante ... Quase todos os editores hoje em dia têm algum tipo de suporte para o git. Este foi o ponto da resposta, como você pode ler "Use seu editor".
prosti
26

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
Sam Weaver
fonte
6
OK, eu já mencionei isso na resposta de Umur, mas o uso evalno código-fonte original do script não é a melhor ideia. Diga ao seu amigo para usar em while IFS= read -r -p "git> " gitcmd; do [ "x$gitcmd" != "x" ] && git "$gitcmd";donevez disso
Sergiy Kolodyazhnyy 10/10
23

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".

nomadictype
fonte
5
Observe que se você estiver usando outro shell, precisará colocá-lo no arquivo apropriado. Por exemplo, para zsh, você o colocará ~/zshrc, para o tcsh, o colocará ~/tcshrc, etc.
TheOnlyMrCat
20

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.

LogicalBranch
fonte
17

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.

Lie Ryan
fonte
15

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.

john01dav
fonte
Apenas o meu pensamento. Qualquer pessoa no Stack Overflow deve ser capaz de codificar esse programa. A linguagem de programação realmente não importa.
Thomas Weller
@ThomasWeller Eu definitivamente concordo. Postei o programa para mostrar com precisão o que estava falando, não porque é um programa difícil de escrever.
precisa saber é o seguinte
9
Você vai investir muito tempo com essa abordagem se quiser que o programa seja livre de erros e tenha uma quantidade razoável de recursos. Por exemplo, após corrigir a falha inicial de construção (std :: system () deseja const char *), você notará que há um loop infinito no EOF. Você pode precisar de suporte para histórico / linha de leitura, conclusão de guias, alguns recursos internos para alterar o diretório / definir env vars / shell out / ..., etc. Se houver software existente (como o gitsh neste caso), por que não usá-lo?
Nomadictype
1
@nomadictype Essa é uma crítica válida, mas aprender outro software também é um compromisso de tempo. As vantagens dessa abordagem são que são necessários apenas alguns minutos para fazê-la funcionar, e isso fará exatamente o que você espera ou deseja (com alterações).
91119 JohnJohn_Dav
2
A perda de linha de leitura, edição de linha, suporte ao histórico, a capacidade de executar comandos simples como ls, etc, custarão muito mais do que as quatro teclas digitadas ou então você salvou com isso.
Lie Ryan
13

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

Umur Kontacı
fonte
2
Idéia decente, porém há dois problemas. Um, o ;depois do leva a bash: syntax error near unexpected token ; `` Segundo, a evalparte é propensa a vulnerabilidades. Por exemplo, considere o que acontece se eu digitar status;cat /etc/passwdesse pequeno shell. Exemplo inofensivo, mas você entendeu o que pode acontecer. Você pode simplificar isso em while IFS= read -r -p "git> " gitcmd; do [ "x$gitcmd" != "x" ] && git "$gitcmd";doneIsso obviamente não é à prova de balas, mas 1 - é mais simples e 2 - evita a execução de comandos não-git (em virtude de aspas duplas). Não é o ideal, apenas um pouco melhor
Sergiy Kolodyazhnyy
@ Abigail Funny :) Por que sim, o próprio shell não é o aplicativo mais seguro. Até mesmo criar um arquivo pode ser um problema. No entanto, o ponto que eu estava enfatizando originalmente é que não vemos o interpretador mysql executando comandos do shell, não sem systemou \!no começo pelo menos. Onde a suposição pode ser que esse "repl" execute gitapenas comandos, na verdade permite mais do que isso.
Sergiy Kolodyazhnyy
@ Abigail Não tenho medo, porque sei o que isso faz. Outros que não - podem acabar quebrando algo que não deveriam. E novamente - eval não é a melhor idéia para executar comandos, especialmente quando há entrada controlada pelo usuário.
Sergiy Kolodyazhnyy 16/06/19
Corrigido o erro de digitação após do . Obrigado! re: security: obviamente não é para ser distribuído como um aplicativo separado. Basta colocar no seu .bash_profilese você não gosta de digitar git. Eu não estou muito preocupado com isso ser "inseguro". Se você colar coisas no seu bash que não entende (incluindo esse script oneliner), terá um mau momento. Gosto disso porque é simples, fácil de escrever, de ler e de melhorar.
Umur Kontacı
2

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.

Adamsan
fonte
2

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

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

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 .

akash
fonte