¿Cómo evito escribir "git" al comienzo de cada comando Git?

Me pregunto si hay una manera de evitar tener que escribir la palabra git al comienzo de cada comando Git.

Sería bueno si hubiera una manera de usar el gitcomando solo una vez al principio después de abrir un símbolo del sistema para ingresar al "modo Git" .

Por ejemplo:

git>

Después de lo cual, cada comando que escribimos se interpreta por defecto como un comando Git.

De manera similar a cómo usamos el shell MySQL para escribir comandos de la base de datos:

mysql>

Esto me ahorrará tener que escribir gitcientos de veces al día.

NOTA: Estoy usando git-bash, en Windows.

Es posible que desee probar gitsh . De su léame:

El gitshprograma es un shell interactivo para git. Desde dentro gitshpuede emitir cualquier comando git, incluso utilizando sus alias locales y configuración.

• Los comandos Git tienden a venir en grupos. Evite escribir gituna y otra vez ejecutándolos en un shell de git dedicado:

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

O echa un vistazo a los otros proyectos vinculados allí:

• git-sh : un shell bash personalizado con un indicador Git, alias y finalización.
• gitsh : un shell Git simple escrito en Perl.
• repl - Envuelve cualquier programa con subcomandos en un REPL.

Nota: No he usado esto yo mismo.

Un Perl one-liner que hará esto:

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

Esto ejecutará lo que escriba, con el prefijo git. Y seguirá haciéndolo hasta que golpees ^D.

Esto no es exactamente lo que está pidiendo, pero puede configurar algunos alias de shell en ~/.bashrclos comandos Git que usa con más frecuencia:

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

También tenga en cuenta que puede crear alias dentro de Git:

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

Esto le permite escribir en git cilugar de git commit, y así sucesivamente.

Soy un gran fanático del uso de alias en ~ / .bash_profile para mi GitBash. Si sigue este enfoque, estos son algunos de mis 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'

Usa tu editor.

Escriba el comando like commitde su editor favorito como vs code y sea más eficiente con git:

O escriba gitpara obtener todos los comandos:

Un amigo mío hizo un pequeño script de bash que logra esto. Se llama Replificar .

$ 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

Aquí hay otra manera. Tampoco es exactamente lo que se pidió, pero lo he estado usando durante algún tiempo y es bastante agradable. Agregue la siguiente línea a su ~/.bashrc:

complete -E -W git

Ahora, presionando Tab en un indicador de Bash vacío escribirá "git".

Sé que esta es una respuesta muy tardía, pero esta pregunta realmente me llamó la atención porque he estado lidiando con sufrimiento de este tipo de repetición durante bastante tiempo.

No estoy seguro de ti, pero honestamente no (repito NO ) quiero crear alias para cada gitcomando, así que escribí un script de Python llamado NoGit para resolver este 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 es un script simple de Python para evitar la repetición innecesaria de la palabra clave "git".

Documentación:

• el %undo comando elimina el último comando de la pila
• el %run comando ejecuta los comandos en la pila y borra la pila
• el %exit comando cierra la CLI sin hacer nada
• presionar ctr+ces lo mismo que correr%run; %exit
• el script guarda los comandos que se ejecutaron en un archivo llamado git.history en la misma carpeta que el script
• puedes agregar múltiples comandos en una línea usando un punto y coma
• puede usar la palabra clave gital comienzo del comando y el script no la duplicará (por ejemplo, git init no se convierte git git init)

Comandos de ejemplo:

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

Información adicional (para usuarios de Linux):

Si lo desea, puede eliminar la .pyextensión y convertirla en un ejecutable usando:

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

Luego, en lugar de llamar al script de esta manera:

python3 git.py

En su lugar, ejecutarías esto:

./git

Información adicional (para personas perezosas):

Si eres flojo y no quieres escribir un, ./entonces puedes mover este script a tu /bin/carpeta y crear un alias para él.

Si usted es realmente, realmente perezoso, utilice los siguientes comandos:

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

Si eres muy, muy, muy vago, copia y pega la siguiente línea:

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

Si su pereza ha alcanzado niveles previamente desconocidos para la humanidad, aquí hay una versión más compacta de la misma frase:

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

Buena suerte.

Otro enfoque que funcionará con cualquier comando: use Ctrl + R (reverse-i-search).

Reverse-i-search le permite buscar en su historial de comandos. Repita Ctrl + R después de presionar su cadena de búsqueda para repetir la búsqueda más atrás con la misma cadena.

Solo necesita escribir un comando una vez, luego puede recuperar ese comando de cualquier subcadena del comando. En la mayoría de los casos, puede recuperar comandos completos muy largos y sus diversas variantes con solo dos o tres letras de búsqueda bien ubicadas. No se necesitan configuraciones previas que no sean usar su shell normalmente y es autoadaptable a la forma en que usó el shell, simplemente escriba el comando completo una vez y los comandos se agregarán automáticamente a su historial 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.

Además, Ctrl-R funciona no solo en bash, sino en muchos programas que usan la biblioteca readline (y hay muchos de ellos), como Python shell, IPython, mysql shell, psql shell, irb (ruby), etc.

En su ejemplo, lo compara con un indicador de MySql. La forma en que funciona es que se inicia un proceso MySql y usted le da sus comandos a ese proceso. Como tal, ¿por qué no escribir algo similar en su idioma de elección? Aquí hay un ejemplo 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;
}

Tenga en cuenta que acabo de escribir eso de memoria y que no lo comprobé con un compilador. Puede haber errores de sintaxis triviales.

Para cosas básicas, puedes hacer:

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>

Salir con ctrl + c

Cuando utilicé Windows 7 con Conemu, agregué lo siguiente a mi script de inicio del entorno de desarrollo:

doskey g=git $*

Con esto, podría usar el gcomando en lugar de escribir git. La última vez que probé con Windows 10 y Conemu, no funcionó, creo que hay un error, pero vale la pena intentarlo.

Use un editor de corchetes, es fácil usar su código y comandos git, también tiene muchas características.

En la esquina superior derecha, el segundo ícono binocular se usa para instalar extensiones.

Busque la extensión brackets gitcomo la imagen de arriba e instálela.

Una vez más, en la esquina superior derecha, aparecerá el cuarto icono, así que solo haga clic y vea los cambios como en la imagen de arriba.

Si desea instalar corchetes, use los siguientes comandos:

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

Para obtener más información, puede leer: Cómo instalar Brackets Code Editor en Ubuntu y Linux Mint en Ubuntupit .