with printf or sprintf characters preceded by the % sign are placeholders (or tokens). They will be replaced by a variable passed as an argument.

Example:

$str1 = 'best';
$str2 = 'world';

$say = sprintf('Tivie is the %s in the %s!', $str1, $str2);
echo $say;

This will output:

Tivie is the best in the world!

Note: There are more placeholders (%s for string, %d for dec number, etc...)

Order:

The order in which you pass the arguments counts. If you switch $str1 with $str2 as

$say = sprintf('Tivie is the %s in the %s!', $str2, $str1); 

it will print

"Tivie is the world in the best!"

You can, however, change the reading order of arguments like this:

$say = sprintf('Tivie is the %2$s in the %1$s!', $str2, $str1);

which will print the sentence correctly.

Also, keep in mind that PHP is a dynamic language and does not require (or support) explicit type definition. That means it juggles variable types as needed. In sprint it means that if you pass a "string" as argument for a number placeholder (%d), that string will be converted to a number (int, float...) which can have strange results. Here's an example:

$onevar = 2;
$anothervar = 'pocket';
$say = sprintf('I have %d chocolate(s) in my %d.', $onevar, $anothervar);
echo $say;

this will print

I have 2 chocolate(s) in my 0.

More reading at PHPdocs

It is hard to use DOMDocument in this specific case, since it wraps automatically text nodes with <p> tags (and add doctype, head, html). A way is to construct a pattern as a lexer using the (?(DEFINE)...) feature and named subpatterns:

$html = <<<EOD
Don't wrap me<p>Hello</p><div class="text">wrap me please!</div><span class="title">wrap me either!</span> Don't wrap me <h1>End</h1>
EOD;

$pattern = <<<'EOD'
~
(?(DEFINE)
    (?<self>    < [^W_]++ [^>]* > )
    (?<comment> <!-- (?>[^-]++|-(?!->))* -->)
    (?<cdata>   Q<![CDATA[E (?>[^]]++|](?!]>))* ]]> )
    (?<text>    [^<]++ )
    (?<tag>
        < ([^W_]++) [^>]* >
        (?> g<text> | g<tag> | g<self> | g<comment> | g<cdata> )*
        </ g{-1} >
    )
)
# main pattern
(?: g<tag> | g<self> | g<comment> | g<cdata> )+
~x
EOD;

$html = preg_replace($pattern, '<code>$0</code>', $html);

echo htmlspecialchars($html);

The (?(DEFINE)..) feature allows to put a definition section inside a regex pattern. This definition section and the named subpatterns inside don't match nothing, they are here to be used later in the main pattern.

(?<abcd> ...) defines a subpattern you can reuse later with g<abcd>. In the above pattern, subpatterns defined in this way are:

• self: that describes a self-closing tag
• comment: for html comments
• cdata: for cdata
• text: for text (all that is not a tag, a comment, or cdata)
• tag: for html tags that are not self-closed

self:
[^W_] is a trick to obtain w without the underscore. [^W]++ represents the tag name and is used too in the tag subpattern.
[^>]* means all that is not a > zero or more times.

comment:
(?>[^-]++|-(?!->))* describes all the possible content inside an html comment:

(?>          # open an atomic group
    [^-]++   # all that is not a literal -, one or more times (possessive)
  |          # OR
    -        # a literal -
    (?!->)   # not followed by -> (negative lookahead)
)*           # close and repeat the group zero or more times 

cdata:
All characters between Q..E are seen as literal characters, special characters like [ don't need to be escaped. (This only a trick to make the pattern more readable).
The content allowed in CDATA is described in the same way than the content in html comments.

text:
[^<]++ all characters until an opening angle bracket or the end of the string.

tag:
This is the most insteresting subpattern. Lines 1 and 3 are the opening and the closing tag. Note that, in line 1, the tag name is captured with a capturing group. In line 3, g{-1} refers to the content matched by the last defined capturing group ("-1" means "one on the left").
The line 2 describes the possible content between an opening and a closing tag. You can see that this description use not only subpatterns defined before but the current subpattern itself to allow nested tags.

Once all items have been set and the definition section closed, you can easily write the main pattern.

'#someDiv' is a CSS3CSS selector which is semantically equivalent to getElementById('someDiv'), in that it will select the element with ID 'someDiv'. So:

document.getElementById('someDiv')

==

// bracket notation will return a DOM element
$("#someDiv")[0]

// leaving it out will return a jQuery object
$("#someDiv")