Tutorial :Hidden Features of PHP? [closed]



Question:

I know this sounds like a point-whoring question but let me explain where I'm coming from.

Out of college I got a job at a PHP shop. I worked there for a year and a half and thought that I had learned all there was to learn about programming.

Then I got a job as a one-man internal development shop at a sizable corporation where all the work was in C#. In my commitment to the position I started reading a ton of blogs and books and quickly realized how wrong I was to think I knew everything. I learned about unit testing, dependency injection and decorator patterns, the design principle of loose coupling, the composition over inheritance debate, and so on and on and on - I am still very much absorbing it all. Needless to say my programming style has changed entirely in the last year.

Now I find myself picking up a php project doing some coding for a friend's start-up and I feel completely constrained as opposed to programming in C#. It really bothers me that all variables at a class scope have to be referred to by appending '$this->' . It annoys me that none of the IDEs that I've tried have very good intellisense and that my SimpleTest unit tests methods have to start with the word 'test'. It drives me crazy that dynamic typing keeps me from specifying implicitly which parameter type a method expects, and that you have to write a switch statement to do method overloads. I can't stand that you can't have nested namespaces and have to use the :: operator to call the base class's constructor.

Now I have no intention of starting a PHP vs C# debate, rather what I mean to say is that I'm sure there are some PHP features that I either don't know about or know about yet fail to use properly. I am set in my C# universe and having trouble seeing outside the glass bowl.

So I'm asking, what are your favorite features of PHP? What are things you can do in it that you can't or are more difficult in the .Net languages?


Solution:1

Documentation. The documentation gets my vote. I haven't encountered a more thorough online documentation for a programming language - everything else I have to piece together from various websites and man pages.


Solution:2

Arrays. Judging from the answers to this question I don't think people fully appreciate just how easy and useful Arrays in PHP are. PHP Arrays act as lists, maps, stacks and generic data structures all at the same time. Arrays are implemented in the language core and are used all over the place which results in good CPU cache locality. Perl and Python both use separate language constructs for lists and maps resulting in more copying and potentially confusing transformations.


Solution:3

Stream Handlers allow you to extend the "FileSystem" with logic that as far as I know is quite difficult to do in most other languages.

For example with the MS-Excel Stream handler you can create a MS Excel file in the following way:

$fp = fopen("xlsfile://tmp/test.xls", "wb");  if (!is_resource($fp)) {       die("Cannot open excel file");  }    $data= array(      array("Name" => "Bob Loblaw", "Age" => 50),        array("Name" => "Popo Jijo", "Age" => 75),        array("Name" => "Tiny Tim", "Age" => 90)  );     fwrite($fp, serialize($data));  fclose($fp);  


Solution:4

Magic Methods are fall-through methods that get called whenever you invoke a method that doesn't exist or assign or read a property that doesn't exist, among other things.

interface AllMagicMethods {      // accessing undefined or invisible (e.g. private) properties      public function __get($fieldName);      public function __set($fieldName, $value);      public function __isset($fieldName);      public function __unset($fieldName);        // calling undefined or invisible (e.g. private) methods      public function __call($funcName, $args);      public static function __callStatic($funcName, $args); // as of PHP 5.3        // on serialize() / unserialize()      public function __sleep();      public function __wakeup();        // conversion to string (e.g. with (string) $obj, echo $obj, strlen($obj), ...)      public function __toString();        // calling the object like a function (e.g. $obj($arg, $arg2))      public function __invoke($arguments, $...);        // called on var_export()      public static function __set_state($array);  }  

A C++ developer here might notice, that PHP allows overloading some operators, e.g. () or (string). Actually PHP allows overloading even more, for example the [] operator (ArrayAccess), the foreach language construct (Iterator and IteratorAggregate) and the count function (Countable).


Solution:5

The standard class is a neat container. I only learned about it recently.

Instead of using an array to hold serveral attributes

$person = array();  $person['name'] = 'bob';  $person['age'] = 5;  

You can use a standard class

$person = new stdClass();  $person->name = 'bob';  $person->age = 5;  

This is particularly helpful when accessing these variables in a string

$string = $person['name'] . ' is ' . $person['age'] . ' years old.';  // vs  $string = "$person->name is $person->age years old.";  


Solution:6

Include files can have a return value you can assign to a variable.

// config.php  return array(      'db' => array(          'host' => 'example.org',          'user' => 'usr',          // ...      ),      // ...  );    // index.php  $config = include 'config.php';  echo $config['db']['host']; // example.org  


Solution:7

You can take advantage of the fact that the or operator has lower precedence than = to do this:

$page = (int) @$_GET['page']     or $page = 1;  

If the value of the first assignment evaluates to true, the second assignment is ignored. Another example:

$record = get_record($id)     or throw new Exception("...");  


Solution:8

__autoload() (class-) files aided by set_include_path().

In PHP5 it is now unnecessary to specify long lists of "include_once" statements when doing decent OOP.

Just define a small set of directory in which class-library files are sanely structured, and set the auto include path:

set_include_path(get_include_path() . PATH_SEPARATOR . '../libs/');`  

Now the __autoload() routine:

function __autoload($classname) {      // every class is stored in a file "libs/classname.class.php"        // note: temporary alter error_reporting to prevent WARNINGS      // Do not suppress errors with a @ - syntax errors will fail silently!        include_once($classname . '.class.php');  }  

Now PHP will automagically include the needed files on-demand, conserving parsing time and memory.


Solution:9

Easiness. The greatest feature is how easy it is for new developers to sit down and write "working" scripts and understand the code.

The worst feature is how easy it is for new developers to sit down and write "working" scripts and think they understand the code.

The openness of the community surrounding PHP and the massive amounts of PHP projects available as open-source is a lot less intimidating for someone entering the development world and like you, can be a stepping stone into more mature languages.

I won't debate the technical things as many before me have but if you look at PHP as a community rather than a web language, a community that clearly embraced you when you started developing, the benefits really speak for themselves.


Solution:10

Variable variables and functions without a doubt!

$foo = 'bar';  $bar = 'foobar';  echo $$foo;    //This outputs foobar    function bar() {      echo 'Hello world!';  }    function foobar() {      echo 'What a wonderful world!';  }  $foo();    //This outputs Hello world!  $$foo();    //This outputs What a wonderful world!  

The same concept applies to object parameters ($some_object->$some_variable);

Very, very nice. Make's coding with loops and patterns very easy, and it's faster and more under control than eval (Thanx @Ross & @Joshi Spawnbrood!).t


Solution:11

You can use functions with a undefined number of arguments using the func_get_args().

<?php    function test() {        $args = func_get_args();      echo $args[2]; // will print 'd'      echo $args[1]; // will print 3  }    test(1,3,'d',4);    ?>  


Solution:12

I love remote files. For web development, this kind of feature is exceptionally useful.

Need to work with the contents of a web page? A simple

$fp = fopen('http://example.com');  

and you've got a file handle ready to go, just like any other normal file.

Or how about reading a remote file or web page directly in to a string?

$str = file_get_contents('http://example.com/file');  

The usefulness of this particular method is hard to overstate.

Want to analyze a remote image? How about doing it via FTP?

$imageInfo = getimagesize('ftp://user:password@ftp.example.com/image/name.jpg');  

Almost any PHP function that works with files can work with a remote file. You can even include() or require() code files remotely this way.


Solution:13

strtr()

It's extremely fast, so much that you would be amazed. Internally it probably uses some crazy b-tree type structure to arrange your matches by their common prefixes. I use it with over 200 find and replace strings and it still goes through 1MB in less than 100ms. For all but trivially small strings strtr() is even significantly faster than strtolower() at doing the exact same thing, even taking character set into account. You could probably write an entire parser using successive strtr calls and it'd be faster than the usual regular expression match, figure out token type, output this or that, next regular expression kind of thing.

I was writing a text normaliser for splitting text into words, lowercasing, removing punctuation etc and strtr was my Swiss army knife, it beat the pants off regular expressions or even str_replace().


Solution:14

One not so well known feature of PHP is extract(), a function that unpacks an associative array into the local namespace. This probably exists for the autoglobal abormination but is very useful for templating:

function render_template($template_name, $context, $as_string=false)  {      extract($context);      if ($as_string)          ob_start();      include TEMPLATE_DIR . '/' . $template_name;      if ($as_string)          return ob_get_clean();  }  

Now you can use render_template('index.html', array('foo' => 'bar')) and only $foo with the value "bar" appears in the template.


Solution:15

Range() isn't hidden per se, but I still see a lot of people iterating with:

for ($i=0; $i < $x; $i++) {       // code...  }  

when they could be using:

foreach (range(0, 12) as $number) {      // ...  }  

And you can do simple things like

foreach (range(date("Y"), date("Y")+20) as $i)  {  print "\t<option value=\"{$i}\">{$i}</option>\n";  }  


Solution:16

PHP enabled webspace is usually less expensive than something with (asp).net. You might call that a feature ;-)


Solution:17

The static keyword is useful outside of a OOP standpoint. You can quickly and easily implement 'memoization' or function caching with something as simple as:

<?php  function foo($arg1)  {      static $cache;        if( !isset($cache[md5($arg1)]) )      {          // Do the work here          $cache[md5($arg1)] = $results;      }        return $cache[md5($arg1)];  }  ?>  

The static keyword creates a variable that persists only within the scope of that function past the execution. This technique is great for functions that hit the database like get_all_books_by_id(...) or get_all_categories(...) that you would call more than once during a page load.

Caveat: Make sure you find out the best way to make a key for your hash, in just about every circumstance the md5(...) above is NOT a good decision (speed and output length issues), I used it for illustrative purposes. sprintf('%u', crc32(...)) or spl_object_hash(...) may be much better depending on the context.


Solution:18

One nice feature of PHP is the CLI. It's not so "promoted" in the documentation but if you need routine scripts / console apps, using cron + php cli is really fast to develop!


Solution:19

Then "and print" trick

<?php $flag and print "Blah" ?>  

Will echo Blah if $flag is true. DOES NOT WORK WITH ECHO.

This is very handy in template and replace the ? : that are not really easy to read.


Solution:20

You can use minus character in variable names like this:

class style  {    ....    function set_bg_colour($c)    {      $this->{'background-color'} = $c;    }  }  

Why use it? No idea: maybe for a CSS model? Or some weird JSON you need to output. It's an odd feature :)


Solution:21

HEREDOC syntax is my favourite hidden feature. Always difficult to find as you can't Google for <<< but it stops you having to escape large chunks of HTML and still allows you to drop variables into the stream.

echo <<<EOM    <div id="someblock">      <img src="{$file}" />    </div>  EOM;  


Solution:22

Probably not many know that it is possible to specify constant "variables" as default values for function parameters:

function myFunc($param1, $param2 = MY_CONST)  {  //code...  }  

Strings can be used as if they were arrays:

$str = 'hell o World';  echo $str; //outputs: "hell o World"    $str[0] = 'H';  echo $str; //outputs: "Hell o World"    $str[4] = null;  echo $str; //outputs: "Hello World"  


Solution:23

The single most useful thing about PHP code is that if I don't quite understand a function I see I can look it up by using a browser and typing:

http://php.net/function

Last month I saw the "range" function in some code. It's one of the hundreds of functions I'd managed to never use but turn out to be really useful:

http://php.net/range

That url is an alias for http://us2.php.net/manual/en/function.range.php. That simple idea, of mapping functions and keywords to urls, is awesome.

I wish other languages, frameworks, databases, operating systems has as simple a mechanism for looking up documentation.


Solution:24

Fast block comments

/*      die('You shall not pass!');  //*/      //*      die('You shall not pass!');  //*/  

These comments allow you to toggle if a code block is commented with one character.


Solution:25

My list.. most of them fall more under the "hidden features" than the "favorite features" (I hope!), and not all are useful, but .. yeah.

// swap values. any number of vars works, obviously    list($a, $b) = array($b, $a);    // nested list() calls "fill" variables from multidim arrays:    $arr = array(      array('aaaa', 'bbb'),      array('cc', 'd')    );    list(list($a, $b), list($c, $d)) = $arr;    echo "$a $b $c $d"; // -> aaaa bbb cc d      // list() values to arrays    while (list($arr1[], $arr2[], $arr3[]) = mysql_fetch_row($res)) { .. }    // or get columns from a matrix    foreach($data as $row) list($col_1[], $col_2[], $col_3[]) = $row;    // abusing the ternary operator to set other variables as a side effect:    $foo = $condition ? 'Yes' . (($bar = 'right') && false) : 'No' . (($bar = 'left') && false);    // boolean False cast to string for concatenation becomes an empty string ''.    // you can also use list() but that's so boring ;-)    list($foo, $bar) = $condition ? array('Yes', 'right') : array('No', 'left');  

You can nest ternary operators too, comes in handy sometimes.

// the strings' "Complex syntax" allows for *weird* stuff.    // given $i = 3, if $custom is true, set $foo to $P['size3'], else to $C['size3']:    $foo = ${$custom?'P':'C'}['size'.$i];    $foo = $custom?$P['size'.$i]:$C['size'.$i]; // does the same, but it's too long ;-)    // similarly, splitting an array $all_rows into two arrays $data0 and $data1 based    // on some field 'active' in the sub-arrays:    foreach ($all_rows as $row) ${'data'.($row['active']?1:0)}[] = $row;    // slight adaption from another answer here, I had to try out what else you could    // abuse as variable names.. turns out, way too much...    $string = 'f.> <!-? o+';    ${$string} = 'asdfasf';    echo ${$string}; // -> 'asdfasf'    echo $GLOBALS['f.> <!-? o+']; // -> 'asdfasf'    // (don't do this. srsly.)    ${''} = 456;    echo ${''}; // -> 456    echo $GLOBALS['']; // -> 456    // I have no idea.    

Right, I'll stop for now :-)


Hmm, it's been a while..

// just discovered you can comment the hell out of php:  $q/* snarf */=/* quux */$_GET/* foo */[/* bar */'q'/* bazz */]/* yadda */;  

So, just discovered you can pass any string as a method name IF you enclose it with curly brackets. You can't define any string as a method alas, but you can catch them with __call(), and process them further as needed. Hmmm....

class foo {    function __call($func, $args) {      eval ($func);    }  }    $x = new foo;  $x->{'foreach(range(1, 10) as $i) {echo $i."\n";}'}();  

Found this little gem in Reddit comments:

$foo = 'abcde';  $strlen = 'strlen';  echo "$foo is {$strlen($foo)} characters long."; // "abcde is 5 characters long."  

You can't call functions inside {} directly like this, but you can use variables-holding-the-function-name and call those! (*and* you can use variable variables on it, too)


Solution:26

Array manipulation.
Tons of tools for working with and manipulating arrays. It may not be unique to PHP, but I've never worked with a language that made it so easy.


Solution:27

I'm a bit like you, I've coded PHP for over 8 years. I had to take a .NET/C# course about a year ago and I really enjoyed the C# language (hated ASP.NET) but it made me a better PHP developer.

PHP as a language is pretty poor, but, I'm extremely quick with it and the LAMP stack is awesome. The end product far outweighs the sum of the parts.

That said, in answer to your question:

http://uk.php.net/SPL

I love the SPL, the collection class in C# was something that I liked as soon as I started with it. Now I can have my cake and eat it.

Andrew


Solution:28

I'm a little surprised no-one has mentioned it yet, but one of my favourite tricks with arrays is using the plus operator. It is a little bit like array_merge() but a little simpler. I've found it's usually what I want. In effect, it takes all the entries in the RHS and makes them appear in a copy of the LHS, overwriting as necessary (i.e. it's non-commutative). Very useful for starting with a "default" array and adding some real values all in one hit, whilst leaving default values in place for values not provided.

Code sample requested:

// Set the normal defaults.  $control_defaults = array( 'type' => 'text', 'size' => 30 );    // ... many lines later ...    $control_5 = $control_defaults + array( 'name' => 'surname', 'size' => 40 );  // This is the same as:  // $control_5 = array( 'type' => 'text', 'name' => 'surname', 'size' => 40 );  


Solution:29

Here's one, I like how setting default values on function parameters that aren't supplied is much easier:

function MyMethod($VarICareAbout, $VarIDontCareAbout = 'yippie') { }  


Solution:30

Quick and dirty is the default.
The language is filled with useful shortcuts, This makes PHP the perfect candidate for (small) projects that have a short time-to-market. Not that clean PHP code is impossible, it just takes some extra effort and experience.

But I love PHP because it lets me express what I want without typing an essay.

PHP:

if (preg_match("/cat/","one cat")) {     // do something  }  

JAVA:

import java.util.regex.*;  Pattern p = Pattern.compile("cat");  Matcher m = p.matcher("one cat")  if (m.find()) {    // do something  }  

And yes, that includes not typing Int.


Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »