Execute o mesmo comando com parâmetros diferentes

Question

Eu não tenho um programa realmente permissivo para trabalhar. Infelizmente, este programa não permite apenas o seguinte

"command -a -b -c"

ou

"command -abc"

Portanto, sempre tenho que digitar o seguinte

command -a && command -b && command -c

Tenho certeza de que há uma maneira mais eficiente de digitar isso, mas não consigo descobrir.

    

Answer 1

Você poderia fazer:

echo -a -b -c | xargs -n 1 command

Ou:

xargs -n1 command <<< '-a -b -c'

com algumas conchas.

Mas cuidado, pois isso afeta o status de command .

com zsh :

autoload zargs # best in ~/.zshrc
zargs -n 1 -- -a -b -c -- command

Ou simplesmente:

for o (-a -b -c) command $o

Nenhum desses abortaria se alguma das invocações de command falhasse (exceto se falhasse com o status de saída 255).

Para isso, você deseja:

for o (-a -b -c) command $o || break

Isso ainda falha no $? do status de saída da falha command invocation). Você poderia mudar isso para:

(){for o (-a -b -c) command $o || return}

Mas, nessa altura, já é mais do que:

command -a && command -b && command -c

    

Answer 2

Você pode consultar a primeira palavra da linha de comando anterior ( command no seu caso) pela expansão do histórico !!:0 e, em seguida, pode adicionar apenas os argumentos necessários a ela.

command -a && !!:0 -b && !!:0 -c

Por exemplo:

% echo foobar && !!:0 spamegg && !!:0 baz    
echo foobar && echo spamegg && echo baz
foobar
spamegg
baz

Observe que, como Stéphane Chazelas apontado , isso pode resultar em expansões inesperadas também.

    

Answer 3

Que tal uma função shell envolvendo um loop?

yourcmd() {
    local arg
    for arg; do
        thing "$arg" || return
    done
}

Onde "coisa" é o comando real que você deseja invocar. Então simplesmente

yourcmd -a -b -c

Você pode até generalizar isso para qualquer comando:

splitargs() {
    local cmd arg 
    cmd="$1"
    shift
    for arg; do
        "$cmd" "$arg" || return
    done
}

Então

splitargs somecommand -a -b -c

    

Answer 4

Em meio a respostas criativas e perspicazes, aqui está algo simples no nome de digitar menos caracteres:

# under the assumption that you have a frequently-used set of flags: -a -b -c
alias c='command -a && command -b && command -c'

# slightly more generally, name some aliases according to the set of flags
alias cabc='command -a && command -b && command -c'
alias cdef='command -d && command -e && command -f'

# more generally, just shorten the command name and then pass whatever flags you want
alias c=command
c -e && c -f && c -f

    

Answer 5

Crie um script de shell MultiRun , que recebe o primeiro Parameter como Comando e o executa com os Parâmetros restantes, um de cada vez.

./ MultiRun curl A B C D

Seu script deve se enrolar como o comando e executar "curl A", "curl B", "curl C", "curl D". Agora, como seu script está no controle, você pode decidir se uma falha em qualquer comando terminará o script ou continuará no próximo parâmetro ou aguardará a entrada do usuário ou o que for. Você pode até decidir o status de saída de todo o script, com base na execução dos comandos individuais.

Script MultiRun pode ser algo assim:

#! /bin/bash
COMMAND=$1
shift #### Remove COMMAND from existing Parameters
for PARAMETER in "$@" ; #### Process all remaining Parameters
do
  # echo Executing "$COMMAND $PARAMETER" now #### Uncomment this line to see what command is getting executed.
  $COMMAND $PARAMETER
  # Check exit status and take action or wait for user input , if required.
  # read -p "finished executing command. press enter to continue. waiting..." #### Uncomment this line to pause between commands.
done
# Depending on the individual exit statuses , choose your exit status N with "exit $N".

Agora execute isto:
./MultiRun echo 1 2 3 4
obter saída de "echo 1", "echo 2", "echo 3", "echo 4" como este:
1
2
3
4

É muito flexível & solução reutilizável.