어떻게하면 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의 전역 하위 문자열을 대체하지 마십시오 ${var// /=}. 엄청나게 느립니다.

다음은 OSX 10.10.4 및 bash 3.2.57을 실행하는 3.2GHz Intel Core i5 CPU 및 Fusion Drive가 장착 된 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 (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

• 질문의 펄 솔루션이 훨씬 빠릅니다.
• Bash의 전역 문자열 교체 ( ${foo// /=})는 큰 문자열로 인해 예상치 못하게 느리게 진행되며 Bash 4.3.30에서 약 50 분 (!)이 걸리고 Bash 3.2.57에서 더 길어졌습니다. 완료).
• 배쉬 루프는 느리고 산술 루프 ( (( 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를 사용 하여이 작업을 수행하는 매우 쉬운 방법을 찾았습니다.

업데이트 : 이것은 seqOS X과 함께 제공 되는 BSD에서 작동합니다. 다른 버전의 YMMV

seq  -f "#" -s '' 10

다음과 같이 '#'을 10 번 인쇄합니다.

##########

• -f "#"숫자를 무시하고 #각 숫자 에 대해 인쇄하도록 형식 문자열을 설정합니다 .
• -s '' seq가 각 숫자 사이에 삽입하는 줄 바꿈을 제거하기 위해 구분 기호를 빈 문자열로 설정합니다.
• 공간이 후 -f하고 -s중요한 것 같다.

편집 : 여기에 편리한 기능이 있습니다 ...

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

이런 식으로 전화 할 수 있습니다 ...

repeat "#" 10

참고 : 반복 #하는 경우 따옴표가 중요합니다!

흥미로운 두 가지 방법이 있습니다.

우분투 @ 우분투 : ~ $ yes = | 머리 -10 | 붙여 넣기 -s -d ''-
==========
우분투 @ 우분투 : ~ $ yes = | 머리 -10 | tr -d "\ n"
========== ubuntu @ ubuntu : ~ $ 

이 둘은 미묘하게 다르다는 점에 유의하십시오.이 paste방법은 새로운 줄로 끝납니다. tr방법은하지 않습니다.

간단한 방법은 없습니다. 루프를 사용 printf하고 대체 하지 마십시오 .

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

다음과 같은 다른 구현 echo및 printf및 / 또는 쉘에서 POSIX 준수 및 일관성을 원할 경우 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, 하위 셸, 외부 도구, 괄호 확장 (즉, 변수에서 숫자를 반복 할 수 있음) :

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형식화 된 문자열의 내용을 variable에 넣습니다 varname.
• '% * s': printf인수를 사용하여 해당하는 수의 공백을 인쇄합니다. 예를 들어 printf '%*s' 4242 칸을 인쇄합니다.
• 우리는 우리의 변수 공간의 원하는 수있을 때 마지막으로, 우리는 우리의 패턴에 의해 모든 공백을 대체 할 매개 변수 확장을 사용 ${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 "="
}

예

질문의 원래 목적은 쉘의 내장 명령 으로이 작업을 수행하는 것이 었습니다. 그래서 for루프와 printfs는, 합법적 인 것이지만 rep, perl, 또한 jot아래 않을 것입니다. 여전히 다음 명령

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

예를 들어, 창 전체 줄을 인쇄합니다. \/\/\/\/\/\/\/\/\/\/\/\/

다른 사람들이 말했듯이, bash 괄호 확장은 매개 변수 확장 보다 우선 하므로 범위에는 리터럴 만 포함될 수 있습니다. 그리고 각에서 같은 쉘을 사용하는 경우에도 깨끗한 솔루션을 제공하지만, 한 시스템에서 다른 시스템으로 완벽하게 이식 할 수 없습니다. ( 예를 들어 FreeBSD 9.3 이상에서 점점 더 많이 이용 가능 하지만 ) 다른 형태의 간접적 인 지시는 항상 작동하지만 다소 우아하지는 않습니다.{m,n}seqjotseqeval

다행히도 bash 는 C 스타일 for 루프를 지원합니다 (산술 표현식 만 해당). 간결한 "순수한 배쉬"방법은 다음과 같습니다.

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

첫 번째 인수로 반복 횟수를, 두 번째 인수로 반복 할 문자열 (문제 설명에서와 같이 단일 문자 일 수 있음)을 사용합니다. repecho 7 b출력 bbbbbbb(개행으로 종료).

Dennis Williamson 은 기본적으로이 솔루션을 4 년 전에 쉘 스크립트에서 반복되는 문자열 만들기 에 대한 탁월한 답변 을 제공했습니다 . 내 함수 본문은 코드와 약간 다릅니다.

• 여기서 초점은 단일 문자를 반복하고 쉘은 bash이므로, echo대신 사용하는 것이 안전합니다 printf. 그리고이 질문의 문제 설명을 인쇄 기본 설정을 나타내는 것으로 읽었습니다 echo. 위 함수 정의는 bash 및 ksh93 에서 작동합니다 . 하지만 printf휴대 성이다 (일반적으로 이런 종류의에 사용한다) echo의 구문은 틀림없이 더 읽을 수 있습니다.

  일부 쉘의 echo내장 은 입력으로 stdin을 사용 -한다는 일반적인 의미가 . zsh 가이를 수행합니다. 그리고 확실히 존재 인식하지 못하는들 로, 이 표준되지 않습니다 . 많은 Bourne 스타일 쉘은 C 스타일 for 루프를 전혀 허용하지 않으므로 해당 동작을 고려할 필요가 없습니다.-echoecho-necho

• 여기서 과제는 순서를 인쇄하는 것입니다. 거기 에 변수에 할당했습니다.

만약이 $n반복 원하는 수의 그리고 당신은 그것을 다시 사용할 필요가 없습니다, 당신은 심지어 짧은 뭔가를 원하는 :

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

n변수 여야합니다.이 방법은 위치 매개 변수에서 작동하지 않습니다. $s반복 할 텍스트입니다.

파이썬은 어디에나 있으며 어디에서나 동일하게 작동합니다.

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

문자와 개수는 별도의 매개 변수로 전달됩니다.

bash 3.0 이상에서

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

임의의 문자열을 n 번 반복하는 또 다른 방법 :

장점 :

• POSIX 쉘과 함께 작동합니다.
• 변수에 출력을 할당 할 수 있습니다.
• 문자열을 반복합니다.
• 반복이 매우 큰 경우에도 매우 빠릅니다.

단점 :

• 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 또는 1 바이트 ISO 문자 만 반복 할 수 있습니다.
• 마지막 열에서 반복이 중지되므로 터미널 너비에 관계없이 큰 값을 사용하여 전체 행을 채울 수 있습니다.
• 반복은 표시 전용입니다. 쉘 변수로 출력을 캡처하면 repeat_charANSI CSI 시퀀스가 ​​반복되는 문자로 확장되지 않습니다 .

다음은 리눅스에서 화면 전체에 한 줄의 문자를 인쇄하는 데 사용하는 것입니다 (터미널 / 화면 너비 기준)

화면에서 "="를 인쇄하십시오.

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

설명:

주어진 순서만큼 등호를 인쇄하십시오.

printf '=%.0s' #sequence

명령의 출력을 사용하십시오 (명령 대체라는 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 번 반복하려면 다음을 수행하십시오.

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

이 버전은 대시와 호환됩니다 :

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

i는 초기 번호입니다.

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경우이 작업을 수행 할 수 있습니다 .echosed

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또는 오픈 BSD의 ksh대부분의 비 배쉬 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 =