Come posso iterare su un intervallo di numeri in Bash quando l'intervallo è dato da una variabile?

So di poterlo fare (chiamato "espressione di sequenza" nella documentazione di Bash ):

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

Che dà:

1
2
3
4
5

Tuttavia, come posso sostituire uno dei due endpoint con una variabile? Questo non funziona:

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

Che stampa:

{1..5}

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

modifica: preferisco seqrispetto agli altri metodi perché posso davvero ricordarlo;)

Il seqmetodo è il più semplice, ma Bash ha una valutazione aritmetica integrata.

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

Il for ((expr1;expr2;expr3));costrutto funziona proprio come for (expr1;expr2;expr3)in C e in linguaggi simili e, come in altri ((expr))casi, Bash li considera aritmetici.

discussione

L'uso seqva bene, come ha suggerito Jiaaro. Pax Diablo ha suggerito un loop Bash per evitare di chiamare un sottoprocesso, con l'ulteriore vantaggio di essere più amico della memoria se $ END è troppo grande. Zathrus ha individuato un tipico bug nell'implementazione del ciclo e ha anche suggerito che, poiché si itratta di una variabile di testo, le conversioni continue avanti e indietro vengono eseguite con un rallentamento associato.

aritmetica intera

Questa è una versione migliorata del loop Bash:

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

Se l'unica cosa che vogliamo è la echo, allora potremmo scrivereecho $((i++)) .

effimero mi ha insegnato qualcosa: Bash permette for ((expr;expr;expr))costrutti. Da quando non ho mai letto l'intera pagina man di Bash (come ho fatto con la shell Korn (ksh pagina man della ), e molto tempo fa), mi mancava.

Così,

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

sembra essere il modo più efficiente in termini di memoria (non sarà necessario allocare memoria per consumare seq l'output, il che potrebbe essere un problema se END è molto grande), anche se probabilmente non è il "più veloce".

la domanda iniziale

eschercycle ha notato che la notazione { a .. b } Bash funziona solo con valori letterali; vero, secondo il manuale di Bash. Si può superare questo ostacolo con un singolo (interno) fork()senza un exec()(come nel caso della chiamata seq, che essendo un'altra immagine richiede un fork + exec):

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

Entrambi evale echosono built-in di Bash, ma fork()è necessario per la sostituzione del comando (il $(…)costrutto).

Ecco perché l'espressione originale non ha funzionato.

Da man bash :

L'espansione del controvento viene eseguita prima di qualsiasi altra espansione e nel risultato vengono preservati tutti i caratteri speciali di altre espansioni. È rigorosamente testuale. Bash non applica alcuna interpretazione sintattica al contesto dell'espansione o al testo tra parentesi graffe.

Quindi, l' espansione del controvento è qualcosa fatto all'inizio come un'operazione macro puramente testuale, prima dell'espansione dei parametri.

Le shell sono ibridi altamente ottimizzati tra processori macro e linguaggi di programmazione più formali. Al fine di ottimizzare i casi d'uso tipici, la lingua è resa piuttosto complessa e vengono accettate alcune limitazioni.

Raccomandazione

Vorrei suggerire di attenersi alle funzionalità di Posix ¹ . Ciò significa utilizzare for i in <list>; do, se l'elenco è già noto, altrimenti, utilizzare whileo seq, come in:

#!/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

Il modo POSIX

Se ti interessa la portabilità, usa l' esempio dello standard POSIX :

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

Produzione:

2
3
4
5

Cose che non sono POSIX:

• (( ))senza dollaro, sebbene si tratti di un'estensione comune, come indicato dallo stesso POSIX .
• [[. [è abbastanza qui. Vedi anche: Qual è la differenza tra parentesi quadre singole e doppie in Bash?
• for ((;;))
• seq (GNU Coreutils)
• {start..end}e che non può funzionare con le variabili come indicato nel manuale di Bash .
• let i=i+1: POSIX 7 2. Shell Command Language non contiene la parola lete ha esito negativo su bash --posix4.3.42

• il dollaro a i=$i+1potrebbe essere richiesto, ma non sono sicuro. POSIX 7 2.6.4 Arithmetic Expansion dice:

  Se la variabile di shell x contiene un valore che forma una costante intera valida, opzionalmente includendo un segno più o meno iniziale, le espansioni aritmetiche "$ ((x))" e "$ (($ x))" restituiranno lo stesso valore.

  ma leggerlo letteralmente ciò non implica che si $((x+1))espanda poiché x+1non è una variabile.

Un altro livello di riferimento indiretto:

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

Puoi usare

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

Se ti serve il prefisso di quanto potresti apprezzare

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

che produrrà

07
08
09
10
11
12

Se sei su BSD / OS X puoi usare jot invece di seq:

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

Funziona bene in bash:

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

Ho combinato alcune idee qui e misurato le prestazioni.

TL; DR Takeaways:

1. seqe {..}sono davvero veloci
2. fore i whileloop sono lenti
3. $( ) è lento
4. for (( ; ; )) i loop sono più lenti
5. $(( )) è ancora più lento
6. Preoccuparsi per i numeri N in memoria (seq o {..}) è sciocco (almeno fino a 1 milione.)

Queste non sono conclusioni . Dovresti guardare il codice C dietro ognuno di questi per trarre delle conclusioni. Si tratta più di come tendiamo a utilizzare ciascuno di questi meccanismi per eseguire il looping del codice. La maggior parte delle singole operazioni sono abbastanza vicine da avere la stessa velocità che nella maggior parte dei casi non avrà importanza. Ma un meccanismo come for (( i=1; i<=1000000; i++ ))è molte operazioni come puoi vedere visivamente. Sono anche molte più operazioni per ciclo di quante ne riceviatefor i in $(seq 1 1000000) . E questo potrebbe non essere ovvio per te, motivo per cui fare test come questo è prezioso.

Demos

# 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

So che questa domanda riguarda bash, ma - solo per la cronaca - ksh93è più intelligente e la implementa come previsto:

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

Questo è un altro modo:

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

Se vuoi rimanere il più vicino possibile alla sintassi dell'espressione di parentesi graffa, prova la rangefunzione da bash-tricks 'range.bash .

Ad esempio, tutto quanto segue farà esattamente la stessa cosa di echo {1..10}:

source range.bash
one=1
ten=10

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

Cerca di supportare la sintassi bash nativa con il minor numero possibile di "gotcha": non solo sono supportate le variabili, ma il comportamento spesso indesiderabile di intervalli non validi viene fornito come stringhe (ad es. for i in {1..a}; do echo $i; done viene impedito anche il ).

Le altre risposte funzioneranno nella maggior parte dei casi, ma tutte presentano almeno uno dei seguenti inconvenienti:

• Molti di loro usano le conchiglie , che possono danneggiare le prestazioni e potrebbero non essere possibili su alcuni sistemi.
• Molti di loro si affidano a programmi esterni. Ancheseq è un binario che deve essere installato per essere utilizzato, deve essere caricato da bash e deve contenere il programma che ci si aspetta, affinché funzioni in questo caso. Ubiquo o no, è molto di più su cui contare oltre al linguaggio Bash stesso.
• Le soluzioni che utilizzano solo funzionalità native di Bash, come quelle di @ephemient, non funzioneranno su intervalli alfabetici, come {a..z}; l'espansione del rinforzo sarà. La domanda riguardava gli intervalli di numeri , quindi, questo è un cavillo.
• La maggior parte di essi non è visivamente simile alla {1..10}sintassi dell'intervallo ampliato con parentesi graffe, quindi i programmi che usano entrambi possono essere un po 'più difficili da leggere.
• La risposta di @ bobbogo utilizza parte della sintassi familiare, ma fa qualcosa di inaspettato se la $ENDvariabile non è un intervallo "bookend" valido per l'altro lato dell'intervallo. Se END=a, ad esempio, non si verificherà un errore e {1..a}verrà ripetuto il valore alla lettera . Questo è anche il comportamento predefinito di Bash: è spesso inaspettato.

Disclaimer: sono l'autore del codice collegato.

Sostituisci {}con (( )):

tmpstart=0;
tmpend=4;

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

I rendimenti:

0
1
2
3
4

Questi sono tutti belli ma seq è presumibilmente deprecato e la maggior parte funziona solo con intervalli numerici.

Se racchiudi il tuo ciclo for tra virgolette doppie, le variabili di inizio e fine verranno dereferenziate quando fai eco alla stringa e puoi spedire la stringa a BASH per l'esecuzione. $ideve essere sottoposto a escape con \ 's, quindi NON viene valutato prima di essere inviato alla subshell.

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

Questo output può anche essere assegnato a una variabile:

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

L'unico "overhead" che questo dovrebbe generare dovrebbe essere la seconda istanza di bash, quindi dovrebbe essere adatto per operazioni intensive.

Se stai eseguendo comandi shell e tu (come me) hai un feticcio per il pipelining, questo è buono:

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

Ci sono molti modi per farlo, tuttavia quelli che preferisco sono indicati di seguito

utilizzando seq

Sinossi di man seq

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

Sintassi

Comando completo
seq first incr last

• il primo è il numero iniziale nella sequenza [è facoltativo, per impostazione predefinita: 1]
• incr is increment [è facoltativo, per impostazione predefinita: 1]
• last è l'ultimo numero nella sequenza

Esempio:

$ seq 1 2 10
1 3 5 7 9

Solo con il primo e l'ultimo:

$ seq 1 5
1 2 3 4 5

Solo con l'ultimo:

$ seq 5
1 2 3 4 5

utilizzando {first..last..incr}

Qui primo e ultimo sono obbligatori e incr è facoltativo

Usando solo il primo e l'ultimo

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

Utilizzando incr

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

Puoi usarlo anche per personaggi come di seguito

$ 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 non si desidera utilizzare ' seq' o ' eval' o il jotformato di espansione aritmetica, ad es. for ((i=1;i<=END;i++))o altri loop, ad es. whilee non vuoi solo " printf" e felice di " echo", quindi questa semplice soluzione potrebbe adattarsi al tuo budget:

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

PS: Il mio bash non ha seqcomunque il comando ' '.

Testato su Mac OSX 10.6.8, Bash 3.2.48

Questo funziona in Bash e Korn, inoltre può andare da numeri più alti a più bassi. Probabilmente non è il più veloce o più bello ma funziona abbastanza bene. Gestisce anche i negativi.

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