Aralık bir değişken tarafından verildiğinde Bash'deki bir sayı aralığını nasıl yineleyebilirim?

Bunu yapabilirim (Bash belgelerinde "dizi ifadesi" denir ):

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

Hangi verir:

1
2
3
4
5

Yine de, aralık uç noktalarından herhangi birini bir değişkenle nasıl değiştirebilirim? Bu işe yaramaz:

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

Hangi baskılar:

{1..5}

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

edit: seqAslında hatırlayabiliyorum çünkü diğer yöntemleri tercih ederim ;)

seqYöntem en basit olmakla birlikte, Bash yerleşik aritmetik değerlendirme.

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));Yapı gibi çalışır for (expr1;expr2;expr3)araçlar ve benzeri dillerde ve diğer benzeri ((expr))durumlarda, Bash aritmetik olarak davranır.

tartışma

Kullanılması seqJiaaro önerildiği gibi, gayet iyi. Pax Diablo, $ END çok büyükse daha fazla bellek dostu olmanın ek avantajı ile bir alt işlem çağırmamak için bir Bash döngüsü önerdi. Zathrus, döngü uygulamasında tipik bir hatayı fark etti ve ayrıca ibir metin değişkeni olduğu için, sürekli-ileri-geri sayı dönüşümlerinin ilişkili bir yavaşlama ile gerçekleştirildiğini ima etti .

tam sayı aritmetiği

Bu, Bash döngüsünün geliştirilmiş bir sürümüdür:

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

İstediğimiz tek şey ise echo, o zaman yazabiliriz echo $((i++)).

ephemient bana bir şey öğretti: Bash for ((expr;expr;expr))yapılara izin veriyor . Bash için tüm adam sayfasını hiç okumadığımdan beri (Korn shell ( ksh) adam sayfasıyla yaptığım gibi ve bu uzun zaman önceydi), bunu özledim.

Yani,

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

en verimli bellek yolu gibi görünüyor (tüketmek için bellek ayırmaya gerek yok seqmuhtemelen "en hızlı" çok büyükse sorun olabilir), çıkışını .

ilk soru

eschercycle { a .. b } Bash gösteriminin sadece değişmez değerlerle çalıştığını belirtti; Bash kılavuzuna göre doğrudur. Bir tek (dahili) ile bu engeli aşabiliriz fork()bir olmadan exec()(çağırarak örneğinde olduğu gibi seqbaşka bir görüntü olan bir çatal + exec gerektiren,):

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

Her ikisi de evalve echoBash yerleşikleridir, ancak fork()komut ikamesi ( $(…)yapı) için a gereklidir .

Orijinal ifadenin çalışmadığı neden budur.

Gönderen adam bash :

Köşeli ayraç genişletmesi diğer genişletmelerden önce gerçekleştirilir ve sonuçta diğer genişletmelere özel karakterler korunur. Kesinlikle metinseldir. Bash, genişleme bağlamına veya parantezler arasındaki metne sözdizimsel bir yorum uygulamaz.

Bu nedenle, küme ayracı genişletmesi , parametre genişletmeden önce tamamen metinsel bir makro işlemi olarak yapılan bir şeydir .

Kabuklar, makro işlemciler ve daha resmi programlama dilleri arasında oldukça optimize edilmiş hibritlerdir. Tipik kullanım durumlarını optimize etmek için dil oldukça daha karmaşık hale getirilir ve bazı sınırlamalar kabul edilir.

Öneri

Posix ¹ özelliklerine bağlı kalmanızı öneririm . Bu for i in <list>; do, eğer liste zaten biliniyorsa, aksi halde, whileveya kullanmak için kullanılır 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

POSIX yolu

Taşınabilirliği önemsiyorsanız , POSIX standardındaki örneği kullanın :

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

Çıktı:

2
3
4
5

POSIX olmayan şeyler :

• (( ))POSIX'in belirttiği gibi yaygın bir uzantı olmasına rağmen, dolar olmadan .
• [[. [burada yeter. Ayrıca bakınız: Bash'te tek ve çift köşeli parantezler arasındaki fark nedir?
• for ((;;))
• seq (GNU Coreutils)
• {start..end}ve Bash kılavuzunda belirtildiği gibi değişkenlerle çalışamaz .
• let i=i+1: POSIX 7 2. Kabuk Komut Dili sözcüğü içermiyor letve bash --posix4.3.42'de başarısız oluyor

• adresindeki dolar i=$i+1gerekli olabilir, ancak emin değilim. POSIX 7 2.6.4 Aritmetik Genişleme şöyle diyor:

  Kabuk değişkeni x, isteğe bağlı olarak önde gelen artı veya eksi işareti içeren geçerli bir tamsayı sabiti oluşturan bir değer içeriyorsa, "$ ((x))" ve "$ (($ x))" aritmetik genişletmeleri aynı döndürür değer.

  ancak kelimenin tam anlamıyla okumak , bir değişken olmadığı için $((x+1))genişlediği anlamına gelmez x+1.

Başka bir dolaylama katmanı:

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

Kullanabilirsiniz

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

Bunun gibi olabileceğinden daha fazla önek gerekiyorsa

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

bu getirecek

07
08
09
10
11
12

BSD / OS X kullanıyorsanız seq yerine jot kullanabilirsiniz:

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

Bu iyi çalışıyor bash:

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

Burada birkaç fikri birleştirdim ve performansı ölçtüm.

TL; DR Paket İçeriği:

1. seqve {..}gerçekten hızlı
2. forve whiledöngüler yavaş
3. $( ) yavaş
4. for (( ; ; )) döngüler daha yavaş
5. $(( )) daha yavaş
6. Endişesi N saçma ({..} seq veya) hafızasına sayı olduğu (1 milyon, en azından kadar).

Bunlar bir sonuç değildir . Sonuç çıkarmak için bunların her birinin arkasındaki C koduna bakmanız gerekir. Bu daha çok, bu mekanizmaların her birini kod üzerinde döngü için nasıl kullandığımızla ilgilidir. Çoğu tek işlem, çoğu durumda önemli olmayacak kadar hızlı olacak kadar yakındır. Ama benzer bir mekanizma for (( i=1; i<=1000000; i++ ))görsel olarak görebileceğiniz gibi birçok işlemdir. Ayrıca döngü başına aldığınızdan çok daha fazla işlemdir for i in $(seq 1 1000000). Ve bu sizin için açık olmayabilir, bu yüzden böyle testler yapmak değerlidir.

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

Bu sorunun hakkında olduğunu biliyorum bash, ama - sadece kayıt için - ksh93daha akıllı ve beklendiği gibi uygular:

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

Bu başka bir yol:

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

Brace-ifade sözdizimine mümkün olduğunca yakın kalmak istiyorsanız, rangeişlevi bash-tricks 'denrange.bash deneyin .

Örneğin, aşağıdakilerin tümü tam olarak aynı şeyi yapar echo {1..10}:

source range.bash
one=1
ten=10

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

Yerel bash sözdizimini olabildiğince az "gotchas" ile desteklemeye çalışır: yalnızca değişkenler desteklenmez, aynı zamanda geçersiz aralıkların dizeler (örneğin for i in {1..a}; do echo $i; done) olarak sağlanması gibi istenmeyen davranışları da önlenir.

Diğer cevaplar çoğu durumda işe yarar, ancak hepsinin aşağıdaki dezavantajlarından en az biri vardır:

• Birçoğu kullanmak altkabuklarda olabilir, performansına zarar ve mümkün olmayabilir bazı sistemlerde.
• Birçoğu harici programlara güveniyor. seqKullanılması için yüklenmesi gereken, bash tarafından yüklenmesi gereken ve bu durumda çalışması için beklediğiniz programı içermesi gereken bir ikili dosya bile . Her yerde ya da her yerde, sadece Bash dilinin kendisinden daha fazla güvenmek gerekiyor.
• @ Ephemient'inki gibi yalnızca yerel Bash işlevlerini kullanan çözümler, örneğin alfabetik aralıklarda çalışmaz {a..z}; küme ayracı genişletme. Soru, sayı aralıklarıyla ilgiliydi , bu yüzden bu bir tartışma .
• Çoğu, {1..10}küme ayracı genişletilmiş aralık sözdizimine görsel olarak benzemez, bu nedenle her ikisini de kullanan programların okunması biraz daha zor olabilir.
• @ bobbogo'nun cevabı tanıdık sözdiziminin bir kısmını kullanır, ancak $ENDdeğişken aralığın diğer tarafı için geçerli bir "bookend" aralığı değilse beklenmedik bir şey yapar . Eğer END=a, örneğin, bir hata oluşmaz ve harfi harfine değeri {1..a}yankılandı edilecektir. Bu, Bash'ın varsayılan davranışıdır - genellikle beklenmediktir.

Feragatname: Bağlantılı kodun yazarıyım.

Değiştir {}ile (( )):

tmpstart=0;
tmpend=4;

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

Verim:

0
1
2
3
4

Bunların hepsi güzel ama seq sözde itiraz edildi ve çoğu sadece sayısal aralıklarla çalışıyor.

For döngünüzü çift tırnak içine alırsanız, dizeyi yankıladığınızda başlangıç ​​ve bitiş değişkenlerinin kaydı kaldırılır ve dizeyi yürütmek üzere doğrudan BASH'e gönderebilirsiniz. $i\ 'ın kaçması gerekir, bu nedenle alt kabuğa gönderilmeden önce DEĞİLDİR.

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

Bu çıktı bir değişkene de atanabilir:

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

Bunun üretmesi gereken tek "ek yük", bash'ın ikinci örneği olmalıdır, bu nedenle yoğun operasyonlar için uygun olmalıdır.

Kabuk komutları yapıyorsanız ve (benim gibi) boru hattı için bir fetişiniz varsa, bu iyi:

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

Bunu yapmanın birçok yolu vardır, ancak tercih ettiğimler aşağıda verilmiştir.

kullanma seq

Özeti man seq

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

Sözdizimi

Tam komut
seq first incr last

• birincisi sıradaki başlangıç ​​numarasıdır [varsayılan olarak isteğe bağlıdır: 1]
• incr artıştır [varsayılan olarak isteğe bağlıdır: 1]
• son sıradaki son sayıdır

Misal:

$ seq 1 2 10
1 3 5 7 9

Sadece ilk ve son ile:

$ seq 1 5
1 2 3 4 5

Sadece sonuncusu ile:

$ seq 5
1 2 3 4 5

kullanma {first..last..incr}

Burada ilk ve son zorunludur ve incr isteğe bağlıdır

Sadece ilk ve son kullanma

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

İncr kullanma

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

Bunu aşağıdaki gibi karakterler için bile kullanabilirsiniz

$ 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

eğer kullanmak istemiyorsanseq ' veya ' eval' veya jotveya aritmetik genişleme biçimini örn. for ((i=1;i<=END;i++))veya diğer döngüler örn. whileve yalnızca ' printf' ve ' ' mutlu olmak istemezseniz echo, bu basit geçici çözüm bütçenize uygun olabilir:

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

PS: Bash'ımın seqzaten ' ' komutu yok .

Mac OSX 10.6.8, Bash 3.2.48 üzerinde test edildi

Bu Bash ve Korn'da çalışır, aynı zamanda daha yüksekten daha düşük sayılara da gidebilir. Muhtemelen en hızlı veya en güzel değil ama yeterince iyi çalışıyor. Negatifleri de ele alır.

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