Comment puis-je itérer sur une plage de nombres définis par des variables dans Bash?

la méthode seq est la plus simple, mais Bash a intégré l'évaluation arithmétique.

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

le for ((expr1;expr2;expr3)); construire des travaux tout comme for (expr1;expr2;expr3) en C et langues similaires, et comme d'autres ((expr)) cas, Bash les traite comme arithmétique.

discussion

en utilisant seq est très bien, comme Jiaaro suggéré. Pax Diablo a suggéré une boucle de Bash pour éviter d'appeler un sous-processus, avec l'avantage supplémentaire d'être plus convivial en mémoire si $END est trop grand. Zathrus a repéré un bug typique dans l'implémentation de la boucle, et a aussi laissé entendre que puisque i est une variable texte, les conversions continues vers-et-vers les nombres sont effectuées avec un ralentissement associé.

entier arithmétique

c'est une version améliorée de la boucle de Bash:

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

si la seule chose que nous voulons est le echo , alors nous pourrions écrire echo $((i++)) .

ephemient m'a appris quelque chose: Bash permet for ((expr;expr;expr)) constructions. Puisque je n'ai jamais lu la page de man entière pour Bash( comme j'ai fait avec la page de man Korn shell ( ksh ), et c'était il y a longtemps), j'ai manqué que.

,

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

semble être le moyen le plus efficace de la mémoire (il ne sera pas nécessaire d'allouer la mémoire pour consommer la sortie de seq , qui pourrait être un problème si la fin est très grande), mais probablement pas le"plus rapide".

la question initiale

eschercycle a noté que le { a .. 1519380920 b 1519390920; vrai, en conséquence, pour le Bash manuel. On peut surmonter cet obstacle avec un simple (interne) fork() sans un exec() (comme c'est le cas avec l'appel seq , qui est une autre image nécessite une fourche+exec):

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

les deux eval et echo sont des constructions Bash, mais un fork() est nécessaire pour la substitution de commande (la $(…) construction).

Voici pourquoi l'expression originale n'a pas fonctionné.

à Partir de man bash :

l'expansion de L'attelle est effectuée avant toute autre expansion, et toute caractères spéciaux pour les autres les expansions sont préservées dans les résultat. Il est strictement textuelle. Bash n'applique pas de syntaxique l'interprétation au contexte de l'extension ou le texte entre accolade.

So, brace expansion est quelque chose fait très tôt comme une opération de macro purement textuelle, avant paramètre expansion.

sont des hybrides hautement optimisés entre Macro processeurs et langages de programmation plus formels. Afin d'optimiser les cas d'utilisation typiques, le langage est rendu un peu plus complexe et certaines limites sont acceptées.

recommandation

je suggère de coller avec les caractéristiques de Posix ¹ . Cela signifie qu'il faut utiliser for i in <list>; do , si la liste est déjà connue, sinon, utiliser while ou seq , comme dans:

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

POSIX façon

si vous vous souciez de la portabilité, utilisez l'exemple de la norme POSIX :

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

sortie:

2
3
4
5

les Choses qui sont pas POSIX:

• (( )) sans dollar, bien qu'il s'agisse d'une extension courante comme mentionné par POSIX lui-même .
• [[ . [ suffit ici. Voir aussi: Quelle est la différence entre les crochets simples et doubles dans Bash?
• for ((;;))
• seq (GNU Coreutils)
• {start..end} , et qui ne peut pas fonctionner avec les variables mentionnées par le manuel de Bash .
• let i=i+1 : POSIX 7 2. La commande Shell Language ne contient pas le mot let , et elle échoue sur bash --posix 4.3.42

• le dollar à i=$i+1 pourrait être nécessaire, mais je ne suis pas sûr. POSIX 7 2.6.4 Expansion arithmétique dit:

  si la variable shell x contient une valeur qui forme une constante entière valide, incluant éventuellement un signe plus ou moins, alors l'arithmétique les expansions "$((x))" et "$(($x))" doit retourner la même valeur.

  mais sa lecture littérale ne signifie pas que $((x+1)) s'étend depuis x+1 n'est pas une variable.

une autre couche d'effet indirect:

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

vous pouvez utiliser

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

si vous êtes sur BSD / OS X, vous pouvez utiliser jot au lieu de seq:

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

cela fonctionne très bien dans bash :

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

si vous avez besoin d'un préfixe que vous pourriez aimer ceci

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

qui donnera

07
08
09
10
11
12

je sais que cette question concerne bash , mais - juste pour info - ksh93 est plus intelligent et le met en œuvre comme prévu:

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

C'est une autre façon:

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

ceux-ci sont tous beaux mais seq est supposé déprécié et la plupart ne fonctionnent avec des gammes numériques.

si vous enfermez votre boucle for dans des guillemets doubles, les variables start et end seront déréférencées lorsque vous faites écho à la chaîne, et vous pouvez renvoyer la chaîne directement à BASH pour exécution. $i doit être échappé avec \'S de sorte qu'il n'est pas évalué avant d'être envoyé à la subshell.

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

cette sortie peut aussi être assignée à un variable:

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

La seule "frais généraux" ce qui devrait générer devrait être la deuxième instance de bash de sorte qu'il devrait être adapté pour des opérations intensives.

remplacer {} par (( )) :

tmpstart=0;
tmpend=4;

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

Donne:

0
1
2
3
4

si vous faites des commandes shell et que vous (comme moi) avez un fétiche pour le pipelinage, celui-ci est bon:

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

si vous voulez rester aussi près que possible de la syntaxe de l'expression des attelles, essayez la fonction range de bash-tricks' range.bash .

par exemple, tout ce qui suit fera exactement la même chose que echo {1..10} :

source range.bash
one=1
ten=10

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

il essaie de supporter la syntaxe de bash natif avec aussi peu de "gotchas" que possible: non seulement les variables sont supportées, mais le comportement souvent indésirable des Invalides les gammes fournies sous forme de chaînes (par exemple for i in {1..a}; do echo $i; done ) sont également empêchées.

les autres réponses fonctionneront dans la plupart des cas, mais elles présentent toutes au moins un des inconvénients suivants:

• beaucoup d'entre eux utilisent subshells , qui peut performances de dommage et peut ne pas être possible sur certains systèmes.
• beaucoup d'entre eux dépendent de programmes externes. Même seq est un binaire qui doit être installé pour être utilisé, doit être chargé par bash, et doit contenir le programme que vous attendez, pour que cela fonctionne dans ce cas. Omniprésent ou pas, c'est bien plus que le Bash lui-même.
• les Solutions qui n'utilisent que la fonctionnalité native de Bash, comme @ephemient, ne fonctionneront pas sur les plages alphabétiques, comme {a..z} ; l'expansion de brace le fera. La question portait sur les fourchettes de nombres , mais, si c'est une argutie.
• la plupart d'entre eux ne sont pas visuellement similaires à la syntaxe {1..10} brace-expanded range, de sorte que les programmes qui utilisent les deux peuvent être un tout petit peu plus difficile à lire.
• la réponse de @bobbogo utilise une partie de la syntaxe familière, mais fait quelque chose d'inattendu si la variable $END n'est pas une plage valide "bookend" pour l'autre côté de la plage. Si END=a , par exemple, une erreur ne se produira pas et la valeur mot à mot {1..a} fera écho. C'est aussi le comportement par défaut de Bash, c'est juste souvent inattendu.

clause de non-responsabilité: je suis l'auteur du code lié.

cela fonctionne à Bash et Korn, peut aussi aller de plus en plus bas nombres. Probablement pas le plus rapide ou le plus beau mais fonctionne assez bien. Poignées négatifs.

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