ฉันจะทำสิ่งนี้ด้วยได้echoอย่างไร

perl -E 'say "=" x 100'

คุณสามารถใช้ได้:

printf '=%.0s' {1..100}

มันทำงานอย่างไร:

Bash ขยาย {1..100} ดังนั้นคำสั่งจะกลายเป็น:

printf '=%.0s' 1 2 3 4 ... 100

ฉันได้ตั้งค่ารูปแบบของ printf =%.0sซึ่งหมายความว่ามันจะพิมพ์เพียงครั้งเดียว=ไม่ว่าจะมีการโต้แย้งอะไรก็ตาม ดังนั้นจึงพิมพ์ 100 =วินาที

ไม่มีวิธีง่ายๆ แต่ตัวอย่างเช่น:

seq -s= 100|tr -d '[:digit:]'

หรืออาจเป็นวิธีที่ได้มาตรฐาน:

printf %100s |tr " " "="

นอกจากนี้ยังมีtput repแต่สำหรับมือถือของฉัน (xterm และ linux) พวกเขาดูเหมือนจะไม่สนับสนุน :)

^{เคล็ดลับของหมวกถึง @ gniourf_gniourfสำหรับการป้อนข้อมูลของเขา}

หมายเหตุ: คำตอบนี้ไม่ได้ตอบคำถามเดิม แต่เติมเต็มคำตอบที่มีอยู่และเป็นประโยชน์โดยการเปรียบเทียบประสิทธิภาพเปรียบเทียบประสิทธิภาพการทำงาน

โซลูชั่นจะถูกเปรียบเทียบในแง่ของความเร็วในการดำเนินการเท่านั้น - ข้อกำหนดหน่วยความจำไม่ได้เป็นถูกนำมาพิจารณา

สรุป:

• หากจำนวนการทำซ้ำของคุณมีน้อยพูดได้ถึงประมาณ 100 มันจะคุ้มค่ากับการแก้ปัญหาอย่าง Bash เท่านั้นเนื่องจากต้นทุนเริ่มต้นของระบบสาธารณูปโภคภายนอกมีความสำคัญโดยเฉพาะอย่างยิ่ง Perl
  • ในทางปฏิบัติการพูดอย่างไรก็ตามถ้าคุณต้องการเพียงหนึ่งอินสแตนซ์ของอักขระที่ซ้ำกันโซลูชันที่มีอยู่ทั้งหมดอาจไม่เป็นไร
• ด้วยขนาดใหญ่นับซ้ำ , ใช้สาธารณูปโภคภายนอกเช่นที่พวกเขาจะได้เร็วขึ้นมาก
  • โดยเฉพาะอย่างยิ่งหลีกเลี่ยงการแทนที่สตริงย่อยทั่วโลกของ Bash ด้วยสตริงขนาดใหญ่
    (เช่น${var// /=}) เนื่องจากมีข้อห้ามที่ช้า

ต่อไปนี้คือเวลาใน iMac ช่วงปลายปี 2012 ด้วยซีพียู Intel Core i5 3.2 GHz และฟิวชั่นไดรฟ์ใช้ OSX 10.10.4 และทุบตี 3.2.57 และเฉลี่ย 1,000 ครั้ง

รายการคือ:

• แสดงรายการในลำดับของระยะเวลาดำเนินการ (น้อยไปหามาก)
• นำหน้าด้วย:
  • M... วิธีแก้ปัญหาที่มีหลายตัวเลือก
  • S... ทางออกเดียว -character เท่านั้น
  • P ... โซลูชันที่สอดคล้องกับ POSIX
• ตามด้วยคำอธิบายสั้น ๆ ของการแก้ปัญหา
• ต่อท้ายด้วยชื่อของผู้เขียนของคำตอบที่มา

• จำนวนการนับซ้าเล็กน้อย: 100

[M, P] printf %.s= [dogbane]:                           0.0002
[M   ] printf + bash global substr. replacement [Tim]:  0.0005
[M   ] echo -n - brace expansion loop [eugene y]:       0.0007
[M   ] echo -n - arithmetic loop [Eliah Kagan]:         0.0013
[M   ] seq -f [Sam Salisbury]:                          0.0016
[M   ] jot -b [Stefan Ludwig]:                          0.0016
[M   ] awk - $(count+1)="=" [Steven Penny (variant)]:   0.0019
[M, P] awk - while loop [Steven Penny]:                 0.0019
[S   ] printf + tr [user332325]:                        0.0021
[S   ] head + tr [eugene y]:                            0.0021
[S, P] dd + tr [mklement0]:                             0.0021
[M   ] printf + sed [user332325 (comment)]:             0.0021
[M   ] mawk - $(count+1)="=" [Steven Penny (variant)]:  0.0025
[M, P] mawk - while loop [Steven Penny]:                0.0026
[M   ] gawk - $(count+1)="=" [Steven Penny (variant)]:  0.0028
[M, P] gawk - while loop [Steven Penny]:                0.0028
[M   ] yes + head + tr [Digital Trauma]:                0.0029
[M   ] Perl [sid_com]:                                  0.0059

• วิธีการแก้ปัญหา Bash เท่านั้นนำแพ็ค - แต่ด้วยซ้ำนับเล็ก ๆ นี้! (ดูด้านล่าง)
• ต้นทุนเริ่มต้นของยูทิลิตี้ภายนอกมีความสำคัญที่นี่โดยเฉพาะ Perl หากคุณต้องเรียกสิ่งนี้ในลูป - ด้วยการทำซ้ำเล็กๆ ในแต่ละการวนซ้ำ - หลีกเลี่ยงการใช้งานยูทิลิตี้awkและperlการแก้ปัญหา

• จำนวนซ้ำขนาดใหญ่: 1000000 (1 ล้าน)

[M   ] Perl [sid_com]:                                  0.0067
[M   ] mawk - $(count+1)="=" [Steven Penny (variant)]:  0.0254
[M   ] gawk - $(count+1)="=" [Steven Penny (variant)]:  0.0599
[S   ] head + tr [eugene y]:                            0.1143
[S, P] dd + tr [mklement0]:                             0.1144
[S   ] printf + tr [user332325]:                        0.1164
[M, P] mawk - while loop [Steven Penny]:                0.1434
[M   ] seq -f [Sam Salisbury]:                          0.1452
[M   ] jot -b [Stefan Ludwig]:                          0.1690
[M   ] printf + sed [user332325 (comment)]:             0.1735
[M   ] yes + head + tr [Digital Trauma]:                0.1883
[M, P] gawk - while loop [Steven Penny]:                0.2493
[M   ] awk - $(count+1)="=" [Steven Penny (variant)]:   0.2614
[M, P] awk - while loop [Steven Penny]:                 0.3211
[M, P] printf %.s= [dogbane]:                           2.4565
[M   ] echo -n - brace expansion loop [eugene y]:       7.5877
[M   ] echo -n - arithmetic loop [Eliah Kagan]:         13.5426
[M   ] printf + bash global substr. replacement [Tim]:  n/a

• โซลูชัน Perl จากคำถามนั้นเร็วที่สุด
• การแทนที่สตริงทั่วโลกของ Bash ( ${foo// /=}) นั้นช้ามากอย่างน่าอัศจรรย์กับสตริงจำนวนมากและถูกนำออกจากการแข่งขัน (ใช้เวลาประมาณ 50 นาที (!) ใน Bash 4.3.30 และนานกว่าใน Bash 3.2.57 - ฉันไม่เคยรอ เสร็จสิ้น)
• Bash loops นั้นช้าและ arithmetic loops ( (( i= 0; ... ))) จะช้ากว่า brace-extended ( {1..n}) - ถึงแม้ว่า arithmetic loops จะมีประสิทธิภาพในการใช้หน่วยความจำมากกว่า
• awkอ้างถึงBSD awk (เท่าที่พบใน OSX) - มันช้ากว่าอย่างเห็นได้ชัดgawk(GNU Awk) และโดยเฉพาะอย่างยิ่งmawkและโดยเฉพาะอย่างยิ่ง
• โปรดทราบว่าด้วยจำนวนมากและหลายตัวอักษร สตริงการใช้หน่วยความจำอาจกลายเป็นการพิจารณา - แนวทางที่แตกต่างกันในเรื่องนั้น

นี่คือสคริปต์ Bash ( testrepeat) ที่สร้างรายการด้านบน ใช้เวลา 2 ข้อโต้แย้ง:

• จำนวนตัวอักษรซ้ำ
• เป็นทางเลือกจำนวนของการทดสอบที่จะดำเนินการและคำนวณเวลาเฉลี่ยจาก

กล่าวอีกนัยหนึ่ง: การกำหนดเวลาด้านบนได้ด้วยtestrepeat 100 1000และtestrepeat 1000000 1000

#!/usr/bin/env bash

title() { printf '%s:\t' "$1"; }

TIMEFORMAT=$'%6Rs'

# The number of repetitions of the input chars. to produce
COUNT_REPETITIONS=${1?Arguments: <charRepeatCount> [<testRunCount>]}

# The number of test runs to perform to derive the average timing from.
COUNT_RUNS=${2:-1}

# Discard the (stdout) output generated by default.
# If you want to check the results, replace '/dev/null' on the following
# line with a prefix path to which a running index starting with 1 will
# be appended for each test run; e.g., outFilePrefix='outfile', which
# will produce outfile1, outfile2, ...
outFilePrefix=/dev/null

{

  outFile=$outFilePrefix
  ndx=0

  title '[M, P] printf %.s= [dogbane]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  # !! In order to use brace expansion with a variable, we must use `eval`.
  eval "
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    printf '%.s=' {1..$COUNT_REPETITIONS} >"$outFile"
  done"

  title '[M   ] echo -n - arithmetic loop [Eliah Kagan]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    for ((i=0; i<COUNT_REPETITIONS; ++i)); do echo -n =; done >"$outFile"
  done


  title '[M   ] echo -n - brace expansion loop [eugene y]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  # !! In order to use brace expansion with a variable, we must use `eval`.
  eval "
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    for i in {1..$COUNT_REPETITIONS}; do echo -n =; done >"$outFile"
  done
  "

  title '[M   ] printf + sed [user332325 (comment)]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    printf "%${COUNT_REPETITIONS}s" | sed 's/ /=/g' >"$outFile"
  done


  title '[S   ] printf + tr [user332325]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    printf "%${COUNT_REPETITIONS}s" | tr ' ' '='  >"$outFile"
  done


  title '[S   ] head + tr [eugene y]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    head -c $COUNT_REPETITIONS < /dev/zero | tr '\0' '=' >"$outFile"
  done


  title '[M   ] seq -f [Sam Salisbury]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    seq -f '=' -s '' $COUNT_REPETITIONS >"$outFile"
  done


  title '[M   ] jot -b [Stefan Ludwig]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    jot -s '' -b '=' $COUNT_REPETITIONS >"$outFile"
  done


  title '[M   ] yes + head + tr [Digital Trauma]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    yes = | head -$COUNT_REPETITIONS | tr -d '\n'  >"$outFile"
  done

  title '[M   ] Perl [sid_com]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    perl -e "print \"=\" x $COUNT_REPETITIONS" >"$outFile"
  done

  title '[S, P] dd + tr [mklement0]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  time for (( n = 0; n < COUNT_RUNS; n++ )); do 
    dd if=/dev/zero bs=$COUNT_REPETITIONS count=1 2>/dev/null | tr '\0' "=" >"$outFile"
  done

  # !! On OSX, awk is BSD awk, and mawk and gawk were installed later.
  # !! On Linux systems, awk may refer to either mawk or gawk.
  for awkBin in awk mawk gawk; do
    if [[ -x $(command -v $awkBin) ]]; then

      title "[M   ] $awkBin"' - $(count+1)="=" [Steven Penny (variant)]'
      [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
      time for (( n = 0; n < COUNT_RUNS; n++ )); do 
        $awkBin -v count=$COUNT_REPETITIONS 'BEGIN { OFS="="; $(count+1)=""; print }' >"$outFile"
      done

      title "[M, P] $awkBin"' - while loop [Steven Penny]'
      [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
      time for (( n = 0; n < COUNT_RUNS; n++ )); do 
        $awkBin -v count=$COUNT_REPETITIONS 'BEGIN { while (i++ < count) printf "=" }' >"$outFile"
      done

    fi
  done

  title '[M   ] printf + bash global substr. replacement [Tim]'
  [[ $outFile != '/dev/null' ]] && outFile="$outFilePrefix$((++ndx))"
  # !! In Bash 4.3.30 a single run with repeat count of 1 million took almost
  # !! 50 *minutes*(!) to complete; n Bash 3.2.57 it's seemingly even slower -
  # !! didn't wait for it to finish.
  # !! Thus, this test is skipped for counts that are likely to be much slower
  # !! than the other tests.
  skip=0
  [[ $BASH_VERSINFO -le 3 && COUNT_REPETITIONS -gt 1000 ]] && skip=1
  [[ $BASH_VERSINFO -eq 4 && COUNT_REPETITIONS -gt 10000 ]] && skip=1
  if (( skip )); then
    echo 'n/a' >&2
  else
    time for (( n = 0; n < COUNT_RUNS; n++ )); do 
      { printf -v t "%${COUNT_REPETITIONS}s" '='; printf %s "${t// /=}"; } >"$outFile"
    done
  fi
} 2>&1 | 
 sort -t$'\t' -k2,2n | 
   awk -F $'\t' -v count=$COUNT_RUNS '{ 
    printf "%s\t", $1; 
    if ($2 ~ "^n/a") { print $2 } else { printf "%.4f\n", $2 / count }}' |
     column -s$'\t' -t

มีมากกว่าหนึ่งวิธีที่จะทำ

ใช้วง:

• การขยายรั้งสามารถใช้กับตัวอักษรจำนวนเต็ม:

  for i in {1..100}; do echo -n =; done    

• การวนรอบเหมือน C ช่วยให้สามารถใช้ตัวแปรได้:

  start=1
  end=100
  for ((i=$start; i<=$end; i++)); do echo -n =; done

ใช้printfbuiltin:

printf '=%.0s' {1..100}

การระบุความแม่นยำที่นี่ตัดสตริงให้พอดีกับความกว้างที่ระบุ ( 0) เมื่อprintfนำสตริงการจัดรูปแบบกลับมาใช้เพื่อใช้อาร์กิวเมนต์ทั้งหมดพิมพ์เพียง"="100 ครั้ง

ใช้head( printf, ฯลฯ ) และtr:

head -c 100 < /dev/zero | tr '\0' '='
printf %100s | tr " " "="

ฉันเพิ่งพบวิธีที่ง่ายอย่างจริงจังในการทำเช่นนี้โดยใช้ seq:

อัปเดต: ใช้งานได้กับ BSD seqที่มาพร้อมกับ OS X. YMMV กับเวอร์ชันอื่น

seq  -f "#" -s '' 10

จะพิมพ์ '#' 10 ครั้งเช่นนี้

##########

• -f "#"กำหนดสตริงรูปแบบเพื่อละเว้นตัวเลขและเพียงพิมพ์#สำหรับแต่ละคน
• -s '' ตั้งค่าตัวคั่นเป็นสตริงว่างเพื่อลบบรรทัดใหม่ที่ seq แทรกระหว่างแต่ละหมายเลข
• ช่องว่างหลัง-fและ-sดูเหมือนจะมีความสำคัญ

แก้ไข: ที่นี่มันอยู่ในฟังก์ชั่นที่มีประโยชน์ ...

repeat () {
    seq  -f $1 -s '' $2; echo
}

ซึ่งคุณสามารถโทรแบบนี้ ...

repeat "#" 10

หมายเหตุ:หากคุณกำลังทำซ้ำ#คำพูดนั้นมีความสำคัญ!

นี่คือสองวิธีที่น่าสนใจ:

ubuntu @ ubuntu: ~ $ yes = | หัว -10 | วาง -s -d '' -
==========
ubuntu @ ubuntu: ~ $ yes = | หัว -10 | tr -d "\ n"
========== อูบุนตู @ อูบุนตู: ~ $ 

หมายเหตุทั้งสองนี้มีความแตกต่างกันเล็กน้อย - pasteวิธีสิ้นสุดในบรรทัดใหม่ trวิธีการไม่ได้

ไม่มีวิธีง่ายๆ หลีกเลี่ยงการใช้ลูปprintfและการแทนที่

str=$(printf "%40s")
echo ${str// /rep}
# echoes "rep" 40 times.

หากคุณต้องการความสอดคล้อง POSIX และความสอดคล้องในการใช้งานที่แตกต่างกันของechoและprintfและ / หรือเชลล์อื่นที่ไม่ใช่แค่bash:

seq(){ n=$1; while [ $n -le $2 ]; do echo $n; n=$((n+1)); done ;} # If you don't have it.

echo $(for each in $(seq 1 100); do printf "="; done)

... จะสร้างผลลัพธ์เดียวกันperl -E 'say "=" x 100'กับทุกที่

คำถามคือทำอย่างไรกับecho:

echo -e ''$_{1..100}'\b='

สิ่งนี้จะทำเช่นเดียวกันperl -E 'say "=" x 100'กับที่มี แต่echoเท่านั้น

วิธีทุบตีบริสุทธิ์โดยไม่ eval , ไม่มี subshells, ไม่มีเครื่องมือภายนอก, ไม่มีการขยายรั้ง (เช่นคุณสามารถมีหมายเลขที่จะทำซ้ำในตัวแปร):

หากคุณได้รับตัวแปรnที่ขยายไปยังหมายเลข (ไม่ใช่ลบ) และตัวแปรpatternเช่น

$ n=5
$ pattern=hello
$ printf -v output '%*s' "$n"
$ output=${output// /$pattern}
$ echo "$output"
hellohellohellohellohello

คุณสามารถสร้างฟังก์ชั่นด้วยสิ่งนี้:

repeat() {
    # $1=number of patterns to repeat
    # $2=pattern
    # $3=output variable name
    local tmp
    printf -v tmp '%*s' "$1"
    printf -v "$3" '%s' "${tmp// /$2}"
}

ด้วยชุดนี้:

$ repeat 5 hello output
$ echo "$output"
hellohellohellohellohello

สำหรับเคล็ดลับเล็ก ๆ นี้เราใช้printfมันค่อนข้างมากกับ:

• -v varname: แทนการพิมพ์ไปออกมาตรฐานจะใส่เนื้อหาของสตริงรูปแบบในตัวแปรprintfvarname
• '% * s': printfจะใช้อาร์กิวเมนต์เพื่อพิมพ์จำนวนช่องว่างที่สอดคล้องกัน เช่นprintf '%*s' 42จะพิมพ์ 42 ช่องว่าง
• สุดท้ายเมื่อเรามีจำนวนที่ต้องการของช่องว่างในตัวแปรของเราเราใช้การขยายตัวพารามิเตอร์เพื่อแทนที่ช่องว่างทั้งหมดตามรูปแบบของเรา: ${var// /$pattern}จะขยายไปยังการขยายตัวของที่มีช่องว่างทั้งหมดแทนที่ด้วยการขยายตัวของvar$pattern

คุณสามารถกำจัดtmpตัวแปรในrepeatฟังก์ชันโดยใช้การขยายทางอ้อม:

repeat() {
    # $1=number of patterns to repeat
    # $2=pattern
    # $3=output variable name
    printf -v "$3" '%*s' "$1"
    printf -v "$3" '%s' "${!3// /$2}"
}

#!/usr/bin/awk -f
BEGIN {
  OFS = "="
  NF = 100
  print
}

หรือ

#!/usr/bin/awk -f
BEGIN {
  while (z++ < 100) printf "="
}

ตัวอย่าง

ฉันเดาว่าจุดประสงค์ดั้งเดิมของคำถามก็คือทำสิ่งนี้ด้วยคำสั่งในตัวของเชลล์ ดังนั้นforloops และprintfs จะถูกต้องตามกฎหมายในขณะที่rep, perlและjotด้านล่างจะไม่ ยังคงคำสั่งดังต่อไปนี้

jot -s "/" -b "\\" $((COLUMNS/2))

ตัวอย่างเช่นพิมพ์บรรทัดกว้างของหน้าต่าง \/\/\/\/\/\/\/\/\/\/\/\/

ดังที่คนอื่น ๆ กล่าวไว้ในการขยาย bash braceนำหน้าการขยายพารามิเตอร์ดังนั้นช่วงสามารถมีได้เพียงตัวอักษรเท่านั้น และมอบโซลูชันที่สะอาด แต่ไม่สามารถพกพาได้อย่างสมบูรณ์จากระบบหนึ่งไปยังอีกระบบแม้ว่าคุณจะใช้เชลล์ตัวเดียวกันในแต่ละระบบ (แม้ว่าจะมีให้บริการเพิ่มมากขึ้นเช่นใน FreeBSD 9.3 และสูงกว่า ) และการอ้อมในรูปแบบอื่น ๆ มักจะใช้งานได้ แต่ไม่ค่อยมีความเหมาะสม{m,n}seqjotseqeval

โชคดีที่ทุบตีรองรับ C-style สำหรับลูป (ที่มีนิพจน์ทางคณิตศาสตร์เท่านั้น) ดังนั้นนี่คือวิธี "ทุบตีบริสุทธิ์" โดยย่อ:

repecho() { for ((i=0; i<$1; ++i)); do echo -n "$2"; done; echo; }

สิ่งนี้ใช้จำนวนการทำซ้ำเป็นอาร์กิวเมนต์แรกและสตริงที่จะทำซ้ำ (ซึ่งอาจเป็นอักขระเดียวเช่นเดียวกับในคำอธิบายปัญหา) เป็นอาร์กิวเมนต์ที่สอง repecho 7 bเอาต์พุตbbbbbbb(ถูกยกเลิกโดยขึ้นบรรทัดใหม่)

เดนนิสวิลเลียมสันให้เป็นหลักแก้ปัญหานี้สี่ปีที่ผ่านมาในคำตอบที่ดีเยี่ยมของเขาในการสร้างสายอักขระซ้ำในเชลล์สคริปต์ ฟังก์ชั่นร่างกายของฉันแตกต่างจากรหัสที่นั่นเล็กน้อย:

• เนื่องจากมุ่งเน้นที่นี่อยู่ในการทำซ้ำตัวเดียวและเปลือกเป็นทุบตีมันอาจจะปลอดภัยที่จะใช้แทนecho และผมอ่านคำอธิบายปัญหาที่เกิดขึ้นในคำถามนี้เช่นการแสดงการตั้งค่าการพิมพ์ด้วยprintf echoความหมายของฟังก์ชั่นข้างต้นทำงานในทุบตีและksh93 แม้ว่าprintfจะพกพาได้มากกว่า (และโดยปกติควรใช้กับสิ่งของประเภทนี้) แต่echoไวยากรณ์ของอ่านง่ายกว่า

  บางหอยechobuiltins ตีความ-ด้วยตัวเองเป็นตัวเลือก - แม้ว่าความหมายตามปกติของ-การใช้ stdin echoสำหรับการป้อนข้อมูลเป็นไร้สาระสำหรับ zshทำสิ่งนี้ และมีแน่นอนอยู่echoของที่ไม่รู้จัก-nเป็นมันไม่ได้มาตรฐาน (กระสุนสไตล์ Bourne จำนวนมากไม่ยอมรับ C-style สำหรับลูปเลยดังนั้นechoพฤติกรรมของพวกเขาไม่จำเป็นต้องพิจารณา .. )

• ที่นี่งานคือการพิมพ์ลำดับ; ตรงนั้นมันเป็นการกำหนดให้ตัวแปร

หาก$nเป็นจำนวนซ้ำที่ต้องการและคุณไม่ต้องใช้ซ้ำและคุณต้องการบางสิ่งที่สั้นกว่า:

while ((n--)); do echo -n "$s"; done; echo

nต้องเป็นตัวแปร - วิธีนี้ใช้ไม่ได้กับพารามิเตอร์ตำแหน่ง $sเป็นข้อความที่จะต้องทำซ้ำ

Python แพร่หลายและทำงานได้ทุกที่

python -c "import sys; print('*' * int(sys.argv[1]))" "=" 100

ตัวละครและการนับจะถูกส่งเป็นพารามิเตอร์แยกต่างหาก

ใน bash 3.0 หรือสูงกว่า

for i in {1..100};do echo -n =;done

อีกวิธีหนึ่งในการทำซ้ำสตริงโดยพลการ n ครั้ง:

ข้อดี:

• ทำงานร่วมกับ POSIX เชลล์
• สามารถกำหนดเอาต์พุตให้กับตัวแปรได้
• ทำซ้ำสตริงใด ๆ
• เร็วมากถึงแม้จะมีการทำซ้ำขนาดใหญ่มาก

จุดด้อย:

• ต้องการyesคำสั่งของ Gnu Core Utils

#!/usr/bin/sh
to_repeat='='
repeat_count=80
yes "$to_repeat" | tr -d '\n' | head -c "$repeat_count"

ด้วยเทอร์มินัล ANSI และอักขระ US-ASCII เพื่อทำซ้ำ คุณสามารถใช้ลำดับ escape ของ ANSI CSI มันเป็นวิธีที่เร็วที่สุดในการทำซ้ำตัวละคร

#!/usr/bin/env bash

char='='
repeat_count=80
printf '%c\e[%db' "$char" "$repeat_count"

หรือแบบคงที่:

พิมพ์บรรทัด 80 ครั้ง=:

printf '=\e[80b\n'

ข้อ จำกัด :

• ไม่ใช่เทอร์มินัลทั้งหมดที่เข้าใจrepeat_charลำดับ ANSI CSI
• สามารถทำซ้ำอักขระ ISO-ASCII หรือไบต์เดียวเท่านั้น
• หยุดซ้ำที่คอลัมน์สุดท้ายดังนั้นคุณสามารถใช้ค่าขนาดใหญ่เพื่อเติมทั้งบรรทัดได้โดยไม่คำนึงถึงความกว้างของเทอร์มินัล
• การทำซ้ำมีไว้สำหรับแสดงผลเท่านั้น การบันทึกเอาต์พุตลงในตัวแปรเชลล์จะไม่ขยายrepeat_charลำดับ ANSI CSI เป็นอักขระซ้ำ

นี่คือสิ่งที่ฉันใช้พิมพ์บรรทัดของอักขระผ่านหน้าจอใน linux (ตามความกว้างของหน้าจอเทอร์มินัล / หน้าจอ)

พิมพ์ "=" ผ่านหน้าจอ:

printf '=%.0s' $(seq 1 $(tput cols))

คำอธิบาย:

พิมพ์เครื่องหมายเท่ากับหลาย ๆ ครั้งตามลำดับที่กำหนด:

printf '=%.0s' #sequence

ใช้เอาต์พุตของคำสั่ง (นี่คือคุณลักษณะทุบตีที่เรียกว่าการทดแทนคำสั่ง):

$(example_command)

ให้ลำดับฉันใช้ 1 ถึง 20 เป็นตัวอย่าง ในคำสั่งสุดท้ายคำสั่ง tput จะถูกใช้แทน 20:

seq 1 20

ระบุจำนวนคอลัมน์ที่ใช้ในเทอร์มินัลในปัจจุบัน:

tput cols

for i in {1..100}
do
  echo -n '='
done
echo

repeat() {
    # $1=number of patterns to repeat
    # $2=pattern
    printf -v "TEMP" '%*s' "$1"
    echo ${TEMP// /$2}
}

ที่ง่ายที่สุดคือการใช้หนึ่งซับใน csh / tcsh นี้:

printf "%50s\n" '' | tr '[:blank:]' '[=]'

ทางเลือกที่หรูหรากว่าสำหรับโซลูชัน Python ที่เสนออาจเป็น:

python -c 'print "="*(1000)'

ในกรณีที่คุณต้องการทำซ้ำตัวอักษร n ครั้งเป็น na จำนวนครั้งที่หลากหลายขึ้นอยู่กับความยาวของสตริงที่คุณสามารถทำได้:

#!/bin/bash
vari='AB'
n=$(expr 10 - length $vari)
echo 'vari equals.............................: '$vari
echo 'Up to 10 positions I must fill with.....: '$n' equal signs'
echo $vari$(perl -E 'say "=" x '$n)

มันแสดง:

vari equals.............................: AB  
Up to 10 positions I must fill with.....: 8 equal signs  
AB========  

นี่เป็นเวอร์ชันที่ยาวกว่าของสิ่งที่ Eliah Kagan ได้รับมอบหมาย:

while [ $(( i-- )) -gt 0 ]; do echo -n "  "; done

แน่นอนคุณสามารถใช้ printf สำหรับสิ่งนั้นได้เช่นกัน แต่ก็ไม่ได้ตามความชอบของฉัน:

printf "%$(( i*2 ))s"

เวอร์ชันนี้รองรับ Dash:

until [ $(( i=i-1 )) -lt 0 ]; do echo -n "  "; done

โดยที่ฉันเป็นหมายเลขเริ่มต้น

function repeatString()
{
    local -r string="${1}"
    local -r numberToRepeat="${2}"

    if [[ "${string}" != '' && "${numberToRepeat}" =~ ^[1-9][0-9]*$ ]]
    then
        local -r result="$(printf "%${numberToRepeat}s")"
        echo -e "${result// /${string}}"
    fi
}

ตัวอย่างการวิ่ง

$ repeatString 'a1' 10 
a1a1a1a1a1a1a1a1a1a1

$ repeatString 'a1' 0 

$ repeatString '' 10 

อ้างอิง lib ที่: https://github.com/gdbtek/linux-cookbooks/blob/master/lไลบรารี/util.bash

ฉันจะทำสิ่งนี้ด้วยเสียงสะท้อนได้อย่างไร

คุณสามารถทำได้ด้วยechoหากechoมีการติดตามด้วยsed:

echo | sed -r ':a s/^(.*)$/=\1/; /^={100}$/q; ba'

จริงๆแล้วechoมันไม่จำเป็นเลย

คำตอบของฉันค่อนข้างซับซ้อนและอาจไม่สมบูรณ์แบบ แต่สำหรับผู้ที่ต้องการส่งออกจำนวนมากฉันสามารถทำประมาณ 10 ล้านใน 3 วินาที

repeatString(){
    # argument 1: The string to print
    # argument 2: The number of times to print
    stringToPrint=$1
    length=$2

    # Find the largest integer value of x in 2^x=(number of times to repeat) using logarithms
    power=`echo "l(${length})/l(2)" | bc -l`
    power=`echo "scale=0; ${power}/1" | bc`

    # Get the difference between the length and 2^x
    diff=`echo "${length} - 2^${power}" | bc`

    # Double the string length to the power of x
    for i in `seq "${power}"`; do 
        stringToPrint="${stringToPrint}${stringToPrint}"
    done

    #Since we know that the string is now at least bigger than half the total, grab however many more we need and add it to the string.
    stringToPrint="${stringToPrint}${stringToPrint:0:${diff}}"
    echo ${stringToPrint}
}

ที่ง่ายที่สุดคือการใช้หนึ่งซับในทุบตี:

seq 10 | xargs -n 1 | xargs -I {} echo -n  ===\>;echo

อีกตัวเลือกหนึ่งคือการใช้ GNU seq และลบหมายเลขและบรรทัดใหม่ทั้งหมดที่สร้าง:

seq -f'#%.0f' 100 | tr -d '\n0123456789'

คำสั่งนี้พิมพ์#ตัวอักษร 100 ครั้ง

โซลูชันที่มีอยู่ส่วนใหญ่ทั้งหมดขึ้นอยู่กับ{1..10}การสนับสนุนทางไวยากรณ์ของเชลล์ซึ่งเป็นbash- และzsh- เจาะจงและไม่ทำงานในtcshหรือ OpenBSD's kshและ non-bash ส่วนใหญ่shและส่วนใหญ่ไม่ใช่ทุบตี

ข้อมูลต่อไปนี้ควรใช้กับ OS X และระบบ * BSD ทั้งหมดในเชลล์ใด ๆ ในความเป็นจริงมันสามารถใช้ในการสร้างเมทริกซ์พื้นที่ตกแต่งประเภทต่างๆ:

$ printf '=%.0s' `jot 64` | fold -16
================
================
================
================$ 

น่าเศร้าที่เราไม่ได้ขึ้นบรรทัดใหม่ ซึ่งสามารถแก้ไขได้โดยการเสริมprintf '\n'หลังจากการพับ:

$ printf "=%.0s" `jot 64` | fold -16 ; printf "\n"
================
================
================
================
$ 

อ้างอิง:

• http://mdoc.su/-/printf.1
• http://mdoc.su/-/jot.1
• http://mdoc.su/-/fold.1

ข้อเสนอของฉัน (ยอมรับค่าตัวแปรสำหรับ n):

n=100
seq 1 $n | xargs -I {} printf =