The Basics

Comparison operators

Comparison operators are an often overlooked aspect of PHP, which can lead to many unexpected outcomes. One such problem stems from strict comparisons (the comparison of booleans as integers).

<?php
$a = 5;   // 5 as an integer

var_dump($a == 5);       // compare value; return true
var_dump($a == '5');     // compare value (ignore type); return true
var_dump($a === 5);      // compare type/value (integer vs. integer); return true
var_dump($a === '5');    // compare type/value (integer vs. string); return false

/**
 * Strict comparisons
 */
if (strpos('testing', 'test')) {    // 'test' is found at position 0, which is interpreted as the boolean 'false'
    // code...
}

// vs

if (strpos('testing', 'test') !== false) {    // true, as strict comparison was made (0 !== false)
    // code...
}

Conditional statements

If statements

While using ‘if/else’ statements within a function or class, there is a common misconception that ‘else’ must be used in conjunction to declare potential outcomes. However if the outcome is to define the return value, ‘else’ is not necessary as ‘return’ will end the function, causing ‘else’ to become moot.

<?php
function test($a)
{
    if ($a) {
        return true;
    } else {
        return false;
    }
}

// vs

function test($a)
{
    if ($a) {
        return true;
    }
    return false;    // else is not necessary
}

If statements

Switch statements

Switch statements are a great way to avoid typing endless if’s and elseif’s, but there are a few things to be aware of:

Switch statements only compare values, and not the type (equivalent to ‘==’)
They Iterate case by case until a match is found. If no match is found, then the default is used (if defined)
Without a ‘break’, they will continue to implement each case until reaching a break/return
Within a function, using ‘return’ alleviates the need for ‘break’ as it ends the function

<?php
$answer = test(2);    // the code from both 'case 2' and 'case 3' will be implemented

function test($a)
{
    switch ($a) {
        case 1:
            // code...
            break;             // break is used to end the switch statement
        case 2:
            // code...         // with no break, comparison will continue to 'case 3'
        case 3:
            // code...
            return $result;    // within a function, 'return' will end the function
        default:
            // code...
            return $error;
    }
}

Global namespace

When using namespaces, you may find that internal functions are hidden by functions you wrote. To fix this, refer to the global function by using a backslash before the function name.

<?php
namespace phptherightway;

function fopen()
{
    $file = \fopen();    // Our function name is the same as an internal function.
                         // Execute the function from the global space by adding '\'.
}

function array()
{
    $iterator = new \ArrayIterator();    // ArrayIterator is an internal class. Using its name without a backslash
                                         // will attempt to resolve it within your namespace.
}

Strings

Concatenation

If your line extends beyond the recommended line length (120 characters), consider concatenating your line
For readability it is best to use concatenation operators over concatenating assignment operators
While within the original scope of the variable, indent when concatenation uses a new line

<?php
$a  = 'Multi-line example';    // concatenating assignment operator (.=)
$a .= "\n";
$a .= 'of what not to do';

// vs

$a = 'Multi-line example'      // concatenation operator (.)
    . "\n"                     // indenting new lines
    . 'of what to do';

String Operators

String types

String types are a constant feature within the PHP community, but hopefully this section will explain the differences between the string types and their benefits/uses.

Single quotes

Single quotes are the simplest way to define a string and are often the quickest. Their speed stems from PHP not parsing the string (does not parse for variables). They are best suited for:

Strings that do not need to be parsed
Writing of a variable into plain text

<?php
echo 'This is my string, look at how pretty it is.';    // no need to parse a simple string

/**
 * Output:
 *
 * This is my string, look at how pretty it is.
 */

Single quote

Double quotes

Double quotes are the Swiss army knife of strings, but are slower due to the string being parsed. They are best suited for:

Escaped strings
Strings with multiple variables and plain text
Condensing multi-line concatenation, and improving readability

<?php
echo 'phptherightway is ' . $adjective . '.'     // a single quotes example that uses multiple concatenating for
    . "\n"                                       // variables and escaped string
    . 'I love learning' . $code . '!';

// vs

echo "phptherightway is $adjective.\n I love learning $code!"  // Instead of multiple concatenating, double quotes
                                                               // enables us to use a parsable string

While using double quotes that contain variables, it is often the case that the variable will be touching another character. This will result in PHP not parsing the variable due to the variable being camouflaged. To fix this problem, wrap the variable within a pair of curly brackets.

<?php
$juice = 'plum';
echo "I drank some juice made of $juices";    // $juice cannot be parsed

// vs

$juice = 'plum';
echo "I drank some juice made of {$juice}s";    // $juice will be parsed

/**
 * Complex variables will also be parsed within curly brackets
 */

$juice = array('apple', 'orange', 'plum');
echo "I drank some juice made of {$juice[1]}s";   // $juice[1] will be parsed

Double quotes

Nowdoc syntax

Nowdoc syntax was introduced in 5.3 and internally behaves the same way as single quotes except it is suited toward the use of multi-line strings without the need for concatenating.

<?php
$str = <<<'EOD'             // initialized by <<<
Example of string
spanning multiple lines
using nowdoc syntax.
$a does not parse.
EOD;                        // closing 'EOD' must be on it's own line, and to the left most point

/**
 * Output:
 *
 * Example of string
 * spanning multiple lines
 * using nowdoc syntax.
 * $a does not parse.
 */

Nowdoc syntax

Heredoc syntax

Heredoc syntax internally behaves the same way as double quotes except it is suited toward the use of multi-line strings without the need for concatenating.

<?php
$a = 'Variables';

$str = <<<EOD               // initialized by <<<
Example of string
spanning multiple lines
using heredoc syntax.
$a are parsed.
EOD;                        // closing 'EOD' must be on it's own line, and to the left most point

/**
 * Output:
 *
 * Example of string
 * spanning multiple lines
 * using heredoc syntax.
 * Variables are parsed.
 */

Heredoc syntax

Ternary operators

Ternary operators are a great way to condense code, but are often used in excess. While ternary operators can be stacked/nested, it is advised to use one per line for readability.

<?php
$a = 5;
echo ($a == 5) ? 'yay' : 'nay';

In comparison, here is an example that sacrifices all forms of readability for the sake of reducing the line count.

<?php
echo ($a) ? ($a == 5) ? 'yay' : 'nay' : ($b == 10) ? 'excessive' : ':(';    // excess nesting, sacrificing readability

To ‘return’ a value with ternary operators use the correct syntax.

<?php
$a = 5;
echo ($a == 5) ? return true : return false;    // this example will output an error

// vs

$a = 5;
return ($a == 5) ? 'yay' : 'nope';    // this example will return 'yay'

It should be noted that you do not need to use a ternary operator for returning a boolean value. An example of this would be.

<?php
$a = 3;
return ($a == 3) ? true : false; // Will return true or false if $a == 3

// vs

$a = 3;
return $a == 3; // Will return true or false if $a == 3

This can also be said for all operations(===, !==, !=, == etc).

Utilising brackets with ternary operators for form and function

When utilising a ternary operator, brackets can play their part to improve code readability and also to include unions within blocks of statements. An example of when there is no requirement to use bracketing is:

<?php
$a = 3;
return ($a == 3) ? "yay" : "nope"; // return yay or nope if $a == 3

// vs

<?php
$a = 3;
return $a == 3 ? "yay" : "nope"; // return yay or nope if $a == 3

Bracketing also affords us the capability of creating unions within a statement block where the block will be checked as a whole. Such as this example below which will return true if both ($a == 3 and $b == 4) are true and $c == 5 is also true.

<?php
return ($a == 3 && $b == 4) && $c == 5;

Another example is the snippet below which will return true if ($a != 3 AND $b != 4) OR $c == 5.

<?php
return ($a != 3 && $b != 4) || $c == 5;

Ternary operators

Variable declarations

At times, coders attempt to make their code “cleaner” by declaring predefined variables with a different name. What this does in reality is to double the memory consumption of said script. For the example below, let us say an example string of text contains 1MB worth of data, by copying the variable you’ve increased the scripts execution to 2MB.

<?php
$about = 'A very long string of text';    // uses 2MB memory
echo $about;

// vs

echo 'A very long string of text';        // uses 1MB memory

Performance tips