diff options
| -rw-r--r-- | php.html.markdown | 576 |
1 files changed, 284 insertions, 292 deletions
diff --git a/php.html.markdown b/php.html.markdown index 339499eb..1a8dea2c 100644 --- a/php.html.markdown +++ b/php.html.markdown @@ -6,15 +6,8 @@ author_url: http://emarref.net/ 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 <?php and ?> 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) <? and ?>. - -## [Comments](http://www.php.net/manual/en/language.basic-syntax.comments.php) - ```php -<?php +<?php // PHP code must be enclosed with <?php ? > tags // Two forward slashes start a one-line comment. @@ -24,27 +17,36 @@ configured to respect the [short open tags](http://www.php.net/manual/en/ini.cor 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. +// Use "echo" or "print" to print output +print('Hello '); // Prints "Hello " with no line break -### Scalars +// () are optional for print and echo +echo 'World\n'; // Prints "World" with a line break +// (all statements must end with a semicolon) -```php +// Anything outside <?php tags is echoed automatically +?>Hello World Again! <?php + +/************************************ + * Types & Variables + */ + +// Variables begin with the $ symbol. +// A valid variable name starts with a letter or underscore, +// followed by any number of letters, numbers, or underscores. + // 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) +$int1 = 19; // => 19 +$int2 = -19; // => -19 +$int3 = 019; // => 15 (a leading 0 denotes an octal number) +$int4 = 0x0F; // => 15 (a leading 0x denotes a hex literal) // Floats (aka doubles) $float = 1.234; @@ -52,28 +54,30 @@ $float = 1.2e3; $float = 7E-10; // Arithmetic -$sum = $number + $float; -$difference = $number - $float; -$product = $number * $float; -$quotient = $number / $float; +$sum = 1 + 1; // 2 +$difference = 2 - 1; // 1 +$product = 2 * 2; // 4 +$quotient = 2 / 1; // 2 // Shorthand arithmetic +$number = 0; $number += 1; // Add 1 to $number -$number++; // Add 1 to $number after it is used -++$number; // Add 1 to $number before it is used. -$number /= $float // Divide and assign the quotient to $number +echo $number++; // Prints 1 (increments after evaluation) +echo ++$number; // Prints 3 (increments before evalutation) +$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' +$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String' -// Escape special characters with backslash +// 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 $${integer} in the bank." +$money = "I have $${number} in the bank."; // Since PHP 5.3, nowdocs can be used for uninterpolated multi-liners $nowdoc = <<<'END' @@ -81,35 +85,40 @@ Multi line string END; +// Heredocs will do string interpolation $heredoc = <<<END Multi line $sgl_quotes -END; // Nowdoc syntax is available in PHP 5.3.0 +END; -// Manipulation -$concatenated = $sgl_quotes . $dbl_quotes; -``` +// String concatenation is done with . +echo 'This string ' . 'is concatenated'; -### Compound -```php -<?php +/******************************** + * Arrays + */ -// Arrays -$array = array(1, 2, 3); -$array = [1, 2, 3]; // As of PHP 5.4 -$string = ["One", "Two", "Three"]; -$string[0]; // Holds the value "One"; +// All arrays in PHP are associative arrays (hashmaps), // Associative arrays, known as hashmaps in some languages. -$associative = ["One" => 1, "Two" => 2, "Three" => 3]; -$associative["One"]; // Holds the value 1 -``` -## Output +// Works with all PHP versions +$associative = array('One' => 1, 'Two' => 2, 'Three' => 3); -```php -<?php +// 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" + + +/******************************** + * Output + */ echo('Hello World!'); // Prints Hello World! to stdout. @@ -121,133 +130,127 @@ print('Hello World!'); // The same as echo echo 'Hello World!'; print 'Hello World!'; // So is print +$paragraph = 'paragraph'; + echo 100; -echo $variable; -echo function_result(); +echo $paragraph; // If short open tags are configured, or your PHP version is // 5.4.0 or greater, you can use the short echo syntax -<?= $variable ?> -``` - -## [Operators](http://www.php.net/manual/en/language.operators.php) - -### Assignment - -```php +?> +<p><?= $paragraph ?></p> <?php $x = 1; $y = 2; $x = $y; // A now contains the same value sa $y -$x = &$y; +$z = &$y; // $x now contains a reference to $y. Changing the value of // $x will change the value of $y also, and vice-versa. -``` -### Comparison +echo $x; // => 2 +echo $z; // => 2 +$y = 0; +echo $x; // => 2 +echo $z; // => 0 -```php -<?php -// These comparisons will always be true, even if the types aren't the same. -$a == $b // TRUE if $a is 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 after type juggling. -$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. +/******************************** + * Logic + */ +$a = 0; +$b = '0'; +$c = '1'; +$d = '1'; -// The following will only be true if the values match and are the same type. -$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, or they are not of the same type. -1 == '1' // TRUE -1 === '1' // FALSE -``` +// assert throws a warning if its argument is not true -## [Type Juggling](http://www.php.net/manual/en/language.types.type-juggling.php) +// These comparisons will always be true, even if the types aren't the same. +assert($a == $b); // equality +assert($b != $a); // inequality +assert($a <> $b); // alternative inequality +assert($a < $c); +assert($c > $b); +assert($a <= $b); +assert($c >= $d); -Variables can be converted between types, depending on their usage. +// 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'); -```php -<?php +// Variables can be converted between types, depending on their usage. $integer = 1; -echo $integer + $integer; // Outputs 2; +echo $integer + $integer; // => 2 $string = '1'; -echo $string + $string; -// Also outputs 2 because the + operator converts the strings to integers +echo $string + $string; // => 2 (strings are coerced to integers) $string = 'one'; -echo $string + $string; +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 temporarily by using cast operators in parentheses. +// Type casting can be used to treat a variable as another type -```php -$boolean = (boolean) $integer; // $boolean is true +$boolean = (boolean) 1; // => true $zero = 0; -$boolean = (boolean) $zero; // $boolean is false +$boolean = (boolean) $zero; // => false +// There are also dedicated functions for casting most types $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 -<?php +/******************************** + * Control Structures + */ -if (/* test */) { - // Do something +if (true) { + print 'I get printed'; } -if (/* test */) { - // Do something +if (false) { + print "I don't"; } else { - // Do something else + print 'I get printed'; } -if (/* test */) { - // Do something -} elseif(/* test2 */) { - // Do something else, only if test2 +if (false) { + print 'Does not get printed'; +} elseif(true) { + print 'Does'; } -if (/* test */) { - // Do something -} elseif(/* test2 */) { - // Do something else, only if test2 +$x = 0; +if ($x === '0') { + print 'Does not print'; +} elseif($x == '1') { + print 'Does not print'; } else { - // Do something default + print 'Does print'; } + +// This alternative syntax is useful for templates: ?> -<?php if (/* test */): ?> +<?php if ($x): ?> This is displayed if the test is truthy. <?php else: ?> This is displayed otherwise. <?php endif; ?> -``` - -### Switch statements -```php <?php -switch ($variable) { - case 'one': - // Do something if $variable == 'one' - break; +// Use switch to save some logic. +switch ($x) { + case '0': + print 'Switch does type coercion'; + break; // You must include a break, or you will fall through case 'two': case 'three': // Do something if $variable is either 'two' or 'three' @@ -256,106 +259,98 @@ switch ($variable) { // Do something by default } -``` - -### Loops - -```php -<?php - +// While, do...while and for loops are probably familiar $i = 0; while ($i < 5) { echo $i++; -} +}; // Prints "01234" + +echo "\n"; $i = 0; do { echo $i++; -} while ($i < 5); +} while ($i < 5); // Prints "01234" + +echo "\n"; for ($x = 0; $x < 10; $x++) { echo $x; // Will echo 0 - 9 -} +}// Prints "0123456789" + +echo "\n"; + +$wheels = ['bicycle' => 2, 'car' => 4]; -$wheels = ["bicycle" => 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"; } -// This loop will stop after outputting 2 +echo "\n"; + $i = 0; while ($i < 5) { - if ($i == 3) { - break; // Exit out of the while loop and continue. + if ($i === 3) { + break; // Exit out of the while loop } echo $i++; -} +}// Prints "012" -// This loop will output everything except 3 -$i = 0; -while ($i < 5) { - if ($i == 3) { +for($i = 0; $i < 5; $i++){ + if ($i === 3) { continue; // Skip this iteration of the loop } - echo $i++; -} -``` - -## Functions + echo $i; +} // Prints "0124" -Functions are created with the ```function``` keyword. -```php -<?php +/******************************** + * Functions + */ -function my_function($my_arg) { - $my_variable = 1; +// Define a function with "function": +function my_function() { + return 'Hello'; } -// $my_variable and $my_arg cannot be accessed outside of the function -``` - -Functions may be invoked by name. - -```php -<?php - -my_function_name(); - -$variable = get_something(); // A function may return a value -``` +echo my_function(); // => "Hello" -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. +// A valid function name starts with a letter or underscore, followed by any +// number of letters, numbers, or underscores. -### [User-defined](http://www.php.net/manual/en/functions.user-defined.php) - -```php -<?php - -function my_function_name ($arg_1, $arg_2) { - // $arg_1 and $arg_2 are required +function add($x, $y = 1) { // $y is optional, and defaults to 2 + $result = $x + $y; + return $result; } -// 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' - } -} +echo add(4); // => 5 +echo add(4, 2); // => 6 -// inner_function() does not exist and cannot be called until -// outer_function() is called -``` +// $result is not accessible outside the function +// print $result; // Gives a warning. -This enables [currying](http://en.wikipedia.org/wiki/Currying) in PHP. +// Since PHP 5.3 you can declare anonymous functions; +$inc = function($x){ + return $x + 1; +}; + +echo $inc(2); // => 3 -```php 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); }; @@ -363,92 +358,77 @@ function bar ($x, $y) { $bar = bar('A', 'B'); $bar('C'); -``` - -### [Variable](http://www.php.net/manual/en/functions.variable-functions.php) -```php -<?php - -$function_name = 'my_function_name'; +// You can call named functions using strings +$function_name = 'add'; +echo $function_name(1, 2); // => 3 +// But, you should probably use anonymous functions instead. -$function_name(); // will execute the my_function_name() function -``` - -### [Anonymous](http://www.php.net/manual/en/functions.anonymous.php) +/******************************** + * Classes + */ -Similar to variable functions, functions may be anonymous. - -```php -<?php - -function my_function($callback) { - $callback('My argument'); -} - -my_function(function ($my_argument) { - // 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 -<?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 instantiated with the ```new``` keyword. Functions are referred to as -methods if they belong to a class. - -```php -<?php +//Classes are defined with the class keyword class MyClass { - function myFunction() { + const MY_CONST = 'value'; // A constant + static $staticVar = 'static'; + public $property = 'public'; // Properties must declare their visibility + private $privprop = 'private'; // Accessible within the class only + protected $protprop = 'protected'; // Accessible within the class and subclasses + public $instanceProp; + + // Create a constructor with __construct + public function __construct($instanceProp){ + // Access instance variables with $this + $this->instanceProp = $instanceProp; + } + // Methods are declared as functions inside a class + public function myMethod() { + print "MyClass"; } final function youCannotOverrideMe() { } public static function myStaticMethod() { + print "I am static"; } } -$cls = new MyClass(); // The parentheses are optional. +echo MyClass::MY_CONST; // Outputs "value"; +echo MyClass::$staticVar; // Outputs 'static'; +MyClass::myStaticMethod(); // Outputs "I am static"; -echo MyClass::$staticVar; // Access to static vars +// Access class members using ->. +$my_class = new MyClass("An instance property"); // The parentheses are optional. +echo $my_class->property; // => "public" +echo $my_class->instanceProp; // => "An instance property" +$my_class->myMethod(); // => "MyClass" -echo $cls->property; // Access to properties -MyClass::myStaticMethod(); // myStaticMethod cannot be run on $cls -``` +// Extend classes using "extends" +class MyOtherClass extends MyClass{ + function printProtectedProperty(){ + echo $this->protprop; + } -PHP offers some [magic methods](http://www.php.net/manual/en/language.oop5.magic.php) for classes. + // Override a method + function myMethod() { + parent::myMethod(); + print " > MyOtherClass"; + } +} -```php -<?php +$my_other_class = new MyOtherClass("Instance prop"); +$my_other_class->printProtectedProperty(); // => Prints "protected" +$my_other_class->myMethod(); // Prints "MyClass > MyOtherClass" -class MyClass { +final class YouCannotExtendMe { +} + +// You can use "magic methods" to create getters and setters +class MyMapClass { private $property; public function __get($key) @@ -462,16 +442,13 @@ class MyClass { } } -$x = new MyClass(); +$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), extend other classes (using the ```extends``` keyword) and -implement interfaces (using the ```implements``` keyword). An interface is declared with the ```interface``` keyword. -```php -<?php +// 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 { @@ -480,90 +457,105 @@ interface InterfaceOne interface InterfaceTwo { - public function doSomething(); + public function doSomethingElse(); } abstract class MyAbstractClass implements InterfaceOne { + public $x = "doSomething"; } -class MyClass extends MyAbstractClass implements InterfaceTwo +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"; + } } -``` -### [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. +/******************************** + * Traits + */ +//Traits are available since PHP 5.4.0 and are declared using the trait keyword. + +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 + +/* +``` ```php <?php +// By default, classes exist in the global namespace, and can +// be explicitly called with a backslash. + $cls = new \MyClass(); -``` -```php -<?php + +// Set the namespace for a file namespace My\Namespace; class MyClass { } +// (from another file) $cls = new My\Namespace\MyClass; -``` - -Or from within another namespace. - -```php -<?php +//Or from within another namespace. namespace My\Other\Namespace; use My\Namespace\MyClass; $cls = new MyClass(); -``` -Or you can alias the namespace; - -```php -<?php +// Or you can alias the namespace; 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 -<?php -trait MyTrait { - public function myTraitMethod() - { - // Do something - } -} - -class MyClass -{ - use MyTrait; -} +*/ -$cls = new MyClass(); -$cls->myTraitMethod(); ``` ## More Information |