Как я могу повторить символ в Bash?

Question

Как я могу сделать это с echo?

perl -E 'say "=" x 100'

Answer 1

Вы можете использовать:

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

Как это работает:

Bash расширяется {1..100}, поэтому команда становится:

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

I 'мы установили формат printf на =%.0s, что означает, что он всегда будет печатать один = независимо от того, какой аргумент ему дан.Поэтому печатает 100 = с.

Answer 2

Нет простого пути.Но, например:

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

Или, может быть, в соответствии со стандартом:

printf %100s |tr " " "="

Также есть tput rep, но что касается моих терминалов под рукой (xterm и linux), оникажется, не поддерживает его:)

Answer 3

Существует более одного способа сделать это.

Использование цикла:

• Расширение скобки можно использовать с целочисленными литералами:

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

Answer 4

^{Кончик шляпы @ gniourf_gniourf для его ввода.}

Примечание. Этот ответ не отвечает на исходный вопрос, но дополняет существующие, полезные ответы при сравнении производительности .

Решения сравниваются только с точки зрения скорости выполнения - требования к памяти не учитываются (они различаются в зависимости от решения и могут иметь значение при большом количестве повторений).

Резюме:

• Если количество повторений составляет small , скажем, до 100, то стоит с решениями Bash-only , поскольку стоимость запуска внешних утилит имеет значение, особенно Perl.
  • Прагматично говоря, однако, если вам нужен только один экземпляр повторяющихся символов, все существующие решения могут подойти.
• При больших повторных счетах , использование внешних утилит , так как они будут намного быстрее.
  • В частности, избегайте глобальной замены подстроки в Bash большими строками
    (например, ${var// /=}), поскольку он слишком медленный.

Ниже приведены тайминги , сделанные на iMac в конце 2012 года с 3,2 ГГц процессором Intel Core i5 и Fusion Drive, работающие с OSX 10.10.4 и bash 3.2.57, и в среднем составляют 1000 работает.

Записи:

• в порядке возрастания продолжительности выполнения (самый быстрый сначала)
• с префиксом:
  • M ... потенциально мульти -характерное решение
  • S ... a одиночное решение только для символов
  • 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-only лидируют - но только с таким небольшим количеством повторений! (см. ниже).
• Здесь имеет значение стоимость запуска внешних утилит, особенно Perl. Если вы должны вызывать это в цикле - с small счетчиками повторений в каждой итерации - избегайте решений с несколькими утилитами, 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 медленны, а арифметические циклы ((( i= 0; ... ))) медленнее, чем расширенные скобками ({1..n}) - хотя арифметические циклы более эффективны для памяти.
• 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

Answer 5

Я только что нашел серьезно простой способ сделать это, используя 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

ПРИМЕЧАНИЕ: Если вы повторяете #, тогда цитаты важны!

Answer 6

Вот два интересных способа:

ubuntu@ubuntu:~$ yes = | head -10 | paste -s -d '' -
==========
ubuntu@ubuntu:~$ yes = | head -10 | tr -d "\n"
==========ubuntu@ubuntu:~$ 

Обратите внимание, что эти два тонко различаются - метод paste заканчивается новой строкой. Метод tr не подходит.

Answer 7

Простого пути не существует. Избегайте циклов, используя printf и замену.

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

Answer 8

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

Или

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

Пример

Answer 9

Если вы хотите 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' почти везде.

Answer 10

Как уже говорили другие, в bash расширение скобки предшествует расширению параметра , поэтому диапазоны {<em>m</em>,<em>n</em>} могут содержать только литералы.seq и jot обеспечивают чистые решения, но не являются полностью переносимыми из одной системы в другую, даже если вы используете одну и ту же оболочку на каждой.(Хотя seq становится все более доступным; например, в FreeBSD 9.3 и более поздних версиях .) eval и другие формы косвенного обращения всегда работают, но в некоторой степени не элегантны.

К счастью, bash поддерживает C-стиль для циклов (только с арифметическими выражениями).Итак, вот краткий способ «чистого bash»:

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

В качестве первого аргумента принимается количество повторений и повторяющаяся строка (которая может быть одним символом, как в описании проблемы) какВторой аргумент.repecho 7 b выводит bbbbbbb (завершается новой строкой).

Деннис Уильямсон дал по существу это решение четыре года назад в своем превосходном ответе на Созданиестрока повторяющихся символов в скрипте оболочки .Мое тело функции немного отличается от кода:

• Поскольку основное внимание здесь уделяется повторению одного символа, а оболочка - bash, вероятно, безопасно использовать echo вместо printf.И я прочитал описание проблемы в этом вопросе как выражение предпочтения печатать с echo.Приведенное выше определение функции работает в bash и ksh93 .Хотя printf является более переносимым (и обычно должен использоваться для такого рода вещей), синтаксис echo возможно более читабелен.

  Некоторые оболочки echo встроенные функции интерпретируют - сами по себев качестве опции - хотя обычное значение -, использовать stdin для ввода, бессмысленно для echo. zsh делает это.И определенно существуют echo с, которые не распознают -n, так как это не стандарт .(Многие оболочки типа Bourne вообще не принимают C-стиль для циклов, поэтому их поведение echo не нужно учитывать ..)

• Здесь задача состоит в том, чтобы напечататьпоследовательность; там , он был назначен переменной.

Если $n - желаемое количество повторений, и вам не нужно его повторно использовать, иВы хотите что-то еще короче:

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

n должно быть переменной - этот способ не работает с позиционными параметрами.$s - текст для повторения.