Início / unix / Perguntas / 791550
Accepted
Whitehot
Asked: 2025-02-24 21:09:01 +0800 CST

Passe vários arquivos como uma única opção

  • 772

Estou tentando construir um wrapper para executar uma ferramenta várias vezes e, em seguida, concatenar alguns dos resultados. Gostaria de passar dois conjuntos de arquivos para meu script wrapper e, em seguida, executar a ferramenta para cada par de arquivos. Gostaria que ela se comportasse assim:

multitool.sh -a a*.txt -b b*.txt(expandindo os curingas para corresponder a todos os arquivos disponíveis)

Então multitool.sh, dentro do , executo a ferramenta em a1.txt b1.txt, a2.txt b1.txt, a1.txt b2.txt, a2.txt b2.txt, etc, com números variáveis ​​de arquivos a e b.

Eu segui este tutorial explicando os conceitos básicos de manipulação de opções e consegui usar getopspara manipular um -h, mas nada mais.

É aqui que estou agora:

#!/bin/bash


while getopts ":hpg:" option; do
    case $option in 
        h) # display help
            echo "-h to print this help and exit, -p is peak files, -g is bedgraph files."
            exit;;
        p) # get list of peak files to process
            l_peaks=$OPTARG;;
        g) # get list of bedgraph files to process
            l_bgraphs=$OPTARG;;
        \?) # Invalid option
            echo "Error! Invalid option!"
            echo "-h to print this help and exit, -p is peak files, -g is bedgraph files."
            exit;;
    esac
done

echo "$l_peaks"
echo "$l_bgraphs"

Estou trabalhando com uma equipe que não tem muita familiaridade com computadores, então, se eu puder manter o wrapper em uma execução simples de uma linha, seria melhor.

Como posso passar essas listas de arquivos como uma opção cada?

shell-script

4 respostas

  1. Best Answer

    Não, não esmague vários nomes de arquivo em uma única string. Primeiro, porque os shells não suportam isso(*), mas também porque, em geral, nomes de arquivo podem ser quaisquer strings . Não há caractere ou sequência de caracteres que você possa usar como separador que não seja válido em um nome de arquivo. Exceto pelo byte NUL, mas você não pode passar isso como um argumento de linha de comando de qualquer maneira.

    (* Com a possível exceção do zsh.)

    Então, basta preencher dois arrays com os nomes de arquivo que você obtém como argumentos. A partir daí, também é simples fazer um loop sobre as listas.

    No entanto, getoptsele irá parar quando vir um argumento não opcional, então teremos que procurar manualmente por alguma string separadora. (O que, novamente, necessariamente é algo que poderia ser um nome de arquivo, mas pelo menos precisará corresponder a um nome de arquivo completo para que as coisas fiquem confusas. Vamos escolher ::, e se você tiver um nome de arquivo como esse, certifique-se de passá-lo como ./::.)

    #!/bin/bash

while getopts "xy" option; do
    # silly placeholder
    echo "option $option"
done
shift $(( OPTIND - 1 ))

list=a
lista=()
listb=()
while [ "$1" ]; do
    case $1 in 
        ::) list=b;;
        *) if [ "$list" = a ]; then lista+=("$1")
           else                     listb+=("$1")
           fi;;
    esac
    shift
done

printf "files in list a:\n"
printf " <%s>\n" "${lista[@]}"
printf "\n"
printf "files in list b:\n"
printf " <%s>\n" "${listb[@]}"
printf "\n"
printf "combinations:\n"
for b in "${listb[@]}"; do
    for a in "${lista[@]}"; do
        printf "<%s> <%s>\n" "$a" "$b"
    done
done

    correndo que dá algo assim:

    $ bash lists.sh -x a* :: b*
option x
files in list a:
 <a1.txt>
 <a2.txt>
 <a3.txt>

files in list b:
 <b1.txt>
 <b2.txt>

combinations:
<a1.txt> <b1.txt>
<a2.txt> <b1.txt>
<a3.txt> <b1.txt>
<a1.txt> <b2.txt>
<a2.txt> <b2.txt>
<a3.txt> <b2.txt>

    Ajuste o loop getopts conforme necessário, mas lembre-se de manter o comando shift para limpar as opções getopts já processadas.

    Ou seja, presumi acima que você queria combinar o primeiro A com todos os Bs, e o segundo A com todos os Bs, etc.

    Se, em vez disso, você quiser o primeiro A com o primeiro B, o segundo A com o segundo B, etc., então o último loop precisaria ser algo como:

    i=0
# stop when either list ends
while [ "${lista[i]}" ] && [ "${listb[i]}" ]; do
    printf "<%s> <%s>\n" "${lista[i]}" "${listb[i]}"
    i=$((i + 1))
done

    Porém, como @terdon observou em um comentário, o GNU parallel poderia fazer isso diretamente.

    Assim:

    $ parallel echo {1} {2} ::: a*.txt ::: b*.txt
a1.txt b1.txt
a1.txt b2.txt
a2.txt b1.txt
a2.txt b2.txt
a3.txt b1.txt
a3.txt b2.txt

# or

$ parallel echo {1} {2} ::: a*.txt :::+ b*.txt
a1.txt b1.txt
a2.txt b2.txt

    Ele passa o comando dado por um shell, se caracteres especiais precisariam de algumas aspas extras. E é claro que você precisa ter cuidado com os separadores, com esse extra +sendo bastante significativo.

    • 9

  2. Se você estiver feliz em copiar a abordagem usada por finde citar os dois padrões glob curinga, você pode usar seu script para expandir os valores apropriadamente. Nesta configuração, os padrões citados são então manipulados pelo shell (e, portanto, por getopts) como apenas um argumento cada.

    Aqui está um exemplo, onde peguei seu código existente praticamente inalterado e o encolhi para (minha) conveniência. Seu código está melhor disposto, mas as partes interessantes são o processamento dos argumentos -aand -b:

    #!/bin/bash
#
# Multiple arguments: multitool -hp -a 'a*.txt' -b 'b*.txt'
#
########################################################################
#
while getopts ':hpg:a:b:' option
do
    case "$option" in
        a) a_list=($OPTARG) ;;    # Expand the (quoted) argument to the a_list array
        b) b_list=($OPTARG) ;;    # Expand the (quoted) argument to the b_list array
        h) echo "HELP!" >&2; exit 1 ;;
        p) l_peaks="$OPTARG" ;;
        g) l_bgraphs="$OPTARG" ;;
        \?) echo "ERROR!" >&2; exit 1 ;;
    esac
done
shift $(( OPTIND - 1 ))

# Checking values
#
echo "l_peaks=$l_peaks, l_bgraphs=$l_bgraphs"
echo "a_list=(${a_list[@]})"
echo "b_list=(${b_list[@]})"
echo

for ((i=0; i<="${#a_list[@]}"; i++))
do
    printf '%d\t%s\t%s\n' "$i" "${a_list[$i]}" "${b_list[$i]}"
done

    Exemplo

    ls
aapple  abanana  acherry  bone  bthree  btwo

./multitool -p -a 'a*' -b 'b*'
l_peaks=, l_bgraphs=
a_list=(aapple abanana acherry)
b_list=(bone bthree btwo)

0       aapple  bone
1       abanana bthree
2       acherry btwo
    • 4

  3. Uma das abordagens comuns para comandos que lidam com opções que aceitam mais de um argumento é chamar as opções várias vezes, como em:

    cmd -vvi file1 -i file2 -ifile3 -o out1 -ifile4

    (acima mostrando exemplos onde o argumento é fornecido como um argumento separado ou no mesmo argumento)

    Para aplicar isso aos globs, se estiver usando zsh, você pode fazer:

    cmd -vv file*(nP[-i]) -o out1

    Onde o P[prefix]qualificador glob insere um argumento extra -iantes de cada arquivo gerado para que ele acabe sendo executado cmd -vv -i file1 -i file2 ... -o out.

    (observe também o nqualificador para garantir que os arquivos sejam classificados numericamente, de modo que file10venha depois de file9e não entre file1e, file2como aconteceria na ordem lexical padrão).

    Ou:

    cmd -vv file*(ne:REPLY[1,0]=-i:) -o out1

    Ou:

    files=(file*(n)); cmd -vv -i$^files -o out1

    Ou, com a histsubstpatternopção habilitada:

    cmd -vv file*(n:s/#/-i) -o out1

    Ter -iadicionado (no mesmo argumento) a cada nome de arquivo, para que ele acabe executando cmd -vv -ifile1 -ifile2 ... -o out1.

    No bash (ou ksh93 de onde o bash copiou essa sintaxe), você pode fazer:

    files=(file*); cmd -vv "${files[@]/#/-i}" -o out

    Porém, tenha cuidado, pois o bash não tem equivalente para o qualificador do zsh, nentão file10ele será classificado entre file1e file2e, a menos que você ative a failglobopção, ele será chamado cmdcom um -ifile*argumento literal se não houver nenhum arquivo correspondente.

    No cmdpróprio script, você faria algo como:

    inputs=()
while getopts i: option; do
  case $option in
    (i) inputs+=( "$OPTARG" );;
    # rest of option parsing
  esac
done
echo "I got ${#inputs[@]} input files"
    • 3

  4. Sabemos que a lista de arquivos será um número par, dado que eles devem ser pareados uns com os outros. Usando isso, podemos usar um loop sobre todos os nomes de arquivo fornecidos e, enquanto iteramos sobre eles, nós os contamos. Quando tivermos atingido o ponto médio, podemos começar a parear o primeiro nome na lista com o nome atual no loop, então shift(o que remove o primeiro item da lista) e repetir.

    Isso funciona porque um forloop sempre itera sobre uma lista estática. Assim, "salvamos" a lista de nomes ao fazer um loop sobre ela, e podemos modificar a lista de parâmetros posicionais dentro do loop sem perturbar o loop em si.

    #!/bin/sh

n=$(( $# / 2 ))

for name do
        if [ "$n" -le 0 ]; then
                # The pair is "$1" (from the 1st set of files)
                # and "$name" (from the 2nd set of files).
                printf 'a-file = "%s"\tb-file = "%s"\n' "$1" "$name"
                shift
        fi

        n=$(( n - 1 ))
done

    Observe que nada disso requer o bashshell; podemos executá-lo com um shshell mais simples.

    Teste:

    $ ls
a1.txt   a2.txt  a4.txt  a6.txt  a8.txt  b1.txt   b2.txt  b4.txt  b6.txt  b8.txt  script
a10.txt  a3.txt  a5.txt  a7.txt  a9.txt  b10.txt  b3.txt  b5.txt  b7.txt  b9.txt

    $ sh script a* b*
a-file = "a1.txt"       b-file = "b1.txt"
a-file = "a10.txt"      b-file = "b10.txt"
a-file = "a2.txt"       b-file = "b2.txt"
a-file = "a3.txt"       b-file = "b3.txt"
a-file = "a4.txt"       b-file = "b4.txt"
a-file = "a5.txt"       b-file = "b5.txt"
a-file = "a6.txt"       b-file = "b6.txt"
a-file = "a7.txt"       b-file = "b7.txt"
a-file = "a8.txt"       b-file = "b8.txt"
a-file = "a9.txt"       b-file = "b9.txt"

    Se você precisar fazer uma análise de opções, faça isso antes do código que emparelha os nomes dos arquivos:

    #!/bin/sh

myself=$0

usage () {
        cat <<-USAGE_MESSAGE
        USAGE:
            $myself -h
            $myself -- {File set A} {File set B}

            -h          Display usage info
            File set A  Filenames for file set A
            File set B  Filenames for file set B
        USAGE_MESSAGE
}

while getopts h opt; do
        case $opt in
                h)
                        usage
                        exit
                        ;;
                *)
                        printf '%s: Error in option parsing\n' "$myself" >&2
                        exit 1
        esac
done
shift "$(( OPTIND - 1 ))"

if [ "$#" -eq 0 ]; then
        usage >&2
        exit 1
fi

n=$(( $# / 2 ))

for name do
        if [ "$n" -le 0 ]; then
                printf 'a-file = "%s"\tb-file = "%s"\n' "$1" "$name"
                shift
        fi

        n=$(( n - 1 ))
done
    • 0

relate perguntas