Bunu nasıl yapabilirim echo?

perl -E 'say "=" x 100'

Kullanabilirsiniz:

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

Bu nasıl çalışır:

Bash {1..100} 'i genişletir, böylece komut şöyle olur:

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

Printf'in formatını ayarladım =%.0s, yani =hangi argümanın verildiğine bakılmaksızın her zaman tek bir baskı yapacak . Bu nedenle 100 =s yazdırır .

Kolay yolu yok. Ancak, örneğin:

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

Ya da belki standartlara uygun bir yol:

printf %100s |tr " " "="

Bir de var tput rep, ama eldeki terminallerim için (xterm ve linux) desteklemiyorlar :)

^{@ Gniourf_gniourf girişi için şapka ucu .}

Not: Bu cevap vermez değil orijinal soruya cevap ancak tamamlar tarafından mevcut, faydalı cevaplar performansını karşılaştıran .

Çözümler edilir sadece yürütme hızı açısından karşılaştırıldığında - bellek gereksinimleri vardır değil hesabı (onlar çözümleri arasında farklılık ve büyük tekrarlama sayıları ile fark olabilir) önünde.

Özet:

• Senin Eğer tekrar sayısıdır küçük , yaklaşık 100, 's kadar söylemek değer ile devam Bash okunur çözümleri başlangıç dış kamu konuların maliyet özellikle Perl en gibi.
  • Pragmatik olarak söylemek gerekirse, tekrarlayan karakterlerin yalnızca bir örneğine ihtiyacınız varsa , mevcut tüm çözümler iyi olabilir.
• İle büyük tekrarlama sayıları , kullanmak ek programlar onlar çok daha hızlı olacak gibi.
  • Özellikle, Bash'in büyük dizelerle
    (örn. ${var// /=}) Küresel alt dize değiştirme işleminden kaçınılmalıdır , çünkü yasaklanmıştır.

Aşağıdaki zamanlamalar OSX 10.10.4 ve bash 3.2.57 çalıştıran bir 3.2 GHz Intel Core i5 CPU ve Fusion Drive, bir geç-2012 iMac alınan ve 1000 koşular ortalamasıdır.

Girişler:

• artan yürütme süresine göre listelenir (en hızlısı önce)
• ön ekiyle birlikte:
  • M... potansiyel olarak çok karakterli bir çözüm
  • S... tek karakterli bir çözüm
  • P ... POSIX uyumlu bir çözüm
• ardından çözümün kısa bir açıklaması
• kaynak cevap yazarı adı ile sonek

• Küçük tekrar sayısı: 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

• Sadece Bash çözümleri paketi yönetir - ancak bu tekrar küçük sayılır! (aşağıya bakınız).
• Dış hizmetlerin başlangıç ​​maliyeti, özellikle Perl'ler için önemlidir. Bunu bir döngüde çağırmanız gerekiyorsa - her yinelemede küçük tekrar sayıları ile - çoklu yardımcı programdan awkve perlçözümlerden kaçının .

• Büyük tekrar sayısı: 1000000 (1 milyon)

[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

• Sorunun Perl çözümü çok hızlı.
• Bash'in küresel dize değiştirme ( ${foo// /=}), büyük dizelerle açıklanamaz derecede yavaştır ve Bash 4.3.30'da (50 dakika (!) Ve Bash 3.2.57'de daha da uzun sürdü - hiç beklemedim bitirmek için).
• Bash döngüleri yavaştır ve aritmetik döngüler ( (( i= 0; ... ))) küme ayracı genişletilmiş olanlardan ( {1..n}) daha yavaştır - aritmetik döngüler daha fazla bellek verimlidir.
• awkanlamına gelir BSD awk (ayrıca OSX'te bulunduğu gibi) - gözle görülür şekilde daha yavaş olduğunu gawk(GNU AWK) ve özelliklemawk .
• Büyük sayılar ve çoklu karakter ile unutmayın. bellek tüketimi dikkate alınabilir - yaklaşımlar bu açıdan farklılık gösterir.

İşte Bash komut ( testrepeatyukarıda üretilen). 2 argüman alır:

• karakter tekrar sayısı
• isteğe bağlı olarak, ortalama zamanlamayı hesaplamak ve hesaplamak için test çalıştırması sayısı

Başka bir deyişle: yukarıdaki zamanlamalar testrepeat 100 1000vetestrepeat 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

Bunu yapmanın birden fazla yolu var.

Bir döngü kullanma:

• Brace genişletmesi tamsayı değişmez değerleri ile kullanılabilir:

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

• C benzeri bir döngü değişkenlerin kullanımına izin verir:

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

Yerleşik kullanımı printf:

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

Burada bir hassasiyet belirtilmesi, dizeyi belirtilen genişliğe ( 0) uyacak şekilde keser . Gibi printftekrar kullanım biçimi dize bu basitçe yazdırır tüm argüman tüketmeye "="100 kez.

Kullanılması head( printfvs) ve tr:

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

Ben seq kullanarak bunu yapmak için çok kolay bir yol buldum:

GÜNCELLEME: Bu seq, OS X ile birlikte gelen BSD'de çalışır.YMMV diğer sürümlerle birlikte

seq  -f "#" -s '' 10

'#' 10 kez yazdıracak, şöyle:

##########

• -f "#"biçim dizesini sayıları yok saymak ve #her biri için yazdırmak üzere ayarlar .
• -s '' her sayı arasına eklenen satırları kaldırmak için ayırıcıyı boş bir dizeye ayarlar
• Sonraki boşluklar -fve -sönemli gibi görünüyor.

EDIT: İşte kullanışlı bir işlevi var ...

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

Buna şöyle diyebilirsiniz ...

repeat "#" 10

NOT: Tekrarlıyorsanız #, tırnak işaretleri önemlidir!

İşte iki ilginç yol:

ubuntu @ ubuntu: ~ $ evet = | kafa -10 | yapıştır -s -d '' -
==========
ubuntu @ ubuntu: ~ $ evet = | kafa -10 | tr -d "\ n"
========== ubuntu @ ubuntu: ~ $ 

Bu ikisinin son derece farklı olduğuna dikkat edin - pasteYöntem yeni bir satırda sona erer. trYöntem değildir.

Basit bir yolu yok. Kullanarak printfve değiştirerek döngülerden kaçının .

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

Eğer farklı uygulamaları üzerinden POSIX uyumu ve tutarlılığı istiyorsanız echove printfdiğeri sadece daha ve / veya kabukları 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'hemen hemen her yerde aynı çıktıyı üretecek .

Soru, bunun nasıl yapılacağıydı echo:

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

Bu irade tamamen aynı yapacak perl -E 'say "=" x 100'fakat echosadece.

evalAlt kabukları, harici araçları, küme ayracı genişletmeleri olmayan saf bir Bash yolu (yani, bir değişkente yinelenecek numaraya sahip olabilirsiniz):

Size n(negatif olmayan) bir sayıya genişleyen bir değişken patternve örneğin,

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

Bununla bir işlev yapabilirsiniz:

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

Bu set ile:

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

Bu küçük hile için aşağıdakileri çok kullanıyoruz printf:

• -v varname: standart çıktıya yazdırmak yerine printf, biçimlendirilmiş dizenin içeriğini değişkene koyacaktır varname.
• '% * s': printfbağımsız değişkeni karşılık gelen boşluk sayısını yazdırmak için kullanır. Örneğin, printf '%*s' 4242 boşluk basacaktır.
• Son olarak, değişkenimizde istenen sayıda boşluk olduğunda, tüm boşlukları modelimizle değiştirmek için bir parametre genişletmesi kullanırız: ${var// /$pattern}genişlemesine, genişlemesinin varyerini alan tüm boşluklarla genişler $pattern.

Dolaylı genişletmeyi kullanarak işlevdeki tmpdeğişkenten de kurtulabilirsiniz 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
}

Veya

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

Misal

Sorunun asıl amacı bunu sadece kabuğun yerleşik komutlarıyla yapmaktı. Yani fordöngüler ve printfs, meşru olurdu süre rep, perlve ayrıca jotaşağıda olmaz. Yine de, aşağıdaki komut

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

örneğin, bir pencere genişliğinde \/\/\/\/\/\/\/\/\/\/\/\/

Diğerlerinin söylediği gibi, bash ayracı genişletmesinde parametre genişletmesinden önce gelir , bu nedenle aralıklar yalnızca değişmez değerler içerebilir. ve temiz çözümler sunar ancak her birinde aynı kabuğu kullansanız bile bir sistemden diğerine tamamen taşınabilir değildir. (Her ne kadar artan bir şekilde mevcut olsa da; örneğin, FreeBSD 9.3 ve üstü sürümlerde ) ve diğer dolaylı biçimler her zaman işe yarar, ancak bir şekilde yetersizdir.{m,n}seqjotseqeval

Neyse ki, bash döngüler için C stilini destekler (yalnızca aritmetik ifadelerle). İşte özlü bir "saf bash" yolu:

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

Bu, ilk bağımsız değişken olarak tekrar sayısını ve ikinci bağımsız değişken olarak tekrarlanacak dizeyi (sorun açıklamasında olduğu gibi tek bir karakter olabilir) alır. repecho 7 bçıktılar bbbbbbb(bir satırsonu ile sonlandırılır).

Dennis Williamson verdi onun mükemmel cevap dört yıl önce esasen bu çözümü için kabuk komut dosyası tekrarlanan karakter dizesini oluşturma . Benim işlev gövdesi orada kod biraz farklıdır:

• Buradaki odak tek bir karakteri tekrarlamak ve kabuk bash olduğundan, muhtemelen echoyerine kullanmak güvenlidir printf. Ve bu sorudaki sorun tanımını yazdırmayı tercih ettiğini ifade ediyorum echo. Yukarıdaki fonksiyon tanımı bash ve ksh93 ile çalışır . Her ne kadar printfdaha taşınabilir olsa da (ve genellikle bu tür şeyler için kullanılmalıdır), echosözdizimi muhtemelen daha okunabilirdir.

  Bazı mermilerin echoyapıları -tek başına bir seçenek olarak yorumlanır - her ne kadar -giriş için stdin kullanmak anlamsız olsa da echo. zsh bunu yapar. Ve kesinlikle orada mevcut echotanımaz s -nolarak, standart değildir . (Bourne tarzı mermilerin çoğu döngüler için C-stili kabul etmezler, bu nedenle echodavranışlarının dikkate alınması gerekmez.)

• Burada görev diziyi yazdırmak; orada bir değişkene atamaktı.

Eğer $ntekrar istenilen sayı ve bunu yeniden gerekmez, ve hatta daha kısa bir şey istiyorum:

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

ndeğişken olmalıdır - bu şekilde konumsal parametrelerle çalışmaz. $stekrarlanacak metindir.

Python her yerde bulunur ve her yerde aynı şekilde çalışır.

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

Karakter ve sayı ayrı parametreler olarak iletilir.

Bash 3.0 veya üstü sürümlerde

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

Rasgele bir dizeyi n kez tekrarlamanın başka bir anlamı:

Artıları:

• POSIX kabuğu ile çalışır.
• Çıktı bir değişkene atanabilir.
• Herhangi bir dizeyi tekrarlar.
• Çok büyük tekrarlarla bile çok hızlı.

Eksileri:

• Gnu Core Utils'in yeskomutunu gerektirir .

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

Bir ANSI terminali ve US-ASCII karakterleri ile tekrarlayın. Bir ANSI CSI kaçış dizisi kullanabilirsiniz. Bir karakteri tekrar etmenin en hızlı yoludur.

#!/usr/bin/env bash

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

Veya statik olarak:

80 kez bir satır yazdırın =:

printf '=\e[80b\n'

Sınırlamalar:

• Tüm terminaller repeat_charANSI CSI dizisini anlamaz .
• Yalnızca US-ASCII veya tek baytlık ISO karakterleri tekrarlanabilir.
• Son sütunda tekrar durur, böylece terminal genişliğinden bağımsız olarak tüm bir satırı doldurmak için büyük bir değer kullanabilirsiniz.
• Tekrarlama yalnızca görüntüleme içindir. Çıktıyı bir kabuk değişkenine yakalamak repeat_charANSI CSI dizisini tekrarlanan karaktere genişletmez .

Linux'ta ekran boyunca bir karakter satırı yazdırmak için kullandığım şey (terminal / ekran genişliğine göre)

Ekranda "=" yazdırın:

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

Açıklama:

Belirtilen sırayla eşit sayıda işaret yazdırın:

printf '=%.0s' #sequence

Bir komutun çıkışını kullanın (bu, Komut Değiştirme olarak adlandırılan bir bash özelliğidir):

$(example_command)

Bir dizi verin, örnek olarak 1'den 20'ye kadar kullandım. Son komutta 20 yerine tput komutu kullanılır:

seq 1 20

Terminalde şu anda kullanılan sütun sayısını verin:

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

En basit olanı bu tek astarı csh / tcsh'de kullanmaktır:

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

Önerilen Python çözümüne daha zarif bir alternatif olabilir:

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

Örneğin, yapabileceğiniz bir dizenin uzunluğuna bağlı olarak bir karakteri n kez DEĞİŞKEN olmak üzere tekrarlamak istediğinizde:

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

Görüntüleniyor:

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

Eliah Kagan'ın benimsediği şeyin daha uzun versiyonu:

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

Elbette bunun için printf kullanabilirsiniz, ancak benim zevkime göre değil:

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

Bu sürüm Dash uyumludur:

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

ben ilk sayı olmak.

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
}

Örnek çalışmalar

$ repeatString 'a1' 10 
a1a1a1a1a1a1a1a1a1a1

$ repeatString 'a1' 0 

$ repeatString '' 10 

Referans lib: https://github.com/gdbtek/linux-cookbooks/blob/master/libraries/util.bash

Bunu yankı ile nasıl yapabilirim?

Bunu , ardından echogelirse yapabilirsiniz :echosed

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

Aslında, bu echogereksiz.

Cevabım biraz daha karmaşık ve muhtemelen mükemmel değil, ancak çok sayıda çıktı almak isteyenler için 3 saniyede yaklaşık 10 milyon yapmayı başardım.

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

En basit olanı, bu tek astarı bash'de kullanmaktır:

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

Başka bir seçenek GNU seq kullanmak ve oluşturduğu tüm sayıları ve yeni satırları kaldırmaktır:

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

Bu komut #karakteri 100 kez yazdırır .

Mevcut çözümlerin çoğu {1..10}, kabuğun sözdizimi desteğine bağlıdır ; bu bash- ve zsh- spesifiktir ve tcshOpenBSD'lerde kshve çoğu bash içinde çalışmazsh .

Aşağıdakiler OS X ve tüm * BSD sistemleri üzerinde herhangi bir kabukta çalışmalıdır; aslında, çeşitli dekoratif alan türlerinden oluşan bir bütün matris oluşturmak için kullanılabilir:

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

Ne yazık ki, sondaki yeni bir satır almıyoruz; printf '\n'kattan sonra ekstra bir şekilde sabitlenebilir :

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

Referanslar:

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

Teklifim ( n için değişken değerleri kabul etmek ):

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