This way vs this way?

[spiritssight]

Hello,

I for some reason can not find in my post where a person said they like one way better then the other way.

Ok, here is the question:
Which way is the better way and why do you think this?
". $POST['test']." // with and without '' or "" in the []
{$POST['test']} // with and without '' or "" in the []
and if there is other ways of doing this

ok, here is another question:
should one user ". $var ." or '. $var.' with a echo that has strings like html?
which one would be better when doing some thing with a db?

I keep going back and forth withen my code as I am not sure which way is the better way.

Sincerely,
Christopher

[bradgrafelman]

spiritssight wrote:

". $POST['test']." // with and without '' or "" in the []
{$POST['test']} // with and without '' or "" in the []

Which is better, an apple or an orange? There is no definitive answer to that question - it's up to you to decide which fits your programming style better. I will say that either example without quotes inside the [] brackets is incorrect as this will generate an E_WARNING error message (array indexes are strings, not constants, unless you specifically [man]define/man'ed a constant and are intentionally using it).

spiritssight wrote:

should one user ". $var ." or '. $var.' with a echo that has strings like html?
which one would be better when doing some thing with a db?

Again, should you buy an apple or should you buy an orange? It's up to you to decide - both will work.

There's nothing wrong with mixing the two, especially if it would make it easier to type rather than escaping every quote within the string. Example:

$author = 'Brad';

echo '<div id="comment">Since this is "HTML" code, and it has these double quotes ( " ), I used a single quote ( \' ) to delimit this string.</div>' . "\n";

echo "<p>Note that I, $author, mixed quote delimiters.</p>\n";

[NogDog]

There is a slight performance disadvantage to having variables interpolated within double-quoted strings versus concatenating them (via the "." operator). However, that difference is so small that for 99.9% of the applications we work on, it's probably not worth worrying about, and it's probably better to go with whatever method makes your code the easiest to read and maintain.

When things start to get really complex, my personal preference is the [man]sprintf[/man]/[man]printf/man method, which is even slower than the interpolation method but which can avoid some ugly messes:

// ugly:
$sql = "SELECT * FROM table WHERE col1 ='" . mysql_real_escape_string($_SESSION['val1']) .
       "' AND col2 = '" . mysql_real_escape_string($data[$ix]['val2']) . "'";

// not so ugly:
$sql = sprintf(
   "SELECT * FROM table WHERE col1 = '%s' AND col2 = '%s'",
   mysql_real_escape_string($_SESSION['val1']),
   mysql_real_escape_string($data[$ix]['val2'])
);

[bradgrafelman]

NogDog wrote:

that difference is so small that for 99.9% of the applications we work on, it's probably not worth worrying about

That's the only reason I didn't mention it... I figure if you've got nothing more to optimize than single vs. double quoted strings, then you might as well just buy a faster processor and ignore the difference! :p

I did forget to mention your sprintf() method when doing SQL queries, though - I'm pretty sure you (indirectly) are the one who I've copied that method from when doing SQL queries myself! If you're not using [man]PDO[/man] and prepared statements and whatnot, sprintf() does seem like a positive step (albeit a small one) in that direction IMHO.

[Weedpacket]

bradgrafelman wrote:

I figure if you've got nothing more to optimize than single vs. double quoted strings...

I figured (literally) that the speed difference between the two was so slight that it would be wiped out by the time it took to edit the source from one to the other, even after a million executions. Even assuming no mistakes en route.

I did have my reasons. One of them was to avoid a diktat which would have meant doing exactly that.

[Joseph07]

I'm not sure where did I read this but it says that

// Single Quote
$_POST['hello'];
// Is much better than double quote
$_POST["hello"];

So my practices is to write it with single quote.

[NogDog]

Decided to run my own test:

<?php
header('Content-Type: text/plain');
$tests = 5;
$runs = 100000;
$var = '';
microtime(); // prime the pump for this function
$testData = array();
$string = 'a test';

for($test = 1; $test <= $tests; $test++)
{
   // single quote
   $testData['single quote']['start'] = microtime(true);
   for($i = 1; $i <= $runs; $i++)
   {
      $var = 'This is a test. It is only a test.';
   }
   $testData['single quote']['end'] = microtime(true);

   // double quote
   $testData['double quote']['start'] = microtime(true);
   for($i = 1; $i <= $runs; $i++)
   {
      $var = "This is a test. It is only a test.";
   }
   $testData['double quote']['end'] = microtime(true);

   // double quote with interpolation
   $testData['interpolation']['start'] = microtime(true);
   for($i = 1; $i <= $runs; $i++)
   {
      $var = "This is $string. It is only $string.";
   }
   $testData['interpolation']['end'] = microtime(true);

   // single quote with concatenation
   $testData['concatenation']['start'] = microtime(true);
   for($i = 1; $i <= $runs; $i++)
   {
      $var = 'This is ' . $string . '. It is only ' . $string .'.';
   }
   $testData['concatenation']['end'] = microtime(true);

   // sprintf()
   $testData['sprintf']['start'] = microtime(true);
   for($i = 1; $i <= $runs; $i++)
   {
      $var = sprintf('This is %s. It is only %s.', $string, $string);
   }
   $testData['sprintf']['end'] = microtime(true);

   echo "\nTest $test:\n";
   foreach($testData as $key => $case)
   {
      printf("%-13s : %.6f sec.\n", $key, $case['end'] - $case['start']);
   }
}

Results:

Test 1:
single quote  : 0.048748 sec.
double quote  : 0.069866 sec.
interpolation : 0.269186 sec.
concatenation : 0.131611 sec.
sprintf       : 0.278026 sec.

Test 2:
single quote  : 0.049839 sec.
double quote  : 0.054555 sec.
interpolation : 0.242619 sec.
concatenation : 0.121509 sec.
sprintf       : 0.241977 sec.

Test 3:
single quote  : 0.043801 sec.
double quote  : 0.051809 sec.
interpolation : 0.245308 sec.
concatenation : 0.107619 sec.
sprintf       : 0.239919 sec.

Test 4:
single quote  : 0.054118 sec.
double quote  : 0.043594 sec.
interpolation : 0.238972 sec.
concatenation : 0.095669 sec.
sprintf       : 0.248440 sec.

Test 5:
single quote  : 0.044829 sec.
double quote  : 0.051337 sec.
interpolation : 0.225972 sec.
concatenation : 0.116391 sec.
sprintf       : 0.233471 sec.

My analysis:

• The difference between single and double quotes is none, for all practical purposes.

• Embedding variables within a string is fastest using concatenation.

• Variable interpolation within a double-quoted string or via sprintf() are roughly equivalent, taking about twice as long as concatenation. *

---

• However, note that based on the test runs above using 100000 iterations, we are literally talking single-digit microseconds per occurrence, so still nothing to lose sleep over unless you are working on a web site with millions of hits a day, and anyway probably lost in the noise compared to the I/O times needed for reading include files and such.