විචල්‍යය මඟින් පරාසය ලබා දෙන විට, මම බාෂ් හි සංඛ්‍යා පරාසයක් හරහා නැවත ක්‍රියා කරන්නේ කෙසේද?

මට මෙය කළ හැකි බව මම දනිමි (බෑෂ් ප්‍රලේඛනයේ "අනුක්‍රමික ප්‍රකාශනය" ලෙස හැඳින්වේ ):

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

ලබා දෙන්නේ:

1
2
3
4
5

එහෙත්, පරාසයේ අන්ත ලක්ෂ්‍යයන් විචල්‍යයක් සමඟ ප්‍රතිස්ථාපනය කරන්නේ කෙසේද? මෙය ක්‍රියාත්මක නොවේ:

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

කුමන මුද්‍රණ:

{1..5}

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

සංස්කරණය කරන්න: මම seqඅනෙක් ක්‍රමවලට වඩා කැමතියි එය මට මතක තබා ගත හැකි නිසා;)

මෙම seqක්‍රමය සරලම ය, නමුත් බාෂ් විසින් ගණිතමය ඇගයීමක් ගොඩනගා ඇත.

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));ඉදිකිරීම for (expr1;expr2;expr3)සී හා සමාන භාෂාවලින් ක්‍රියාත්මක වන අතර අනෙක් ((expr))අවස්ථා වලදී මෙන් බාෂ් ඒවා ගණිතමය ලෙස සලකයි.

සාකච්ඡා

seqජියාරෝ යෝජනා කළ පරිදි භාවිතා කිරීම හොඳයි. පැක්ස් ඩයබ්ලෝ විසින් උපසිරැසියක් ඇමතීමෙන් වළක්වා ගැනීම සඳහා බෑෂ් ලූපයක් යෝජනා කළ අතර memory END ඉතා විශාල නම් මතක හිතකාමී වීමට අමතර වාසියක් ඇත. සැත්රස් ලූප ක්‍රියාත්මක කිරීමේදී සාමාන්‍ය දෝෂයක් දුටු අතර එතැන් සිට එය ඉඟි කළේයi , පෙළ විචල්‍යයක් වන බැවින්, සංඛ්‍යාංක වෙත අඛණ්ඩ පරිවර්තනයන් සම්බන්ධ වන්නේ මන්දගාමී වීමෙනි.

නිඛිල අංක ගණිතය

මෙය Bash loop හි වැඩිදියුණු කළ අනුවාදයකි:

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

අපට අවශ්‍ය එකම දෙය නම් echo, අපට ලිවිය හැකිය echo $((i++)).

ephemient මට යමක් ඉගැන්නුවා: Bash for ((expr;expr;expr))ඉදිකිරීම් සඳහා ඉඩ දෙයි . මම කවදාවත් බාෂ් සඳහා සම්පූර්ණ මෑන් පිටුව කියවා නැති නිසා (මම කෝර්න් ෂෙල් එකෙන් කළාක් මෙන්)ksh ) මෑන් පිටුව සමඟ කර ඇති පරිදි, එය බොහෝ කලකට පෙර සිදු වූවක් මෙන්), මට එය මග හැරුණි.

නිසා,

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

වඩාත්ම මතක-කාර්යක්ෂම ක්‍රමය ලෙස පෙනේ (පරිභෝජනය සඳහා මතකය වෙන් කිරීම අවශ්‍ය නොවේ seq නිමැවුම් , එය END ඉතා විශාල නම් ගැටළුවක් විය හැකිය), බොහෝ විට “වේගවත්ම” නොවේ.

ආරම්භක ප්‍රශ්නය

eshercycle සඳහන් කළේ { a .. b } බෑෂ් අංකනය ක්‍රියාත්මක වන්නේ වචනාර්ථයෙන් පමණක් බවයි; සත්‍ය, බාෂ් අත්පොතට අනුව. කෙනෙකුට මෙම බාධකය තනි (අභ්‍යන්තර) fork()රහිතව ජය ගත හැකිය (ඇමතුම exec()මෙන්ම seq, වෙනත් රූපයක් සඳහා දෙබලක + ක්‍රියාත්මක කිරීමක් අවශ්‍ය වේ):

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

දෙකම evalසහ echoBash buildins වේ, නමුත් fork()විධාන ආදේශනය සඳහා ( $(…)ඉදිකිරීම්) අවශ්‍ය වේ.

මෙන්න මුල් ප්‍රකාශනය ක්‍රියාත්මක නොවීමට හේතුව.

මෑන් බැෂ් වෙතින් :

වෙනත් ඕනෑම ප්‍රසාරණයකට පෙර වරහන් ප්‍රසාරණය සිදු කරනු ලබන අතර, වෙනත් පුළුල් කිරීම් වලට විශේෂිත වූ ඕනෑම අක්‍ෂරයක් ප්‍රති .ලය තුළ ආරක්ෂා වේ. එය තදින් පා ual මය. පුළුල් කිරීමේ සන්දර්භය හෝ වරහන් අතර ඇති පෙළට බාෂ් කිසිදු සින්ටැක්ටික් අර්ථකථනයක් අදාළ නොකරයි.

එබැවින්, වරහන් ප්‍රසාරණය යනු පරාමිති ප්‍රසාරණයට පෙර තනිකරම පා ma මය සාර්ව මෙහෙයුමක් ලෙස කළ හැකි දෙයකි .

ෂෙල් වෙඩි යනු සාර්ව සකසනයන් සහ වඩාත් විධිමත් ක්‍රමලේඛන භාෂා අතර ඉහළ ප්‍රශස්ත දෙමුහුන් ය. සාමාන්‍ය භාවිත අවස්ථා ප්‍රශස්ත කිරීම සඳහා, භාෂාව වඩාත් සංකීර්ණ කර ඇති අතර සමහර සීමාවන් පිළිගනු ලැබේ.

නිර්දේශය

පොසික්ස් ¹ විශේෂාංග සමඟ රැඳී සිටීමට මම යෝජනා කරමි . මෙම භාවිතා මාර්ගයෙන් for i in <list>; doලැයිස්තුව මේ වන විටත් දන්නවා නම් වේ, වෙනත් ආකාරයකින්, භාවිතා කරන්න, whileහෝ 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 මාර්ගය

ඔබ අතේ ගෙන යා හැකි බව ගැන සැලකිලිමත් නම් , POSIX ප්‍රමිතියෙන් උදාහරණය භාවිතා කරන්න :

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

ප්‍රතිදානය:

2
3
4
5

පොසික්ස් නොවන දේවල් :

• (( ))පොසික්ස් විසින්ම සඳහන් කළ පරිදි එය පොදු දිගුවක් වුවද ඩොලරයක් නොමැතිව .
• [[. [මෙතන ඇති. මෙයද බලන්න: බාෂ් හි තනි සහ ද්විත්ව වර්ග වරහන් අතර වෙනස කුමක්ද?
• for ((;;))
• seq (GNU Coreutils)
• {start..end}, සහ Bash අත්පොතෙහි සඳහන් පරිදි විචල්‍යයන් සමඟ ක්‍රියා කළ නොහැක .
• let i=i+1: POSIX 7 2. ෂෙල් විධාන භාෂාවේ වචනය අඩංගු නොවන letඅතර එය bash --posix4.3.42 හි අසමත් වේ

• ඩොලරය i=$i+1අවශ්‍ය විය හැකි නමුත් මට විශ්වාස නැත. POSIX 7 2.6.4 අංක ගණිත ප්‍රසාරණය පවසන්නේ:

  ෂෙල් විචල්ය x හි වලංගු නිඛිල නියතයක් සාදන අගයක් තිබේ නම්, විකල්පයක් ලෙස ප්‍රමුඛ ප්ලස් හෝ us ණ ලකුණක් ඇතුළත් වේ නම්, "$ ((x))" සහ "$ (($ x))" යන අංක ගණිත ප්‍රසාරණයන් එකම වේ. අගය.

  නමුත් එය වචනානුසාරයෙන් කියවීම විචල්‍ය නොවන $((x+1))බැවින් පුළුල් වන බවක් අඟවන්නේ x+1නැත.

අවිනිශ්චිතතාවයේ තවත් ස්ථරයක්:

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

ඔයාට පාවිච්චි කරන්න පුළුවන්

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

ඔබට මෙය අවශ්‍ය වීමට වඩා උපසර්ගය අවශ්‍ය නම්

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

එය ලැබෙනු ඇත

07
08
09
10
11
12

ඔබ BSD / OS X හි සිටී නම් ඔබට seq වෙනුවට jot භාවිතා කළ හැකිය:

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

මෙය හොඳින් ක්‍රියාත්මක වේ bash:

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

මම මෙහි අදහස් කිහිපයක් ඒකාබද්ධ කර කාර්ය සාධනය මැන බැලුවෙමි.

ටීඑල්; ඩීආර් රැගෙන යාම:

1. seq සහ {..} ඇත්තටම වේගවත්
2. forසහ whileලූප මන්දගාමී වේ
3. $( ) මන්දගාමී වේ
4. for (( ; ; )) ලූප මන්දගාමී වේ
5. $(( )) ඊටත් වඩා මන්දගාමී වේ
6. ගැන කනගාටු එන් (මහලේකම් පා හෝ {..}) මතකයේ අංක (මිලියන 1 දක්වා අවම වශයෙන් දක්වා දී.) ඒක වෙනස්

මේවා නිගමන නොවේ . නිගමන උකහා ගැනීම සඳහා ඔබට මේ සෑම එකක් පිටුපස ඇති සී කේතය දෙස බැලිය යුතුය. කේතය ඉක්මවා යාම සඳහා මෙම එක් එක් යාන්ත්‍රණය භාවිතා කිරීමට අපි නැඹුරු වන්නේ කෙසේද යන්න පිළිබඳ වැඩි විස්තරයකි. බොහෝ තනි මෙහෙයුම් එකම අවස්ථාවන්හිදී ප්‍රමාණවත් නොවන අතර එය බොහෝ අවස්ථාවන්හිදී වැදගත් නොවේ. නමුත් for (( i=1; i<=1000000; i++ ))ඔබට පෙනෙන පරිදි බොහෝ යාන්ත්‍රණයන් වැනි යාන්ත්‍රණයක් ඇත. එය ඔබ ලබා ගන්නා ප්‍රමාණයට වඩා ලූපයකට තවත් බොහෝ මෙහෙයුම් වේfor i in $(seq 1 1000000) . එය ඔබට පැහැදිලිව පෙනෙන්නට නොතිබිය හැකිය, මේ නිසා මෙවැනි පරීක්ෂණ සිදු කිරීම වටී.

ඩිමෝස්

# 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

මෙම ප්‍රශ්නය ගැන මම දනිමි bash, නමුත් - වාර්තාවක් සඳහා පමණක් - ksh93වඩා දක්ෂ වන අතර එය අපේක්ෂා කළ පරිදි ක්‍රියාත්මක කරයි:

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

මෙය තවත් ක්‍රමයකි:

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

ඔබට වරහන්-ප්‍රකාශන වාක්‍ය ඛණ්ඩයට හැකි තරම් සමීපව සිටීමට අවශ්‍ය නම්, rangeකාර්යය බාෂ්-උපක්‍රම වලින්range.bash උත්සාහ කරන්න .

නිදසුනක් ලෙස, පහත සඳහන් සියල්ලම හරියටම එකම දේ කරනු ඇත echo {1..10}:

source range.bash
one=1
ten=10

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

එය ස්වදේශික බැෂ් සින්ටැක්ස් වලට හැකි තරම් "ගොචා" කිහිපයක් සමඟ සහය දැක්වීමට උත්සාහ කරයි: විචල්‍යයන්ට සහය දැක්වීම පමණක් නොව, වලංගු නොවන පරාසයන්හි නූල් ලෙස සපයනු ලබන බොහෝ විට නුසුදුසු හැසිරීම (උදා. for i in {1..a}; do echo $i; done ) වලක්වනු ලැබේ.

අනෙක් පිළිතුරු බොහෝ අවස්ථාවන්හිදී ක්‍රියාත්මක වනු ඇත, නමුත් ඒවා සියල්ලටම අවම වශයෙන් පහත සඳහන් අඩුපාඩු වලින් එකක්වත් තිබේ:

• ඔවුන්ගෙන් බොහෝ දෙනෙක් භාවිතා උපකවච හැකි, කාර්ය සාධනය හානි හා විය හැකිය , සමහරක් පද්ධති මත.
• ඔවුන්ගෙන් බොහෝ දෙනෙක් බාහිර වැඩසටහන් මත රඳා සිටිති. පවාseqද්විමය භාවිතා කිරීමට ස්ථාපනය කළ යුතු අතර, එය බාෂ් මඟින් පටවා තිබිය යුතු අතර, මෙම නඩුවේදී එය ක්‍රියාත්මක වන පරිදි ඔබ අපේක්ෂා කරන වැඩසටහන අඩංගු විය යුතුය. සර්වබලධාරී හෝ නැත, එය හුදෙක් බාෂ් භාෂාවට වඩා විශ්වාසය තැබිය යුතුය.
• @ එෆීමන්ට්ස් වැනි ස්වදේශීය බෑෂ් ක්‍රියාකාරිත්වය පමණක් භාවිතා කරන විසඳුම්, අකාරාදී පරාසයන් මත ක්‍රියා නොකරනු ඇත {a..z}; වරහන් පුළුල් කිරීම. ප්‍රශ්නය වූයේ සංඛ්‍යා පරාසයන් ගැන ය , එනමුත් මෙය විකාරයකි.
• ඒවායින් බොහොමයක් දෘශ්‍යමය වශයෙන් {1..10}වරහන් පුළුල් කරන ලද සින්ටැක්ස් වලට සමාන නොවේ , එබැවින් දෙකම භාවිතා කරන වැඩසටහන් කියවීමට තරමක් අපහසු විය හැකිය.
• @ බොබ්බෝගෝගේ පිළිතුර හුරුපුරුදු සින්ටැක්ස් කිහිපයක් භාවිතා කරයි, නමුත් $ENDවිචල්‍යය පරාසයේ අනෙක් පැත්තට වලංගු පරාසයක් වන "බුකෙන්ඩ්" නොවේ නම් අනපේක්ෂිත දෙයක් කරයි. නම් END=a, උදාහරණයක් ලෙස, දෝෂයක් ඇති නො වනු සහ සිදුකිරීමේදී පැවැත්වෙන කථා ඒ අයුරින්ම අගය {1..a}ප්රතිරාවය කරනු ඇත. මෙය Bash හි සුපුරුදු හැසිරීම ද වේ - එය බොහෝ විට අනපේක්ෂිත ය.

වියාචනය: සම්බන්ධිත කේතයේ කර්තෘ මම වෙමි.

{}සමඟ ප්රතිස්ථාපනය කරන්න (( )):

tmpstart=0;
tmpend=4;

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

අස්වැන්න:

0
1
2
3
4

මේ සියල්ල හොඳයි, නමුත් සීක් අවලංගු කර ඇති අතර බොහෝමයක් වැඩ කරන්නේ සංඛ්‍යාත්මක පරාසයන් සමඟ පමණි.

ඔබ ඔබේ ලූපය ද්විත්ව උපුටා දැක්වීම් සමඟ සම්බන්ධ කළහොත්, ඔබ නූල් දෝංකාර දෙන විට ආරම්භක සහ අවසාන විචල්‍යයන් අවලංගු වන අතර, ක්‍රියාත්මක කිරීම සඳහා ඔබට නූල නැවත බාෂ් වෙත යැවිය හැකිය. $is සමඟ පැන යා යුතුය, එබැවින් එය උප කුලකයට යැවීමට පෙර ඇගයීමට ලක් නොකෙරේ.

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

මෙම ප්‍රතිදානය විචල්‍යයකට ද පැවරිය හැකිය:

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

මෙය ජනනය කළ යුතු එකම “උඩිස්” බැෂ් හි දෙවන අවස්ථාව විය යුතුය, එබැවින් එය දැඩි මෙහෙයුම් සඳහා සුදුසු විය යුතුය.

ඔබ ෂෙල් විධාන කරන්නේ නම් සහ ඔබට (මා වැනි) නල මාර්ගගත කිරීම සඳහා ish ලදායීතාවයක් තිබේ නම්, මෙය හොඳයි:

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

මෙය කිරීමට බොහෝ ක්‍රම තිබේ, කෙසේ වෙතත් මා කැමති ඒවා පහත දැක්වේ

භාවිතා කිරීම seq

සිට සාරාංශය man seq

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

සින්ටැක්ස්

සම්පූර්ණ විධානය
seq first incr last

• පළමුවැන්න අනුක්‍රමයේ ආරම්භක අංකයයි [අත්‍යවශ්‍ය නොවේ, පෙරනිමියෙන්: 1]
• incr යනු වර්ධක වේ [අත්‍යවශ්‍ය නොවේ, පෙරනිමියෙන්: 1]
• අන්තිමයා අනුක්‍රමයේ අවසාන අංකය වේ

උදාහරණයක්:

$ seq 1 2 10
1 3 5 7 9

පළමු හා අවසාන සමඟ පමණි:

$ seq 1 5
1 2 3 4 5

අන්තිමයන් සමඟ පමණි:

$ seq 5
1 2 3 4 5

භාවිතා කිරීම {first..last..incr}

මෙහි පළමු හා අවසාන අනිවාර්යය වන අතර incr අත්‍යවශ්‍ය නොවේ

පළමු හා අවසාන භාවිතා කිරීම

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

Incr භාවිතා කිරීම

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

පහත වැනි අක්ෂර සඳහා පවා ඔබට මෙය භාවිතා කළ හැකිය

$ 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

ඔබට ' seq' හෝ ' eval' jotහෝ ගණිත පුළුල් කිරීමේ ආකෘතිය භාවිතා කිරීමට අවශ්‍ය නැතිනම් උදා. for ((i=1;i<=END;i++)), හෝ වෙනත් ලූප උදා. while, ඔබට අවශ්‍ය නැති printfඅතර " echo" පමණක් සතුටු විය යුතුය , එවිට මෙම සරල ක්‍රියාමාර්ගය ඔබේ අයවැයට ගැලපේ:

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

PS: මගේ බැෂ්ටයට seqකෙසේ හෝ විධානයක් නැත.

මැක් ඕඑස්එක්ස් 10.6.8, බෑෂ් 3.2.48 හි පරීක්ෂා කර ඇත

මෙය Bash සහ Korn හි ක්‍රියාත්මක වන අතර ඉහළ සිට පහළ සංඛ්‍යා දක්වාද යා හැකිය. බොහෝ විට වේගවත් හෝ ලස්සන නැති නමුත් ප්‍රමාණවත් ලෙස ක්‍රියා කරයි. නිෂේධනයන් ද හසුරුවයි.

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