summaryrefslogtreecommitdiffhomepage
path: root/php.html.markdown
diff options
context:
space:
mode:
Diffstat (limited to 'php.html.markdown')
-rw-r--r--php.html.markdown576
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