From dd8abee4b432b57c017dfef368c975c5bef6e1e1 Mon Sep 17 00:00:00 2001 From: Malcolm Fell Date: Thu, 27 Jun 2013 21:42:07 +1200 Subject: [PATCH] Add the PHP language --- php.html.markdown | 474 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 474 insertions(+) create mode 100644 php.html.markdown diff --git a/php.html.markdown b/php.html.markdown new file mode 100644 index 00000000..18324736 --- /dev/null +++ b/php.html.markdown @@ -0,0 +1,474 @@ +--- +language: php +author: Malcolm Fell +author_url: http://emarref.net/ +--- + +# PHP + +This document describes PHP 5+. + +## [Basic Syntax](http://www.php.net/manual/en/language.basic-syntax.php) + +All statements must end with a semi-colon; All PHP code must be between tags. PHP can also be configured to respect the [short open tags](http://www.php.net/manual/en/ini.core.php#ini.short-open-tag) . + +## [Comments](http://www.php.net/manual/en/language.basic-syntax.comments.php) + +```php +// Two forward slashes start a one-line comment. + +# So will a hash (aka pound symbol) but // is more common + +/* + Surrounding text in slash-asterisk and asterisk-slash + makes it a multi-line comment. +*/ +``` + +## [Types](http://www.php.net/manual/en/language.types.php) + +Types are [weakly typed](http://en.wikipedia.org/wiki/Strong_and_weak_typing) and begin with the $ symbol. A valid variable name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. + +### Scalars + +```php +// Boolean values are case-insensitive +$boolean = true; // or TRUE or True +$boolean = false; // or FALSE or False + +// Integers +$integer = 1234; // decimal number +$integer = -123; // a negative number +$integer = 0123; // octal number (equivalent to 83 decimal) +$integer = 0x1A; // hexadecimal number (equivalent to 26 decimal) + +// Floats (aka doubles) +$float = 1.234; +$float = 1.2e3; +$float = 7E-10; + +// Arithmetic +$sum = $number + $float; +$difference = $number - $float; +$product = $number * $float; +$quotient = $number / $float; + +// Shorthand arithmetic +$number += 1; // Will add 1 to $number +$number++; // Will add 1 to $number after it is used +++$number; // Will add 1 to $number before it is used. +$number /= $float // Will divide $number $float, and assign the quotient to $number + +// Strings +$sgl_quotes = 'String'; // Strings should be enclosed in single quotes; +$dbl_quotes = "This is a $sgl_quotes." // Avoid using double quotes to embed other variables +$escaped = "This contains a \t tab character."; // Escape special characters with backslash +$money = "I have $${integer} in the bank." // Enclose a variable in curly braces if needed +$nowdoc = <<<'END' +Multi line +string +END; +$heredoc = << 1, "Two" => 2, "Three" => 3]; +$associative["One"]; // Holds the value 1 +``` + +## Output + +```php +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 'Hello World!'; // echo is actually a language construct, so you can drop the parentheses. +echo 100; +echo $variable; +echo function_result(); // Output the result of a function call that returns a value. More on functions later. + +// If [short open tags](http://www.php.net/manual/en/ini.core.php#ini.short-open-tag) are configured, or your PHP version is 5.4.0 or greater, you can use the short echo syntax + +``` + +## [Operators](http://www.php.net/manual/en/language.operators.php) + +### Assignment + +```php +$a = 1; +$b = 2; +$a = $b; // A now contains the same value sa $b +$a =& $b; // A now contains a reference to $b. Changing the value of $a will change the value of $b also, and vice-versa. +``` + +### Comparison + +```php +$a == $b // TRUE if $a is equal to $b after type juggling. +$a === $b // TRUE if $a is equal to $b, and they are of the same type. +$a != $b // TRUE if $a is not equal to $b after type juggling. +$a <> $b // TRUE if $a is not equal to $b after type juggling. +$a !== $b // TRUE if $a is not equal to $b, or they are not of the same type. +$a < $b // TRUE if $a is strictly less than $b. +$a > $b // TRUE if $a is strictly greater than $b. +$a <= $b // TRUE if $a is less than or equal to $b. +$a >= $b // TRUE if $a is greater than or equal to $b. +``` + +## [Type Juggling](http://www.php.net/manual/en/language.types.type-juggling.php) + +Variables can be converted between types, depending on their usage. + +```php +$integer = 1; +echo $integer + $integer; // Outputs 2; + +$string = '1'; +echo $string + $string; // Also outputs 2 because the + operator converts the strings to integers + +$string = 'one'; +echo $string + $string; // Outputs 0 because the + operator cannot cast the string 'one' to a number + +$boolean = (boolean) $integer; // $boolean is true + +$zero = 0; +$boolean = (boolean) $zero; // $boolean is false + +$integer = 5; +$string = strval($integer); // There are also dedicated functions for casting most types + +$var = null; // Null value +``` + +## [Control Structures](http://www.php.net/manual/en/language.control-structures.php) + +### If Statements + +```php +if (/* test */) { + // Do something +} + +if (/* test */) { + // Do something +} else { + // Do something else +} + +if (/* test */) { + // Do something +} elseif(/* test2 */) { + // Do something else, only if test2 +} + +if (/* test */) { + // Do something +} elseif(/* test2 */) { + // Do something else, only if test2 +} else { + // Do something default +} + + + + + + +``` + +### Switch statements + +```php +switch ($variable) { + case 'one': + // Do something if $variable == 'one' + break; + case 'two': + case 'three': + // Do something if $variable is either 'two' or 'three' + break; + default: + // Do something by default +} + +``` + +### Loops + +```php +$i = 0; +while ($i < 5) { + echo $i++; +} + +$i = 0; +do { + echo $i++; +} while ($i < 5); + +for ($x = 0; $x < 10; $x++) { + echo $x; // Will echo 0 - 9 +} + +$wheels = ["bicycle" => 2, "car" => 4]; + +foreach ($wheels as $vehicle => $wheel_count) { + echo "A $vehicle has $wheel_count wheels"; +} + +// This loop will stop after outputting 2 +$i = 0; +while ($i < 5) { + if ($i == 3) { + break; // Exit out of the while loop and continue. + } + + echo $i++; +} + +// This loop will output everything except 3 +$i = 0; +while ($i < 5) { + if ($i == 3) { + continue; // Skip this iteration of the loop + } + + echo $i++; +} +``` + +## Functions + +Functions are created with the ```function``` keyword. + +```php +function my_function($my_arg) { + $my_variable = 1; +} + +// $my_variable and $my_arg cannot be accessed outside of the function +``` + +Functions may be invoked by name. + +```php +my_function_name(); + +$variable = get_something(); // A function may return a value +``` + +A valid function name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. There are three ways to declare functions. + +### [User-defined](http://www.php.net/manual/en/functions.user-defined.php) + +```php +function my_function_name ($arg_1, $arg_2) { // $arg_1 and $arg_2 are required + // Do something with $arg_1 and $arg_2; +} + +// Functions may be nested to limit scope +function outer_function ($arg_1 = null) { // $arg_1 is optional + function inner_function($arg_2 = 'two') { // $arg_2 will default to 'two' + } +} + +// inner_function() does not exist and cannot be called until outer_function() is called +``` + +### [Variable](http://www.php.net/manual/en/functions.variable-functions.php) + +```php +$function_name = 'my_function_name'; + +$function_name(); // will execute the my_function_name() function +``` + +### [Anonymous](http://www.php.net/manual/en/functions.anonymous.php) + +Similar to variable functions, functions may be anonymous. + +```php +my_function(function () { + // do something +}); + +// Closure style +$my_function = function() { + // Do something +}; + +$my_function(); +``` + +## [Classes](http://www.php.net/manual/en/language.oop5.php) + +Classes are defined with the ```class``` keyword. + +```php +class MyClass { + const MY_CONST = 'value'; + static $staticVar = 'something'; + public $property = 'value'; // Properties must declare their visibility +} + +echo MyClass::MY_CONST; // Outputs "value"; + +final class YouCannotExtendMe { +} +``` + +Classes are insantiated with the ```new``` keyword. Functions are referred to as methods if they belong to a class. + +```php +class MyClass { + function myFunction() { + } + + function function youCannotOverrideMe() + { + } + + public static function myStaticMethod() + { + } +} + +$cls = new MyClass(); // The parentheses are optional. + +echo MyClass::$staticVar; // Access to static vars + +echo $cls->property; // Access to properties + +MyClass::myStaticMethod(); // myStaticMethod cannot be run on $cls +``` + +PHP offers some [magic methods](http://www.php.net/manual/en/language.oop5.magic.php) for classes. + +```php +class MyClass { + private $property; + + public function __get($key) + { + return $this->$key; + } + + public function __set($key, $value) + { + $this->$key = $value; + } +} + +$x = new MyClass(); +echo $x->property; // Will use the __get() method to retrieve the value of $property +$x->property = 'Something'; // Will use the __set() method to set the value of property +``` + +Classes can be abstract (using the ```abstract``` keyword), extend other classes (using the ```extends``` keyword) and implement interfaces (using the ```implements``` keyword). An interface is declared with the ```interface``` keyword. + +```php +interface InterfaceOne +{ + public function doSomething(); +} + +interface InterfaceTwo +{ + public function doSomething(); +} + +abstract class MyAbstractClass implements InterfaceOne +{ +} + +class MyClass extends MyAbstractClass implements InterfaceTwo +{ +} + +// Classes can implement more than one interface +class SomeOtherClass implements InterfaceOne, InterfaceTwo +{ +} +``` + +### [Namespaces](http://www.php.net/manual/en/language.namespaces.rationale.php) + +By default, classes exist in the global namespace, and can be explicitly called with a backslash. + +```php +$cls = new \MyClass(); +``` + +```php +namespace My\Namespace; + +class MyClass +{ +} + +$cls = new My\Namespace\MyClass; +``` + +Or from within another namespace. + +```php +namespace My\Other\Namespace; + +use My\Namespace\MyClass; + +$cls = new MyClass(); +``` + +Or you can alias the namespace; + +```php +namespace My\Other\Namespace; + +use My\Namespace as SomeOtherNamespace; + +$cls = new SomeOtherNamespace\MyClass(); +``` + +### [Traits](http://www.php.net/manual/en/language.oop5.traits.php) + +Traits are available since PHP 5.4.0 and are declared using the ```trait``` keyword. + +```php +trait MyTrait { + public function myTraitMethod() + { + // Do something + } +} + +class MyClass +{ + use MyTrait; +} + +$cls = new MyClass(); +$cls->myTraitMethod(); +``` + +## More Information + +Visit the [official PHP documentation](http://www.php.net/manual/) for reference and community input. + +If you're interested in up-to-date best practices, visit [PHP The Right Way](http://www.phptherightway.com/). + +If you're coming from a language with good package management, check out [Composer](http://getcomposer.org/). \ No newline at end of file