Search, Modify and Replace

hcooper

I've written a script to move a static blog system over to wordpress, and in the process need to change the format of hyperlinks.

I need to convert:

[[My Link|[url]http://www.link.com]][/url]

into the standard HTML format:

I can handle the whole database side, but would appreciate advise on how to do this search, modify and replace in a block of text.

Cheers.

sneakyimp

This code might help. Get the text you want to modify into $var and then $foo should have the modified text

<?

$var = "Here is some text with links [[Link One|http://www.link1.com]] and more \n\n\nlinks [[Link Two|http://www.link2.com]] and beyond that there is not much to say\n";

$pattern = '/\[\[(.*)\|(.*)\]\]/';
$replace = '<a href="$2">$1</a>';

$foo = preg_replace($pattern, $replace, $var);

echo $foo;

?>

hcooper

Thanks for the help. I've found the code works alright with multiple links if they are on separate lines. However if there are two links on one line, the output is a little confused:

this is <a href="http://link2.com">a test|[url]http://link.com]][/url] and here is [[another link</a> and so on

<?php

$linkpat = '/\[\[(.*)\|(.*)\]\]/';
$linkhtml = '<a href="$2">$1</a>';

$testcontent = "this is [[a test|http://link.com]] and here is [[another link|http://link2.com]] and so on";
$testcontent = preg_replace($linkpat, $linkhtml, $testcontent);
echo $testcontent;

?>

Any ideas on how to fix it?

sneakyimp

Add the U modifier to the pattern. This will make wildcards 'ungreedy'. Like this:

    $linkpat = '/\[\[(.*)\|(.*)\]\]/U';

nrg_alpha

I would suggest this:

$var = "Here is some text with links [[Link One|http://www.link1.com]] and more \n\n\nlinks [[Link Two|http://www.link2.com]] and beyond that there is not much to say\n";
$var = preg_replace('#\[\[([^|]+)\|([^]]+)\]\]#', '<a href="$2">$1</a>', $var);

Just to add a note on using .* - this is a very highly inefficient way of doing things...

As an extremely simplified example (from another post of mine):
Say your string is: "I'm Gerry, hi!"
And suppose you are using this pattern: #(.*)gerry#i

What happens is regex sees .* and greedily captures everything up to the end.. so at this point, the capture is equal to the whole string (I'm Gerry, hi!). Along the way, the engine is inserting saved states (position markers between each character) as it captures each character greedily.

However, since there is more after the (.) in the pattern (in this case, the letters g,e,r,r and y), the engine attempts to satisfy the rest of the pattern. So is starts to backtrack.. it relinquishes the last saved state character from the capture (which points to the ! character) and checks to see if this character is the same as the first character that follows (.) in the pattern [in this case, the g in gerry]. Nope.. now the engine must go backtrack and relinquish yet another saved state character from the capture and see if that character (i) matches g. Nope. So on and on the engine backtracks in reverse order and checks to see if the newest backtracked character matches.. only when the engine reaches g, does things start to move forward again..thus Gerry (case insensitive due to the I modifier) indeed follows after (.) So we are left with (I'm ) as the capture...this is alot of work to capture what comes before Gerry in the string.. While this example is a small one, it gets worse when you use . or .+ to find something in the middle of much larger chunks of data.

So in my case in the ULR replacement, I made use of negated character classes instead. Example: ([^|]+) // capture anything that is not a pipe character, one or more times.. this doesn't require backtracking, thus saves the regex engine some work and as a result is faster. While I realize there are some newlines in the middle of the string (and as a result, (.*) wouldn't capture all the way to the end of the complete string), it still requires some backtracking...

Just something to consider.

sneakyimp

That sounds like good, knowledgeable advice to me.