PHP 7.1 replace multiple values with dynamic variables

I would make a simple template class to parse it,

class SimpleTemplate
{      
    protected $src;        
    protected $vars;
    
    public function __construct($src)
    {
        $this->src = $src;
    }
    
    public function assign($key, $value)
    {
        $this->vars[$key] = $value;
    }
    
    public function out()
    {
        return str_replace(array_keys($this->vars),$this->vars,$this->src);
    }        
}

$T = new SimpleTemplate("We have received ##AMOUNT## ##CURRENCY## for your OrderID n. ##ORDER_ID##");
$T->assign('##AMOUNT##', 'foo');
$T->assign('##CURRENCY##', 'bar');
$T->assign('##ORDER_ID##', 'hello');

echo $T->out();

Outputs:

"We have received foo bar for your OrderID n. hello"

You can see it here live:

And you can always expand on it and add features, like removing the ## from the assignment, and removing any un-used tags. etc...

Basically it's just an array management tool for your variables. Because we are building an array like this:

[
  '##AMOUNT##' => 'foo',
  '##CURRENCY##' => 'bar',
  '##ORDER_ID##' => 'hello'
];

And then using str_replace we use the keys as the search, the value as the replacement value.

If you want to remove the ## from the tag assignment just change this:

public function assign($key, $value)
{
    $this->vars['##'.$key.'##'] = $value;
}

And then call like this:

$T->assign('AMOUNT', 'foo');

The real benefit here, is having a class to implement your logic in. It keeps it clean and re-usable.

UPDATE

As @LawrenceCherone mentioned in the comments, you can get a cleaner interface by using a couple magic methods.

class SimpleTemplate
{      
    protected $src;
    protected $vars;
    
    public function __construct($src)
    {
        $this->src = $src;
    }
    
    public function __set($key, $value)
    {
        $this->vars['##'.strtoupper($key).'##'] = $value;
    }
    
    public function __toString()
    {
        return str_replace(array_keys($this->vars),$this->vars,$this->src);
    }     
}

$T = new SimpleTemplate("We have received ##AMOUNT## ##CURRENCY## for your OrderID n. ##ORDER_ID##");
$T->Amount = 'foo';  //any casing works because of the transforms, in __set
$T->CURRENCY = 'bar';
$T->order_id = 'hello';

echo $T; //using __toString() lets us just output the class as our result string.

Specifically __set and __toString. For this one I did a few transforms on the key so as to make it a bit less error prone, and a bit less ugly. For example the use of Mixed Casing for the dynamic Properties. By using strtoupper they can be input in any case, and removing the # prevents having to wrap them like this $T->{'##AMOUNT##'} = 'foo';

The last thing I will add, is if you can have "tags" that are not assigned but want them removed you can use this regx to remove them.

    public function __toString()
    {
        $str = str_replace(array_keys($this->vars),$this->vars,$this->src);
        return preg_replace(['/##\w+##/', '/\s{2,}/'], ['', ' '], $str); //remove any left over ##{word}## tags, and compress any run-on spaces.
    } 

You can see an example of this here

The second one in the array /\s{2,}/, just takes run on spaces and compresses them to a single space, so if you have like 4 spaces it becomes a single space. It's not well documented but preg_replace can take an array just like str_replace does.

This is why I suggest building up a class, it gives you a nice place to implement all this "stuff" if you want, and not have to keep re-writing it all the time.

You can use str_replace function with two arrays, one of the searched words and the second of the replacements:

 $words = ["##AMOUNT##", "##CURRENCY##", "##ORDER_ID##"];
 $replaces = [$AMOUNT,$CURRENCY,$ORDER_ID];
 $newString = str_replace($words, $replaces, $string);
 echo $newString;

str_replace will work with arrays. If $find is an array and $replace is a string it will replace everything in $find with the string in $replace if both are arrays it will replace each corresponding element $find[index] with their corresponding $replace[index] example:

$find = ["find1", "find2" ];
$replace = [ "replace1", "replace2" ];

$string = "Find find1 and find2"; 

echo str_replace($find, $replace, $string); // "Find replace1 and replace2"

However there is a small catch in that the replacements are done in sequence. It generally isn't a problem until you encounter something like:

$find = [ "find", "find2" ];
$replace = [ "replace", "replaceXX2" ];
$string = "Find find1 and find2"; 

echo str_replace($find, $replace, $string); // "Find replace1 and replace2"

Why? Because it will replace both the "find" word and the "find" that is part of find2 with replace before it even looks for "find2".

If you want to avoid that you can use strtr as follows:

$find = [ "find" => "replace" , "find2" => "replaceXX" ];

$string = "Find find1 and find2"; 

echo strtr($string, $find); // "Find replace1 and replaceXX"

An another way with @Lawrence Cherone's answer. Maybe you want to use key => value list.

<?php
$message = "We have received ##AMOUNT## ##CURRENCY## for your OrderID n. ##ORDER_ID##";

$messageParameters = [
    'AMOUNT' => 83,
    'CURRENCY' => 'USD',
    'ORDER_ID' => 3271096
    ];

$parsedMessage = str_replace(
    array_map(function($v){ return '##'.$v.'##'; }, array_keys($messageParameters)), 
    array_values($messageParameters), 
    $message
);

echo $parsedMessage;

Result:

We have received 83 USD for your OrderID n. 3271096

https://3v4l.org/9b7lO

The more elegant way is printf funtion.

vsprintf("We have received %s %s for your OrderID n. %s", array($AMOUNT, $CURRENCY, $ORDER_ID));

More info here: http://php.net/manual/en/function.vsprintf.php