Brace expansion with variable?

Question

#!/bin/sh
for i in {1..5}
do
   echo "Welcome"
done

Would work, displays Welcome 5 times.

#!/bin/sh
howmany=`grep -c $1 /root/file`
for i in {1..$howmany}
do
   echo "Welcome"
done

Doesn't work! howmany would equal 5 as that is what the output of grep -c would display. $1 is parameter 1 which is specific when running the script.

Any ideas?

Answer 1

Workarounds for not being able to use variables in a sequence brace expression:

• If the intent is merely to iterate over numbers in a range - as in the OP's case - the best choice is not to use brace expansion, but instead use bash's C-style loop - see user000001's answer.

  • If the specific numbers aren't important and you simply need to execute a loop body a specified number of times, Cole Tierney's answer is an option.

• If use of brace expansion is desired nonetheless:

  • If you do NOT need the numbers in the list to have a prefix or postfix, use the seq utility with an unquoted command substitution (small caveat: seq is NOT a POSIX utility, but it is widely available); e.g.

    • echo $(seq 3) -> 1 2 3; start number 1 implied
      • echo $(seq -f '%02.f' 3) -> 01 02 03 - zero-padded
    • echo $(seq 2 4) -> 2 3 4; explicit start and end numbers
    • echo $(seq 1 2 5) -> 1 3 5; custom increment (the 2 in the middle)

  • If you DO need the numbers in the list to have a prefix or postfix, you have several choices:

    • Use the seq utility with its -f option for providing a printf-style format string (as used above for zero-padding), or pure Bash workarounds based on eval (extra care needed!) or building an array in a loop, all of which are detailed in this answer.
    • You could also consider implementing the functionality generically, such as by writing a custom shell function or a custom script with utilities such as awk or perl.

Example of safe use of eval with variables driving a sequence brace expression:

The variables are validated beforehand, to make sure they contain decimal integers.

from=1 to=3  # sample values

# Ensure that $from and $to are decimal numbers and abort, if they are not.
(( 10#$from + 10#$to || 1 )) 2>/dev/null || { echo "Need decimal integers" >&2; exit 1; }

eval echo "A{$from..$to}"  # -> 'A1 A2 A3'

General overview of brace expansion

The main purpose of brace expansion is to expand to a list of tokens with each token having an optional prefix and/or postfix; brace expansions must be unquoted and come in 2 flavors:

• a fixed series (list) of comma-separated strings - variables supported
  • specifies and expands to a fixed number of tokens (2 or more); e.g.:
  • echo A{b,c,d} -> Ab Ac Ad, i.e., 3 tokens, as implied by the number of args.
  • echo {/,$HOME/}Library e.g., -> /Library /User/jdoe/Library
  • Variable references - and even globs - are supported, but note that they get expanded after brace expansion, in its result, in the course of normal evaluation.

• a sequence expression (range) with .., typically numerical - variables NOT supported

  • expands to a variable number of tokens, driven by literal start and end points (for historical reasons, use of variables is NOT supported - see the comments on user000001's answer):
    • [rare] strings: only single English letters allowed; e.g. {a..c}
    • numbers: decimal integers only; e.g., {1..10}, {10..1}, {-1..2}
      • example with prefix and postfix: A{1..3}# -> A1# A2# A3#
      • broken example with variables: {$from..$to} # !! FAILS - $from and $to are interpreted as literals and therefore not recognized as either a single letter or a decimal integer - no brace expansion is performed (see below).
        • by contrast, using variables does work in zsh and ksh.
    • bash 4+ adds two features:
      • optional increment step value:
        • echo A{1..5..2} -> A1 A3 A5 - numbers incremented by 2
      • ability to zero-pad:
        • echo A{001..003} -> A001 A002 A003

• An invalid brace expression is not expanded (treated like a regular unquoted string, with { and } treated as literals):

  • echo {} -> '{}' - invalid as a brace expr.: at least 2 ,-separated tokens needed
    • ^{This allows the use of unquoted {} with find, for instance.}
  • echo {1..$to} -> '{1..<value-of-$to>}' - invalid as a brace expr. in bash: variables not supported; however, valid in ksh and zsh.
  • (fish, by contrast, expands any {...} sequence; similarly, zsh has option BRACE_CCL (OFF by default) for expanding individual characters inside {..}, which effectively causes expansion of any nonempty {...} sequence.)

Answer 2

The brace expansion is evaluated before the variables are expanded. You need a c-style for loop instead:

for ((i=1;i<=howmany;i++))
do
   echo "Welcome"
done

Answer 3

create a sequence to control your loop

for i in $(seq 1 $howmany); do
echo "Welcome";
done

Answer 4

The problem is that the "brace expansion" is performed before the "variable expansion"

for i in $(seq 1 $howmany) 

works as @damienfrancois said, or, if you would like:

for i in $(eval echo "{$start..10}") 

probably does, but don't use it for everyone's sanity.

Answer 5

You could also use a while loop:

while ((howmany--)); do
   echo "Welcome"
done

Answer 6

With ksh, can be run in a subshell in bash:

#!/bin/bash

x=0-9

read -ra digits < <(
    ksh -c '
        range={$1}
        echo ${range/-/..}
    ' ksh $x
)
echo "${digits[@]}"

Will work with any brace expansion too.

With a filtered eval (use at your own risks, the first solution is preferred if ksh can be installed, and the filter have to be modified for other expansion than digits)

#!/bin/bash

x=1-3
case $x in
    '' | *[!0123456789-]*)
        printf '%s\n' "$0: $x: invalid entry" >&2; exit 1;;
esac
exp={$x}
eval "echo ${exp/-/..}"

If you try to make some code injection, like

x='$(reboot)'

you will have

script.sh: $(reboot): invalid entry

Output

0 1 2 3 4 5 6 7 8 9

Answer 7

We could also use eval in this case:

howmany=`grep -c $1 /root/file`
for i in $(eval echo {1..$howmany}); do
    echo "Welcome"
done