Comment éviter de taper «git» au début de chaque commande Git?

Je me demande s'il existe un moyen d'éviter d'avoir à taper le mot gitau début de chaque commande Git.

Ce serait bien s'il y avait un moyen d'utiliser la gitcommande une seule fois au début après avoir ouvert une invite de commande pour passer en "mode Git" .

Par exemple:

git>

Après quoi, chaque commande que nous tapons est interprétée par défaut comme une commande Git.

D'une manière similaire à la façon dont nous utilisons le shell MySQL pour écrire des commandes de base de données:

mysql>

Cela m'évitera d'avoir à taper des gitcentaines de fois par jour.

REMARQUE: j'utilise git-bash, sous Windows.

Vous voudrez peut-être essayer gitsh . De leur readme:

Le gitshprogramme est un shell interactif pour git. De l'intérieur, gitshvous pouvez lancer n'importe quelle commande git, même en utilisant vos alias locaux et votre configuration.

• Les commandes Git ont tendance à venir en groupes. Évitez de taper gitencore et encore en les exécutant dans un shell git dédié:

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

Ou jetez un œil aux autres projets qui y sont liés:

• git-sh - Un shell bash personnalisé avec une invite Git, des alias et une complétion.
• gitsh - Un simple shell Git écrit en Perl.
• repl - Enveloppe tout programme avec des sous-commandes dans un REPL.

Remarque: je ne l'ai pas utilisé moi-même.

Un one-liner Perl qui fera ceci:

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

Cela exécutera tout ce que vous tapez, préfixé par git. Et il continuera à le faire jusqu'à ce que vous frappiez ^D.

Ce n'est pas exactement ce que vous demandez, mais vous pouvez configurer des alias de shell dans votre ~/.bashrcpour les commandes Git que vous utilisez le plus fréquemment:

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

Notez également que vous pouvez créer des alias dans Git lui-même:

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

Cela vous permet de taper git ciau lieu de git commit, et ainsi de suite.

Je suis un grand fan de l'utilisation d'alias dans ~ / .bash_profile pour mon GitBash. Si vous optez pour cette approche, voici quelques-uns de mes favoris:

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

Utilisez votre éditeur.

Tapez la commande comme commitdans votre éditeur préféré comme vs code et soyez plus efficace avec git:

Ou tapez gitpour obtenir toutes les commandes:

Un de mes amis a fait un petit script bash qui accomplit cela. Cela s'appelle 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

Voici une autre manière. Ce n'est pas non plus tout à fait ce qui a été demandé, mais je l'utilise depuis un certain temps et c'est plutôt sympa. Ajoutez la ligne suivante à votre ~/.bashrc:

complete -E -W git

Maintenant, en appuyant sur Tab à une invite Bash vide, vous tapez "git".

Je sais que c'est une réponse très tard , mais cette question vraiment frappé une note avec moi parce que j'ai affaire à la souffrance de ce genre de répétition pour un certain temps maintenant.

Je ne suis pas sûr de vous mais honnêtement, je ne veux pas (je répète NE PAS ) créer des alias pour chaque gitcommande, alors j'ai plutôt écrit un script python appelé NoGit pour résoudre ce problème:

#!/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 est un simple script python pour éviter la répétition inutile du mot-clé "git".

Documentation:

• la %undocommande supprime la dernière commande de la pile
• la %runcommande exécute les commandes dans la pile et efface la pile
• la %exitcommande ferme la CLI sans rien faire
• presser ctr+céquivaut à courir%run; %exit
• le script enregistre les commandes qui ont été exécutées dans un fichier appelé git.historydans le même dossier que le script
• vous pouvez ajouter plusieurs commandes sur une seule ligne en utilisant un point-virgule
• vous pouvez utiliser le mot-clé gitau début de la commande et le script ne le dupliquera pas ( EG: git init ne devient pas git git init)

Exemples de commandes:

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

Informations supplémentaires (pour les utilisateurs Linux):

Si vous le souhaitez, vous pouvez supprimer l' .pyextension et la convertir en exécutable en utilisant:

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

Alors au lieu d'appeler le script comme ceci:

python3 git.py

Vous exécuteriez ceci à la place:

./git

Informations supplémentaires (pour les paresseux):

Si vous êtes paresseux et que vous ne voulez pas taper un, ./vous pouvez déplacer ce script dans votre /bin/dossier et créer un alias pour celui-ci.

Si vous êtes vraiment, vraiment paresseux, utilisez les commandes suivantes:

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

Si vous êtes vraiment, vraiment, vraiment paresseux, copiez et collez le one-liner suivant:

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

Si votre paresse a atteint des niveaux auparavant inconnus de l'humanité, voici une version plus compacte du même one-liner:

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

Bonne chance.

Une autre approche qui fonctionnera avec toutes les commandes: utilisez Ctrl + R (reverse-i-search).

La recherche inversée vous permet de rechercher dans l'historique de vos commandes. Répétez Ctrl + R après avoir appuyé sur votre chaîne de recherche pour répéter la recherche plus en arrière avec la même chaîne.

Vous n'avez besoin de taper une commande qu'une seule fois, puis vous pouvez rappeler cette commande à partir de n'importe quelle sous-chaîne de la commande. Dans la plupart des cas, vous pouvez rappeler des commandes très longues entières et leurs différentes variantes avec seulement deux à trois lettres de recherche bien placées. Aucune préconfiguration nécessaire autre que l'utilisation normale de votre shell et il s'adapte automatiquement à la façon dont vous avez utilisé le shell, tapez simplement la commande complète une fois et les commandes seraient automatiquement ajoutées à votre historique de commandes.

• 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

De plus, Ctrl-R ne fonctionne pas seulement sur bash, mais sur de nombreux programmes utilisant la bibliothèque readline (et il y en a beaucoup), comme le shell Python, IPython, mysql shell, psql shell, irb (ruby), etc.

Dans votre exemple, vous le comparez à une invite MySql. La façon dont cela fonctionne est qu'un processus MySql démarre, et vous donnez vos commandes à ce processus. En tant que tel, pourquoi ne pas écrire quelque chose de similaire dans la langue de votre choix? Voici un exemple simple en 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;
}

Veuillez noter que je viens de l'écrire de mémoire et que je ne l'ai pas vérifié avec un compilateur. Il peut y avoir des erreurs de syntaxe triviales.

Pour les choses de base, vous pouvez faire:

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>

Quitter avec ctrl + c

Lorsque j'ai utilisé Windows 7 avec Conemu, j'ai ajouté ce qui suit à mon script de démarrage d'environnement de développement:

doskey g=git $*

Avec cela, je pourrais simplement utiliser la gcommande au lieu de taper git. La dernière fois que j'ai essayé avec Windows 10 et Conemu, cela n'a pas fonctionné, il y a un bug, je pense, mais ça vaut le coup d'essayer.

Utilisez un éditeur de crochets, il est facile d'utiliser votre code et vos commandes git, il possède également de nombreuses fonctionnalités.

Dans le coin supérieur droit, la deuxième icône binoculaire est utilisée pour installer les extensions.

Recherchez l'extension brackets gitcomme l'image ci-dessus et installez-la.

Encore une fois dans le coin supérieur droit, la quatrième icône apparaîtra, alors cliquez simplement et voyez les changements comme l'image ci-dessus.

Si vous souhaitez installer des crochets, utilisez les commandes suivantes:

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

Pour plus d'informations, vous pouvez lire: Comment installer l'éditeur de code Brackets dans Ubuntu et Linux Mint sur Ubuntupit .