Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/dechristopher/php-doc

An unofficial personal reference fork of the learnxinyminutes PHP repository.
https://github.com/dechristopher/php-doc

Last synced: 4 months ago
JSON representation

An unofficial personal reference fork of the learnxinyminutes PHP repository.

Awesome Lists containing this project

README 

          
---

language: PHP

contributors:

    - ["Malcolm Fell", "http://emarref.net/"]

    - ["Trismegiste", "https://github.com/Trismegiste"]

---



This document describes PHP 5+.



```php



Hello World Again!

 12

$int2 = -12;  // => -12

$int3 = 012;  // => 10 (a leading 0 denotes an octal number)

$int4 = 0x0F; // => 15 (a leading 0x denotes a hex literal)

// Binary integer literals are available since PHP 5.4.0.

$int5 = 0b11111111; // 255 (a leading 0b denotes a binary number)



// Floats (aka doubles)

$float = 1.234;

$float = 1.2e3;

$float = 7E-10;



// Delete variable

unset($int1);



// Arithmetic

$sum        = 1 + 1; // 2

$difference = 2 - 1; // 1

$product    = 2 * 2; // 4

$quotient   = 2 / 1; // 2



// Shorthand arithmetic

$number = 0;

$number += 1;      // Increment $number by 1

echo $number++;    // Prints 1 (increments after evaluation)

echo ++$number;    // Prints 3 (increments before evaluation)

$number /= $float; // Divide and assign the quotient to $number



// Strings should be enclosed in single quotes;

$sgl_quotes = '$String'; // => '$String'



// Avoid using double quotes except to embed other variables

$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'



// Special characters are only escaped in double quotes

$escaped   = "This contains a \t tab character.";

$unescaped = 'This just contains a slash and a t: \t';



// Enclose a variable in curly braces if needed

$money = "I have $${number} in the bank.";



// Since PHP 5.3, nowdocs can be used for uninterpolated multi-liners

$nowdoc = <<<'END'

Multi line

string

END;



// Heredocs will do string interpolation

$heredoc = << 1, 'Two' => 2, 'Three' => 3);



// PHP 5.4 introduced a new syntax

$associative = ['One' => 1, 'Two' => 2, 'Three' => 3];



echo $associative['One']; // prints 1



// List literals implicitly assign integer keys

$array = ['One', 'Two', 'Three'];

echo $array[0]; // => "One"



// Add an element to the end of an array

$array[] = 'Four';

// or

array_push($array, 'Five');



// Remove element from array

unset($array[3]);



/********************************

 * Output

 */



echo('Hello World!');

// Prints Hello World! to stdout.

// Stdout is the web page if running in a browser.



print('Hello World!'); // The same as echo



// echo and print are language constructs too, so you can drop the parentheses

echo 'Hello World!';

print 'Hello World!';



$paragraph = 'paragraph';



echo 100;        // Echo scalar variables directly

echo $paragraph; // or variables



// If short open tags are configured, or your PHP version is

// 5.4.0 or greater, you can use the short echo syntax

?>

= $paragraph ?>


 2

echo $z; // => 2

$y = 0;

echo $x; // => 2

echo $z; // => 0



// Dumps type and value of variable to stdout

var_dump($z); // prints int(0)



// Prints variable to stdout in human-readable format

print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three )



/********************************

 * Logic

 */

$a = 0;

$b = '0';

$c = '1';

$d = '1';



// assert throws a warning if its argument is not true



// These comparisons will always be true, even if the types aren't the same.

assert($a == $b); // equality

assert($c != $a); // inequality

assert($c <> $a); // alternative inequality

assert($a < $c);

assert($c > $b);

assert($a <= $b);

assert($c >= $d);



// The following will only be true if the values match and are the same type.

assert($c === $d);

assert($a !== $d);

assert(1 === '1');

assert(1 !== '1');



// 'Spaceship' operator (since PHP 7)

// Returns 0 if values on either side are equal

// Returns 1 if value on the left is greater

// Returns -1 if the value on the right is greater



$a = 100;

$b = 1000;



echo $a <=> $a; // 0 since they are equal

echo $a <=> $b; // -1 since $a < $b

echo $b <=> $a; // 1 since $b > $a



// Variables can be converted between types, depending on their usage.



$integer = 1;

echo $integer + $integer; // => 2



$string = '1';

echo $string + $string; // => 2 (strings are coerced to integers)



$string = 'one';

echo $string + $string; // => 0

// Outputs 0 because the + operator cannot cast the string 'one' to a number



// Type casting can be used to treat a variable as another type



$boolean = (boolean) 1; // => true



$zero = 0;

$boolean = (boolean) $zero; // => false



// There are also dedicated functions for casting most types

$integer = 5;

$string = strval($integer);



$var = null; // Null value



/********************************

 * Control Structures

 */



if (true) {

    print 'I get printed';

}



if (false) {

    print 'I don\'t';

} else {

    print 'I get printed';

}



if (false) {

    print 'Does not get printed';

} elseif(true) {

    print 'Does';

}



// ternary operator

print (false ? 'Does not get printed' : 'Does');



// ternary shortcut operator since PHP 5.3

// equivalent of "$x ? $x : 'Does'""

$x = false;

print($x ?: 'Does');



// null coalesce operator since php 7

$a = null;

$b = 'Does print';

echo $a ?? 'a is not set'; // prints 'a is not set'

echo $b ?? 'b is not set'; // prints 'Does print'



$x = 0;

if ($x === '0') {

    print 'Does not print';

} elseif($x == '1') {

    print 'Does not print';

} else {

    print 'Does print';

}



// This alternative syntax is useful for templates:

?>



This is displayed if the test is truthy.



This is displayed otherwise.



 2, 'car' => 4];



// Foreach loops can iterate over arrays

foreach ($wheels as $wheel_count) {

    echo $wheel_count;

} // Prints "24"



echo "\n";



// You can iterate over the keys as well as the values

foreach ($wheels as $vehicle => $wheel_count) {

    echo "A $vehicle has $wheel_count wheels";

}



echo "\n";



$i = 0;

while ($i < 5) {

    if ($i === 3) {

        break; // Exit out of the while loop

    }

    echo $i++;

} // Prints "012"



for ($i = 0; $i < 5; $i++) {

    if ($i === 3) {

        continue; // Skip this iteration of the loop

    }

    echo $i;

} // Prints "0124"



/********************************

 * Functions

 */



// Define a function with "function":

function my_function () {

    return 'Hello';

}



echo my_function(); // => "Hello"



// A valid function name starts with a letter or underscore, followed by any

// number of letters, numbers, or underscores.



function add ($x, $y = 1) { // $y is optional and defaults to 1

    $result = $x + $y;

    return $result;

}



echo add(4); // => 5

echo add(4, 2); // => 6



// $result is not accessible outside the function

// print $result; // Gives a warning.



// Since PHP 5.3 you can declare anonymous functions;

$inc = function ($x) {

    return $x + 1;

};



echo $inc(2); // => 3



function foo ($x, $y, $z) {

    echo "$x - $y - $z";

}



// Functions can return functions

function bar ($x, $y) {

    // Use 'use' to bring in outside variables

    return function ($z) use ($x, $y) {

        foo($x, $y, $z);

    };

}



$bar = bar('A', 'B');

$bar('C'); // Prints "A - B - C"



// You can call named functions using strings

$function_name = 'add';

echo $function_name(1, 2); // => 3

// Useful for programatically determining which function to run.

// Or, use call_user_func(callable $callback [, $parameter [, ... ]]);



// You can get the all the parameters passed to a function

function parameters() {

    $numargs = func_num_args();

    if ($numargs > 0) {

        echo func_get_arg(0) . ' | ';

    }

    $args_array = func_get_args();

    foreach ($args_array as $key => $arg) {

        echo $key . ' - ' . $arg . ' | ';

    }

}



parameters('Hello', 'World'); // Hello | 0 - Hello | 1 - World |



// Since PHP 5.6 you can get a variable number of arguments

function variable($word, ...$list) {

	echo $word . " || ";

	foreach ($list as $item) {

		echo $item . ' | ';

	}

}



variable("Separate", "Hello", "World") // Separate || Hello | World | 



/********************************

 * Includes

 */



instanceProp = $instanceProp;

    }



    // Methods are declared as functions inside a class

    public function myMethod()

    {

        print 'MyClass';

    }



    //final keyword would make a function unoverridable

    final function youCannotOverrideMe()

    {

    }



/*

 * Declaring class properties or methods as static makes them accessible without

 * needing an instantiation of the class. A property declared as static can not

 * be accessed with an instantiated class object (though a static method can).

 */



    public static function myStaticMethod()

    {

        print 'I am static';

    }

}



// Class constants can always be accessed statically

echo MyClass::MY_CONST;    // Outputs 'value';



echo MyClass::$staticVar;  // Outputs 'static';

MyClass::myStaticMethod(); // Outputs 'I am static';



// Instantiate classes using new

$my_class = new MyClass('An instance property');

// The parentheses are optional if not passing in an argument.



// Access class members using ->

echo $my_class->property;     // => "public"

echo $my_class->instanceProp; // => "An instance property"

$my_class->myMethod();        // => "MyClass"



// Extend classes using "extends"

class MyOtherClass extends MyClass

{

    function printProtectedProperty()

    {

        echo $this->prot;

    }



    // Override a method

    function myMethod()

    {

        parent::myMethod();

        print ' > MyOtherClass';

    }

}



$my_other_class = new MyOtherClass('Instance prop');

$my_other_class->printProtectedProperty(); // => Prints "protected"

$my_other_class->myMethod();               // Prints "MyClass > MyOtherClass"



final class YouCannotExtendMe

{

}



// You can use "magic methods" to create getters and setters

class MyMapClass

{

    private $property;



    public function __get($key)

    {

        return $this->$key;

    }



    public function __set($key, $value)

    {

        $this->$key = $value;

    }

}



$x = new MyMapClass();

echo $x->property; // Will use the __get() method

$x->property = 'Something'; // Will use the __set() method



// Classes can be abstract (using the abstract keyword) or

// implement interfaces (using the implements keyword).

// An interface is declared with the interface keyword.



interface InterfaceOne

{

    public function doSomething();

}



interface InterfaceTwo

{

    public function doSomethingElse();

}



// interfaces can be extended

interface InterfaceThree extends InterfaceTwo

{

    public function doAnotherContract();

}



abstract class MyAbstractClass implements InterfaceOne

{

    public $x = 'doSomething';

}



class MyConcreteClass extends MyAbstractClass implements InterfaceTwo

{

    public function doSomething()

    {

        echo $x;

    }



    public function doSomethingElse()

    {

        echo 'doSomethingElse';

    }

}



// Classes can implement more than one interface

class SomeOtherClass implements InterfaceOne, InterfaceTwo

{

    public function doSomething()

    {

        echo 'doSomething';

    }



    public function doSomethingElse()

    {

        echo 'doSomethingElse';

    }

}



/********************************

 * Traits

 */



// Traits are available from PHP 5.4.0 and are declared using "trait"



trait MyTrait

{

    public function myTraitMethod()

    {

        print 'I have MyTrait';

    }

}



class MyTraitfulClass

{

    use MyTrait;

}



$cls = new MyTraitfulClass();

$cls->myTraitMethod(); // Prints "I have MyTrait"



/********************************

 * Namespaces

 */



// This section is separate, because a namespace declaration

// must be the first statement in a file. Let's pretend that is not the case