web-dev-qa-db-fra.com

Préfixe toutes les commandes dans le shell

Comment puis-je préfixer toutes les commandes dans un shell sans le taper à chaque fois?

Mon cas d'utilisation 1:

$ git init
$ git add -A
$ git commit
$ git Push

Le préfixe doit être git␣ (␣ est le caractère espace)

init
add -A
commit
Push

Mon cas d'utilisation 2:

Sudo docker run my-repo/my-image
Sudo docker ps
Sudo docker images

Le préfixe doit être Sudo docker␣

run my-repo/my-image
ps
images

Ce serait mieux si je pouvais faire quelque chose comme ça:

$ git init
$ use_prefix Sudo docker
> ps
> images
> exit
$ Sudo docker run my-repo/my-image
bashshellcommand-line
21
iybkyqjpbEP

Vous pouvez utiliser une fonction comme la suivante:

use_prefix () {
    while read -ra c; do
        "$@" "${c[@]}"
    done
}

Cela acceptera votre préfixe comme arguments de la use_prefix, puis lisez à partir de stdin pour chaque commande à préfixer.

Remarque: Vous devrez utiliser ctrl + c pour quitter la boucle de lecture while.

16
jesse_b

Vous pouvez utiliser xargs, mais en tenant dûment compte de mises en garde associé à son utilisation

xargs -L1 git

puis saisissez init, add -A etc, un par ligne

13
iruvar

Avec le shell zsh, vous pouvez exécuter:

zle-line-init() if [[ $CONTEXT = start ]] LBUFFER=$zle_prefix$LBUFFER
zle -N zle-line-init

Pour le contenu de $zle_prefix à insérer au début du tampon lorsque vous commencez à entrer une nouvelle ligne de commande.

Vous pouvez donc faire:

zle_prefix='Sudo docker '

Pour ça Sudo docker à insérer au début des commandes suivantes.

Vous pouvez définir un autre widget qui nombres premiers$zle_prefix avec ce qui est actuellement devant votre curseur:

prime-zle-prefix() zle_prefix=$LBUFFER
zle -N prime-zle-prefix
bindkey '\eP' prime-zle-prefix

Et puis vous pouvez taper

$ Sudo docker Alt+Shift+P ls

Alors Sudo docker sera inséré pour toutes les commandes suivantes. Lorsque vous avez terminé, videz la ligne (Ctrl+U) et entrez Alt+Shift+P à nouveau pour vider $zle_prefix.

10
Stéphane Chazelas

Une solution serait de configurer des alias, mais vous devrez faire attention lorsqu'ils entrent en collision avec des commandes intégrées et des binaires système (par exemple ps).

Dans ton ~/.bashrc ajoutez des lignes comme ceci (prend effet au prochain démarrage de bash ou tapez source ~/.bashrc):

alias commit='git commit'
alias docker='Sudo docker'
alias images='docker images'
alias ps='docker ps'

Pour exécuter un ps réel, vous devez taper command ps ou \ps. Cela n'affecterait généralement que la saisie sur la ligne de commande, sauf si vous mettez spécifiquement les alias à la disposition des scripts.

Quant à une interface Shell interactive comme vous le suggérez, cela nécessiterait quelque chose de plus complexe.

À savoir, une extension de la belle suggestion de @ Jesse_B:

use_prefix () {
    while read -p "$* >" -ra c; do
        [ "${c[0]}" = "exit" ] && break
        "$@" "${c[@]}"
    done
}

Activation de la clé exit Word et ajout d'une invite vous rappelant ce que vous faites.

8
bxm

Bonjour et bienvenue sur le site.

une solution possible consiste à utiliser aliasing

bien qu'il n'annule pas le "préfixe", il peut économiser beaucoup de temps

par exemple.

alias g=git

$ g init
$ g add -A
$ g commit
$ g Push

OR

s'il y a plusieurs mots, utilisez simplement des guillemets

alias sd="Sudo docker"

sd run my-repo/my-image
sd ps
sd images

vous devrez cependant réinitialiser ces alias à chaque session

4
CyberStems

Vous voulez essentiellement un sous-shell à usage général pour la commande spécifique:

Shell() {
    TOPCMD=$@ bash -c 'while read -p "${TOPCMD##*/}> " -ra sub; do
        case ${sub[0]:-} in
        "") continue;;
        exit) exit;;
        escape) (set -x; ${sub[@]:1});;
        *) (set -x; ${TOPCMD} ${sub[@]});;
        esac
        done'
}

Donc alors:

$ Shell git -p
git -p> init
+ git -p init
Initialized Git repository in /path/to/.git/
git -p> escape touch foo
+ touch foo
git -p> add .
+ git -p add .
git -p> status
+ git -p status
On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)

        new file:   foo

git -p>

Toute commande que vous tapez est préfixée par la commande d'origine (absolue ou relative, plus tous les arguments). L'invite vous rappelle dans quelle commande d'origine vous vous trouvez. Vous pouvez exit sortir entièrement, ou escape une commande.

1
bishop

Vous pouvez créer l'alias dans le fichier .bashrc de Linux: alias init = "git init"

et lorsque vous exécutez la commande init à partir du terminal, la commande "git init" est invoquée automatiquement.

0
Nikita Bakshi

En supposant que vous utilisez bash, il existe plusieurs façons de procéder, comme mentionné ci-dessus. Voici ce que j'ai trouvé le plus pratique - YMMV:

  1. Créez une fonction pour chaque "raccourci" que vous souhaitez utiliser.
  2. Avoir toutes ces fonctions dans un fichier appelé, disons, ~/.bash_aliases
  3. Sourcez ce fichier dans votre .bash_profile.
  4. Appelez la fonction suivie du ou des arguments.

Notez que, strictement parlant, le fichier ne contient pas d'alias, mais j'utilise ce nom pour garder les choses épurées. Vous pouvez l'appeler .bash_functions.

Voici un exemple extrêmement simple pour vous aider à démarrer. Il ne vérifie pas si vous avez réellement transmis un argument ou non.

$ cat ~/.bash_aliases

g() {
 git "$@"
}

sudock() {
 Sudo docker "$@"
}

Vous pouvez ensuite ajouter une ligne dans votre .bash_profile pour le source comme ceci:

. ~/.bash_aliases

Voici quelques exemples d'utilisations:

g status
g commit -m 'initial commit' fileName
sudock run my-repo/my-image

Notez que vous pouvez utiliser $ 1 à la place de $ @, mais cela ne prendra qu'un seul argument au lieu de considérer tout ce qui a été transmis à la fonction.

HTH.

0
Hopping Bunny