Como iterar em um intervalo de números no Bash quando o intervalo é fornecido por uma variável?

Eu sei que posso fazer isso (chamado "expressão de sequência" na documentação do Bash ):

 for i in {1..5}; do echo $i; done

Que dá:

1
2
3
4
5

No entanto, como posso substituir qualquer um dos pontos de extremidade do intervalo por uma variável? Isso não funciona:

END=5
for i in {1..$END}; do echo $i; done

Que imprime:

{1..5}

for i in $(seq 1 $END); do echo $i; done

edit: eu prefiro seqos outros métodos, porque na verdade consigo me lembrar;)

O seqmétodo é o mais simples, mas o Bash possui avaliação aritmética integrada.

END=5
for ((i=1;i<=END;i++)); do
    echo $i
done
# ==> outputs 1 2 3 4 5 on separate lines

A for ((expr1;expr2;expr3));construção funciona como for (expr1;expr2;expr3)em C e linguagens semelhantes e, como em outros ((expr))casos, Bash os trata como aritméticos.

discussão

Usar seqé bom, como Jiaaro sugeriu. Pax Diablo sugeriu um loop Bash para evitar chamar um subprocesso, com a vantagem adicional de ser mais amigável à memória se $ END for muito grande. Zathrus detectou um erro típico na implementação do loop e também sugeriu que, como ié uma variável de texto, as conversões contínuas para números são executadas com uma desaceleração associada.

aritmético inteiro

Esta é uma versão aprimorada do loop Bash:

typeset -i i END
let END=5 i=1
while ((i<=END)); do
    echo $i
    …
    let i++
done

Se a única coisa que queremos é a echo, então poderíamos escrever echo $((i++)).

ephemient me ensinou algo: Bash permite for ((expr;expr;expr))construções. Como nunca li a página de manual inteira do Bash (como fiz com a kshpágina de manual do Korn shell ( ), e isso foi há muito tempo), senti falta disso.

Assim,

typeset -i i END # Let's be explicit
for ((i=1;i<=END;++i)); do echo $i; done

parece ser a maneira mais eficiente em termos de memória (não será necessário alocar memória para consumir seq a saída, o que pode ser um problema se END for muito grande), embora provavelmente não seja o "mais rápido".

a pergunta inicial

eschercycle observou que a notação { a .. b } Bash funciona apenas com literais; true, de acordo com o manual do Bash. Pode-se superar esse obstáculo com um único (interno) fork()sem um exec()(como é o caso da chamada seq, que sendo outra imagem requer um fork + exec):

for i in $(eval echo "{1..$END}"); do

Ambos são evale echoBash builtins, mas um fork()é necessário para a substituição de comando (a $(…)construção).

Aqui está o porquê da expressão original não funcionar.

De man bash :

A expansão entre chaves é executada antes de qualquer outra expansão e quaisquer caracteres especiais para outras expansões são preservados no resultado. É estritamente textual. O Bash não aplica nenhuma interpretação sintática ao contexto da expansão ou ao texto entre os chavetas.

Portanto, a expansão entre chaves é algo feito cedo como uma operação macro puramente textual, antes da expansão dos parâmetros.

Os shells são híbridos altamente otimizados entre processadores macro e linguagens de programação mais formais. Para otimizar os casos de uso típicos, a linguagem é bastante mais complexa e algumas limitações são aceitas.

Recomendação

Eu sugeriria manter os recursos do Posix ¹ . Isso significa usar for i in <list>; do, se a lista já for conhecida, caso contrário, use whileou seq, como em:

#!/bin/sh

limit=4

i=1; while [ $i -le $limit ]; do
  echo $i
  i=$(($i + 1))
done
# Or -----------------------
for i in $(seq 1 $limit); do
  echo $i
done

A maneira POSIX

Se você se importa com portabilidade, use o exemplo do padrão POSIX :

i=2
end=5
while [ $i -le $end ]; do
    echo $i
    i=$(($i+1))
done

Resultado:

2
3
4
5

Coisas que não são POSIX:

• (( ))sem dólar, embora seja uma extensão comum, como mencionado pelo próprio POSIX .
• [[. [é suficiente aqui. Veja também: Qual é a diferença entre colchetes simples e duplos no Bash?
• for ((;;))
• seq (GNU Coreutils)
• {start..end}, e isso não pode funcionar com variáveis, conforme mencionado no manual do Bash .
• let i=i+1: POSIX 7 2. A linguagem de comandos do shell não contém a palavra lete falha no bash --posix4.3.42

• i=$i+1pode ser necessário o dólar em , mas não tenho certeza. O POSIX 7 2.6.4 Expansão aritmética diz:

  Se a variável shell x contiver um valor que forme uma constante inteira válida, incluindo opcionalmente um sinal de mais ou menos, as expansões aritméticas "$ ((x))" e "$ (($ x))" retornarão o mesmo valor.

  mas lê-lo literalmente, não implica que se $((x+1))expanda, pois x+1não é uma variável.

Outra camada de indireção:

for i in $(eval echo {1..$END}); do
    ∶

Você pode usar

for i in $(seq $END); do echo $i; done

Se você precisar dele como prefixo, poderá gostar deste

 for ((i=7;i<=12;i++)); do echo `printf "%2.0d\n" $i |sed "s/ /0/"`;done

isso renderá

07
08
09
10
11
12

Se você estiver no BSD / OS X, poderá usar jot em vez de seq:

for i in $(jot $END); do echo $i; done

Isso funciona bem em bash:

END=5
i=1 ; while [[ $i -le $END ]] ; do
    echo $i
    ((i = i + 1))
done

Combinei algumas das idéias aqui e medi o desempenho.

TL; DR Takeaways:

1. seqe {..}são muito rápidos
2. fore whileloops são lentos
3. $( ) é lento
4. for (( ; ; )) loops são mais lentos
5. $(( )) é ainda mais lento
6. Preocupar-se com os números N na memória (seq ou {..}) é bobo (pelo menos até 1 milhão).

Estas não são conclusões . Você teria que olhar o código C por trás de cada um deles para tirar conclusões. Isso é mais sobre como tendemos a usar cada um desses mecanismos para fazer loop sobre o código. A maioria das operações individuais está perto o suficiente para ter a mesma velocidade que não importa na maioria dos casos. Mas um mecanismo como esse for (( i=1; i<=1000000; i++ ))é muitas operações, como você pode ver visualmente. Também há muito mais operações por loop do que você obtém for i in $(seq 1 1000000). E isso pode não ser óbvio para você, e é por isso que fazer testes como esse é valioso.

Demonstrações

# show that seq is fast
$ time (seq 1 1000000 | wc)
 1000000 1000000 6888894

real    0m0.227s
user    0m0.239s
sys     0m0.008s

# show that {..} is fast
$ time (echo {1..1000000} | wc)
       1 1000000 6888896

real    0m1.778s
user    0m1.735s
sys     0m0.072s

# Show that for loops (even with a : noop) are slow
$ time (for i in {1..1000000} ; do :; done | wc)
       0       0       0

real    0m3.642s
user    0m3.582s
sys 0m0.057s

# show that echo is slow
$ time (for i in {1..1000000} ; do echo $i; done | wc)
 1000000 1000000 6888896

real    0m7.480s
user    0m6.803s
sys     0m2.580s

$ time (for i in $(seq 1 1000000) ; do echo $i; done | wc)
 1000000 1000000 6888894

real    0m7.029s
user    0m6.335s
sys     0m2.666s

# show that C-style for loops are slower
$ time (for (( i=1; i<=1000000; i++ )) ; do echo $i; done | wc)
 1000000 1000000 6888896

real    0m12.391s
user    0m11.069s
sys     0m3.437s

# show that arithmetic expansion is even slower
$ time (i=1; e=1000000; while [ $i -le $e ]; do echo $i; i=$(($i+1)); done | wc)
 1000000 1000000 6888896

real    0m19.696s
user    0m18.017s
sys     0m3.806s

$ time (i=1; e=1000000; while [ $i -le $e ]; do echo $i; ((i=i+1)); done | wc)
 1000000 1000000 6888896

real    0m18.629s
user    0m16.843s
sys     0m3.936s

$ time (i=1; e=1000000; while [ $i -le $e ]; do echo $((i++)); done | wc)
 1000000 1000000 6888896

real    0m17.012s
user    0m15.319s
sys     0m3.906s

# even a noop is slow
$ time (i=1; e=1000000; while [ $((i++)) -le $e ]; do :; done | wc)
       0       0       0

real    0m12.679s
user    0m11.658s
sys 0m1.004s

Eu sei que essa pergunta é sobre bash, mas - apenas para constar - ksh93é mais inteligente e a implementa conforme o esperado:

$ ksh -c 'i=5; for x in {1..$i}; do echo "$x"; done'
1
2
3
4
5
$ ksh -c 'echo $KSH_VERSION'
Version JM 93u+ 2012-02-29

$ bash -c 'i=5; for x in {1..$i}; do echo "$x"; done'
{1..5}

Esta é outra maneira:

end=5
for i in $(bash -c "echo {1..${end}}"); do echo $i; done

Se você deseja permanecer o mais próximo possível da sintaxe da expressão entre chaves, tente a rangefunção em bash-tricks 'range.bash .

Por exemplo, tudo o que se segue fará exatamente a mesma coisa que echo {1..10}:

source range.bash
one=1
ten=10

range {$one..$ten}
range $one $ten
range {1..$ten}
range {1..10}

Ele tenta suportar a sintaxe nativa do bash com o mínimo possível de "truques": não apenas as variáveis ​​são suportadas, mas o comportamento muitas vezes indesejável de intervalos inválidos sendo fornecidos como strings (por exemplo, for i in {1..a}; do echo $i; done ).

As outras respostas funcionarão na maioria dos casos, mas todas elas têm pelo menos uma das seguintes desvantagens:

• Muitos deles usam subcascas , o que pode prejudicar o desempenho e pode não ser possível em alguns sistemas.
• Muitos deles contam com programas externos. Atéseq é um binário que deve ser instalado para ser usado, deve ser carregado pelo bash e deve conter o programa que você espera, para que ele funcione nesse caso. Onipresente ou não, é muito mais para confiar do que apenas a própria linguagem Bash.
• As soluções que usam apenas a funcionalidade nativa do Bash, como @ ephemient, não funcionarão em intervalos alfabéticos, como {a..z}; cinta expansão vontade. A pergunta era sobre faixas de números , no entanto, então isso é uma queixa.
• A maioria deles não é visualmente semelhante à {1..10}sintaxe da faixa expandida, então os programas que usam os dois podem ser um pouco mais difíceis de ler.
• A resposta de @ bobbogo usa algumas das sintaxes familiares, mas faz algo inesperado se a $ENDvariável não for um "bookend" de intervalo válido para o outro lado do intervalo. Se END=a, por exemplo, um erro não ocorrer e o valor literal {1..a}for repetido. Esse também é o comportamento padrão do Bash - geralmente é inesperado.

Isenção de responsabilidade: eu sou o autor do código vinculado.

Substitua {}por (( )):

tmpstart=0;
tmpend=4;

for (( i=$tmpstart; i<=$tmpend; i++ )) ; do 
echo $i ;
done

Rendimentos:

0
1
2
3
4

Tudo isso é bom, mas seq é supostamente obsoleto e a maioria funciona apenas com intervalos numéricos.

Se você colocar o loop for entre aspas duplas, as variáveis ​​de início e fim serão desreferenciadas quando você repetir a sequência e poderá enviá-la de volta ao BASH para execução. $iprecisa ser escapado com \ 's, para NÃO ser avaliado antes de ser enviado ao subshell.

RANGE_START=a
RANGE_END=z
echo -e "for i in {$RANGE_START..$RANGE_END}; do echo \\${i}; done" | bash

Esta saída também pode ser atribuída a uma variável:

VAR=`echo -e "for i in {$RANGE_START..$RANGE_END}; do echo \\${i}; done" | bash`

A única "sobrecarga" que isso deve gerar deve ser a segunda instância do bash, portanto deve ser adequada para operações intensivas.

Se você está executando comandos de shell e você (como eu) tem um fetiche por pipelining, este é bom:

seq 1 $END | xargs -I {} echo {}

Existem muitas maneiras de fazer isso, mas as que eu prefiro são apresentadas abaixo

Usando seq

Sinopse de man seq

$ seq [-w] [-f format] [-s string] [-t string] [first [incr]] last

Sintaxe

Comando completo
seq first incr last

• primeiro é o número inicial na sequência [é opcional, por padrão: 1]
• incr é incremento [é opcional, por padrão: 1]
• last é o último número na sequência

Exemplo:

$ seq 1 2 10
1 3 5 7 9

Somente com o primeiro e o último:

$ seq 1 5
1 2 3 4 5

Somente com o último:

$ seq 5
1 2 3 4 5

Usando {first..last..incr}

Aqui, o primeiro e o último são obrigatórios e o incr é opcional

Usando apenas o primeiro e o último

$ echo {1..5}
1 2 3 4 5

Usando incr

$ echo {1..10..2}
1 3 5 7 9

Você pode usar isso mesmo para caracteres como abaixo

$ echo {a..z}
a b c d e f g h i j k l m n o p q r s t u v w x y z

se você não quiser usar o formato de expansão ' seq' ou ' eval' jotou aritmético, por exemplo. for ((i=1;i<=END;i++)), ou outros loops, por exemplo. while, e você não quer ' printf' e gosta de ' echo' apenas, essa solução alternativa simples pode caber no seu orçamento:

a=1; b=5; d='for i in {'$a'..'$b'}; do echo -n "$i"; done;' echo "$d" | bash

PS: Meu bash não tem seqcomando ' ' de qualquer maneira.

Testado no Mac OSX 10.6.8, Bash 3.2.48

Isso funciona em Bash e Korn, também pode ir de números maiores para menores. Provavelmente não é o mais rápido ou o mais bonito, mas funciona bem o suficiente. Lida com negativos também.

function num_range {
   # Return a range of whole numbers from beginning value to ending value.
   # >>> num_range start end
   # start: Whole number to start with.
   # end: Whole number to end with.
   typeset s e v
   s=${1}
   e=${2}
   if (( ${e} >= ${s} )); then
      v=${s}
      while (( ${v} <= ${e} )); do
         echo ${v}
         ((v=v+1))
      done
   elif (( ${e} < ${s} )); then
      v=${s}
      while (( ${v} >= ${e} )); do
         echo ${v}
         ((v=v-1))
      done
   fi
}

function test_num_range {
   num_range 1 3 | egrep "1|2|3" | assert_lc 3
   num_range 1 3 | head -1 | assert_eq 1
   num_range -1 1 | head -1 | assert_eq "-1"
   num_range 3 1 | egrep "1|2|3" | assert_lc 3
   num_range 3 1 | head -1 | assert_eq 3
   num_range 1 -1 | tail -1 | assert_eq "-1"
}