PHP string concatenation speed
Something I have always wondered is the speed difference between concatenation strings with in-string variables verses the . operator. I've always assumed . would be much faster, and today I found out.
$amount = 0x1FFFF; $start = microtime(true); while ($amount--) $throwAway = "this is a test at the $amount point!"; //$throwAway = "this is a test at the ". $amount ." point!"; echo "Time: ". (microtime(true) - $start);
Exactly as expected, leaving it up to in-string parsing of variables ended up with a bench mark time of 0.1574 and manually concatenating in the variable was 0.1384, which is not a huge difference, but I wanted to see how this would scale when doing multiple concatenations. The string was changed to $throwAway = "this is ". $amount ." a test ". $amount ." at the ". $amount ." point!"; and it's respective in-string.
What I found is that it actually scales to in-string far better! In-string averaged to 0.3235 and manual to 0.3597. After some research it turns out this is because it does a single large concatenation while manually doing it could perform the operation 3 separate times.
PHP Array Performance
Index Checking
The functional difference between array_key_exists($key, $array) and isset($array[$key]) is that isset returns false when the key exists but contains null. Functionality aside, there is a demonstrable performance difference.
$dataSet = array(); $size = 0x1FFFF; $i = $size; while ($i--) $dataSet[$i] = $i+1; $start = microtime(true); $i = $size; while ($i--) array_key_exists($i, $dataSet); //isset($dataSet[$i]); echo "Time: ". (microtime(true) - $start);
Sure enough, after averaging a few benchmarks together the outcome was clear.
- isset
- 0.0248870849609
- array_key_exists
- 0.604112148285
When performance is important target isset() when applicable. It's even possible to use a fall through to increase performance, here's an example from my Options class: if (!isset($this->_options[$resolvedName]) && !array_key_exists($resolvedName, $this->_options))
Append Performance
In the following test case there was no performance difference between usage of append or directly addressing an index.
$dataSet = array(); $size = 0x1FFFF; $i = $size; $start = microtime(true); while ($i--) $dataSet[] = $i+1; //$dataSet[$i] = $i+1; echo "Time: ". (microtime(true) - $start);
Remodeling PHP’s compact()/extract() into an OO Pattern
A common usage, at least for extract(), has been to allow an associative array to be passed to a function for use as named optional parameters, however, there is a lot wrong with dumping an array into the symbol table and then checking if what you want exists or not.
I have designed a pattern that allows an object to accept and address public level optional named arguments without the problems that could be associated with the compact()/extract() pattern. This pattern does require at least PHP 5.3 (uses late static binding) and overloads __get/__set preventing the child class from doing so.
Queryable Food Nutrition Database
The USDA releases data for food nutritional information. I've taken this data and loaded it into my local database, and created a front end to allow it to be queryable.
Database Schema
Message Hasher
A small web-based message hasher, good for generating hashes of small amounts of text. No binary support yet, but it's planned via file uploads!
Creating a Google Page Rank Finder in Javascript
An interesting technology are Google Page Rank Finders. What they do is discover which result and page number a website is in Google's search results for a given term.
I thought an interesting implementation would be a completely client side one written in Javascript using Google's search API. To spoil the ending, after creating this I discovered the API only allows 8 results per page and 8 pages, making this useless if the site is beyond the 64th result, but the API is interesting and powerful regardless.
The finished version can be found at pagerank.red-stars.net with the complete Javascript.