Вы можете использовать

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

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

edit: я предпочитаю seq другим методам, потому что я действительно могу его запомнить;)

Это отлично работает в bash:

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

обсуждение

Как предложил Джиааро, использование seq - это нормально. Pax Diablo предложил цикл Bash, чтобы избежать вызова подпроцесса, с дополнительным преимуществом, заключающимся в том, что он более дружественен к памяти, если $ END слишком велик. Затрус обнаружил типичную ошибку в реализации цикла, а также намекнул, что, поскольку i является текстовой переменной, непрерывные преобразования туда-сюда числа выполняются с соответствующим замедлением.

целочисленная арифметика

Это улучшенная версия цикла Bash:

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

Если единственное, что нам нужно, это echo, мы могли бы написать echo $((i++)).

эфемерный научил меня кое-чему: Bash допускает конструкции for ((expr;expr;expr)). Поскольку я никогда не читал всю справочную страницу для Bash (как я сделал с справочной страницей оболочки Korn (ksh), и это было очень давно), я пропустил это.

Так,

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

кажется наиболее эффективным с точки зрения памяти способом (не нужно выделять память для использования вывода seq, что может быть проблемой, если END очень велик), хотя, вероятно, не самый «быстрый».

начальный вопрос

eschercycle отметил, что нотация {а..б} Bash работает только с литералами; true, согласно руководству Bash. Это препятствие можно преодолеть с помощью одного (внутреннего) fork() без exec() (как в случае с вызовом seq, который является другим образом требует fork + exec):

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

И eval, и echo являются встроенными командами Bash, но для подстановки команд требуется fork() (конструкция $(…)).

Метод seq самый простой, но Bash имеет встроенную арифметическую оценку.

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

Конструкция for ((expr1;expr2;expr3)); работает так же, как for (expr1;expr2;expr3) в C и подобных языках, и, как и другие случаи ((expr)), Bash рассматривает их как арифметические.

Еще один уровень косвенности:

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

Если вы используете BSD / OS X, вы можете использовать jot вместо seq:

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

Вот почему исходное выражение не сработало.

От мужик:

Brace expansion is performed before any other expansions, and any characters special to other expansions are preserved in the result. It is strictly textual. Bash does not apply any syntactic interpretation to the context of the expansion or the text between the braces.

Итак, расширение скобки - это то, что делается на ранней стадии чисто текстовой макрооперации, до расширение параметра.

Оболочки - это высокооптимизированные гибриды макропроцессоров и более формальных языков программирования. Чтобы оптимизировать типичные варианты использования, язык стал более сложным, и были приняты некоторые ограничения.

Recommendation

Я бы посоветовал придерживаться функций Posix¹. Это означает использование for i in <list>; do, если список уже известен, в противном случае используйте while или seq, как в:

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

Все они хороши, но seq предположительно устарел, и большинство из них работают только с числовыми диапазонами.

Если вы заключите цикл for в двойные кавычки, начальная и конечная переменные будут разыменованы при выводе строки, и вы можете отправить строку обратно в BASH для выполнения. $i должен быть экранирован с помощью \, поэтому он НЕ оценивается перед отправкой в ​​подоболочку.

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

Этот вывод также можно присвоить переменной:

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

Единственные "накладные расходы", которые это должно генерировать, должны быть вторым экземпляром bash, поэтому он должен быть подходящим для интенсивных операций.

Я знаю, что этот вопрос касается bash, но - для записи - ksh93 умнее и реализует его, как ожидалось:

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

Замените {} на (( )):

tmpstart=0;
tmpend=4;

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

Урожайность:

0
1
2
3
4

Путь POSIX

Если вы заботитесь о переносимости, используйте пример из стандарта POSIX:

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

Выход:

2
3
4
5

Что такое нет POSIX:

• (( )) без доллара, хотя это обычное расширение как упоминается самим POSIX.
• [[. [ здесь достаточно. См. Также: В чем разница между одинарными и двойными квадратными скобками в Bash?
• for ((;;))
• seq (GNU Coreutils)
• {start..end}, и это не может работать с переменными, как упоминалось по руководству Bash.
• let i=i+1: POSIX 7 2. Язык команд оболочки не содержит слова let и не работает на bash --posix 4.3.42

• доллар по i=$i+1 может потребоваться, но я не уверен. POSIX 7 2.6.4 Расширение арифметики говорит:

  If the shell variable x contains a value that forms a valid integer constant, optionally including a leading plus or minus sign, then the arithmetic expansions "$((x))" and "$(($x))" shall return the same value.

  но если читать буквально, это не означает, что $((x+1)) расширяется, поскольку x+1 не является переменной.

Это еще один способ:

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

Если вы выполняете команды оболочки и у вас (как и у меня) есть фетиш на конвейерную обработку, это хорошо:

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

Если вам нужен префикс, то вам может понравиться этот

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

что даст

07
08
09
10
11
12

Если вы хотите максимально приблизиться к синтаксису выражения фигурных скобок, попробуйте Функция range из range.bash от bash-tricks.

Например, все следующие действия будут делать то же самое, что и echo {1..10}:

source range.bash
one=1
ten=10

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

Он пытается поддерживать собственный синтаксис bash с минимальным количеством ошибок: не только поддерживаются переменные, но также предотвращается часто нежелательное поведение недопустимых диапазонов, передаваемых в виде строк (например, for i in {1..a}; do echo $i; done).

Другие ответы будут работать в большинстве случаев, но все они имеют как минимум один из следующих недостатков:

• Многие из них используют подоболочки, который может использовать нанести вред производительности и может быть невозможно в некоторых системах.
• Многие из них полагаются на внешние программы. Даже seq - это двоичный файл, который должен быть установлен для использования, должен быть загружен с помощью bash и должен содержать ожидаемую программу, чтобы он работал в этом случае. Вездесущий или нет, это гораздо больше, чем просто сам язык Bash.
• Решения, которые используют только встроенные функции Bash, такие как @ ephemient, не будут работать с алфавитными диапазонами, такими как {a..z}; скобка расширение будет. Однако вопрос касался диапазонов числа, так что это придирка.
• Большинство из них визуально не похожи на синтаксис диапазона {1..10} с расширенными скобками, поэтому программы, которые используют оба, могут быть немного сложнее для чтения.
• Ответ @bobbogo использует знакомый синтаксис, но делает что-то неожиданное, если переменная $END не является допустимым диапазоном "bookend" для другой стороны диапазона. Если, например, END=a, ошибки не произойдет, и будет отображено дословное значение {1..a}. Это поведение по умолчанию и для Bash - просто часто бывает неожиданным.

Отказ от ответственности: я являюсь автором связанного кода.

Это работает в Bash и Korn, также может идти от большего к меньшему числу. Наверное, не самый быстрый и не самый красивый, но работает достаточно хорошо. Также обрабатывает негативы.

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

Я объединил здесь несколько идей и измерил производительность.

TL; DR Выводы:

1. seq и {..} действительно быстрые
2. Шлейфы for и while медленные
3. $( ) медленный
4. Петли for (( ; ; )) медленнее
5. $(( )) еще медленнее
6. Беспокоиться о числах N в памяти (seq или {..}) глупо (по крайней мере, до 1 миллиона).

Это не выводы. Чтобы сделать выводы, вам нужно будет взглянуть на код C, стоящий за каждым из них. Это больше о том, как мы склонны использовать каждый из этих механизмов для перебора кода. Большинство отдельных операций достаточно близки к одной и той же скорости, что в большинстве случаев не имеет значения. Но такой механизм, как for (( i=1; i<=1000000; i++ )), - это много операций, как вы можете визуально увидеть. Кроме того, операций за петлю намного больше, чем у for i in $(seq 1 1000000). И это может быть неочевидно для вас, поэтому проведение подобных тестов имеет большое значение.

Демо

# 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

Есть много способов сделать это, но те, которые я предпочитаю, приведены ниже.

Использование seq

Synopsis from man seq

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

Syntax

Полная команда
seq first incr last

• первый - это начальный номер в последовательности [необязательно, по умолчанию: 1]
• incr - приращение [необязательно, по умолчанию: 1]
• last - это последнее число в последовательности

Пример:

$ seq 1 2 10
1 3 5 7 9

Только с первым и последним:

$ seq 1 5
1 2 3 4 5

Только с последним:

$ seq 5
1 2 3 4 5

Использование {first..last..incr}

Здесь first и last являются обязательными, а incr - необязательными

Использование только первого и последнего

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

Использование incr

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

Вы можете использовать это даже для таких персонажей, как показано ниже

$ 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

если вы не хотите использовать «seq», «eval» или «jot» или формат арифметического расширения, например. for ((i=1;i<=END;i++)) или другие петли, например. while, и вы не хотите использовать printf и довольны только echo, тогда этот простой обходной путь может соответствовать вашему бюджету:

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

PS: В моем bash все равно нет команды seq.

Проверено на Mac OSX 10.6.8, Bash 3.2.48