it-swarm.com.de

Wie kann ich einen Charakter in Bash wiederholen?

Wie kann ich das mit echo machen?

Perl -E 'say "=" x 100'
181
sid_com

Sie können verwenden:

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

Wie das funktioniert:

Bash erweitert {1..100}, sodass der Befehl wie folgt lautet:

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

Ich habe das Format von printf auf =%.0s gesetzt, was bedeutet, dass immer ein einziger = ausgegeben wird, unabhängig davon, welches Argument angegeben wird. Daher werden 100 =s gedruckt.

307
dogbane

Kein einfacher Weg. Aber zum Beispiel:

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

Oder vielleicht eine normkonforme Methode:

printf %100s |tr " " "="

Es gibt auch einen tput rep, aber was meine Terminals (xterm und linux) angeht, so scheinen sie es nicht zu unterstützen :)

75
user332325

Tipp des Hutes an @ gniourf_gniourf für seine Eingabe.

Hinweis: Diese Antwort beantwortet nicht die ursprüngliche Frage, aber ergänzt die vorhandenen, hilfreichen Antworten von Vergleich der Leistung.

Lösungen werden nur in Bezug auf die Ausführungsgeschwindigkeit verglichen - Speicheranforderungen werden nicht berücksichtigt (sie variieren je nach Lösung und kann mit großen Wiederholungszahlen von Bedeutung sein).

Zusammenfassung:

  • Wenn Ihre Wiederholungszahl small ist, sagen Sie bis zu 100, es ist Es lohnt sich, Nur-Bash-Lösungen zu wählen, da die Startkosten für externe Dienstprogramme, insbesondere für Perl, von Bedeutung sind.
    • Pragmatisch gesehen sind jedoch alle vorhandenen Lösungen in Ordnung, wenn Sie nur one Instanzen von sich wiederholenden Zeichen benötigen.
  • Mit groß Wiederholungszählungen verwenden Sie externe Dienstprogramme, da sie viel schneller sein werden.
    • Vermeiden Sie insbesondere das Ersetzen der globalen Teilzeichenfolge von Bash durch große Zeichenfolgen
      (z.B., ${var// /=}), da es unerschwinglich langsam ist.

Das Folgende sind Timings , die auf einem iMac von Ende 2012 mit einer Intel Core i5-CPU mit 3,2 GHz und einem Fusion-Laufwerk unter OSX 10.10.4 und Bash 3.2 erstellt wurden .57 und sind der Durchschnitt von 1000 Läufen.

Die Einträge sind:

  • in aufsteigender Reihenfolge der Ausführungsdauer aufgeführt (schnellste zuerst)
  • vorangestellt mit:
    • M ... eine potenziell multi - zeichenbehaftete Lösung
    • S ... a single - Nur-Zeichen-Lösung
    • P ... eine POSIX-kompatible Lösung
  • gefolgt von einer kurzen Beschreibung der Lösung
  • angefügt mit dem Namen des Autors der ursprünglichen Antwort

  • Kleine Wiederholungszahl: 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
  • Die Bash-only-Lösungen sind führend - aber nur mit einer Wiederholungszahl, die so klein ist! (siehe unten).
  • Hier spielen die Startkosten externer Dienstprogramme eine Rolle, insbesondere die von Perl. Wenn Sie dies in einer Schleife aufrufen müssen - mit small Wiederholungszählern in jeder Iteration - vermeiden Sie die Multi-Utility-, awk- und Perl -Lösungen.

  • Große Wiederholungszahl: 1000000 (1 Million)
[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
  • Die Perl-Lösung von der Frage ist bei weitem die schnellste.
  • Bashs globaler String-Ersatz (${foo// /=}) ist unerklärlich langsam mit großen Saiten und wurde aus dem Rennen genommen (hat in Bash 4.3.30 ungefähr 50 Minuten (!) und in Bash 3.2.57 noch länger gedauert - ich habe nie darauf gewartet, dass es zu Ende ist) .
  • Bash-Schleifen sind langsam und arithmetische Schleifen ((( i= 0; ... ))) sind langsamer als geschweifte ({1..n}) - obwohl arithmetische Schleifen speichereffizienter sind.
  • awk bezieht sich auf [~ # ~] bsd [~ # ~]awk (wie auch unter OSX) - es ist merklich langsamer als gawk (GNU Awk) und insbesondere mawk.
  • Beachten Sie, dass mit großen Zählern und Multi-Char. Strings kann der Speicherverbrauch eine Überlegung werden - die Ansätze unterscheiden sich in dieser Hinsicht.

Hier ist das Bash-Skript (testrepeat), das das oben Genannte erzeugt hat. Es braucht 2 Argumente:

  • die Anzahl der Zeichenwiederholungen
  • optional die Anzahl der durchzuführenden Testläufe und die Berechnung des Durchschnitts Timings aus

Mit anderen Worten: Die obigen Timings wurden mit testrepeat 100 1000 und 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
41
mklement0

Es gibt mehr als eine Möglichkeit, dies zu tun. 

Verwenden einer Schleife:

  • Die Stützenerweiterung kann mit ganzzahligen Literalen verwendet werden:

    for i in {1..100}; do echo -n =; done    
    
  • Eine C-ähnliche Schleife ermöglicht die Verwendung von Variablen: 

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

Verwenden der printf builtin:

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

Wenn Sie hier eine Genauigkeit angeben, wird der String auf die angegebene Breite (0) gekürzt. Da printf die Formatzeichenfolge wiederverwendet, um alle Argumente zu verwenden, wird "=" einfach 100 Mal gedruckt.

Verwendung von head (printf usw.) und tr:

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

Ich habe gerade einen wirklich einfachen Weg gefunden, dies mit seq zu tun:

UPDATE: Dies funktioniert auf der BSD seq, die in OS X enthalten ist. YMMV mit anderen Versionen

seq  -f "#" -s '' 10

Wird '#' 10 Mal so gedruckt:

##########
  • -f "#" setzt die Formatzeichenfolge, um die Zahlen zu ignorieren und einfach # für jede zu drucken.
  • -s '' setzt das Trennzeichen auf eine leere Zeichenfolge, um die Zeilenumbrüche zu entfernen, die seq zwischen den einzelnen Zahlen einfügt
  • Die Leerzeichen nach -f und -s scheinen wichtig zu sein.

EDIT: Hier ist es eine praktische Funktion ...

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

Was kannst du so nennen ...

repeat "#" 10

HINWEIS: Wenn Sie # wiederholen, sind die Anführungszeichen wichtig!

25
Sam Salisbury

Hier sind zwei interessante Wege:

 ubuntu @ ubuntu: ~ $ yes = | Kopf -10 | Einfügen -s -d '' -
 ========== 
 ubuntu @ ubuntu: ~ $ yes = | Kopf -10 | tr -d "\ n" 
 ========== ubuntu @ ubuntu: ~ $ 

Beachten Sie, dass sich diese beiden geringfügig unterscheiden - Die paste-Methode endet in einer neuen Zeile. Die tr-Methode funktioniert nicht.

16
Digital Trauma

Es gibt keinen einfachen Weg. Vermeiden Sie Schleifen mit printf und Substitution.

str=$(printf "%40s")
echo ${str// /rep}
# echoes "rep" 40 times.
11
Tim
#!/usr/bin/awk -f
BEGIN {
  OFS = "="
  NF = 100
  print
}

Oder

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

Beispiel

7
Steven Penny

Wenn Sie POSIX-Konformität und Konsistenz für verschiedene Implementierungen von echo und printf und/oder andere Shells als nur bash wünschen:

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)

... erzeugt fast überall dieselbe Ausgabe wie Perl -E 'say "=" x 100'.

5
Geoff Nixon

Ich denke, der ursprüngliche Zweck der Frage bestand darin, dies nur mit den eingebauten Befehlen der Shell zu tun. Also wären for Schleifen und printf legitim, während rep, Perl und auch jot darunter nicht legitim wären. Immer noch der folgende Befehl

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

druckt beispielsweise eine fensterweite Zeile mit \/\/\/\/\/\/\/\/\/\/\/\/

4
Stefan Ludwig

Wie andere schon gesagt haben, in bash brace expansion precedes parameter expansion können {m,n}-Bereiche nur Literale enthalten. seq und jot bieten saubere Lösungen, sind jedoch nicht vollständig von einem System zum anderen portierbar, selbst wenn Sie die gleiche Shell auf jedem verwenden. (Obwohl seq zunehmend verfügbar ist; z. B. in FreeBSD 9.3 und höher .) eval und andere Formen der Dereferenzierung funktionieren immer, sind jedoch etwas unelegant.

Zum Glück unterstützt bash für Loops den C-Stil (nur bei arithmetischen Ausdrücken). Hier ist also ein prägnanter "pure bash" Weg:

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

Dabei wird die Anzahl der Wiederholungen als erstes Argument und die zu wiederholende Zeichenfolge (die wie in der Problembeschreibung ein einzelnes Zeichen sein kann) als zweites Argument verwendet. repecho 7 b gibt bbbbbbb aus (wird durch eine Newline beendet).

Dennis Williamson gab im Wesentlichen diese Lösung vor vier Jahren in seiner ausgezeichneten Antwort to Erstellen von Zeichenfolgen aus sich wiederholenden Zeichen in Shell-Skript . Mein Funktionskörper unterscheidet sich etwas vom Code dort:

  • Da der Schwerpunkt hier auf der Wiederholung eines einzelnen Zeichens liegt und die Shell bash ist, ist es wahrscheinlich sicher, echo anstelle von printf zu verwenden. Und ich las die Problembeschreibung in dieser Frage als Ausdruck einer Präferenz für das Drucken mit echo. Die obige Funktionsdefinition funktioniert in bash und ksh93 . Obwohl printf portabler ist (und normalerweise für diese Art von Dingen verwendet werden sollte), ist die Syntax von echo wohl lesbarer.

    Einige echo builtins von Shells interpretieren - als Option - selbst wenn die übliche Bedeutung von -, stdin für die Eingabe zu verwenden, für echo nicht sinnvoll ist. zsh macht das. Und es gibt definitiv echos, die -n nicht erkennen, da es ist kein Standard . (Viele Bourne-Style-Shells akzeptieren keine C-Styles für Loops, daher muss ihr echo-Verhalten nicht berücksichtigt werden.)

  • Hier besteht die Aufgabe darin, die Sequenz auszudrucken; dort war es, es einer Variablen zuzuweisen.

Wenn $n die gewünschte Anzahl von Wiederholungen ist, müssen Sie sie nicht wiederverwenden, und Sie möchten etwas noch kürzer:

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

n muss eine Variable sein - dieser Weg funktioniert nicht mit Positionsparametern. $s ist der Text, der wiederholt werden soll.

4
Eliah Kagan

Ein reiner Bash-Weg ohne eval, keine Subshells, keine externen Werkzeuge, keine Klammererweiterungen (d. H. Sie können die zu wiederholende Nummer in einer Variablen haben):

Wenn Sie eine Variable n erhalten, die sich zu einer (nicht negativen) Zahl erweitert, und eine Variable pattern, z.

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

Sie können damit eine Funktion erstellen:

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

Mit diesem Set:

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

Für diesen kleinen Trick verwenden wir printf ziemlich häufig mit:

  • -v varname: Anstatt in der Standardausgabe zu drucken, wird printf den Inhalt der formatierten Zeichenfolge in die Variable varname einfügen.
  • '% * s': printf verwendet das Argument, um die entsprechende Anzahl von Leerzeichen zu drucken. Zum Beispiel werden printf '%*s' 42 42 Leerzeichen gedruckt.
  • Wenn wir schließlich die gewünschte Anzahl von Leerzeichen in unserer Variablen haben, verwenden wir eine Parametererweiterung, um alle Leerzeichen durch unser Muster zu ersetzen: ${var// /$pattern} erweitert sich auf die Erweiterung von var, wobei alle Leerzeichen durch die Erweiterung von $pattern ersetzt werden.

Sie können die Variable tmp in der Funktion repeat auch loswerden, indem Sie die indirekte Erweiterung verwenden:

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

In bash 3.0 oder höher

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

Die Frage war, wie es mit echo geht:

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

Dies wird genau wie Perl -E 'say "=" x 100' geschehen, jedoch nur mit echo.

1
chevallier

Dies ist die längere Version von Eliah Kagan:

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

Natürlich können Sie printf auch dafür verwenden, aber nicht wirklich nach meinem Geschmack:

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

Diese Version ist Dash-kompatibel:

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

wobei ich die erste Nummer ist.

1
Xennex81

Eine elegantere Alternative zur vorgeschlagenen Python-Lösung könnte sein:

python -c 'print "="*(1000)'
1
Anas Tiour

Wie könnte ich das mit Echo tun?

Sie können dies mit echo tun, wenn auf echosed folgt:

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

Eigentlich ist der echo dort nicht notwendig.

1
DaBler

Für den Fall, dass Sie ein Zeichen n-mal wiederholen möchten, wobei es sich nicht um eine VARIABLE-Anzahl handelt, die von der Länge einer Zeichenfolge abhängt: 

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

Es zeigt an:

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

Eine andere Möglichkeit besteht darin, GNU seq zu verwenden und alle generierten Zahlen und Zeilenumbrüche zu entfernen:

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

Dieser Befehl gibt das Zeichen # 100 Mal aus.

0
sigalor

Die meisten vorhandenen Lösungen hängen alle von der Syntaxunterstützung von {1..10} der Shell ab, die bash- und zsh- spezifisch ist und in tcsh- oder OpenBSDs ksh und den meisten Nicht-Bash sh nicht funktioniert.

Das Folgende sollte auf OS X und allen * BSD-Systemen in einer beliebigen Shell funktionieren. Tatsächlich kann damit eine ganze Matrix verschiedener Arten von dekorativen Räumen erzeugt werden:

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

Leider erhalten wir keinen nachgestellten Zeilenumbruch. was durch einen zusätzlichen printf '\n' nach der Falte behoben werden kann:

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

Verweise:

0
cnst

Python ist allgegenwärtig und funktioniert überall gleich.

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

Zeichen und Anzahl werden als separate Parameter übergeben.

0
loevborg

Meine Antwort ist etwas komplizierter und wahrscheinlich nicht perfekt, aber für diejenigen, die große Zahlen ausgeben möchten, konnte ich in drei Sekunden rund 10 Millionen erreichen.

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}
}
0
Silver Ogre

Am einfachsten ist es, diesen Einzeiler in bash zu verwenden:

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

0
shahin aref
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
}

Probeläufe

$ repeatString 'a1' 10 
a1a1a1a1a1a1a1a1a1a1

$ repeatString 'a1' 0 

$ repeatString '' 10 

Referenz-Lib unter: https://github.com/gdbtek/linux-cookbooks/blob/master/libraries/util.bash

0
Nam Nguyen

Am einfachsten ist es, diesen Einzeiler in csh/tcsh zu verwenden:

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

0
Shawn Givler