Bagaimana cara saya mengulangi rentang angka di Bash ketika rentang diberikan oleh variabel?

Saya tahu saya bisa melakukan ini (disebut "ekspresi urutan" dalam dokumentasi Bash ):

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

Pemberian yang mana:

1
2
3
4
5

Namun, bagaimana saya bisa mengganti salah satu dari titik akhir rentang dengan variabel? Ini tidak berfungsi:

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

Yang mencetak:

{1..5}

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

sunting: Saya lebih suka seqdaripada metode lain karena saya benar-benar dapat mengingatnya;)

The seqmetode adalah yang paling sederhana, tapi Bash telah built-in evaluasi aritmatika.

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

The for ((expr1;expr2;expr3));membangun bekerja seperti for (expr1;expr2;expr3)di C dan bahasa yang sama, dan seperti lainnya ((expr))kasus, Bash memperlakukan mereka sebagai aritmatika.

diskusi

Menggunakan seqtidak apa-apa, seperti yang disarankan Jiaaro. Pax Diablo menyarankan Bash loop untuk menghindari memanggil subproses, dengan keuntungan tambahan menjadi lebih ramah memori jika $ END terlalu besar. Zathrus melihat bug khas dalam implementasi loop, dan juga mengisyaratkan bahwa karena imerupakan variabel teks, konversi berkesinambungan ke-dan-nomor mondar-mandir dilakukan dengan perlambatan terkait.

aritmatika integer

Ini adalah versi perbaikan dari Bash loop:

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

Jika satu-satunya hal yang kita inginkan adalah echo, maka kita bisa menulis echo $((i++)).

ephemient mengajari saya sesuatu: Bash memungkinkan for ((expr;expr;expr))konstruksi. Karena saya belum pernah membaca halaman manual untuk Bash (seperti yang saya lakukan dengan halaman manual shell Korn ( ksh), dan itu sudah lama sekali), saya melewatkan itu.

Begitu,

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

tampaknya menjadi cara yang paling hemat memori (tidak perlu mengalokasikan memori untuk menggunakan seqoutput, yang bisa menjadi masalah jika END sangat besar), walaupun mungkin bukan yang "tercepat".

pertanyaan awal

eschercycle mencatat bahwa notasi { a .. b } hanya bekerja dengan literal; benar, sesuai dengan manual Bash. Seseorang dapat mengatasi kendala ini dengan satu (internal) fork()tanpa exec()(seperti halnya dengan panggilan seq, yang menjadi gambar lain membutuhkan fork + exec):

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

Kedua eval dan echoBash builtins, tetapi fork()diperlukan untuk substitusi perintah ( $(…)konstruk).

Inilah mengapa ekspresi asli tidak berfungsi.

Dari man bash :

Ekspansi brace dilakukan sebelum ekspansi lainnya, dan setiap karakter khusus ekspansi lainnya dipertahankan dalam hasilnya. Ini sangat tekstual. Bash tidak menerapkan interpretasi sintaksis apa pun untuk konteks ekspansi atau teks di antara kurung kurawal.

Jadi, ekspansi brace adalah sesuatu yang dilakukan sejak awal sebagai operasi makro murni tekstual, sebelum ekspansi parameter.

Shell adalah hibrida yang sangat dioptimalkan antara prosesor makro dan bahasa pemrograman yang lebih formal. Untuk mengoptimalkan kasus penggunaan umum, bahasa dibuat agak lebih kompleks dan beberapa batasan diterima.

Rekomendasi

Saya sarankan tetap menggunakan fitur Posix ¹ . Ini berarti menggunakan for i in <list>; do, jika daftar sudah diketahui, jika tidak, gunakan whileatau seq, seperti dalam:

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

Cara POSIX

Jika Anda peduli tentang portabilitas, gunakan contoh dari standar POSIX :

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

Keluaran:

2
3
4
5

Hal-hal yang bukan POSIX:

• (( ))tanpa dolar, meskipun itu adalah ekstensi umum seperti yang disebutkan oleh POSIX sendiri .
• [[. [sudah cukup di sini. Lihat juga: Apa perbedaan antara tanda kurung kotak tunggal dan ganda di Bash?
• for ((;;))
• seq (GNU Coreutils)
• {start..end}, dan itu tidak bisa bekerja dengan variabel seperti yang disebutkan oleh manual Bash .
• let i=i+1: POSIX 7 2. Bahasa Perintah Shell tidak mengandung kata let, dan gagal pada bash --posix4.3.42

• dolar i=$i+1mungkin diperlukan, tapi saya tidak yakin. POSIX 7 2.6.4 Ekspansi Aritmatika mengatakan:

  Jika variabel shell x berisi nilai yang membentuk konstanta integer yang valid, secara opsional menyertakan tanda plus atau minus terkemuka, maka ekspansi aritmatika "$ ((x))" dan "$ (($ x))" akan mengembalikan yang sama nilai.

  tetapi membacanya secara harfiah yang tidak menyiratkan bahwa $((x+1))memperluas karena x+1bukan variabel.

Lapisan tipuan lainnya:

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

Kamu bisa menggunakan

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

Jika Anda membutuhkannya awalan daripada yang Anda mungkin suka ini

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

itu akan menghasilkan

07
08
09
10
11
12

Jika Anda menggunakan BSD / OS X Anda dapat menggunakan jot alih-alih seq:

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

Ini berfungsi dengan baik di bash:

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

Saya telah menggabungkan beberapa ide di sini dan mengukur kinerja.

TL; DR Takeaways:

1. seqdan {..}sangat cepat
2. fordan whileloop lambat
3. $( ) lambat
4. for (( ; ; )) loop lebih lambat
5. $(( )) bahkan lebih lambat
6. Khawatir tentang nomor N di memori (seq atau {..}) konyol (setidaknya hingga 1 juta.)

Ini bukan kesimpulan . Anda harus melihat kode C di belakang masing-masing untuk menarik kesimpulan. Ini lebih tentang bagaimana kita cenderung menggunakan masing-masing mekanisme ini untuk pengulangan kode. Kebanyakan operasi tunggal cukup dekat untuk menjadi kecepatan yang sama sehingga tidak menjadi masalah dalam banyak kasus. Tetapi mekanisme seperti for (( i=1; i<=1000000; i++ ))ini adalah banyak operasi yang dapat Anda lihat secara visual. Ini juga lebih banyak operasi per loop dari yang Anda dapatkanfor i in $(seq 1 1000000) . Dan itu mungkin tidak jelas bagi Anda, itulah sebabnya melakukan tes seperti ini sangat berharga.

Demo

# 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

Saya tahu pertanyaan ini tentang bash, tetapi - hanya untuk catatan - ksh93lebih pintar dan mengimplementasikannya seperti yang diharapkan:

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

Ini adalah cara lain:

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

Jika Anda ingin tetap sedekat mungkin dengan sintaks ekspresi-brace, cobalah rangefungsi dari bash-tricks 'range.bash .

Misalnya, semua hal berikut akan melakukan hal yang sama persis seperti echo {1..10}:

source range.bash
one=1
ten=10

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

Ia mencoba untuk mendukung sintaks bash asli dengan sesedikit mungkin "gotcha": tidak hanya variabel yang didukung, tetapi perilaku rentang tidak valid yang sering diberikan sebagai string (misalnya for i in {1..a}; do echo $i; done) dicegah juga.

Jawaban lain akan berfungsi dalam kebanyakan kasus, tetapi mereka semua memiliki setidaknya satu dari kekurangan berikut:

• Banyak dari mereka menggunakan subkulit , yang dapat merusak kinerja dan mungkin tidak dapat dilakukan pada beberapa sistem.
• Banyak dari mereka mengandalkan program eksternal. Bahkan seqadalah biner yang harus diinstal untuk digunakan, harus dimuat oleh bash, dan harus berisi program yang Anda harapkan, agar bisa berfungsi dalam kasus ini. Di mana-mana atau tidak, itu jauh lebih bisa diandalkan daripada hanya bahasa Bash itu sendiri.
• Solusi yang hanya menggunakan fungsionalitas Bash asli, seperti @ ephemient, tidak akan berfungsi pada rentang alfabet, seperti {a..z}; ekspansi brace akan. Pertanyaannya adalah tentang rentang angka , jadi ini adalah pertengkaran.
• Kebanyakan dari mereka tidak secara visual mirip dengan {1..10}sintaks rentang yang dikembangkan, jadi program yang menggunakan keduanya mungkin sedikit lebih sulit untuk dibaca.
• @ bobbogo jawaban menggunakan beberapa sintaks akrab, tetapi melakukan sesuatu yang tidak terduga jika $ENDvariabel bukan rentang "bookend" yang valid untuk sisi lain dari rentang. Jika END=a, misalnya, kesalahan tidak akan terjadi dan nilai kata demi kata {1..a}akan digaungkan. Ini adalah perilaku default Bash, juga - itu sering tak terduga.

Penafian: Saya adalah pembuat kode tertaut.

Ganti {}dengan (( )):

tmpstart=0;
tmpend=4;

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

Hasil:

0
1
2
3
4

Ini semua bagus tapi seq seharusnya sudah usang dan sebagian besar hanya berfungsi dengan rentang numerik.

Jika Anda menyertakan for loop dalam tanda kutip ganda, variabel awal dan akhir akan ditinjau ketika Anda mengulangi string, dan Anda dapat mengirimkan string kembali ke BASH untuk dieksekusi. $iperlu melarikan diri dengan sehingga TIDAK dievaluasi sebelum dikirim ke subkulit.

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

Output ini juga dapat ditugaskan ke variabel:

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

Satu-satunya "overhead" yang harus dihasilkan ini adalah instance kedua dari bash sehingga harus sesuai untuk operasi intensif.

Jika Anda melakukan perintah shell dan Anda (seperti saya) memiliki jimat untuk pipelining, ini bagus:

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

Ada banyak cara untuk melakukan ini, namun yang saya sukai diberikan di bawah ini

Menggunakan seq

Sinopsis dari man seq

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

Sintaksis

Perintah penuh
seq first incr last

• pertama adalah nomor awal dalam urutan [adalah opsional, secara default: 1]
• increment [kenaikan adalah opsional, secara default: 1]
• terakhir adalah angka terakhir dalam urutan

Contoh:

$ seq 1 2 10
1 3 5 7 9

Hanya dengan yang pertama dan terakhir:

$ seq 1 5
1 2 3 4 5

Hanya dengan yang terakhir:

$ seq 5
1 2 3 4 5

Menggunakan {first..last..incr}

Di sini pertama dan terakhir adalah wajib dan tambahan adalah opsional

Menggunakan hanya pertama dan terakhir

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

Menggunakan incr

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

Anda dapat menggunakan ini bahkan untuk karakter seperti di bawah ini

$ 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

jika Anda tidak ingin menggunakan format ekspansi ' seq' atau ' eval' atau jotatau aritmatika misalnya. for ((i=1;i<=END;i++)), atau loop lain misalnya. while, dan Anda tidak ingin ' printf' dan senang ' echo' saja, maka solusi sederhana ini mungkin sesuai dengan anggaran Anda:

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

PS: Lagipula bash saya tidak punya seqperintah.

Diuji pada Mac OSX 10.6.8, Bash 3.2.48

Ini bekerja di Bash dan Korn, juga bisa berubah dari yang lebih tinggi ke angka yang lebih rendah. Mungkin tidak tercepat atau tercantik tetapi bekerja dengan cukup baik. Menangani negatif juga.

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