Làm thế nào để tôi lặp lại một phạm vi số trong Bash khi phạm vi được đưa ra bởi một biến?

Tôi biết tôi có thể làm điều này (được gọi là "biểu thức trình tự" trong tài liệu Bash ):

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

Cung cấp cho:

1
2
3
4
5

Tuy nhiên, làm thế nào tôi có thể thay thế một trong hai điểm cuối phạm vi bằng một biến? Điều này không hoạt động:

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

Bản in nào:

{1..5}

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

chỉnh sửa: Tôi thích seqhơn các phương pháp khác vì tôi thực sự có thể nhớ nó;)

Các seqphương pháp là đơn giản nhất, nhưng Bash đã được xây dựng trong việc đánh giá số học.

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

Cấu for ((expr1;expr2;expr3));trúc hoạt động giống như for (expr1;expr2;expr3)trong C và các ngôn ngữ tương tự, và giống như các ((expr))trường hợp khác , Bash coi chúng là số học.

thảo luận

Sử dụng seqlà tốt, như Jiaaro đề nghị. Pax Diablo đã đề xuất một vòng lặp Bash để tránh gọi một quy trình con, với lợi thế bổ sung là thân thiện với bộ nhớ hơn nếu $ END quá lớn. Zathrus đã phát hiện ra một lỗi điển hình trong việc thực hiện vòng lặp và cũng gợi ý rằng vì ilà một biến văn bản, các số chuyển đổi liên tục sang số được thực hiện với sự chậm lại liên quan.

số học số nguyên

Đây là phiên bản cải tiến của vòng lặp Bash:

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

Nếu điều duy nhất mà chúng ta muốn là echo, thì chúng ta có thể viết echo $((i++)).

ephemient đã dạy tôi một điều: Bash cho phép for ((expr;expr;expr))xây dựng. Vì tôi chưa bao giờ đọc toàn bộ trang man cho Bash (giống như tôi đã làm với kshtrang man Korn shell ( ) và đó là một thời gian dài trước đây), tôi đã bỏ lỡ điều đó.

Vì thế,

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

dường như là cách tiết kiệm bộ nhớ nhất (không cần phân bổ bộ nhớ để tiêu thụ seqđầu ra, điều này có thể là vấn đề nếu END rất lớn), mặc dù có lẽ không phải là nhanh nhất.

câu hỏi ban đầu

eschercycle lưu ý rằng ký hiệu { a .. b } Bash chỉ hoạt động với chữ; đúng, theo hướng dẫn của Bash. Người ta có thể vượt qua trở ngại này bằng một (bên trong) fork()mà không cần exec()(như trường hợp khi gọi seq, đó là một hình ảnh khác yêu cầu fork + exec):

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

Cả hai evalvà echolà các nội trang Bash, nhưng a fork()là bắt buộc để thay thế lệnh ( $(…)cấu trúc).

Đây là lý do tại sao biểu thức ban đầu không hoạt động.

Từ người đàn ông bash :

Mở rộng cú đúp được thực hiện trước bất kỳ bản mở rộng nào khác và kết quả là bất kỳ ký tự nào đặc biệt cho các bản mở rộng khác đều được giữ nguyên. Nó là đúng văn bản. Bash không áp dụng bất kỳ giải thích cú pháp nào cho bối cảnh mở rộng hoặc văn bản giữa các dấu ngoặc nhọn.

Vì vậy, mở rộng cú đúp là một cái gì đó được thực hiện sớm như là một hoạt động macro hoàn toàn bằng văn bản, trước khi mở rộng tham số.

Shell là các giống lai được tối ưu hóa cao giữa các bộ xử lý macro và các ngôn ngữ lập trình chính thức hơn. Để tối ưu hóa các trường hợp sử dụng thông thường, ngôn ngữ được thực hiện khá phức tạp và một số hạn chế được chấp nhận.

sự giới thiệu

Tôi sẽ đề nghị gắn bó với các tính năng Posix ¹ . Điều này có nghĩa là sử dụng for i in <list>; do, nếu danh sách đã được biết, nếu không, sử dụng whilehoặc seq, như trong:

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

Cách POSIX

Nếu bạn quan tâm đến tính di động, hãy sử dụng ví dụ từ tiêu chuẩn POSIX :

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

Đầu ra:

2
3
4
5

Những thứ không phải là POSIX:

• (( ))không có đô la, mặc dù đây là một phần mở rộng phổ biến như được đề cập bởi chính POSIX .
• [[. [là đủ ở đây Xem thêm: Sự khác biệt giữa dấu ngoặc đơn và dấu ngoặc kép trong Bash là gì?
• for ((;;))
• seq (GNU Coreutils)
• {start..end}và điều đó không thể làm việc với các biến như được đề cập trong hướng dẫn Bash .
• let i=i+1: POSIX 7 2. Ngôn ngữ lệnh Shell không chứa từ này letvà nó bị lỗi trong bash --posix4.3.42

• đồng đô la i=$i+1có thể được yêu cầu, nhưng tôi không chắc chắn. POSIX 7 2.6.4 Mở rộng số học cho biết:

  Nếu biến shell x chứa giá trị tạo thành hằng số nguyên hợp lệ, tùy ý bao gồm dấu cộng hoặc dấu trừ hàng đầu, thì phần mở rộng số học "$ ((x))" và "$ (($ x))" sẽ trả về như cũ giá trị.

  nhưng đọc nó theo nghĩa đen không có nghĩa là $((x+1))mở rộng vì x+1nó không phải là một biến.

Một lớp khác của sự gián tiếp:

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

Bạn có thể dùng

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

Nếu bạn cần tiền tố hơn bạn có thể thích điều này

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

điều đó sẽ mang lại

07
08
09
10
11
12

Nếu bạn đang sử dụng BSD / OS X, bạn có thể sử dụng jot thay vì seq:

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

Điều này hoạt động tốt trong bash:

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

Tôi đã kết hợp một vài ý tưởng ở đây và đo lường hiệu suất.

TL; DR Takeaways:

1. seqvà {..}rất nhanh
2. forvà whilevòng lặp chậm
3. $( ) chậm
4. for (( ; ; )) vòng lặp chậm hơn
5. $(( )) thậm chí còn chậm hơn
6. Lo lắng về N số trong bộ nhớ (seq hoặc {..}) là ngớ ngẩn (ít nhất lên tới 1 triệu.)

Đây không phải là kết luận . Bạn sẽ phải nhìn vào mã C đằng sau mỗi mã này để đưa ra kết luận. Đây là nhiều hơn về cách chúng ta có xu hướng sử dụng từng cơ chế này để lặp qua mã. Hầu hết các hoạt động đơn lẻ đều đủ gần để có cùng tốc độ mà nó sẽ không thành vấn đề trong hầu hết các trường hợp. Nhưng một cơ chế như for (( i=1; i<=1000000; i++ ))nhiều hoạt động như bạn có thể thấy trực quan. Nó cũng là nhiều hoạt động trên mỗi vòng lặp hơn bạn nhận được từ for i in $(seq 1 1000000). Và điều đó có thể không rõ ràng với bạn, đó là lý do tại sao làm các bài kiểm tra như thế này là có giá trị.

Trình diễ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

Tôi biết câu hỏi này là về bash, nhưng - chỉ dành cho hồ sơ - ksh93thông minh hơn và thực hiện nó như mong đợi:

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

Đây là một cách khác:

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

Nếu bạn muốn ở gần nhất có thể với cú pháp biểu thức cú đúp, hãy thử rangechức năng từ bash-trick 'range.bash .

Ví dụ: tất cả những điều sau đây sẽ thực hiện chính xác như echo {1..10}:

source range.bash
one=1
ten=10

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

Nó cố gắng hỗ trợ cú pháp bash riêng với càng ít "gotchas" càng tốt: không chỉ các biến được hỗ trợ, mà hành vi thường không mong muốn của các phạm vi không hợp lệ cũng được cung cấp dưới dạng chuỗi (ví dụ for i in {1..a}; do echo $i; done) cũng bị ngăn chặn.

Các câu trả lời khác sẽ hoạt động trong hầu hết các trường hợp, nhưng tất cả chúng đều có ít nhất một trong những nhược điểm sau:

• Nhiều người trong số họ sử dụng các lớp con , có thể gây hại cho hiệu suất và có thể không khả thi trên một số hệ thống.
• Nhiều người trong số họ dựa vào các chương trình bên ngoài. Thậm chí seqlà một nhị phân phải được cài đặt để sử dụng, phải được tải bằng bash và phải chứa chương trình bạn mong đợi, để nó hoạt động trong trường hợp này. Tuyệt vời hay không, đó là rất nhiều để dựa vào chứ không chỉ là ngôn ngữ Bash.
• Các giải pháp chỉ sử dụng chức năng Bash gốc, như @ ephemient, sẽ không hoạt động trên các phạm vi chữ cái, như {a..z}; cú đúp mở rộng sẽ. Tuy nhiên, câu hỏi là về các dãy số , vì vậy đây là một vấn đề khó hiểu.
• Hầu hết trong số chúng không giống với {1..10}cú pháp phạm vi mở rộng bằng nẹp, vì vậy các chương trình sử dụng cả hai có thể khó đọc hơn một chút.
• Câu trả lời của @ bobbogo sử dụng một số cú pháp quen thuộc, nhưng thực hiện điều gì đó bất ngờ nếu $ENDbiến không phải là phạm vi hợp lệ "bookend" cho phía bên kia của phạm vi. Nếu END=a, ví dụ, một lỗi sẽ không xảy ra và giá trị đúng nguyên văn {1..a}sẽ được lặp lại. Đây cũng là hành vi mặc định của Bash - nó thường bất ngờ.

Tuyên bố miễn trừ trách nhiệm: Tôi là tác giả của mã được liên kết.

Thay thế {}bằng (( )):

tmpstart=0;
tmpend=4;

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

Sản lượng:

0
1
2
3
4

Đây là tất cả tốt đẹp nhưng seq được cho là không dùng nữa và hầu hết chỉ hoạt động với các phạm vi số.

Nếu bạn đặt vòng lặp for của mình trong dấu ngoặc kép, các biến bắt đầu và kết thúc sẽ bị hủy đăng ký khi bạn lặp lại chuỗi và bạn có thể gửi chuỗi đó trở lại BASH để thực thi. $icần phải được thoát với \ vì vậy nó KHÔNG được đánh giá trước khi được gửi đến mạng con.

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

Đầu ra này cũng có thể được gán cho một biến:

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

"Chi phí" duy nhất mà cái này sẽ tạo ra phải là ví dụ thứ hai của bash để nó phù hợp với các hoạt động chuyên sâu.

Nếu bạn đang thực hiện các lệnh shell và bạn (như tôi) có một sự tôn sùng cho đường ống, thì điều này là tốt:

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

Có nhiều cách để làm điều này, tuy nhiên những cách tôi thích được đưa ra dưới đây

Sử dụng seq

Tóm tắt từ man seq

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

Cú pháp

Toàn lệnh
seq first incr last

• đầu tiên là số bắt đầu trong chuỗi [là tùy chọn, theo mặc định: 1]
• tăng là tăng [là tùy chọn, theo mặc định: 1]
• cuối cùng là số cuối cùng trong chuỗi

Thí dụ:

$ seq 1 2 10
1 3 5 7 9

Chỉ với đầu tiên và cuối cùng:

$ seq 1 5
1 2 3 4 5

Chỉ cuối cùng:

$ seq 5
1 2 3 4 5

Sử dụng {first..last..incr}

Ở đây đầu tiên và cuối cùng là bắt buộc và tăng là tùy chọn

Chỉ sử dụng đầu tiên và cuối cùng

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

Sử dụng tăng

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

Bạn có thể sử dụng điều này ngay cả đối với các nhân vật như dưới đây

$ 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

nếu bạn không muốn sử dụng định dạng mở rộng ' seq' hoặc ' eval' hoặc jothoặc số học, vd. for ((i=1;i<=END;i++))hoặc các vòng lặp khác, vd. whilevà bạn không muốn ' printf' và vui vẻ ' echo', thì cách giải quyết đơn giản này có thể phù hợp với ngân sách của bạn:

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

PS: seqDù sao thì bash của tôi không có lệnh ''.

Đã thử nghiệm trên Mac OSX 10.6.8, Bash 3.2.48

Điều này hoạt động trong Bash và Korn, cũng có thể đi từ số cao hơn đến số thấp hơn. Có lẽ không nhanh nhất hoặc đẹp nhất nhưng hoạt động đủ tốt. Xử lý tiêu cực quá.

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