PHP Cheat Sheet

define("CURRENT\_DATE", date('Y-m-d'));
// One possible representation
echo CURRENT_DATE;   # => 2021-01-05
# => CURRENT\_DATE is: 2021-01-05
echo 'CURRENT\_DATE is: ' . CURRENT_DATE; 

$str = "Visit Quickref.me";
echo preg\_match("/qu/i", $str); # => 1

See: Regex in PHP

// As of PHP 8.0.0, this line:
$result = $repo?->getUser(5)?->name;
// Equivalent to the following code:
if (is\_null($repo)) {
    $result = null;
} else {
    $user = $repository->getUser(5);
    if (is\_null($user)) {
        $result = null;
    } else {
        $result = $user->name;
    }
}

See also: Nullsafe Operator

class MyException extends Exception {
    // do something
}

Usage

try {
    $condition = true;
    if ($condition) {
        throw new MyException('bala');
    }
} catch (MyException $e) {
    // Handle my exception
}

$nullableValue = null;
try {
    $value = $nullableValue ?? throw new InvalidArgumentException();
} catch (InvalidArgumentException) { // Variable is optional
    // Handle my exception
    echo "print me!";
}

try {
    // Do something
} catch (Exception $e) {
    // Handle exception
} finally {
    echo "Always print!";
}

interface Foo 
{
    public function doSomething();
}
interface Bar
{
    public function doSomethingElse();
}
class Cls implements Foo, Bar 
{
    public function doSomething() {}
    public function doSomethingElse() {}
}

class MyClass
{
    // Object is treated as a String
    public function \_\_toString()
 {
        return $property;
    }
    // opposite to \_\_construct()
    public function \_\_destruct()
 {
        print "Destroying";
    }
}

class MyClass
{
    const MY\_CONST       = 'value';
    static $staticVar    = 'static';
    // Visibility
    public static $var1  = 'pubs';
    // Class only
    private static $var2 = 'pris';
    // The class and subclasses
    protected static $var3 = 'pros';
    // The class and subclasses
    protected $var6      = 'pro';
    // The class only
    private $var7        = 'pri';  
}

Access statically

echo MyClass::MY\_CONST;   # => value
echo MyClass::$staticVar; # => static

class ExtendClass extends SimpleClass
{
    // Redefine the parent method
    function displayVar()
 {
        echo "Extending class\n";
        parent::displayVar();
    }
}
$extended = new ExtendClass();
$extended->displayVar();

class Student {
    public function \_\_construct($name) {
        $this->name = $name;
    }
      public function print() {
        echo "Name: " . $this->name;
    }
}
$alex = new Student("Alex");
$alex->print();    # => Name: Alex

$y = 1;

$fn1 = fn($x) => $x + $y;
// equivalent to using $y by value:
$fn2 = function ($x) use ($y) {
    return $x + $y;
};
echo $fn1(5);   # => 6
echo $fn2(5);   # => 6

function coffee($type = "cappuccino")
{
    return "Making a cup of $type.\n";
}
# => Making a cup of cappuccino.
echo coffee();
# => Making a cup of .
echo coffee(null);
# => Making a cup of espresso.
echo coffee("espresso");

function recursion($x)
{
    if ($x < 5) {
        echo "$x";
        recursion($x + 1);
    }
}
recursion(1);  # => 1234

$greet = function($name)
{
    printf("Hello %s\r\n", $name);
};
$greet('World'); # => Hello World
$greet('PHP');   # => Hello PHP

function bar($arg = '')
{
    echo "In bar(); arg: '$arg'.\n";
}
$func = 'bar';
$func('test'); # => In bar(); arg: test

// Available in PHP 7.1
function voidFunction(): void
{
    echo 'Hello';
    return;
}
voidFunction();  # => Hello

// Available in PHP 7.1
function nullOrString(int $v) : ?string
{
    return $v % 2 ? "odd" : null;
}
echo nullOrString(3);       # => odd
var\_dump(nullOrString(4));  # => NULL

See: Nullable types

// Basic return type declaration
function sum($a, $b): float {/\*...\*/}
function get\_item(): string {/\*...\*/}
class C {}
// Returning an object
function getC(): C { return new C; }

function square($x)
{
    return $x * $x;
}
echo square(4);  # => 16

$a = ['foo' => 1, 'bar' => 2];
# => 12
foreach ($a as $k) {
    echo $k;
}

See: Array iteration

# => 1235
for ($i = 1; $i <= 5; $i++) {
    if ($i === 4) {
        continue;
    }
    echo $i;
}

# => 123
for ($i = 1; $i <= 5; $i++) {
    if ($i === 4) {
        break;
    }
    echo $i;
}

# => 12345
for ($i = 1; $i <= 5; $i++) {
    echo $i;
}

$i = 1;
# => 12345
do {
    echo $i++;
} while ($i <= 5);

$i = 1;
# => 12345
while ($i <= 5) {
    echo $i++;
}

$age = 23;
$result = match (true) {
    $age >= 65 => 'senior',
    $age >= 25 => 'adult',
    $age >= 18 => 'young adult',
    default => 'kid',
};
echo $result; # => young adult

$statusCode = 500;
$message = match($statusCode) {
  200, 300 => null,
  400 => 'not found',
  500 => 'server error',
  default => 'known status code',
};
echo $message; # => server error

See: Match

# => Does
print (false ? 'Not' : 'Does');
$x = false;
# => Does
print($x ?: 'Does');
$a = null;
$b = 'Does print';
# => a is unset
echo $a ?? 'a is unset';
# => print
echo $b ?? 'b is unset';

$x = 0;
switch ($x) {
    case '0':
        print "it's zero";
        break; 
    case 'two':
    case 'three':
        // do something
        break;
    default:
        // do something
}

$a = 10;
$b = 20;
if ($a > $b) {
    echo "a is bigger than b";
} elseif ($a == $b) {
    echo "a is equal to b";
} else {
    echo "a is smaller than b";
}

function foo($first, ...$other) {
    var\_dump($first); # => a
      var\_dump($other); # => ['b', 'c']
}
foo('a', 'b', 'c' /\*, ...\*/ );
// or
function foo($first, string ...$other){}

$array = [1, 2];
function foo(int $a, int $b) {
    echo $a; # => 1
      echo $b; # => 2
}
foo(...$array);

$a = [1, 2];
$b = [3, 4];
// PHP 7.4 later
# => [1, 2, 3, 4]
$result = [...$a, ...$b];

$arr = ["foo" => "bar", "bar" => "foo"];
foreach ( $arr as $key => $value )
{
      echo "key: " . $key . "\n";
    echo "val: {$arr[$key]}\n";
}

$colors = array('red', 'blue', 'green');
foreach ($colors as $color) {
    echo "Do you like $color?\n";
}

$array = array('a', 'b', 'c');
$count = count($array);
for ($i = 0; $i < $count; $i++) {
    echo "i:{$i}, v:{$array[$i]}\n";
}

$array = array(
    "foo" => "bar",
    42    => 24,
    "multi" => array(
         "dim" => array(
             "a" => "foo"
         )
    )
);
# => string(3) "bar"
var\_dump($array["foo"]);
# => int(24)
var\_dump($array[42]);    
# => string(3) "foo"
var\_dump($array["multi"]["dim"]["a"]);

$multiArray = [ 
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
];
print\_r($multiArray[0][0]) # => 1
print\_r($multiArray[0][1]) # => 2
print\_r($multiArray[0][2]) # => 3

$a1 = ["hello", "world", "!"]
$a2 = array("hello", "world", "!");
$a3 = explode(",", "apple,pear,peach");

#Mixed int and string keys

$array = array(
    "foo" => "bar",
    "bar" => "foo",
    100   => -100,
    -100  => 100,
);
var\_dump($array);

#Short array syntax

$array = [
    "foo" => "bar",
    "bar" => "foo",
];

$s = "Hello Phper";
echo strlen($s);       # => 11
echo substr($s, 0, 3); # => Hel
echo substr($s, 1);    # => ello Phper
echo substr($s, -4, 3);# => hpe
echo strtoupper($s);   # => HELLO PHPER
echo strtolower($s);   # => hello phper
echo strpos($s, "l");      # => 2
var\_dump(strpos($s, "L")); # => false

See: String Functions

$str = "foo";
// Uninterpolated multi-liners
$nowdoc = <<<'END'
Multi line string
$str
END;
// Will do string interpolation
$heredoc = <<<END
Multi line
$str
END;

# => '$String'
$sgl\_quotes = '$String';
# => 'This is a $String.'
$dbl\_quotes = "This is a $sgl\_quotes.";
# => a tab character.
$escaped   = "a \t tab character.";
# => a slash and a t: \t
$unescaped = 'a slash and a t: \t';

function bar(): iterable {
    return [1, 2, 3];
}
function gen(): iterable {
    yield 1;
    yield 2;
    yield 3;
}
foreach (bar() as $value) {
    echo $value;   # => 123
} 

$a = null;
$b = 'Hello php!';
echo $a ?? 'a is unset'; # => a is unset
echo $b ?? 'b is unset'; # => Hello php
$a = array();
$a == null    # => true
$a === null   # => false
is\_null($a)   # => false

$float1 = 1.234;
$float2 = 1.2e7;
$float3 = 7E-10;
$float4 = 1\_234.567;  // as of PHP 7.4.0
var\_dump($float4);    // float(1234.567)
$float5 = 1 + "10.5";   # => 11.5
$float6 = 1 + "-1.3e3"; # => -1299

$int1 = 28;    # => 28
$int2 = -32;   # => -32
$int3 = 012;   # => 10 (octal)
$int4 = 0x0F;  # => 15 (hex)
$int5 = 0b101; # => 5 (binary)
# => 2000100000 (decimal, PHP 7.4.0)
$int6 = 2\_000\_100\_000;

See also: Integers

$boolean1 = true;
$boolean2 = TRUE;
$boolean3 = false;
$boolean4 = FALSE;
$boolean5 = (boolean) 1;   # => true
$boolean6 = (boolean) 0;   # => false

Boolean are case-insensitive

class Student {
    public function \_\_construct($name) {
        $this->name = $name;
    }
}
$alex = new Student("Alex");

See: Classes

const MY\_CONST = "hello";
echo MY_CONST;   # => hello
# => MY\_CONST is: hello
echo 'MY\_CONST is: ' . MY_CONST; 

# This is a one line shell-style comment
// This is a one line c++ style comment
/\* This is a multi line comment
 yet another line of comment \*/

function add($num1, $num2 = 1) {
    return $num1 + $num2;
}
echo add(10);    # => 11
echo add(10, 5); # => 15

See: Functions

#vars.php

<?php // begin with a PHP open tag.
$fruit = 'apple';
echo "I was imported";
return 'Anything you like.';
?>

#test.php

<?php
include 'vars.php';
echo $fruit . "\n";   # => apple
/\* Same as include,
cause an error if cannot be included\*/
require 'vars.php';
// Also works
include('vars.php');
require('vars.php');
// Include through HTTP
include 'http://x.com/file.php';
// Include and the return statement
$result = include 'vars.php';
echo $result;  # => Anything you like.
?>

$x = 1;
$y = 2;
$sum = $x + $y;
echo $sum;   # => 3

See: Operators

$num = [1, 3, 5, 7, 9];
$num[5] = 11;
unset($num[2]);    // Delete variable
print\_r($num);     # => 1 3 7 9 11
echo count($num);  # => 5

See: Arrays

$url = "quickref.me";
echo "I'm learning PHP at $url";
// Concatenate strings
echo "I'm learning PHP at " . $url;
$hello = "Hello, ";
$hello .= "World!";
echo $hello;   # => Hello, World!

See: Strings

$boolean1 = true;
$boolean2 = True;
$int = 12;
$float = 3.1415926;
unset($float);  // Delete variable
$str1 = "How are you?";
$str2 = 'Fine, thanks';

See: Types

<?php // begin with a PHP open tag.
echo "Hello World\n";
print("Hello quickref.me");
?>

PHP run command

$ php hello.php