preg_replace_callback

The easiest way to pass more than one parameters to the callback function is with the 'use' keyword. 
[This is better than using global, because it works even when we are already inside a function.]
In this example, the callback function is an anonymous function, which takes one argument, $match, supplied by preg_replace_callback(). The extra 
"use ($ten)" puts the $ten variable into scope for the function.
<?php
$string = "Some numbers: one: 1; two: 2; three: 3 end";
$ten = 10;
$newstring = preg_replace_callback(
 '/(\\d+)/',
 function($match) use ($ten) { return (($match[0] + $ten)); },
 $string
 );
echo $newstring;
#prints "Some numbers: one: 11; two: 12; three: 13 end";
?>

preg_replace_callback returns NULL when pcre.backtrack_limit is reached; this sometimes occurs faster then you might expect. No error is raised either; so don't forget to check for NULL yourself

If you want to call non-static function inside your class, you can do something like this. 
For PHP 5.2 use second argument like array($this, 'replace'):
<?php
class test_preg_callback{
 private function process($text){
 $reg = "/\{([0-9a-zA-Z\- ]+)\:([0-9a-zA-Z\- ]+):?\}/";
 return preg_replace_callback($reg, array($this, 'replace'), $text);
 }
 
 private function replace($matches){
 if (method_exists($this, $matches[1])){
 return @$this->$matches[1]($matches[2]); 
 }
 } 
}
?>

For PHP 5.3 use second argument like "self::replace":
<?php
class test_preg_callback{
 private function process($text){
 $reg = "/\{([0-9a-zA-Z\- ]+)\:([0-9a-zA-Z\- ]+):?\}/";
 return preg_replace_callback($reg, "self::replace", $text);
 }
 
 private function replace($matches){
 if (method_exists($this, $matches[1])){
 return @$this->$matches[1]($matches[2]); 
 }
 } 
}
?>

A simple function to replace a list of complete words or terms in a string (for PHP 5.3 or above because of the closure):
<?php
function replace_words($list, $line, $callback) {
 return preg_replace_callback(
 '/(^|[^\\w\\-])(' . implode('|', array_map('preg_quote', $list)) . ')($|[^\\w\\-])/mi',
 function($v) use ($callback) { return $v[1] . $callback($v[2]) . $v[3]; },
 $line
 );
}
?>

Example of usage:
<?php
$list = array('php', 'apache web server');
$str = "php and the apache web server work fine together. php-gtk, for example, won't match. apache web servers shouldn't too.";
echo replace_words($list, $str, function($v) {
 return "<strong>{$v}</strong>";
});
?>

it is much better on preformance and better practice to use the preg_replace_callback function instead of preg_replace with the e modifier.
function a($text){return($text);}
// 2.76 seconds to run 50000 times
preg_replace("/\{(.*?)\}/e","a('\1円','\2円','\3円',\$b)",$a);
// 0.97 seconds to run 50000 times
preg_replace_callback("/\{(.*?)\}/s","a",$a);

<?php
// Nice little function that convert a string to uppercase by keeping the HTMLentities intact.
public static function strtoupper_entities($str) {
 $patternMajEntities = '/(\&([A-Z])(ACUTE|CEDIL|CARON|CIRC|GRAVE|ORN|RING|SLASH|TH|TILDE|UML)\;)+/';
 $str = preg_replace_callback ($patternMajEntities, 
 function ($matches) {
 return "&" . $matches[2] . strtolower($matches[3]) . ";";
 }, strtoupper($str));
 
 return $str;
}

The good version of the class PhpHex2Str
<?php
class PhpHex2Str
{
 private $strings;
 private static function x_hex2str($hex) {
 $hex = substr($hex[0], 1);
 $str = '';
 for($i=0;$i < strlen($hex);$i+=2) {
 $str.=chr(hexdec(substr($hex,$i,2)));
 }
 return $str;
 }
 public function decode($strings = null) {
 $this->strings = (string) $strings;
 return preg_replace_callback('#\%[a-zA-Z0-9]{2}#', 'PhpHex2Str::x_hex2str', $this->strings);
 }
}
// Exemple
$obj = new PhpHex2Str;
$strings = $obj->decode($strings);
var_dump($strings);
?>

Text lines numeration:
<?PHP
// Multieline text:
 $Text = "
Some 
Multieline
text
for
numeration";
// For count:
 $GLOBALS["LineNUMBER"] = 1;
// Replace linestart on number:
 PRINT preg_replace_callback("/^/m",function ()
 {
 return $GLOBALS["LineNUMBER"]++." ";
 },
 $Text);
?>

1
2 Some
3 Multieline
4 text
5 for
6 numeration

From PHP 5.3 you can use an anonymous function to pass local variables into the callback.
<?php
public function replace_variables( $subject, $otherVars ) {
 $linkPatterns = array(
 '/(<a .*)href=(")([^"]*)"([^>]*)>/U',
 "/(<a .*)href=(')([^']*)'([^>]*)>/U"
 );
 $callback = function( $matches ) use ( $otherVars ) {
 $this->replace_callback($matches, $otherVars);
 };
 return preg_replace_callback($this->patterns, $callback, $subject);
}
public function replace_callback($matches, $otherVars) {
 return $matches[1] . $otherVars['myVar'];
}
?>

<?php
$format = <<<SQL
CREATE DATABASE IF NOT EXISTS :database;
GRANT ALL PRIVILEGES ON :database_name.* TO ':user'@':host';
SET PASSWORD = PASSWORD(':pass');
SQL;
$args = ["database"=>"people", "user"=>"staff", "pass"=>"pass123", "host"=>"localhost"];
preg_replace_callback("/:(\w+)/", function ($matches) use ($args) {
 return @$args[$matches[1]] ?: $matches[0];
}, $format);
/*
Result:
CREATE DATABASE IF NOT EXISTS people;
GRANT ALL PRIVILEGES ON :database_name.* TO 'staff'@'localhost';
SET PASSWORD = PASSWORD('pass123');
The `:database_name` placeholder doesn't exist as a matching key in `$args` so it's returned as is.
This way you know you need to correct the array by adding the "database_name" item.
*/

The pcre.backtrack_limit option (added in PHP 5.2) can trigger a NULL return, with no errors. The default pcre.backtrack_limit value is 100000. If you have a match that exceeds about half this limit it triggers a NULL response.
e.g. My limit was at 100000 but 500500 triggered a NULL response. I'm not running unicode but I *guess* PCRE runs in utf-16.

Please note! if you have defined namespace,
the usage format must me changed:
echo preg_replace_callback(
 "|(\d{2}/\d{2}/)(\d{4})|",
 __NAMESPACE__ . '\\next_year',
 $text);