我该怎么办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// /=}），因为这太慢了。

以下是 时机了3.2 GHz的英特尔酷睿i5 CPU和融合驱动器，运行OSX 10.10.4和bash 3.2.57在后期2012的iMac采取，并且是平均1000个奔跑。

条目是：

• 按执行时间的升序排列（最快的优先）
• 前缀：
  • M...潜在的多重字符解决方案
  • S...一个单只字符数限制的解决方案
  • 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（100万）

[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// /=}）在使用大字符串时令人费解地缓慢，并且已经退出运行（在Bash 4.3.30中花费了大约50分钟（！），在Bash 3.2.57中甚至更长的时间-我从未等待完成）。
• Bash循环较慢，算术循环（(( i= 0; ... ))）比括号扩展的（{1..n}） -尽管算术循环的内存效率更高。
• awk指的是BSD awk（也可以在OSX上找到）-明显比gawk（GNU Awk）慢，尤其是mawk。
• 注意，大量和多字符。字符串，内存消耗可以成为一个考虑因素-方式在这方面有所不同。

这是产生以上内容的Bash脚本（testrepeat）。它有两个参数：

• 字符重复计数
• （可选）要执行的测试运行次数，以及从中计算平均计时的次数

换句话说：上述计时是通过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

使用printf内置的：

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附带的BSD。YMMV和其他版本

seq  -f "#" -s '' 10

将打印“＃”十次，如下所示：

##########

• -f "#" 设置格式字符串以忽略数字并仅打印 #每个。
• -s '' 将分隔符设置为空字符串以删除seq在每个数字之间插入的换行符
• 该空间后-f，并-s似乎是很重要的。

编辑：这是在一个方便的功能...

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

你可以这样称呼...

repeat "#" 10

注意：如果要重复，#则引号很重要！

这是两种有趣的方式：

ubuntu @ ubuntu：〜$是= | 头-10 | 粘贴-s -d''-
==========
ubuntu @ ubuntu：〜$是= | 头-10 | tr -d“ \ n”
========== ubuntu @ ubuntu：〜$ 

请注意，这两者是有细微差别的- paste方法以新行结尾。该tr方法没有。

没有简单的方法。避免使用printf和替换循环。

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

如果您希望POSIX以及echo和printf和/或Shell的不同实现之间的一致性和一致性，而不仅仅是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，没有子shell，没有外部工具，没有括号扩展的纯Bash方式（即，您可以在变量中重复数字）：

如果您得到一个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：printf将格式字符串的内容放入变量中，而不是打印到标准输出中varname。
• '％* 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 "="
}

例

我想这个问题的最初目的是仅使用Shell的内置命令来执行此操作。因此，for循环和printfs就合法，同时rep，perl和也jot低于不肯。尽管如此，以下命令

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

例如，在 \/\/\/\/\/\/\/\/\/\/\/\/

正如其他人所说，在bash中，括号扩展在参数扩展之前，因此范围只能包含文字。并提供干净的解决方案，但即使在每个系统上使用相同的外壳，也不能完全移植到一个系统中。（尽管越来越多；例如，在FreeBSD 9.3及更高版本中。）{m,n}seqjotseqeval和其他形式的间接访问始终有效，但有些不雅。

幸运的是，bash 支持C风格的循环（仅适用于算术表达式）。因此，这是一种简洁的“纯bash”方式：

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

这将重复次数作为第一个参数，将要重复的字符串（如问题描述中的单个字符）作为第二个参数。repecho 7 b输出bbbbbbb（由换行符终止）。

丹尼斯·威廉姆森（Dennis Williamson）在四年前对在shell脚本中创建重复字符字符串的出色回答中就给出了这种解决方案。我的函数体与那里的代码略有不同：

• 由于此处的重点是重复单个字符且shell是bash，因此使用echo代替可能是安全的printf。而且我读到该问题的问题描述是表示倾向于使用echo。上面的函数定义在bash和ksh93中起作用。尽管它printf具有更高的可移植性（通常应用于此类操作），但echo可以说的语法更具可读性。

  一些shell的echo内建函数-本身将其解释为一个选项-尽管-使用stdin作为输入的通常含义对而言是毫无意义的echo。zsh做到了。而且肯定存在echo无法识别的-n，因为它不是标准的。（许多Bourne风格的shell根本不接受C风格的循环，因此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 shell一起使用。
• 可以将输出分配给变量。
• 重复任何字符串。
• 即使重复很大，也非常快。

缺点：

• 需要Gnu Core Utils的yes命令。

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

用ANSI终端和US-ASCII字符重复。您可以使用ANSI CSI转义序列。这是重复字符的最快方法。

#!/usr/bin/env bash

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

或静态地：

打印80行=：

printf '=\e[80b\n'

局限性：

• 并非所有终端都能理解repeat_charANSI CSI序列。
• 只能重复使用US-ASCII或单字节ISO字符。
• 在最后一列重复停止，因此无论端子宽度如何，都可以使用较大的值来填充整行。
• 重复仅用于显示。将输出捕获到shell变量中不会将repeat_charANSI CSI序列扩展为重复的字符。

这是我在linux中跨屏幕打印一行字符的方法（基于终端/屏幕宽度）

在屏幕上打印“ =”：

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

说明：

按给定序列打印等号多次：

printf '=%.0s' #sequence

使用命令的输出（这是一个称为Command Substitution的bash功能）：

$(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次为n个可变次数（例如取决于字符串的长度），则可以执行以下操作：

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

参考库位于：https : //github.com/gdbtek/linux-cookbooks/blob/master/libraries/util.bash

我该如何用echo做到这一点？

echo如果echo后面跟着，您可以执行以下操作sed：

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

实际上，那echo是不必要的。

我的答案有点复杂，可能还不完美，但是对于那些希望输出大量数字的人来说，我能够在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}
}

最简单的方法是在bash中使用这种单线：

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的ksh和大多数非的bashsh。

以下内容适用于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 =