• array_change_key_case()
• array_chunk()
• array_column()
• array_combine()
• array_count_values()
• array_diff_assoc()
• array_diff_key()
• array_diff_uassoc()
• array_diff_ukey()
• array_diff()
• array_fill_keys()
• array_fill()
• array_filter()
• array_flip()
• array_intersect_assoc()
• array_intersect_key()
• array_intersect_uassoc()
• array_intersect_ukey()
• array_intersect()
• array_key_first()
• array_key_last()
• array_keys()
• array_map()
• array_merge_recursive()
• array_merge()
• array_multisort()
• array_pad()
• array_pop()
• array_product()
• array_push()
• array_rand()
• array_reduce()
• array_replace_recursive()
• array_replace()
• array_reverse()
• array_search()
• array_shift()
• array_slice()
• array_splice()
• array_sum()
• array_udiff_assoc()
• array_udiff_uassoc()
• array_udiff()
• array_uintersect_assoc()
• array_uintersect_uassoc()
• array_uintersect()
• array_unique()
• array_unshift()
• array_values()
• array_walk_recursive()
• array_walk()
• arsort()
• asort()
• compact()
• count()
• current()
• each()
• end()
• extract()
• in_array()
• key_exists()
• key()
• krsort()
• ksort()
• list()
• natcasesort()
• natsort()
• next()
• prev()
• range()
• reset()
• rsort()
• shuffle()
• sort()
• uasort()
• uksort()
• usort()

<?php
function (){
        $a = ['a'=>'a', 'BBB'=>"bbb", 'cCcC'=>'CcCc'];
        return [
                'lower' => array_change_key_case($a),
                'upper' => array_change_key_case($a,CASE_UPPER),
            ];
    });
?>

Array
(
    [lower] => Array
        (
            [a] => a
            [bbb] => bbb
            [cccc] => CcCc
        )

    [upper] => Array
        (
            [A] => a
            [BBB] => bbb
            [CCCC] => CcCc
        )

)

<?php
function (){
        $a = [
                'multi_dimensional'=>
                    [
                            'a'=>"a","B"=>"B"
                    ]
        ];
        return  array_change_key_case($a,CASE_UPPER);
    });
?>

Array
(
    [MULTI_DIMENSIONAL] => Array
        (
            [a] => a
            [B] => B
        )

)

<?php
function (){

        $pics = ['jpg1.jpg','jpg2.jpg','jpg3.jpg','jpg4','jpg5'];

        $html = '';

        foreach(array_chunk($pics,2) as $pics_row){
            $html .="
\n";
            foreach($pics_row as $pic) {
                $html .= "\t
 $pic 
\n";
            }
            $html .= "
\n\n";
        }

        return $html;
    });
?>

<div class='row'>
	<div class='col-md-6'> jpg1.jpg </div>
	<div class='col-md-6'> jpg2.jpg </div>
</div>

<div class='row'>
	<div class='col-md-6'> jpg3.jpg </div>
	<div class='col-md-6'> jpg4 </div>
</div>

<div class='row'>
	<div class='col-md-6'> jpg5 </div>
</div>

<?php
function (){
    $pics = ['jpg1.jpg','jpg2.jpg','jpg3.jpg','jpg4.jpg','jpg5.jpg'];

    return array_chunk($pics,2);
});
?>

Array
(
    [0] => Array
        (
            [0] => jpg1.jpg
            [1] => jpg2.jpg
        )

    [1] => Array
        (
            [0] => jpg3.jpg
            [1] => jpg4.jpg
        )

    [2] => Array
        (
            [0] => jpg5.jpg
        )

)

$return = [];
    $input = [
    ["type"=>"car","colour"=>"red"],
    ["type"=>"bike","colour"=>"blue"],
     ];
     $column_key = "type";

foreach($input as $row) {
    $return[] = $row[$column_key];
}
return $return;

<?php
function (){
        $input = [
                ["id"=>123,"type"=>"car","colour"=>"red"],
                ["id"=>456,"type"=>"bike","colour"=>"blue"],
                ["id"=>789,"type"=>"lorry","colour"=>"pink"],
                ["id"=>234,"type"=>"car","colour"=>"orange"],
        ];
        return array_column($input,'type');
    });
?>

Array
(
    [0] => car
    [1] => bike
    [2] => lorry
    [3] => car
)

<?php
function (){
        $input = [
                ["id"=>123,"type"=>"car","colour"=>"red"],
                ["id"=>456,"type"=>"bike","colour"=>"blue"],
                ["id"=>789,"type"=>"lorry","colour"=>"pink"],
                ["id"=>234,"type"=>"car","colour"=>"orange"],
        ];
        return array_column($input,'type','id');
    });
?>

Array
(
    [123] => car
    [456] => bike
    [789] => lorry
    [234] => car
)

<?php
function (){
       $keys = ['football', 'tennis', 'house'];
       $values = ['sport','sport','building'];
       return array_combine($keys, $values);
    });
?>

Array
(
    [football] => sport
    [tennis] => sport
    [house] => building
)

<?php
function (){

        $fav_sports = [
            'running',
            'football',
            'tennis',
            'football',
            'snooker',
            'football',
            'swimming',
            'tennis',
            ];

        return array_count_values($fav_sports);
    });
?>

Array
(
    [running] => 1
    [football] => 3
    [tennis] => 2
    [snooker] => 1
    [swimming] => 1
)

<?php
function (){
        $array1 = ["a" => "green", "b" => "brown", "c" => "blue", "red"];
        $array2 = ["a" => "green", "yellow", "red"];
        return array_diff_assoc($array1, $array2);
    });
?>

Array
(
    [b] => brown
    [c] => blue
    [0] => red
)

<?php
function (){
        $array1 = ['blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4];
        $array2 = ['green' => 5, 'yellow' => 7, 'cyan' => 8];
        return array_diff_key($array1, $array2);
    });
?>

Array
(
    [blue] => 1
    [red] => 2
    [purple] => 4
)

<?php
function (){

    // the user definable function to check if the two keys are equal
    $compare_closure = function ($a, $b)
    {
        if ($a === $b) {
            return 0;
        }
        return ($a > $b)? 1:-1;
    };

    $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
    $array2 = array("a" => "green", "yellow", "red");
    return array_diff_uassoc($array1, $array2, $compare_closure);

}
?>

Array
(
    [b] => brown
    [c] => blue
    [0] => red
)

<?php
function (){


    $callable_func = function($key1, $key2)
    {
        if ($key1 == $key2)
            return 0;
        else if ($key1 > $key2)
            return 1;
        else
            return -1;
    };

    $array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
    $array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);

    return array_diff_ukey($array1, $array2, $callable_func);
}
?>

Array
(
    [red] => 2
    [purple] => 4
)

<?php
function (){
    $array1 = array("a" => "green", "red", "blue", "red");
    $array2 = array("b" => "green", "yellow", "red");
    return array_diff($array1, $array2);
}
?>

Array
(
    [1] => blue
)

<?php
function (){
    $keys = array('foo', 5, 10, 'bar');
    return array_fill_keys($keys, 'banana');
}
?>

Array
(
    [foo] => banana
    [5] => banana
    [10] => banana
    [bar] => banana
)

<?php
function (){
    return array_fill(5, 6, 'banana');
}
?>

Array
(
    [5] => banana
    [6] => banana
    [7] => banana
    [8] => banana
    [9] => banana
    [10] => banana
)

<?php
function (){
    return array_filter([0 => 'foo',
            1 => false,
            2 => -1,
            3 => null,
            4 => '']);
    }
?>

Array
(
    [0] => foo
    [2] => -1
)

<?php
function (){

$array = array(6, 7, 8, 9, 10, 11, 12);

// returns whether the input integer is even:
return array_filter($array,function($var)
{
    return(!($var & 1));
});
            }
?>

Array
(
    [0] => 6
    [2] => 8
    [4] => 10
    [6] => 12
)

<?php
function (){
    $input = ['apples'=>"tasty","bananas"=>"nice","pears"=>"yuck"];
    return array_flip($input);
}
?>

Array
(
    [tasty] => apples
    [nice] => bananas
    [yuck] => pears
)

<?php
function (){
    $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
    $array2 = array("a" => "green", "b" => "yellow", "blue", "red");
    return array_intersect_assoc($array1, $array2);
}
?>

Array
(
    [a] => green
)

<?php
function (){
    $array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
    $array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);

    return array_intersect_key($array1, $array2);
}
?>

Array
(
    [blue] => 1
    [green] => 3
)

<?php
function (){
    $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
    $array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");

    return array_intersect_uassoc($array1, $array2, "strcasecmp");

            });?>
?>

Array
(
    [b] => brown
)

<?php
function (){
    $key_compare_func =  function ($key1, $key2)
    {
        $return= $key1 == $key2 ? 0 : ($key1 > $key2 ? 1 : -1);
        return $return;
    };

    $array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
    $array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);

    return array_intersect_ukey($array1, $array2, $key_compare_func);

} );?>
?>

Array
(
    [blue] => 1
    [green] => 3
)

<?php
function (){
    $array1 = array("a" => "green", "red", "blue");
    $array2 = array("b" => "green", "yellow", "red");
    return array_intersect($array1, $array2);
}
?>

Array
(
    [a] => green
    [0] => red
)

<?php
function (){
    $search_array = array('first' => 1, 'second' => 4);
    if( array_key_exists('first', $search_array)) {
        return 'first was in $search_array';
        }
    else {
        return "key was not found";
        }
}
?>

first was in $search_array

<?php
function (){
    $array = ['a' => 1, 'b' => 2, 'c' => 3];
    $firstKey = array_key_first($array);
    return $firstKey;
}
?>

a

<?php
function (){
                $array = ['a' => 1, 'b' => 2, 'c' => 3];
                $firstKey = array_key_last($array);
                return $firstKey;
            }
?>

c

array_keys($input)[count($input)-1];

<?php
function (){
    $array = array(0 => 100, "color" => "red");
    return array_keys($array);
}
?>

Array
(
    [0] => 0
    [1] => color
)

<?php
function (){
    $array = array("blue", "red", "green", "blue", "blue");
    return array_keys($array,'blue');
}
?>

Array
(
    [0] => 0
    [1] => 3
    [2] => 4
)

$return =[];
$callable = function($input) { return strtoupper($input);};
foreach($items as $item){
    $return[] = $callable($item);
}
return $return;

<?php
function (){
                return array_map('strtoupper', ['hello','WoRlD']);
            }
?>

Array
(
    [0] => HELLO
    [1] => WORLD
)

<?php
function (){
    $cube_function = function ($n)
    {
        return($n * $n * $n);
    };

    return array_map($cube_function, [1, 2, 3, 4, 5]);
}
?>

Array
(
    [0] => 1
    [1] => 8
    [2] => 27
    [3] => 64
    [4] => 125
)

<?php
function (){
    $ar1 = array("color" => array("favorite" => "red"), 5);
    $ar2 = array(10, "color" => array("favorite" => "green", "blue"));
    return array_merge_recursive($ar1, $ar2);
}
?>

Array
(
    [color] => Array
        (
            [favorite] => Array
                (
                    [0] => red
                    [1] => green
                )

            [0] => blue
        )

    [0] => 5
    [1] => 10
)

<?php
function (){
                $ar1 = array("color" => array("favorite" => "red"), 5);
                $ar2 = array(10, "color" => array("favorite" => "green", "blue"));
                return $ar1 + $ar2;
            }
?>

Array
(
    [color] => Array
        (
            [favorite] => red
        )

    [0] => 5
)

<?php
function (){
                $ar1 = array("color" => array("favorite" => "red"), 5);
                $ar2 = array(10, "color" => array("favorite" => "green", "blue"));
                return array_merge($ar1, $ar2);
            }
?>

Array
(
    [color] => Array
        (
            [favorite] => green
            [0] => blue
        )

    [0] => 5
    [1] => 10
)

<?php
function (){
    $ar1 = array(10, 100, 100, 0);
    $ar2 = array(1, 3, 2, 4);

    array_multisort($ar1, $ar2);

    return ['ar1'=>$ar1, 'ar2'=>$ar2];
}
?>

Array
(
    [ar1] => Array
        (
            [0] => 0
            [1] => 10
            [2] => 100
            [3] => 100
        )

    [ar2] => Array
        (
            [0] => 4
            [1] => 1
            [2] => 2
            [3] => 3
        )

)

<?php
function (){
    $ar = array(
            array("10", 11, 100, 100, "a"),
            array(   1,  2, "2",   3,   1)
    );
    array_multisort($ar[0], SORT_ASC, SORT_STRING,
            $ar[1], SORT_NUMERIC, SORT_DESC);
    return $ar;
}
?>

Array
(
    [0] => Array
        (
            [0] => 10
            [1] => 100
            [2] => 100
            [3] => 11
            [4] => a
        )

    [1] => Array
        (
            [0] => 1
            [1] => 3
            [2] => 2
            [3] => 2
            [4] => 1
        )

)

<?php
function (){
    $array = array('Alpha', 'atomic', 'Beta', 'bank');
    $array_lowercase = array_map('strtolower', $array);

    array_multisort($array_lowercase, SORT_ASC, SORT_STRING, $array);

    return $array;
}
?>

Array
(
    [0] => Alpha
    [1] => atomic
    [2] => bank
    [3] => Beta
)

<?php
function (){
    $input = array(12, 10, 9);
    $result_pos = array_pad($input, 5, 'padding');
    $result_neg = array_pad($input, -7, 'asdf');
    return ['pos (put padding on right/bottom)'  => $result_pos,
        'neg (left/top)'=>$result_neg];
}
?>

Array
(
    [pos (put padding on right/bottom)] => Array
        (
            [0] => 12
            [1] => 10
            [2] => 9
            [3] => padding
            [4] => padding
        )

    [neg (left/top)] => Array
        (
            [0] => asdf
            [1] => asdf
            [2] => asdf
            [3] => asdf
            [4] => 12
            [5] => 10
            [6] => 9
        )

)

<?php
function (){

    $stack = array("orange", "banana", "apple", "raspberry");
    $fruit = array_pop($stack);
    return ['stack' => $stack, 'fruit'=>$fruit];
}
?>

Array
(
    [stack] => Array
        (
            [0] => orange
            [1] => banana
            [2] => apple
        )

    [fruit] => raspberry
)

<?php
function (){
    $a = array(2, 4, 6, 8);
    return array_product($a);
}
?>

384

<?php
function (){

    $stack = array("orange", "banana");
    array_push($stack, "apple", "raspberry");

    return $stack;
}
?>

Array
(
    [0] => orange
    [1] => banana
    [2] => apple
    [3] => raspberry
)

<?php
function (){
    $input = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
    return array_rand($input, 2);
}
?>

Array
(
    [0] => 1
    [1] => 4
)

<?php
function (){
    $sum = function ($carry, $item)
    {
        $carry += $item;
        return $carry;
    };

    $product =  function($carry, $item)
    {
        $carry *= $item;
        return $carry;
    };

    $a = array(1, 2, 3, 4, 5);

    return [
    array_reduce($a, $sum),
    array_reduce($a, $product, 10)
            ];
}
?>

Array
(
    [0] => 15
    [1] => 1200
)

<?php
function (){
    $base = array('citrus' => array( "orange") , 'berries' => array("blackberry", "raspberry"), );
    $replacements = array('citrus' => array('pineapple'), 'berries' => array('blueberry'));
    return array_replace_recursive($base, $replacements);
}
?>

Array
(
    [citrus] => Array
        (
            [0] => pineapple
        )

    [berries] => Array
        (
            [0] => blueberry
            [1] => raspberry
        )

)

<?php
function (){
    $base = array("orange", "banana", "apple", "raspberry");
    $replacements = array(0 => "pineapple", 4 => "cherry");
    $replacements2 = array(0 => "grape");
    return array_replace($base, $replacements, $replacements2);
}
?>

Array
(
    [0] => grape
    [1] => banana
    [2] => apple
    [3] => raspberry
    [4] => cherry
)

<?php
function (){
    $input  = array("first", 2, array("third"));
    return array_reverse($input);
}
?>

Array
(
    [0] => Array
        (
            [0] => third
        )

    [1] => 2
    [2] => first
)

<?php
function (){
    $array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');
    return array_search('green', $array);
}
?>

2

<?php
function (){
    $stack = array("orange", "banana", "apple", "raspberry");
    $fruit = array_shift($stack);
    return [$stack,$fruit];
}
?>

Array
(
    [0] => Array
        (
            [0] => banana
            [1] => apple
            [2] => raspberry
        )

    [1] => orange
)

<?php
function (){
    $input = array("a", "b", "c", "d", "e");

    return [array_slice($input, 2),
    array_slice($input, -2, 1),
    array_slice($input, 0, 3)];
}
?>

Array
(
    [0] => Array
        (
            [0] => c
            [1] => d
            [2] => e
        )

    [1] => Array
        (
            [0] => d
        )

    [2] => Array
        (
            [0] => a
            [1] => b
            [2] => c
        )

)

<?php
function (){
    $input = array("red", "green", "blue", "yellow");
    array_splice($input, 2);
    return $input;
}
?>

Array
(
    [0] => red
    [1] => green
)

<?php
function (){
    $input = array("red", "green", "blue", "yellow");
    array_splice($input, 3, 0, "purple");
    return $input;
}
?>

Array
(
    [0] => red
    [1] => green
    [2] => blue
    [3] => purple
    [4] => yellow
)

<?php
function (){
    $input = array("red", "green", "blue", "yellow");
    array_splice($input, -1, 1, array("black", "maroon"));
    return $input;
}
?>

Array
(
    [0] => red
    [1] => green
    [2] => blue
    [3] => black
    [4] => maroon
)

<?php
function (){
    return array_sum([2, 4, 6, 8]);
}
?>

20

<?php
function (){


    $array1 = ['apples' => "red", "bananas" =>"yellow", "oranges"=>"orange"];
    $array2 = ["apples" => "green" ,"bananas"=>"yellow", "grapes"=>"green"];

    return array_udiff_assoc($array1,$array2,function($a,$b) {

        if ($a==$b) {
            return 0;
            }
        return ($a>$b)? 1:-1;

        });

}
?>

Array
(
    [apples] => red
    [oranges] => orange
)

<?php
function (){


    $array1 = ['apples' => "red", "bananas" =>"yellow", "oranges"=>"orange", "foo" =>"bar",];
    $array2 = ["apples" => "green" ,"bananas"=>"green", "grapes"=>"green", "foo" => "notbar",];

    return array_udiff_uassoc($array1,$array2,function($val_a,$val_b) {

        if ($val_a==$val_b) {
            return 0;
        }
        return ($val_a>$val_b)? 1:-1;

    },function($key_a,$key_b) {

        if ($key_a==$key_b) {
            return 0;
        }
        return ($key_a>$key_b)? 1:-1;

        });

}
?>

Array
(
    [apples] => red
    [bananas] => yellow
    [oranges] => orange
    [foo] => bar
)

<?php
function (){
// Arrays to compare
                $array1 = array(new stdclass, new stdclass,
                        new stdclass, new stdclass,
                );

                $array2 = array(
                        new stdclass, new stdclass,
                );

// Set some properties for each object
                $array1[0]->width = 11; $array1[0]->height = 3;
                $array1[1]->width = 7;  $array1[1]->height = 1;
                $array1[2]->width = 2;  $array1[2]->height = 9;
                $array1[3]->width = 5;  $array1[3]->height = 7;

                $array2[0]->width = 7;  $array2[0]->height = 5;
                $array2[1]->width = 9;  $array2[1]->height = 2;

                $compare_by_area = function ($a, $b) {
                    $areaA = $a->width * $a->height;
                    $areaB = $b->width * $b->height;

                    if ($areaA < $areaB) {
                        return -1;
                    } elseif ($areaA > $areaB) {
                        return 1;
                    } else {
                        return 0;
                    }
                };

                return array_udiff($array1, $array2, $compare_by_area);
            }
?>

Array
(
    [0] => stdClass Object
        (
            [width] => 11
            [height] => 3
        )

    [1] => stdClass Object
        (
            [width] => 7
            [height] => 1
        )

)

<?php
function (){


        $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
        $array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");

        // strcasecmp() will return < 0 if str1 is less than str2; > 0 if str1 is greater than str2, and 0 if they are equal.
        // this will return only ['a'=>'green'], as it compares the key only.
        return array_uintersect_assoc($array1, $array2, "strcasecmp");

    });
?>

Array
(
    [a] => green
)

<?php
function (){
        $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
        $array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");
        return array_uintersect_uassoc($array1, $array2, "strcasecmp", "strcasecmp");
    });
?>

Array
(
    [a] => green
    [b] => brown
)

<?php
function (){
        $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
        $array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");

        return array_uintersect($array1, $array2, "strcasecmp");
    });
?>

Array
(
    [a] => green
    [b] => brown
    [0] => red
)

<?php
function (){
        $input = [
                "a" => "green",
                "red",
                "b" => "green",
                "blue", "red"
        ];
        $result = array_unique($input);
        return $result;
    });
?>

Array
(
    [a] => green
    [0] => red
    [1] => blue
)

<?php
function (){
        // mixed types
        $input = [
                4,
                "4",
                "3",
                4,
                3,
                "3"];
        $result = array_unique($input);
        return $result;
    });
?>

Array
(
    [0] => 4
    [2] => 3
)

<?php
function (){
        $queue = array("orange", "banana");
        array_unshift($queue, "apple", "raspberry");
        return $queue;
    });
?>

Array
(
    [0] => apple
    [1] => raspberry
    [2] => orange
    [3] => banana
)

<?php
function (){
        $array = array("size" => "XL", "color" => "gold");
        return array_values($array);

    });
?>

Array
(
    [0] => XL
    [1] => gold
)

<?php
function (){
        $fruits = [
                'sweet' => ['a'=>"apple","b"=>"banana"],
                'sour' => 'lemon'
        ];

        global $array_walk_recursive_output;
        $echo_info_func=function($item, $key)
        {
            // sorry for the rubbish way of doing this. This is just to
            // make the example simple...
            global $array_walk_recursive_output;

            $array_walk_recursive_output.= "$key holds $item\n";
        };

        array_walk_recursive($fruits, $echo_info_func);
        return $array_walk_recursive_output;
    });
?>

a holds apple
b holds banana
sour holds lemon

<?php
function (){
        $fruits = [
                'sweet' => ['a'=>"apple","b"=>"banana"],
                'sour' => 'lemon'
        ];

        global $array_walk_output;
        $echo_info_func=function($item, $key)
        {
            // sorry for the rubbish way of doing this. This is just to
            // make the example simple...
            global $array_walk_output;

            $array_walk_output.= "$key holds: " . print_r($item,true) ."\n";
        };

        array_walk($fruits, $echo_info_func);
        return $array_walk_output;
    });
?>

sweet holds: Array
(
    [a] => apple
    [b] => banana
)

sour holds: lemon

<?php
function (){
        $fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
        arsort($fruits);
        //The fruits have been sorted in reverse alphabetical order, and the index associated with each element has been maintained.


        return $fruits;
    });
?>

Array
(
    [a] => orange
    [d] => lemon
    [b] => banana
    [c] => apple
)

<?php
function (){
        $fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
        asort($fruits);
        return $fruits;
    });
?>

Array
(
    [c] => apple
    [b] => banana
    [d] => lemon
    [a] => orange
)

<?php
function (){
        $city  = "San Francisco";
        $state = "CA";
        $event = "SIGGRAPH";

        $location_vars = array("city", "state");

        $result = compact("event", "nothing_here", $location_vars);

        return $result;

    });
?>

Array
(
    [event] => SIGGRAPH
    [city] => San Francisco
    [state] => CA
)

<?php
function (){
        $array = [111,222,333,"444","555",];
        return count($array);
    });
?>

5

<?php
function (){

        $food = array('fruits' => array('orange', 'banana', 'apple'),
                'veggie' => array('carrot', 'collard', 'pea'));

        return ['recursive_count' => count($food, COUNT_RECURSIVE),
        'normal_count' => count($food)];
        
        });
?>

Array
(
    [recursive_count] => 8
    [normal_count] => 2
)

<?php
function (){

        $return=[];

        $transport = array('foot', 'bike', 'car', 'plane');
        $return['initial'] = current($transport); // $mode = 'foot';

        // switch internal pointer to next element:
         next($transport);

        // and current() will return the 2nd item in array (index 1)
        $return['after_next'] = current($transport); // $mode = 'foot';

        return $return;

    });?>
?>

Array
(
    [initial] => foot
    [after_next] => bike
)

<?php
function (){

        $fruits = array('apple', 'banana', 'cranberry');
        return end($fruits); // cranberry

        });?>
?>

cranberry

<?php
function (){
        $a = [];
        $a[1] = 1;
        $a[0] = 0;
        return end($a);
    });?>
?>

<?php
function (){

        $var_array = ["color" => "blue",
                "size"  => "medium",
                "shape" => "sphere"];

        extract($var_array);

        return "\$color = $color, \$size = $size, \$shape= $shape\n";

    });?>
?>

$color = blue, $size = medium, $shape= sphere

<?php
function (){
        $os = array("Mac", "NT", "Irix", "Linux");
        $irix = in_array("Irix", $os) ? "Got Irix" : "No irix";
        $mac = in_array("mac", $os) ? "Got mac" : "No mac";

        return ['has irix?'=>$irix,'has mac?' =>$mac];
    });?>
?>

Array
(
    [has irix?] => Got Irix
    [has mac?] => No mac
)

<?php
function (){
        $return='';

        $array = array(
                'fruit1' => 'apple',
                'fruit2' => 'orange',
                'fruit3' => 'grape',
                'fruit4' => 'apple',
                'fruit5' => 'apple');

// this cycle echoes all associative array
// key where value equals "apple"
        while ($fruit_name = current($array)) {
            if ($fruit_name == 'apple') {
                $return .= key($array)."\n";
            }
            next($array);
        }

        return $return;
    });?>
?>

fruit1
fruit4
fruit5

<?php
function (){
        $fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
        krsort($fruits);
        return $fruits;
    });?>
?>

Array
(
    [d] => lemon
    [c] => apple
    [b] => banana
    [a] => orange
)

<?php
function (){
        $fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
        ksort($fruits);
        return $fruits;
    });?>
?>

Array
(
    [a] => orange
    [b] => banana
    [c] => apple
    [d] => lemon
)

<?php
function (){

        $info = array('coffee', 'brown', 'caffeine');

        // Listing all the variables
        list($drink, $colour, $power) = $info;
        return "\$drink = $drink, \$colour = $colour, \$power = $power ";
        });
?>

$drink = coffee, $colour = brown, $power = caffeine

<?php
function (){

        $info = array('coffee', 'brown', 'caffeine');

        list($drink, , $power) = $info;
        return "$drink has $power.\n";
    });
?>

coffee has caffeine.

<?php
function (){
        $sort = $nat_case_sort = $nat_sort = ['IMG0.png',
                'img12.png',
                'img10.png',
                'img2.png',
                'img1.png',
                'IMG3.png'];
        sort($sort);
        natcasesort($nat_case_sort);
        natsort($nat_sort);
        return [
                'sort'=>$sort,
                'natural sorted (case insensitive)' =>$nat_case_sort,
                'natural sorted (case sensitive)' =>$nat_sort,
        ];

    });
?>

Array
(
    [sort] => Array
        (
            [0] => IMG0.png
            [1] => IMG3.png
            [2] => img1.png
            [3] => img10.png
            [4] => img12.png
            [5] => img2.png
        )

    [natural sorted (case insensitive)] => Array
        (
            [0] => IMG0.png
            [4] => img1.png
            [3] => img2.png
            [5] => IMG3.png
            [2] => img10.png
            [1] => img12.png
        )

    [natural sorted (case sensitive)] => Array
        (
            [0] => IMG0.png
            [5] => IMG3.png
            [4] => img1.png
            [3] => img2.png
            [2] => img10.png
            [1] => img12.png
        )

)

<?php
function (){
        $sort = $nat_case_sort = $nat_sort = ['IMG0.png',
                'img12.png',
                'img10.png',
                'img2.png',
                'img1.png',
                'IMG3.png'];
        sort($sort);
        natcasesort($nat_case_sort);
        natsort($nat_sort);
        return [
                'sort'=>$sort,
                'natural sorted (case insensitive)' =>$nat_case_sort,
                'natural sorted (case sensitive)' =>$nat_sort,
        ];

    });
?>

Array
(
    [sort] => Array
        (
            [0] => IMG0.png
            [1] => IMG3.png
            [2] => img1.png
            [3] => img10.png
            [4] => img12.png
            [5] => img2.png
        )

    [natural sorted (case insensitive)] => Array
        (
            [0] => IMG0.png
            [4] => img1.png
            [3] => img2.png
            [5] => IMG3.png
            [2] => img10.png
            [1] => img12.png
        )

    [natural sorted (case sensitive)] => Array
        (
            [0] => IMG0.png
            [5] => IMG3.png
            [4] => img1.png
            [3] => img2.png
            [2] => img10.png
            [1] => img12.png
        )

)

<?php
function (){

        $return=[];

        $transport = ['foot',
                'bike',
                'car',
                'plane'];

        $return['first_current'] = current($transport); // $mode = 'foot';
        $return['first_next'] = next($transport);    // $mode = 'bike';

        return $return;
        });?>
?>

Array
(
    [first_current] => foot
    [first_next] => bike
)

<?php
function (){

        $return=[];

        $transport = ['foot',
                'bike',
                'car',
                'plane'];

        $return['first_current'] = current($transport); // $mode = 'foot';
        $return['first_next'] = next($transport);    // $mode = 'bike';
        $return['first_prev'] = prev($transport);    // $mode = 'foot';

        return $return;
    });?>
?>

Array
(
    [first_current] => foot
    [first_next] => bike
    [first_prev] => foot
)

<?php
function (){

      return [

          'numbers 1 to 5' => range(1,5),
          //
          'numbers 0 to 101, in steps of 20' => range(1,101,20),
          'a-z, every 5 letters' => range('a','z',5),
          'm to a (backwards), every 4 letters' => range('m','a',4),


          ];
    });?>
?>

Array
(
    [numbers 1 to 5] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
            [3] => 4
            [4] => 5
        )

    [numbers 0 to 101, in steps of 20] => Array
        (
            [0] => 1
            [1] => 21
            [2] => 41
            [3] => 61
            [4] => 81
            [5] => 101
        )

    [a-z, every 5 letters] => Array
        (
            [0] => a
            [1] => f
            [2] => k
            [3] => p
            [4] => u
            [5] => z
        )

    [m to a (backwards), every 4 letters] => Array
        (
            [0] => m
            [1] => i
            [2] => e
            [3] => a
        )

)

<?php
function (){

        $return =[];
        $array = array('step one', 'step two', 'step three', 'step four');

// by default, the pointer is on the first element
        $return['initial element'] = current($array) ; // "step one"

// skip two steps
        next($array);
        next($array);
        $return['element after 2 next() calls']= current($array); // "step three"

// reset pointer, start again on step one
        reset($array);
        $return['element after reset() was called'] = current($array); // "step one"

        return $return;
        });?>
?>

Array
(
    [initial element] => step one
    [element after 2 next() calls] => step three
    [element after reset() was called] => step one
)

<?php
function (){

        $fruits = ["lemon",
                "orange",
                "banana",
                "apple"];
        rsort($fruits);
        // now they are in reverse alphabetical order.


        return $fruits;


        });?>
?>

Array
(
    [0] => orange
    [1] => lemon
    [2] => banana
    [3] => apple
)

<?php
function (){
        $numbers = range(1, 5);
        shuffle($numbers);

        // this demo actually executes this code
        //  - there is a chance that it got sorted into the same order...
        //  trust me, this does shuffle it!
        return $numbers;
    });?>
?>

Array
(
    [0] => 5
    [1] => 3
    [2] => 2
    [3] => 4
    [4] => 1
)

<?php
function (){
        $fruits = array("lemon", "orange", "banana", "apple");
        sort($fruits);
        return $fruits;
    });?>
?>

Array
(
    [0] => apple
    [1] => banana
    [2] => lemon
    [3] => orange
)

<?php
function (){
        $cmp= function ($a, $b) {
            if ($a == $b) {
                return 0;
            }
            return ($a < $b) ? -1 : 1;
        };

// Array to be sorted
        $array = ['a' => 4,
                'b' => 8,
                'c' => -1,
                'd' => -9,
                'e' => 2,
                'f' => 5,
                'g' => 3,
                'h' => -4];

// Sort and print the resulting array
        uasort($array, $cmp);
        return $array;
    });?>
?>

Array
(
    [d] => -9
    [h] => -4
    [c] => -1
    [e] => 2
    [g] => 3
    [a] => 4
    [f] => 5
    [b] => 8
)

<?php
function (){
        $array = [
                "John" => 1,
                "the Earth" => 2,
                "an apple" => 3,
                "a banana" => 4];

        $cmp= function($a, $b)
        {
            $a = preg_replace('@^(a|an|the) @', '', $a);
            $b = preg_replace('@^(a|an|the) @', '', $b);
            return strcasecmp($a, $b);
        };


        uksort($array, $cmp);
        return $array;

    });?>
?>

Array
(
    [an apple] => 3
    [a banana] => 4
    [the Earth] => 2
    [John] => 1
)

<?php
function (){

$input = array(3, 2, 5, 6, 1);

$cmp = function($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
};


usort($input, $cmp);
return  $input; // 'output' now...

});?>
?>

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)

<?php
function (){

$cmp=function ($a, $b)
{
    return strcmp($a["fruit"], $b["fruit"]);
};

$fruits[0]["fruit"] = "lemons";
$fruits[1]["fruit"] = "apples";
$fruits[2]["fruit"] = "grapes";

usort($fruits, $cmp);

return $fruits;

});
?>

Array
(
    [0] => Array
        (
            [fruit] => apples
        )

    [1] => Array
        (
            [fruit] => grapes
        )

    [2] => Array
        (
            [fruit] => lemons
        )

)

There are a couple of ways to achieve this, both very simple.

The most simple is to use ctype_alnum(). This function has been in PHP since PHP4. The following code would output 'all passed', as all three strings are alphanumeric

If you need a bit more flexibility, then you could use regex:

In the example above, it adds no real advantage and is slower than ctype_alnum so I would recommend just using ctype_alnum.

If you need to check if alpha numeric, but include underscores and dash (hyphen), then you can use the following regex check:

(Both of these are case insensitive, thanks to the i modifier)

You could also do this:

Or even [:alnum:]

There are probably a few ways to do this, but one simple way would be to put your function in a file in /somedir/something.php. Then update php.ini and set auto_prepend_file = /somedir/something.php.

If you want to use a package (via composer) on all of your scripts you could also do something like composer global require THEPACKAGE/NAMEHERE, then do auto_prepend_file = ${HOME}/.composer/vendor/autoload.php

The php://input contains the raw data from a POST request, after all of the HTTP headers. You can think of $_POST as the same data (...sometimes) that has been parsed into an array. php://input gets the raw data. The stream can be accessed in the following way:

As of PHP 5.1.0, the CLI SAPI provides an interactive shell. To use it, enter the following command at a command line:

If you run 'php -a' and just see 'Interactive mode enabled', but nothing happens when you type something and hit enter then this means that the interactive shell isn't activated for your installation of PHP. You must have the readline module installed (check if you do by running php -m | grep -i readline).

If you see 'Interactive mode enabled', then after typing in your PHP code (don't forget the opening PHP tag), press ctrl+d

$ php -a
Interactive mode enabled

<?php echo "hello, world" . rand(); ?>

hello, world665146942

Note: in the above output, I hit ctrl+d in the 2nd to last line, then it executed the PHP code that I typed and echoed the output.

Just run php your-file.php.

php your_file.php

And it will execute the PHP file.

If two objects are compared with ==, then it will check if:

1) - they are two instances of the same type of class

2) - they have the same properties

3) - and those properties have the same values

If two objects are compared with ===, then PHP will return true only if both variables are pointing to the exact same object (the same instance of the object). Remember that objects are always passed by value.

For example, the following will return true:

However, the following (using ===) will return false. If the check was with == then it would return true, as the class type/properties/values are the same

Comments are parts of the code that don't really do anything (some exceptions) apart from be read by humans.

There are a few ways to add comments in PHP.

1: // - single line comments

2: # - single line comments

3: /* ... */ - multi line comments

The only times that comments have any effect on the code that is processed is when some scripts scan 'DocComment'. A DocComment is one that starts like this /** ... */.

If you have an object and you need to check if it has a const SOME_CONSTANT = 'foo' set, then you can use defined in the following way:

This is a classic simple programming question. There are several ways to approach this problem. Here is one solution:

The comparison function:

Let's write some tests

And now let's go through each one.

"Our function said that [asdf] and [asdf] Is an anagram, which is correct"
"Our function said that [asdf] and [fdsa] Is an anagram, which is correct"
"Our function said that [asdfasdf] and [asdfasdf] Is an anagram, which is correct"
"Our function said that [a] and [a] Is an anagram, which is correct"
"Our function said that [a] and [b] Is not an anagram, which is correct"
"Our function said that [aaa] and [aaa] Is an anagram, which is correct"
"Our function said that [aaa] and [aa] Is not an anagram, which is correct"
"Our function said that [aaaa] and [abab] Is not an anagram, which is correct"
"Our function said that [qwerty] and [asdfg] Is not an anagram, which is correct"

BTW, not sure about how the [$a, $b, $is_valid_anagram] = $anagram; line works? See my blog post about array destructuring in PHP 7.

If you want to get an array of (single) letters from a string, it is easy in PHP! Here is how to do it:

Use str_split() to get a text string's characters as an array

To remove a cookie, you should set its expiry to a date in the past.

And then the next time the user loads a page (or makes a request), their browser will remove the cookie.

You should also clear PHP's 'copy' of the cookie:

If you have a query string (such as ?a=foo&b=bar) and want to convert that into a PHP array, this is how to do it.

Let's take a full example, where we begin with a URL, get the query string part of it, then convert that into an array.

array(2) {
      ["foo"]=> string(3) "bar"
      ["foo2"]=> string(4) "bar2"
      }

To find out which php.ini file (and its full file path) just run the following command:

php --ini

Which will output something like this:

$ php --ini
Configuration File (php.ini) Path: /etc
Loaded Configuration File:         /etc/php.ini
Scan for additional .ini files in: (none)
Additional .ini files parsed:      (none)

If you need to check from within a PHP script, you can either put this code in (if it isn't public facing) and search for 'Loaded configuration file':

Or run:

See also: php_ini_scanned_files()

Let's say you have an array with values of people's names. You want to find the 2nd most common name. How would you do this?

First you want to get a count of all values. Luckily PHP has this built in.

So now that we have an array where the keys are the names, and the values are the count of how many times they appear, we just need to sort it and pick the 2nd item.

To pick the 2nd element of the array, we need to use array_keys() so the array is numerically indexed...

The 2 most popular name is: Philip

If you have two (or more) arrays with various values, how do you find the values from the 1st array that are also in the 2nd (and others) array? Use the intersect functions.

PHP has a nice collection of array functions - one of which is array_intersect. You can use it to solve this problem.

Which outputs an array with the single item in both arrays: ['apple'].

What if you need to compare the keys and values?

Then use array_intersect_assoc() which will compare both keys and values.

array:2 [
  "cc" => "c"
  "dd" => "d"
]

If you just want to compare the keys, then use array_intersect_keys().

If you use a framework such as Laravel you almost always have some pagination features built in. Here is how to manually write out your own pagination feature in some simple to follow PHP.

For this code I'll still be using Eloquent, part of Laravel. It would be easy to write out the SQL too, so I've included that as well.

Let's begin by working out how many items we have in total

First we need to know the total number of rows that we are working with, and decide how many we will show per page.

This would be the same as: select count(*) as c from blog_posts

Calculate how many pages there will be:

The ceil() function will round up to the next full integer. So if $count/$per_page was 4.1, it would return 5.

Also, get the current page!

We need to decide what page the user is currently on. The first page would be page 1 (so be sure to remember to hard code that, even if $_GET['page'] (or whatever you use) is not set. I will hard code it in though...

Here we set the current page (but you could replace the 8 with $_GET['page'] ?? 1 (which will be the value of 'page' in the url (for example yoursite.com/your-script.php?page=123) or default to 1.

If the selected page is greater than the number of pages then you should do something like show 404 error, just show the max page's content (which is what the code above does), redirect to another page, or just show 'nothing found' (like a soft 404 error).

Oh, and of course you want to check that the current page is no smaller than 1!

Now you want to decide how many items 'along' you want to start from... (LIMIT startfromhere, takethismany, or LIMIT takethismany OFFSET startfromhere).

Putting it all together

Now we have everything we need!

If you are using a ORM like eloquent, you can do something like this:

This would generate something like this (for page 8, 15 per page): select * from `interview_question_q_and_as` order by `id` asc limit 15 offset 105.

The reason I am focusing on providing Eloquent code and not really playing with SQL direct is because this is a beginners topic (pagination), and I really don't recommend beginners start off with direct SQL as there are so many SQL injection attacks that you will probably leave yourself open for attack with. Always use prepared statements, don't put any variables direct in SQL. I'll have a guide soon explaining everything....

Pagination links

Don't forget to include pagination links. This will simply loop through them all. You might want to modify it to show prev/next links. If you have a a.active { font-weight:bold;} css rule, the current page will be highlighted.

How to do it in Laravel's Eloquent

You can use the array in appends() to automatically include any url parameters.

(for example, if your url was /?page=3&search_for=ducks, you should do appends(['search_for']) to ensure that it gets included in your pagination links.

There are several ways to output data/content. I might have forgotten about one of them

1) A php file with any content apart from <?php . Without the PHP opening tag, everything else will be echoed out.

2) echo 'some text'; - a simple echo

3) print ('some text'); - similar to echo

4) <?='some text':?> or <?=$a_variable:?>

5) and via functions such as print_r(12345) or var_dump($something)

What is the difference between echo and print in PHP?

There isn't much difference. The only two differences are that echo does not return any value, and can take multiple arguments (echo($a,$b,$b). print() returns a value of 1 and can only take one parameter. Years ago echo() used to be a bit faster, now it would be so insignificant that it is not worth even thinking about which is faster..

So you want to do an intersect, but not sure which PHP function to use? There are around 8 variations on the array intersection function built into PHP. Here is a guide for helping your pick which one to use!

The main array intersect functions in PHP

The basic idea of all of them is that it will return an array of all values from the first array that are also in the other arrays.

The differences between them are based on the following:

• If the user provides the compare function (u)
• If it will compare keys (assoc), values, or both

array_intersect()

This is the main one, I guess!

This will return an array with all values from $array1 that are present in all the others. It just compares the values, ignoring the keys

array_intersect_assoc()

Same as above, but it checks both values and keys

array_intersect_uassoc()

It checks the keys (via user supplied function) and values. The values are checked by normal comparison, but they keys are checked by a user supplied function.

array_intersect_key()

Returns array of everything from the first array which have keys in the other arrays.

array_intersect_ukey()

Same as above, but the comparison function for the keys is provided by the user.

array_uintersect()

Same as array_intersect() - but the user provides the comparison function for comparing the values

array_uintersect_assoc()

Same as array_uintersect() (above), but the user provided function checks the keys

array_uintersect_uassoc()

And in this function it is the two above combined. The user provides 2 comparison functions (one for keys, one for values), and it will check against both of those.

I've been coding professionally for years in PHP, and I still have to double check which one to use every time...

Years ago you used to see mysql_... functions everywhere. This has been (fortuantely) replaced by first the mysqli functions and more recently the object oriented way of PDO. Using PDO you can easily swap between database drivers (Mysql, Postgre, SQLite, etc). Here is how to connect to a mysql database, and then how to query it using PDO.

This also applies to mariadb

Connecting to MySQL with PDO in PHP

You should wrap this in a try/catch to handle a database connection error.

How to query the database

With PDO you don't have to think about escaping data. Every query should be 'prepared', then you can bind variables to placeholders. If you follow this example it should make sense.

In this example, we will do an insert and create a blog post with the following data:

Unnamed placeholders

These are indexed, starting at 1.

And then you execute it:

Named placeholders

You can also used named placeholders. They don't have to match anything else in the sql statement.

Although you will see a : before their names (such as :title) here and in most code, they aren't required. But they are a common convention that you should follow!

Now that we have prepared the statement and used some named params, we need to bind them:

And then you execute it:

Alternative ways to do this:

You can also pass an array to ->execute with an array:

An important thing to note about bindParam...

If you look at the method structure:

bool PDOStatement::bindParam ( mixed $parameter , mixed &$variable [, int $data_type = PDO::PARAM_STR [, int $length [, mixed $driver_options ]]] )

You might notice the second parameter. It is &$variable - by reference. So if you did this:

Then a new row would be inserted with "updated title here".

Why? because sent $title to bindParam, which saves the reference. You then update $title to "updated title here", so when you run ->execute() it uses whatever value is in $title, which is obviously the updated value.

Use bindValue() to avoid this issue.

How to get rows from the database?

By default PDO will return an array indexed by both column name and number (e.g. [1=> "some blog title", 'blog_title' => "some blog title", 2 => "some blog post body" , "post_body" => "some blog post body"].

There are a few ways to change this. You can use $statement->setFetchMode(...) (or $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);) to change this behaviour.

If I want to just work with an array I will normally use PDO::FETCH_ASSOC. The fetchObject method is nice too - it fetches the next row and returns it as an object. You can define what class it will create, so you can set it up to return model objects.

But anyway, on to some examples.

SELECT queries...

I am going to use the direct ->query() here, avoiding the binding and execute.

But I could also do this:

Update and delete

You can run these in a similar manner.

Delete SQL statement with PDO

Update SQL statement with PDO

If you want to replace multiple whitespace characters (multiple spaces, new lines, etc) with just a single space, use this:

If you need to reverse or undo htmlentities() you can use the following function to do so in PHP:

This will convert HTML entities to their corresponding characters.

Info about html_entity_decode()

There are a few flags that you can use (as the 2nd parameter):

You can set what encoding to use by passing an option to the 3rd parameter. By default it will use the default_charset php setting.

The following character sets are supported:

Add the following code to set unlimited execution time for a PHP script:

You can also update max_execution_time in php.ini

If the value is 0, it is actually unlimited. Otherwise it is that number of seconds.

In PHP it is very easy to sort an array of dates and times. All you need to do is convert it to a (integer) timestamp, and then do a normal sort. Here are more details:

First, convert the dates into a timestamp

A timestamp is time measured in the number of seconds since the Unix Epoch (January 1 1970 00:00:00 GMT). The current timestamp (when this page was last cached, anyway) is: 1565721779 (time()).

Because there is no standard PHP array function for sorting date strings we will have to convert it ourselves. But we can make a closure, and pass that to usort(&$array, $compare_func) (which lets us define our own function to do the comparisons for the sorting)

The custom comparison function for usort takes 2 parameters. It returns either -1, 0, or 1 depending on how they compare (1 if $a is less than $b; -1 if $a is greater than $b; 0 if equal). We can use PHP's spaceship operator for this (<=>) .

Let's set up the data:

And now the comparison function:

Now we have everything we need - let's sort that data!

array:6 [
  0 => "20 April 1998"
  1 => "5 April 1999"
  2 => "9 September 2000"
  3 => "10 September 2000"
  4 => "9 September 2020"
  5 => "10 September 2020"
]

PHP 7 introduced a new feature of Anonymous classes. Here is how to use them.

They are great for mocking, as you can easily write quick classes to do their purposes for a test.

You cannot define an anonymous class without instantiating it at the same time. I.e. when you create an anonymous class, it is instantiated at the same time.

They can extend other classes and use interfaces too.

It is very simple to see all installed PHP modules. Just run the following command:

php -m

For example, the output on one of my VM machines is:

$ php -m
[PHP Modules]
bcmath
bz2
calendar
Core
ctype
curl
date
dba
dom
exif
fileinfo
filter
ftp
gd
gettext
hash
iconv
imap
json
ldap
libxml
mbstring
mcrypt
mysqli
mysqlnd
openssl
pcntl
pcre
PDO
pdo_mysql
pdo_pgsql
pdo_sqlite
Phar
posix
Reflection
session
shmop
SimpleXML
soap
sockets
SPL
sqlite3
standard
sysvsem
sysvshm
tokenizer
wddx
xml
xmlreader
xmlrpc
xmlwriter
xsl
zip
zlib

[Zend Modules]

Nope! You can extend a class only once. You can, however, use traits.

The date() function in PHP is very simple. It takes two arguments (the second is optional) - the $format, and the optional $timestamp - date('y-m-d',time()- 31536000) = 17-10-12

(If no timestamp is provided then it uses the current date/time. The timestamp is in seconds, since January 1 1970 00:00:00 GMT. Current timestamp right now: 1539357386

The most difficult part of using date() in PHP is remembering its format.

Generators are like little functions that let you iterate over it (for example with a foreach) and it will 'yield' a value on every iteration.

If you do foreach(range(1,10000000) as $i) {...} then PHP will probably crash, as it has to first 'create' the array (with items from 1 to 10000000 in it). This isn't terribly memory efficient.

A better way to do it is using a generator. It will 'output' (yield) one value at a time, so uses much less memory.

Here is an example of a generator - take note of the yield line.

The yield $i is sort of the same as return $i, however the code that called range_generator() (i.e. the foreach loop) can keep asking it to yield again and again and again...

This range_generator() function is often called xrange() in other languages that have this function built in, BTW

The function above can be used like this:

1. The foreach loop starts, and gives the generator two parameters, 1 and 10000000.
2. The generator 'beings', and starts its own for loop. In its first iteration, it will yield 1.
3. This is then passed back to the foreach ( as $i), and the code within the foreach loop is executed (echo $i).
4. Once the first iteration of the foreach is complete, it will go back to the range generator, which will then finish its for loop (nothing else for it to do), and go into its own second iteration of that loop, until it reaches the yield $i again, where the pattern repeats.
5. This carries on until the range_generator stops yielding a variables back to the foreach loop.

If you used the standard range(1,10000000) function then the array of 10000000 elements has to be created and stay in memory. Using this generator means that only one $i exists at a time, massively reducing memory load. If I use the standard range(1,10000000) function, I get a Allowed memory size of 134217728 bytes exhausted (tried to allocate 536870920 bytes) exception.

The memory usage with a generators is constant, no matter how many times it iterates. It isn't really even fair to compare an array and a generator, as they aren't really the same thing. But you can loop them in things like a foreach loop.

How to send data to the generator

When you work with generators, you are actually working with the Generator class. There are a number of methods available to you:

• public mixed current() - Get the yielded value
• public mixed getReturn() - Get the return value of a generator. This is used after you have finished using the generator - as soon as you return anything (null, a value) the generator will stop yielding
• public mixed key() - Get the yielded key
• public void next() - Resume execution of the generator (same as calling Generator::send() with NULL as argument)
• public void rewind() - Rewind the iterator. N.B. If iteration has already begun, this will throw an exception.
• public mixed send( $value ) - Sends the given value to the generator as the result of the current yield expression and resumes execution of the generator.(see below for more details)
• public mixed throw( Throwable $exception ) -- Throw an exception into the generator, and then resumes execution of the generator. The behavior will be the same as if the current yield expression was replaced with a throw $exception statement
• public bool valid() - Check if the iterator has been closed
• public void __wakeup() - not really used - it will just throw an exception as you cannot serialise generators.

I think the most important one to know is the send($val) method. Here is an example:

This will output the following:

I'm printer!
Hello world!
Bye world!

When to use generators and their yielding feature

If you are ever doing something with a large amount of data and iterating over all of it, then your first thought should always be if you should be using a generator.

You don't want to be storing huge amounts of data in memory, especially if you are actually only working on one part (one line, one element, one document, one row) at a time.

Good times to use generators:

• Dealing with things like database rows. It is fine to process a few hundred (even a few thousand) in a normal array based loop. But if you have a big data set then you will very quickly run out of memory. Put it in a generator and handle one row at a time.
• When working with log files. Log files can easily be many GBs of text. Loading it all into memory at once, again, would be a bad idea. But cycling through it line by line means you won't face any memory issues.

PSRs are PHP Standards Recommendations. They are a standard and clearly defined way to do many common tasks.

Some common PSRs:

Source: Wikipedia's list of all PSRs

There are 3 main types of errors: Notices (not very important), Warnings (quite important), and Fatal (so important that the script will halt).

(Please don't ignore Notices just because I said they're not important. It was only to give a comparison between those three. There is often very important information in the Notice errors)

Notices (E_USER_NOTICE) - These are non-critical errors that do not stop further execution of the script (by default). If you try to use a variable that has not been set, you will get an E_USER_NOTICE notice error, but the script will (in default PHP settings) continue to run.

Warnings (E_USER_WARNING) - These are similar to notices, but more important. The script will still run (with default PHP settings), however, you should really pay attention to them. A warning error would be shown (/logged) for things such as attempting to use include() on a file that does not exist.

Fatal Errors (E_ERROR, or E_CORE_ERROR if PHP cannot initialise) - if your scripts encounter a fatal error, it will stop execution. A fatal error comes from doing things such as calling a function that does not exist, or calling require() for a file that does not exist.

There are a handful of predefined variables in PHP. They include:

$GLOBALS — References all variables available in global scope

$_SERVER — Server and execution environment information

$_GET — HTTP GET variables

$_POST — HTTP POST variables

$_FILES — HTTP File Upload variables

$_REQUEST — HTTP Request variables

$_SESSION — Session variables

$_ENV — Environment variables

$_COOKIE — HTTP Cookies

$php_errormsg — The previous error message

$HTTP_RAW_POST_DATA — Raw POST data

$http_response_header — HTTP response headers

$argc — The number of arguments passed to script

$argv — Array of arguments passed to script

The most commonly used ones, in my opinion, are $_GET, $_POST, $_SERVER, $_FILES, $_SESSION and $_COOKIE (so, the majority of them!)

The SPL (Standard PHP Library) includes several data structures that you should be aware of and hopefully use. Here is an overview of them:

SplDoublyLinkedList — The SplDoublyLinkedList class - this provides the main functionalities of a doubly linked list

SplStack — The SplStack class - this provides the main functionalities of a stack implemented using a doubly linked list.

SplQueue — The SplQueue class - this provides the main functionalities of a queue implemented using a doubly linked list.

SplHeap — The SplHeap class - this provides the main functionalities of a Heap.

SplMaxHeap — The SplMaxHeap class - this provides the main functionalities of a heap, keeping the maximum on the top.

SplMinHeap — The SplMinHeap class - this provides the main functionalities of a heap, keeping the minimum on the top.

SplPriorityQueue — The SplPriorityQueue class - this provides the main functionalities of a prioritized queue, implemented using a max heap.

SplFixedArray — The SplFixedArray class - this provides the main functionalities of array. The main differences between a SplFixedArray and a normal PHP array is that the SplFixedArray is of fixed length and allows only integers within the range as indexes. The advantage is that it allows a faster array implementation.

SplObjectStorage — The SplObjectStorage class - this provides a map from objects to data or, by ignoring data, an object set. This dual purpose can be useful in many cases involving the need to uniquely identify objects.

The iterators in the Standard PHP Library (SPL) are the following:

AppendIterator — The AppendIterator class

ArrayIterator — The ArrayIterator class

CachingIterator — The CachingIterator class

CallbackFilterIterator — The CallbackFilterIterator class

DirectoryIterator — The DirectoryIterator class

EmptyIterator — The EmptyIterator class

FilesystemIterator — The FilesystemIterator class

FilterIterator — The FilterIterator class

GlobIterator — The GlobIterator class

InfiniteIterator — The InfiniteIterator class

IteratorIterator — The IteratorIterator class

LimitIterator — The LimitIterator class

MultipleIterator — The MultipleIterator class

NoRewindIterator — The NoRewindIterator class

ParentIterator — The ParentIterator class

RecursiveArrayIterator — The RecursiveArrayIterator class

RecursiveCachingIterator — The RecursiveCachingIterator class

RecursiveCallbackFilterIterator — The RecursiveCallbackFilterIterator class

RecursiveDirectoryIterator — The RecursiveDirectoryIterator class

RecursiveFilterIterator — The RecursiveFilterIterator class

RecursiveIteratorIterator — The RecursiveIteratorIterator class

RecursiveRegexIterator — The RecursiveRegexIterator class

RecursiveTreeIterator — The RecursiveTreeIterator class

RegexIterator — The RegexIterator class

If a class is defined as final class then no other class can extend it. I.e. the following would result in an error:

A final method (final function ...) means that any subclasses of it's class cannot be overridden.

PEAR stands for 'PHP Extension and Application Repository'

It is a set of packages that provide further functionality than what is just built into plain PHP. It used to be more popular, I would say now that PEAR is quite dead. If you need to install a package, it will normally be a standard package installed with Composer. I remember years ago (10 years ago?) it was common to be working with PEAR packages. In 2018, not so much...

Camel case is where you write words/phrases so that each word begins with a capital letter (but lower case for the rest of the word), and there is no space (or other punctuation) between words. It is often used for function/method names, or variables. For example showBlogPosts().

(Note: often the first character will be lower case for things like method names and parameters. The first character will often be upper case for class names (e.g. class BlogController {...}.

Other alternatives include kebab-case (all lowercase, separated by a hyphen -). Also known as lisp-case or spinal-case.

There is also Train-Case (lowercase, but first letter uppercase, separated by hyphens).

Snake case is the way of writing words/phrases, where each word is separated by an underscore character. It is often used for variable names. For example $blog_posts is in snake case. Sometimes it is written as snake_case.

See also Camel case (e.g. $camelCaseVariable)

All four of these are ways to basically check if a variable (or return value) is empty or null. But they all have slight differences in how they approach it.

A lot of people assume that empty() and isset() are opposites, but if you look at the table at the bottom of this page you will see they aren't quite opposite. (e.g. an empty array ([]) will return true for both empty([]) and isset([]) They both also return true for values such as "0", 0, 0.0.

empty($var)

This will check if the variable is empty. The official docs list it as "A variable is considered empty if it does not exist or if its value equals FALSE.".

This means that empty() will return true if:

1. if $var does not exist
2. if $var = false
3. if $var = null
4. if $var = [] (empty array)
5. if $var = "" (empty string)
6. if $var = 0
7. if $var = "0" (0 as a string)
8. if $var = 0.0 (0 as a float)

isset($val)

isset() is a mix between checking if something is set (i.e. the variable exists, or in the case of arrays if the array key exists)) and checking if it is not null

It will return true for most situations, unless the variable does not exist, or if the variable = null

If you supply multiple arguments, it will only return true if all are set.

array(3) {
    ["a b c"]=> bool(true) // all were set and have values
    ["null1 null2"]=> bool(false) // both were null
    ["a b null1"]=> bool(false) // one was null
}

$val == null

This will return true for all situations where $val has a value. There are some weird situations that you must be aware of though.

It will return false for $val = "0"; var_dump($val == null); . I don't know why.

$val === null and is_null($val)

The only time that either of these statements will return true is if $val actually is null (i.e. $val=null;).

By default the max size for values in the $_GET[] array is 2048 bytes. The $_POST[] has no such limit.

The null coalescing operator is two question marks: ??. It is used to replace some ternary operations. Here is an example:

Both of the above lines do the same thing: they set $var to $_GET['variable'] if it is set (if it passes isset()), but if not then it sets $var to 'default_val'.

The spaceship operator was a new feature in PHP 7. It looks like this: <==>

It will return 0 if both sides are equal. 1 if left is greater. -1 if right is greater.

array(6) {
  ["1 <=> 1"]=> 0
  ["1 <=> 0"]=> 1
  ["0 <=> 1"]=> -1
  ["1 <=> "1""]=> 0
  [""abc" <=> "abc""]=> 0
  [""zzz" <=> "abc""]=> 1
}

The __destruct method is called either during the shutdown sequence (i.e. end of execution of a script), or when there are no references to an object.

Remember that if you put a __destruct() method in a subclass, you must call parent::__destruct() if you want the parent's destruct method to execute (assuming there is one).

The method will be called even if exit() is called. However, if exit() is called from within a destructor, then no further destructors will be called.

Note: completely unrelated to Array Destructuring.