Início / unix / Perguntas / 555622
Accepted
iybkyqjpbEP
Asked: 2019-12-05 10:52:39 +0800 CST

Prefixar todos os comandos no shell

  • 772

Como posso prefixar todos os comandos em um shell sem digitá-lo toda vez?

Meu caso de uso 1:

$ git init
$ git add -A
$ git commit
$ git push

O prefixo deve ser git␣( ␣é o caractere de espaço)

init
add -A
commit
push

Meu caso de uso 2:

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

O prefixo deve sersudo docker␣

run my-repo/my-image
ps
images

Seria melhor se eu pudesse fazer algo assim:

$ git init
$ use_prefix sudo docker
> ps
> images
> exit
$ sudo docker run my-repo/my-image
bash shell

8 respostas

  1. Best Answer

    Você poderia usar uma função como a seguinte:

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

    Isso aceitará seu prefixo como argumentos para o use_prefixcomando e, em seguida, lerá de stdin para cada comando a ser prefixado.

    Nota: Você terá que usar ctrl+c para sair do loop while read.

    • 17

  2. Você poderia usar xargs, mas com a devida atenção às ressalvas associadas ao seu uso

    xargs -L1 git

    em seguida, digite init, add -Aetc, um por linha

    • 13

  3. Com o zshshell, você pode executar:

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

    Para que o conteúdo de $zle_prefixseja inserido no início do buffer quando você começar a inserir uma nova linha de comando.

    Então você pode fazer:

    zle_prefix='sudo docker '

    Para que sudo dockerseja inserido no início dos comandos subsequentes.

    Você pode definir outro widget que prime $zle_prefix com o que está atualmente antes do seu cursor:

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

    E então você pode digitar

    $ sudo docker Alt+Shift+Pls

    Então sudo dockerserá inserido para todos os comandos subsequentes. Quando terminar, apague a linha ( Ctrl+U) e digite Alt+Shift+Pnovamente para esvaziar $zle_prefix.

    • 10

  4. Uma solução seria configurar aliases, mas você terá que estar atento quando eles colidirem com comandos internos e binários do sistema (por exemplo ps).

    No seu ~/.bashrcadicione algumas linhas assim (entra em vigor quando você iniciar o bash ou digitar source ~/.bashrc):

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

    Para executar um real ps, você teria que digitar command psou \ps. Isso geralmente afetaria apenas a digitação na linha de comando, a menos que você disponibilize especificamente os aliases para scripts.

    Quanto a uma interface de shell interativa como você sugere, isso exigiria algo mais envolvido.

    A saber, uma expansão da boa sugestão de @Jesse_B:

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

    Ativando a exitpalavra-chave e também adicionando um prompt lembrando o que você está fazendo.

    • 8

  5. Olá e bem-vindo ao site!

    uma possível solução para isso é usaraliasing

    embora não negue o "prefixo", pode economizar muito no tempo

    por exemplo

    alias g=git

$ g init
$ g add -A
$ g commit
$ g push

    OU

    se houver várias palavras, use aspas

    alias sd="sudo docker"

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

    você precisará redefinir esses aliases a cada sessão, no entanto

    • 4

  6. Você essencialmente quer um sub-shell de uso geral para o comando específico:

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

    Então:

    $ 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>

    Qualquer comando que você digitar é prefixado pelo comando original (absoluto ou relativo, além de quaisquer argumentos). O prompt lembra em qual comando original você está. Você pode exitsair inteiramente ou escapeum comando.

    • 3

  7. Você pode criar o alias no arquivo .bashrc do Linux: alias init="git init"

    e quando você executa o comando init do terminal automaticamente o comando "git init" seria invocado.

    • 0

  8. Supondo que você use o bash, existem muitas maneiras de fazer isso, conforme mencionado acima. Aqui está o que achei mais conveniente - YMMV:

    1. Crie uma função para cada "atalho" que você deseja usar.
    2. Tenha todas essas funções em um arquivo chamado, digamos,~/.bash_aliases
    3. Fonte este arquivo em seu .bash_profile.
    4. Chame a função seguida pelo(s) argumento(s).

    Observe que, estritamente falando, o arquivo não contém aliases, mas estou usando esse nome para manter as coisas organizadas. Você pode querer chamá-lo de .bash_functions.

    Aqui está um exemplo extremamente simples para você começar. Ele não verifica se você realmente passou um argumento ou não.

    $ cat ~/.bash_aliases

g() {
 git "$@"
}

sudock() {
 sudo docker "$@"
}

    Você pode então adicionar uma linha em sua .bash_profilefonte assim:

    . ~/.bash_aliases

    Aqui estão alguns exemplos de uso:

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

    Observe que você pode usar $1 no lugar de $@, mas isso levará apenas um argumento em vez de considerar tudo o que foi passado para a função.

    HTH.

    • 0

relate perguntas