如何替换文本文件中的 ${} 占位符？

Question

我想将“模板”文件的输出通过管道传输到 MySQL，该文件散布有诸如 ${dbName} 之类的变量。 用于替换这些实例并将输出转储到标准输出的命令行实用程序是什么？

输入文件被认为是安全的，但可能存在错误的替换定义。 执行替换应避免执行意外的代码。

Answer 1

更新：尝试 envsubst

这是来自 yottatsa 的类似问题的解决方案，该解决方案仅替换 $VAR 或 ${ 等变量 当然，

i=32 word=foo envsubst < template.txt

如果i和word在你的环境中，那么它只是

envsubst < template.txt

在我的Mac上，看起来它是作为一部分安装的gettext 和 MacGPG2

旧答案：尝试 eval

这是对 mogsie 在类似的问题上，我的解决方案不需要您转义双引号，mogsie 需要转义，但他是一个衬垫！

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

这两种解决方案的强大之处在于，您只能获得几种通常不会发生的 shell 扩展 $((...))、`...` 和 $(...)，尽管反斜杠 在这里是一个转义字符，但是您不必担心解析有错误，并且它可以很好地处理多行。

Answer 2

Sed！

鉴于 template.txt：

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

我们只需说：

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

感谢 Jonathan Leffler 提供了将多个 -e 参数传递给同一个 sed 调用的提示。

Answer 3

使用/bin/sh。 创建一个设置变量的小 shell 脚本，然后使用 shell 本身解析模板。 像这样（编辑以正确处理换行符）：

文件 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

Answer 4

鉴于最近的兴趣，我又在考虑这个问题，我认为我最初想到的工具是 m4，自动工具的宏处理器。 因此，您可以使用以下命令来代替我最初指定的变量：

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

Answer 5

创建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

Answer 6

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

Answer 7

这是我基于之前答案的 perl 解决方案，替换了环境变量：

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

Answer 8

这是一个强大的 Bash 函数，尽管使用了eval，但应该可以安全使用。

输入文本中的所有 ${varName} 变量引用都会根据调用 shell 的变量进行扩展。

没有其他内容被扩展：名称​​未包含在 {...} 中的变量引用（例如 $varName），也不是命令替换（$(...) 和旧语法 `...`），也不是算术替换（$((.. .)) 和旧语法 $[...])。

要将 $ 视为文字，请使用 \ 将其转义； 例如：\${HOME}

请注意，仅通过 stdin 接受输入。

示例：

$ 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 '`([
 函数假设没有 0x1、0x2、0x3  和 0x4 控制字符出现在输入中，因为这些字符。   在内部使用 - 由于该函数处理文本，这应该是一个安全的假设。
 '\1\2\3\4')
    # ... then selectively reenable ${ references
    lineEscaped=${lineEscaped//
 函数假设没有 0x1、0x2、0x3  和 0x4 控制字符出现在输入中，因为这些字符。   在内部使用 - 由于该函数处理文本，这应该是一个安全的假设。
\4'{/\${}
    # Finally, escape embedded double quotes to preserve them.
    lineEscaped=${lineEscaped//\"/\\\"}
    eval "printf '%s\n' \"$lineEscaped\"" | tr '\1\2\3\4' '`([
 函数假设没有 0x1、0x2、0x3  和 0x4 控制字符出现在输入中，因为这些字符。   在内部使用 - 由于该函数处理文本，这应该是一个安全的假设。

  done
}

^{函数假设没有 0x1、0x2、0x3 和 0x4 控制字符出现在输入中，因为这些字符。 在内部使用 - 由于该函数处理文本，这应该是一个安全的假设。}

Answer 9

我建议使用类似 Sigil 的东西：
https://github.com/gliderlabs/sigil

它被编译为单个二进制文件，因此非常简单安装在系统上。

然后你可以做一个简单的一行，如下所示：

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

这比 eval 更安全，并且比使用正则表达式或 sed 更容易

Answer 10

这是一种让 shell 为您进行替换的方法，就好像文件的内容是在双引号之间键入的一样。

使用带有内容的 template.txt 示例：

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

以下行将导致 shell 插入 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 "数字是 ${i}\n单词是 ${word}",
  • 其中 i 和 word 是指定的环境变量。

Answer 11

如果您愿意使用 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 < yourfile | mysql

Answer 12

文件.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.

脚本.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

Answer 13

我在想知道同样的事情时发现了这个线程。 这启发了我（小心反引号）

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

Answer 14

这里有很多选择，但我想我会把我的扔到堆上。 它是基于 Perl 的，仅针对 ${...} 形式的变量，将要处理的文件作为参数并在 stdout 上输出转换后的文件：

use Env;
Env::import();

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

print "$text";

当然，我不是一个真正的 Perl 人，所以很容易一个致命的缺陷（不过对我有用）。

Answer 15

如果您可以控制配置文件格式，则可以在 bash 本身中完成。 您只需要获取（“.”）配置文件而不是对其进行 subshel​​l。 这确保了变量是在当前 shell 的上下文中创建的（并继续存在），而不是在子 shell 中创建（当子 shell 退出时，变量会消失）。

$ 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

如果您的配置文件不能是 shell 脚本，您可以在执行之前“编译”它（编译取决于您的输入格式）。

$ 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 '^
  在你的具体情况下，你可以使用类似的东西：
$ 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 中，瞧，希望你不会破坏你的数据库:-)。

        | 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

在你的具体情况下，你可以使用类似的东西：

然后将 go.bash 的输出通过管道传输到 MySQL 中，瞧，希望你不会破坏你的数据库:-)。

Answer 16

对可能的多个文件进行适当的 Perl 编辑，并进行备份。

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

Answer 17

对我来说，这是最简单、最强大的解决方案，您甚至可以使用相同的命令包含其他模板eval echo "$(：

嵌套模板示例

1. 创建模板文件，变量采用常规 bash 语法 ${VARIABLE_NAME} 或 $VARIABLE_NAME

您必须在模板中使用 \ 转义特殊字符，否则它们将被 eval 解释。

template.txt

Hello ${name}!
eval echo $(<nested-template.txt)

nested-template.txt

Nice to have you here ${name} :\)

2. 创建源文件

template.source

declare name=royman 

3. 解析模板

source template.source && eval echo "$(<template.txt)"

4. 输出

Hello royman!
Nice to have you here royman :)

---

Answer 18

我创建了一个名为 shtpl 的 shell 模板脚本。 我的 shtpl 使用类似 jinja 的语法，现在我经常使用 ansible，我对此非常熟悉：

$ cat /tmp/test
{{ aux=4 }}
{{ myarray=( a b c d ) }}
{{ A_RANDOM=$RANDOM }}
$A_RANDOM
{% if $(( $A_RANDOM%2 )) == 0 %}
$A_RANDOM is even
{% else %}
$A_RANDOM is odd
{% endif %}
{% if $(( $A_RANDOM%2 )) == 0 %}
{% for n in 1 2 3 $aux %}
\$myarray[$((n-1))]: ${myarray[$((n-1))]}
/etc/passwd field #$n: $(grep $USER /etc/passwd | cut -d: -f$n)
{% endfor %}
{% else %}
{% for n in {1..4} %}
\$myarray[$((n-1))]: ${myarray[$((n-1))]}
/etc/group field #$n: $(grep ^$USER /etc/group | cut -d: -f$n)
{% endfor %}
{% endif %}


$ ./shtpl < /tmp/test
6535
6535 is odd
$myarray[0]: a
/etc/group field #1: myusername
$myarray[1]: b
/etc/group field #2: x
$myarray[2]: c
/etc/group field #3: 1001
$myarray[3]: d
/etc/group field #4: 

有关我的 github

Answer 19

使用 envsubst

请不要使用其他任何东西（即不要 eval）

简单用法：

export name="Dana the Sane"

使用占位符创建模板 (template.txt) ：

Hello ${name}

安全地替换占位符变量。 将模板提供给 envsubst 的标准输入。

envsubst < template.txt
Hello Dana the Sane

请注意，该命令 envsubst < 模板.txt> template.txt 不起作用。 重定向将在读取输出文件之前将其清零。