Execute o mesmo comando com parâmetros diferentes

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

"command -a -b -c"

ou

"command -abc"

Então, eu sempre devo digitar o seguinte

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

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

Você poderia fazer:

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

Ou:

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

com algumas conchas.

Mas cuidado com o fato de que isso afeta o padrão 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 deles seria cancelado se alguma das commandinvocações falhasse (exceto se falhar com o status de saída 255).

Para isso, você deseja:

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

Isso ainda falha no $?status de saída da commandchamada com falha ). Você pode mudar isso para:

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

Mas a essa altura, já é mais do que:

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

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

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 apontou , isso também pode resultar em expansões inesperadas.

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 chamar. 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

Entre as respostas criativas e perspicazes, aqui está algo simples em nome da digitação de 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

Crie um script de shell MultiRun , que recebe o primeiro parâmetro como comando e o executa com os parâmetros restantes, um de cada vez.

./ MultiRun curl ABCD

Seu script deve usar curl como 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 encerrará o script ou continuará para o 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 de comandos individuais.

O MultiRun Script 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 o seguinte:
./MultiRun echo 1 2 3 4
para obter a saída de "eco 1", "eco 2", "eco 3", "eco 4" como este:
1
2
3
4

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