¿Cómo itero sobre un rango de números en Bash cuando el rango viene dado por una variable?

Sé que puedo hacer esto (llamado "expresión de secuencia" en la documentación de Bash ):

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

Lo que da:

1
2
3
4
5

Sin embargo, ¿cómo puedo reemplazar cualquiera de los puntos finales del rango con una variable? Esto no 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

editar: prefiero seqlos otros métodos porque realmente puedo recordarlo;)

El seqmétodo es el más simple, pero Bash tiene una evaluación aritmética incorporada.

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

La for ((expr1;expr2;expr3));construcción funciona igual que for (expr1;expr2;expr3)en C y lenguajes similares, y como en otros ((expr))casos, Bash los trata como aritméticos.

discusión

Usar seqestá bien, como sugirió Jiaaro. Pax Diablo sugirió un bucle Bash para evitar llamar a un subproceso, con la ventaja adicional de ser más amigable con la memoria si $ END es demasiado grande. Zathrus detectó un error típico en la implementación del bucle y también insinuó que, dado que ies una variable de texto, las conversiones continuas de un lado a otro se realizan con una desaceleración asociada.

aritmética de enteros

Esta es una versión mejorada del bucle Bash:

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

Si lo único que queremos es el echo, entonces podríamos escribir echo $((i++)).

Ephemient me enseñó algo: Bash permite for ((expr;expr;expr))construcciones. Como nunca leí toda la página de manual de Bash (como lo hice con la kshpágina de manual de Korn shell ( ), y eso fue hace mucho tiempo), me lo perdí.

Entonces,

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

parece ser la forma más eficiente de memoria (no será necesario asignar memoria para consumir seqla salida, lo que podría ser un problema si END es muy grande), aunque probablemente no sea el "más rápido".

la pregunta inicial

eschercycle señaló que la notación Bash { a .. b } funciona solo con literales; cierto, de acuerdo con el manual de Bash. Uno puede superar este obstáculo con un solo (interno) fork()sin un exec()(como es el caso con la llamada seq, que ser otra imagen requiere un tenedor + ejecutivo):

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

Ambos evaly echoson Bash incorporados, pero fork()se requiere a para la sustitución del comando (la $(…)construcción).

Aquí es por qué la expresión original no funcionó.

De man bash :

La expansión de llaves se realiza antes que cualquier otra expansión, y cualquier personaje especial para otras expansiones se conserva en el resultado. Es estrictamente textual. Bash no aplica ninguna interpretación sintáctica al contexto de la expansión o al texto entre llaves.

Entonces, la expansión de llaves es algo que se hace temprano como una operación macro puramente textual, antes de la expansión de parámetros.

Los shells son híbridos altamente optimizados entre macroprocesadores y lenguajes de programación más formales. Para optimizar los casos de uso típicos, el lenguaje se hace bastante más complejo y se aceptan algunas limitaciones.

Recomendación

Sugeriría seguir con las características de Posix ¹ . Esto significa usar for i in <list>; do, si la lista ya se conoce, de lo contrario, usar whileo seq, como en:

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

La manera POSIX

Si le importa la portabilidad, use el ejemplo del estándar POSIX :

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

Salida:

2
3
4
5

Cosas que no son POSIX:

• (( ))sin dólar, aunque es una extensión común como lo menciona POSIX .
• [[. [es suficiente aquí Ver también: ¿Cuál es la diferencia entre corchetes simples y dobles en Bash?
• for ((;;))
• seq (GNU Coreutils)
• {start..end}, y eso no puede funcionar con variables como se menciona en el manual de Bash .
• let i=i+1: POSIX 7 2. El lenguaje de comandos de Shell no contiene la palabra lety falla en bash --posix4.3.42

• el dólar i=$i+1podría ser requerido, pero no estoy seguro. POSIX 7 2.6.4 La expansión aritmética dice:

  Si la variable de shell x contiene un valor que forma una constante entera válida, que incluye opcionalmente un signo más o menos inicial, entonces las expansiones aritméticas "$ ((x))" y "$ (($ x))" devolverán lo mismo valor.

  pero leerlo literalmente no implica que se $((x+1))expanda ya x+1que no es una variable.

Otra capa de indirección:

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

Puedes usar

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

Si necesita un prefijo, entonces le gustaría esto

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

eso rendirá

07
08
09
10
11
12

Si estás en BSD / OS X puedes usar jot en lugar de seq:

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

Esto funciona bien en bash:

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

He combinado algunas de las ideas aquí y he medido el rendimiento.

TL; DR Para llevar:

1. seqy {..}son realmente rápidos
2. fory los whilebucles son lentos
3. $( ) es lento
4. for (( ; ; )) los bucles son más lentos
5. $(( )) es aún más lento
6. Preocuparse por los N números en la memoria (seq o {..}) es una tontería (al menos hasta 1 millón).

Estas no son conclusiones . Tendría que mirar el código C detrás de cada uno de estos para sacar conclusiones. Esto es más acerca de cómo tendemos a usar cada uno de estos mecanismos para recorrer el código. La mayoría de las operaciones individuales están lo suficientemente cerca de ser la misma velocidad que no va a importar en la mayoría de los casos. Pero un mecanismo como for (( i=1; i<=1000000; i++ ))es muchas operaciones como puede ver visualmente. También es muchas más operaciones por ciclo de las que obtiene for i in $(seq 1 1000000). Y eso puede no ser obvio para usted, por lo que hacer pruebas como esta es valioso.

Población

# 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

Sé que esta pregunta se trata bash, pero, solo para el registro, ksh93es más inteligente y la implementa como se esperaba:

$ 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 es otra forma:

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

Si desea permanecer lo más cerca posible de la sintaxis de la expresión de llaves, pruebe la rangefunción de bash-tricks 'range.bash .

Por ejemplo, todo lo siguiente hará exactamente lo mismo que echo {1..10}:

source range.bash
one=1
ten=10

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

Intenta admitir la sintaxis nativa de bash con la menor cantidad posible de "problemas": no solo se admiten variables, sino for i in {1..a}; do echo $i; doneque también se evita el comportamiento a menudo indeseable de rangos no válidos que se suministran como cadenas (por ejemplo ).

Las otras respuestas funcionarán en la mayoría de los casos, pero todas tienen al menos uno de los siguientes inconvenientes:

• Muchos de ellos usan subcapas , lo que puede dañar el rendimiento y puede no ser posible en algunos sistemas.
• Muchos de ellos dependen de programas externos. Even seqes un binario que debe instalarse para usarse, debe cargarse mediante bash y debe contener el programa que espera para que funcione en este caso. Ubicuo o no, es mucho más en lo que confiar que solo el lenguaje Bash en sí.
• Las soluciones que solo utilizan la funcionalidad nativa de Bash, como @ ephemient, no funcionarán en rangos alfabéticos, como {a..z}; la expansión de la abrazadera lo hará. Sin embargo, la pregunta era sobre rangos de números , por lo que esta es una objeción.
• La mayoría de ellos no son visualmente similares a la {1..10}sintaxis de rango expandido, por lo que los programas que usan ambos pueden ser un poco más difíciles de leer.
• La respuesta de @ bobbogo usa parte de la sintaxis familiar, pero hace algo inesperado si la $ENDvariable no es un "bookend" de rango válido para el otro lado del rango. Si END=a, por ejemplo, no se produce un error y {1..a}se repite el valor literal . Este es también el comportamiento predeterminado de Bash: a menudo es inesperado.

Descargo de responsabilidad: soy el autor del código vinculado.

Reemplazar {}con (( )):

tmpstart=0;
tmpend=4;

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

Rendimientos:

0
1
2
3
4

Todos estos son agradables, pero supuestamente seq está en desuso y la mayoría solo funciona con rangos numéricos.

Si encierra su bucle for entre comillas dobles, las variables de inicio y final se desreferenciarán cuando haga eco de la cadena, y puede enviar la cadena de regreso a BASH para su ejecución. $idebe escaparse con \ 's para que NO se evalúe antes de enviarse a la subshell.

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

Esta salida también se puede asignar a una variable:

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

La única "sobrecarga" que esto debería generar debería ser la segunda instancia de bash, por lo que debería ser adecuada para operaciones intensivas.

Si está haciendo comandos de shell y usted (como yo) tiene un fetiche por canalizar, este es bueno:

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

Hay muchas formas de hacer esto, sin embargo, las que prefiero se dan a continuación

Utilizando seq

Sinopsis de man seq

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

Sintaxis

Comando completo
seq first incr last

• primero es el número inicial en la secuencia [es opcional, por defecto: 1]
• incr es incremento [es opcional, por defecto: 1]
• último es el último número de la secuencia

Ejemplo:

$ seq 1 2 10
1 3 5 7 9

Solo con primero y último:

$ seq 1 5
1 2 3 4 5

Solo con el último:

$ seq 5
1 2 3 4 5

Utilizando {first..last..incr}

Aquí primero y último son obligatorios e incr es opcional

Usando solo el primero y el último

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

Usando incr

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

Puedes usar esto incluso para los personajes como a continuación

$ 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

si no quiere usar ' seq' o ' eval' o el jotformato de expansión aritmética, por ejemplo. for ((i=1;i<=END;i++)), u otros bucles, por ejemplo. while, y no quiere ' printf' y está contento ' echo' solo, entonces esta solución simple podría ajustarse a su presupuesto:

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

PD: Mi bash no tiene seqel comando ' ' de todos modos.

Probado en Mac OSX 10.6.8, Bash 3.2.48

Esto funciona en Bash y Korn, también puede ir de mayor a menor número. Probablemente no sea el más rápido o el más bonito, pero funciona lo suficientemente bien. Maneja negativos también.

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