Как заменить $ {} заполнителей в текстовом файле?

Я хочу направить вывод файла «шаблона» в MySQL, файл, имеющий переменные, такие как ${dbName}вкрапленные. Что такое утилита командной строки для замены этих экземпляров и вывода вывода на стандартный вывод?

Сед !

Данный шаблон.txt:

Число: $ {i}
Слово это $ {слово}

мы просто должны сказать:

sed -e "s/\${i}/1/" -e "s/\${word}/dog/" template.txt

Спасибо Джонатану Леффлеру за подсказку о передаче нескольких -eаргументов в один sedвызов.

Обновить

Вот решение от yottatsa по аналогичному вопросу, которое выполняет замену только таких переменных, как $ VAR или $ {VAR}, и является кратким однострочником

i=32 word=foo envsubst < template.txt

Конечно, если я и слово в вашей среде, то это просто

envsubst < template.txt

На моем Mac похоже, что он был установлен как часть gettext и из MacGPG2

Старый ответ

Вот улучшение решения от mogsie по аналогичному вопросу, мое решение не требует от вас эскалирования двойных кавычек, это делает mogsie, но он - один лайнер!

eval "cat <<EOF
$(<template.txt)
EOF
" 2> /dev/null

Сила этих двух решений является то , что вы получите только несколько типов расширений оболочки , которые не встречаются обычно $ ((...)), `...` и $ (...), хотя обратный слэш является здесь есть экранирующий символ, но вам не нужно беспокоиться о том, что при разборе есть ошибка, и он отлично справляется с несколькими строками.

Использование /bin/sh. Создайте небольшой скрипт оболочки, который устанавливает переменные, а затем проанализируйте шаблон с помощью самой оболочки. Вот так (отредактируйте, чтобы правильно обрабатывать новые строки):

Файл template.txt:

the number is ${i}
the word is ${word}

Файл script.sh:

#!/bin/sh

#Set variables
i=1
word="dog"

#Read in template one line at the time, and replace variables (more
#natural (and efficient) way, thanks to Jonathan Leffler).
while read line
do
    eval echo "$line"
done < "./template.txt"

Вывод:

#sh script.sh
the number is 1
the word is dog

Я снова думал об этом, учитывая недавний интерес, и я думаю, что инструмент, о котором я первоначально думал, был m4, макропроцессор для автоинструментов. Таким образом, вместо переменной, которую я первоначально указал, вы должны использовать:

$echo 'I am a DBNAME' | m4 -DDBNAME="database name"

template.txt

Variable 1 value: ${var1}
Variable 2 value: ${var2}

data.sh

#!/usr/bin/env bash
declare var1="value 1"
declare var2="value 2"

parser.sh

#!/usr/bin/env bash

# args
declare file_data=$1
declare file_input=$2
declare file_output=$3

source $file_data
eval "echo \"$(< $file_input)\"" > $file_output

./parser.sh data.sh template.txt parsed_file.txt

parsed_file.txt

Variable 1 value: value 1
Variable 2 value: value 2

Вот надежная функция Bash, которая, несмотря на использованиеeval следует использовать безопасно.

Все ${varName}ссылки на переменные во входном тексте расширяются на основе переменных вызывающей оболочки.

Больше ничего не раскрывается: ни ссылки на переменные, имена которых не заключены в {...}(такие как $varName), ни подстановки команд ( $(...)и устаревший синтаксис `...`), ни арифметические подстановки ( $((...))и устаревший синтаксис$[...] ).

Для того, чтобы лечить , $как буквальные, \экранирующий его; например:\${HOME}

Обратите внимание, что ввод принимается только через стандартный ввод .

Пример:

$ expandVarsStrict <<<'$HOME is "${HOME}"; `date` and \$(ls)' # only ${HOME} is expanded
$HOME is "/Users/jdoe"; `date` and $(ls)

Исходный код функции:

expandVarsStrict(){
  local line lineEscaped
  while IFS= read -r line || [[ -n $line ]]; do  # the `||` clause ensures that the last line is read even if it doesn't end with \n
    # Escape ALL chars. that could trigger an expansion..
    IFS= read -r -d '' lineEscaped < <(printf %s "$line" | tr '`([$' '\1\2\3\4')
    # ... then selectively reenable ${ references
    lineEscaped=${lineEscaped//$'\4'{/\${}
    # Finally, escape embedded double quotes to preserve them.
    lineEscaped=${lineEscaped//\"/\\\"}
    eval "printf '%s\n' \"$lineEscaped\"" | tr '\1\2\3\4' '`([$'
  done
}

^{Функция не предполагает , что нет 0x1, 0x2, 0x3, и 0x4управляющие символы присутствуют на входе, потому что эти символы. используются внутренне - так как функция обрабатывает текст , это должно быть безопасным допущением.}

Создать rendertemplate.sh:

#!/usr/bin/env bash

eval "echo \"$(cat $1)\""

И template.tmpl:

Hello, ${WORLD}
Goodbye, ${CHEESE}

Визуализируйте шаблон:

$ export WORLD=Foo
$ CHEESE=Bar ./rendertemplate.sh template.tmpl 
Hello, Foo
Goodbye, Bar

Вот мое решение с Perl на основе предыдущего ответа, заменяет переменные среды:

perl -p -e 's/\$\{(\w+)\}/(exists $ENV{$1}?$ENV{$1}:"missing variable $1")/eg' < infile > outfile

Если вы открыты для использования Perl , это мое предложение. Хотя, вероятно, есть некоторые специалисты по sed и / или AWK, которые, вероятно, знают, как сделать это намного проще. Если у вас есть более сложное сопоставление с заменой dbName для замен, вы можете довольно легко расширить это, но вы можете с таким же успехом поместить его в стандартный сценарий Perl на этом этапе.

perl -p -e 's/\$\{dbName\}/testdb/s' yourfile | mysql

Короткий Perl-скрипт для создания чего-то более сложного (обработка нескольких ключей):

#!/usr/bin/env perl
my %replace = ( 'dbName' => 'testdb', 'somethingElse' => 'fooBar' );
undef $/;
my $buf = <STDIN>;
$buf =~ s/\$\{$_\}/$replace{$_}/g for keys %replace;
print $buf;

Если вы называете вышеуказанный скрипт как replace-script, он может быть использован следующим образом:

replace-script < yourfile | mysql

Вот способ заставить оболочку выполнить за вас замену, как если бы содержимое файла вместо этого было заключено в двойные кавычки.

Используя пример template.txt с содержимым:

The number is ${i}
The word is ${word}

Следующая строка заставит оболочку интерполировать содержимое template.txt и записать результат в стандартный формат.

i='1' word='dog' sh -c 'echo "'"$(cat template.txt)"'"'

Объяснение:

• iи wordпередаются как переменные среды, ограниченные для выполнения sh.
• sh выполняет содержимое строки, которую он передал.
• Строки, написанные рядом друг с другом, становятся одной строкой, эта строка:
  • ' echo "' + " $(cat template.txt)" + ' "'
• Поскольку подстановка между ними ", " $(cat template.txt)" становится выходом cat template.txt.
• Таким образом, команда, выполняемая командой sh -cстановится:
  • echo "The number is ${i}\nThe word is ${word}",
  • где iи word- указанные переменные среды.

file.tpl:

The following bash function should only replace ${var1} syntax and ignore 
other shell special chars such as `backticks` or $var2 or "double quotes". 
If I have missed anything - let me know.

script.sh:

template(){
    # usage: template file.tpl
    while read -r line ; do
            line=${line//\"/\\\"}
            line=${line//\`/\\\`}
            line=${line//\$/\\\$}
            line=${line//\\\${/\${}
            eval "echo \"$line\""; 
    done < ${1}
}

var1="*replaced*"
var2="*not replaced*"

template file.tpl > result.txt

Я бы предложил использовать что-то вроде Sigil : https://github.com/gliderlabs/sigil

Он скомпилирован в один двоичный файл, поэтому его очень легко установить в системах.

Тогда вы можете сделать простой однострочник, как показано ниже:

cat my-file.conf.template | sigil -p $(env) > my-file.conf

Это гораздо безопаснее, чем evalс помощью регулярных выражений илиsed

Я нашел эту тему, хотя удивляюсь тому же самому. Это вдохновило меня на это (осторожно с галочкой)

$ echo $MYTEST
pass!
$ cat FILE
hello $MYTEST world
$ eval echo `cat FILE`
hello pass! world

Здесь много вариантов, но я решил бросить свой в кучу. Это основано на Perl, только целевые переменные вида $ {...}, принимает файл для обработки в качестве аргумента и выводит преобразованный файл на стандартный вывод:

use Env;
Env::import();

while(<>) { $_ =~ s/(\${\w+})/$1/eeg; $text .= $_; }

print "$text";

Конечно, я на самом деле не Perl человек, поэтому легко может быть фатальный недостаток (работает для меня, хотя).

Это можно сделать в самом bash, если у вас есть контроль над форматом файла конфигурации. Вам просто нужно найти (".") Файл конфигурации, а не его оболочку. Это гарантирует, что переменные создаются в контексте текущей оболочки (и продолжают существовать), а не подоболочки (где переменная исчезает при выходе из подоболочки).

$ cat config.data
    export parm_jdbc=jdbc:db2://box7.co.uk:5000/INSTA
    export parm_user=pax
    export parm_pwd=never_you_mind

$ cat go.bash
    . config.data
    echo "JDBC string is " $parm_jdbc
    echo "Username is    " $parm_user
    echo "Password is    " $parm_pwd

$ bash go.bash
    JDBC string is  jdbc:db2://box7.co.uk:5000/INSTA
    Username is     pax
    Password is     never_you_mind

Если ваш конфигурационный файл не может быть сценарием оболочки, вы можете просто «скомпилировать» его перед выполнением (компиляция зависит от вашего формата ввода).

$ cat config.data
    parm_jdbc=jdbc:db2://box7.co.uk:5000/INSTA # JDBC URL
    parm_user=pax                              # user name
    parm_pwd=never_you_mind                    # password

$ cat go.bash
    cat config.data
        | sed 's/#.*$//'
        | sed 's/[ \t]*$//'
        | sed 's/^[ \t]*//'
        | grep -v '^$'
        | sed 's/^/export '
        >config.data-compiled
    . config.data-compiled
    echo "JDBC string is " $parm_jdbc
    echo "Username is    " $parm_user
    echo "Password is    " $parm_pwd

$ bash go.bash
    JDBC string is  jdbc:db2://box7.co.uk:5000/INSTA
    Username is     pax
    Password is     never_you_mind

В вашем конкретном случае вы можете использовать что-то вроде:

$ cat config.data
    export p_p1=val1
    export p_p2=val2
$ cat go.bash
    . ./config.data
    echo "select * from dbtable where p1 = '$p_p1' and p2 like '$p_p2%' order by p1"
$ bash go.bash
    select * from dbtable where p1 = 'val1' and p2 like 'val2%' order by p1

Затем перенаправьте вывод go.bash в MySQL и вуаля, надеюсь, вы не уничтожите свою базу данных :-).

Вместо Perl редактирование потенциально нескольких файлов с резервными копиями.

  perl -e 's/\$\{([^}]+)\}/defined $ENV{$1} ? $ENV{$1} : ""/eg' \
    -i.orig \
    -p config/test/*

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

Вам нужен лучший рендер. Вам нужен лучший рендер. Вам нужен Renderest!

Данный шаблон.txt:

Здравствуйте, {{person}}!

Бегать:

$ person = Bob ./render template.txt

И вы увидите выход

Привет, Боб!

Запишите его в файл, перенаправив стандартный вывод в файл:

$ person = Bob ./render template.txt> rendered.txt

И если вам случится рендерить скрипт, в котором есть переменные $ {}, которые вы не хотите интерполировать, Renderest поможет вам без необходимости делать что-либо еще!

Продолжайте и получите свою копию на https://github.com/relaxdiego/renderest