Wie ersetze ich $ {} Platzhalter in einer Textdatei?

Ich möchte die Ausgabe einer "Vorlagendatei" in MySQL weiterleiten, wobei die Datei Variablen wie " ${dbName}eingestreut" enthält. Was ist das Befehlszeilenprogramm, um diese Instanzen zu ersetzen und die Ausgabe auf die Standardausgabe zu übertragen?

Sed !

Gegeben template.txt:

Die Nummer ist $ {i}
Das Wort ist $ {word}

wir müssen nur sagen:

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

Vielen Dank an Jonathan Leffler für den Tipp, mehrere -eArgumente an denselben sedAufruf zu übergeben.

Aktualisieren

Hier ist eine Lösung von yottatsa zu einer ähnlichen Frage, die nur Variablen wie $ VAR oder $ {VAR} ersetzt und ein kurzer Einzeiler ist

i=32 word=foo envsubst < template.txt

Natürlich, wenn ich und Wort in Ihrer Umgebung sind, dann ist es einfach

envsubst < template.txt

Auf meinem Mac scheint es als Teil von gettext und von MacGPG2 installiert worden zu sein

Alte Antwort

Hier ist eine Verbesserung der Lösung von Mogsie in einer ähnlichen Frage. Meine Lösung erfordert nicht, dass Sie doppelte Anführungszeichen eskalieren, Mogsie's, aber er ist ein Einzeiler!

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

Die Kraft auf diesen beiden Lösungen ist , dass Sie nur ein paar Arten von Shell - Erweiterungen bekommen, die normalerweise nicht $ auftreten ((...)), `...` und $ (...), obwohl Backslash ist ein Escape-Zeichen hier, aber Sie müssen sich keine Sorgen machen, dass das Parsen einen Fehler aufweist und mehrere Zeilen in Ordnung sind.

Verwenden Sie /bin/sh. Erstellen Sie ein kleines Shell-Skript, das die Variablen festlegt, und analysieren Sie dann die Vorlage mithilfe der Shell. So (bearbeiten, um Zeilenumbrüche korrekt zu behandeln):

Datei template.txt:

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

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

Ausgabe:

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

m4Angesichts des jüngsten Interesses habe ich erneut darüber nachgedacht, und ich denke, dass das Tool, an das ich ursprünglich gedacht habe , der Makroprozessor für Autotools war. Anstelle der ursprünglich angegebenen Variablen würden Sie also Folgendes verwenden:

$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

Hier ist eine robuste Bash-Funktion , die trotz Verwendung evalsicher sein sollte.

Alle ${varName}Variablenreferenzen im Eingabetext werden basierend auf den Variablen der aufrufenden Shell erweitert.

Nichts anderes wird erweitert: weder Variablenreferenzen, deren Namen nicht eingeschlossen sind {...}(z. B. $varName), noch Befehlssubstitutionen ( $(...)und Legacy-Syntax `...`) noch arithmetische Substitutionen ( $((...))und Legacy-Syntax)$[...] ).

Um a $als wörtlich zu behandeln , \entkomme es; z.B:\${HOME}

Beachten Sie, dass Eingaben nur über stdin akzeptiert werden .

Beispiel:

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

Funktionsquellcode:

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
}

^{Die Funktion wird davon ausgegangen , dass keine 0x1, 0x2, 0x3, und 0x4Steuerzeichen in der Eingabe vorhanden sind, weil diese Zeichen. werden intern verwendet - da die Funktion Text verarbeitet , sollte dies eine sichere Annahme sein.}

Erstellen rendertemplate.sh:

#!/usr/bin/env bash

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

Und template.tmpl:

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

Rendern Sie die Vorlage:

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

Hier ist meine Lösung mit Perl basierend auf der vorherigen Antwort, ersetzt Umgebungsvariablen:

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

Wenn Sie offen für Perl sind, wäre das mein Vorschlag. Obwohl es wahrscheinlich einige Sed- und / oder AWK- Experten gibt, die wahrscheinlich wissen, wie man das viel einfacher macht. Wenn Sie eine komplexere Zuordnung mit mehr als nur dbName für Ihre Ersetzungen haben, können Sie diese ziemlich einfach erweitern, aber Sie können sie zu diesem Zeitpunkt genauso gut in ein Standard-Perl-Skript einfügen.

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

Ein kurzes Perl-Skript, um etwas etwas komplizierteres zu tun (mehrere Schlüssel verarbeiten):

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

Wenn Sie das obige Skript als Ersetzungsskript bezeichnen, kann es wie folgt verwendet werden:

replace-script < yourfile | mysql

Hier ist eine Möglichkeit, die Shell dazu zu bringen, die Ersetzung für Sie durchzuführen, als ob der Inhalt der Datei stattdessen zwischen doppelten Anführungszeichen eingegeben würde.

Am Beispiel von template.txt mit Inhalten:

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

Die folgende Zeile bewirkt, dass die Shell den Inhalt von template.txt interpoliert und das Ergebnis in standard out schreibt.

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

Erläuterung:

• iund wordwerden als Umgebungsvariablen übergeben, die zur Ausführung vonsh .
• sh führt den Inhalt der übergebenen Zeichenfolge aus.
• Nebeneinander geschriebene Zeichenfolgen werden zu einer Zeichenfolge. Diese Zeichenfolge lautet:
  • ' echo "' + " $(cat template.txt)" + '" '
• Da liegt die Substitution zwischen " , wird " $(cat template.txt)" die Ausgabe von cat template.txt.
• Also der Befehl ausgeführt von sh -c :
  • echo "The number is ${i}\nThe word is ${word}",
  • wo iund wordsind die angegebenen Umgebungsvariablen.

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

Ich würde vorschlagen, etwas wie Sigil zu verwenden : https://github.com/gliderlabs/sigil

Es ist zu einer einzigen Binärdatei kompiliert, sodass die Installation auf Systemen äußerst einfach ist.

Dann können Sie einen einfachen Einzeiler wie den folgenden erstellen:

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

Dies ist viel sicherer als evalund einfacher als die Verwendung von Regex odersed

Ich habe diesen Thread gefunden, als ich mich das Gleiche gefragt habe. Es hat mich dazu inspiriert (vorsichtig mit den Backticks)

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

Viele Möglichkeiten hier, aber ich dachte, ich würde meine auf den Haufen werfen. Es basiert auf Perl, zielt nur auf Variablen der Form $ {...} ab, verwendet die zu verarbeitende Datei als Argument und gibt die konvertierte Datei auf stdout aus:

use Env;
Env::import();

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

print "$text";

Natürlich bin ich nicht wirklich eine Perl-Person, daher kann es leicht zu einem schwerwiegenden Fehler kommen (funktioniert aber für mich).

Dies kann in Bash selbst erfolgen, wenn Sie die Kontrolle über das Konfigurationsdateiformat haben. Sie müssen nur die Konfigurationsdatei als Quelle (".") Geben, anstatt sie zu unterteilen. Dadurch wird sichergestellt, dass die Variablen im Kontext der aktuellen Shell erstellt werden (und weiterhin vorhanden sind) und nicht in der Subshell (wobei die Variable beim Beenden der Subshell verschwindet).

$ 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

Wenn Ihre Konfigurationsdatei kein Shell-Skript sein kann, können Sie sie vor der Ausführung einfach "kompilieren" (die Kompilierung hängt von Ihrem Eingabeformat ab).

$ 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

In Ihrem speziellen Fall könnten Sie Folgendes verwenden:

$ 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

Dann leiten Sie die Ausgabe von go.bash an MySQL und voila weiter, hoffentlich zerstören Sie Ihre Datenbank nicht :-).

Perl-Bearbeitung von potenziell mehreren Dateien mit Backups.

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