mirror of
https://github.com/Fechin/reference.git
synced 2026-11-20 21:23:11 +03:00
1200 lines
20 KiB
Markdown
1200 lines
20 KiB
Markdown
---
|
||
title: PHP
|
||
date: 2021-01-04 15:23:28
|
||
background: bg-[#7477a9]
|
||
tags:
|
||
- web
|
||
categories:
|
||
- Programming
|
||
intro: |
|
||
This [PHP](https://www.php.net/manual/en/) cheat sheet provides a reference for quickly looking up the correct syntax for the code you use most frequently.
|
||
plugins:
|
||
- copyCode
|
||
- runCode
|
||
---
|
||
|
||
## Getting Started
|
||
|
||
### hello.php
|
||
|
||
```php
|
||
<?php // begin with a PHP open tag.
|
||
|
||
echo "Hello World\n";
|
||
print("Hello cheatsheets.zip");
|
||
|
||
?>
|
||
```
|
||
|
||
PHP run command
|
||
|
||
```shell script
|
||
$ php hello.php
|
||
```
|
||
|
||
### Variables
|
||
|
||
```php
|
||
$boolean1 = true;
|
||
$boolean2 = True;
|
||
|
||
$int = 12;
|
||
$float = 3.1415926;
|
||
unset($float); // Delete variable
|
||
|
||
$str1 = "How are you?";
|
||
$str2 = 'Fine, thanks';
|
||
```
|
||
|
||
See: [Types](#php-types)
|
||
|
||
### Strings
|
||
|
||
```php
|
||
$url = "cheatsheets.zip";
|
||
echo "I'm learning PHP at $url";
|
||
|
||
// Concatenate strings
|
||
echo "I'm learning PHP at " . $url;
|
||
|
||
$hello = "Hello, ";
|
||
$hello .= "World!";
|
||
echo $hello; # => Hello, World!
|
||
```
|
||
|
||
See: [Strings](#php-strings)
|
||
|
||
### Arrays
|
||
|
||
```php
|
||
$num = [1, 3, 5, 7, 9];
|
||
$num[5] = 11;
|
||
unset($num[2]); // Delete variable
|
||
print_r($num); # => 1 3 7 9 11
|
||
echo count($num); # => 5
|
||
```
|
||
|
||
See: [Arrays](#php-arrays)
|
||
|
||
### Operators
|
||
|
||
```php
|
||
$x = 1;
|
||
$y = 2;
|
||
|
||
$sum = $x + $y;
|
||
echo $sum; # => 3
|
||
```
|
||
|
||
See: [Operators](#php-operators)
|
||
|
||
### Include {.row-span-3}
|
||
|
||
#### vars.php
|
||
|
||
```php
|
||
<?php // begin with a PHP open tag.
|
||
$fruit = 'apple';
|
||
echo "I was imported";
|
||
return 'Anything you like.';
|
||
?>
|
||
```
|
||
|
||
#### test.php
|
||
|
||
```php
|
||
<?php
|
||
include 'vars.php';
|
||
echo $fruit . "\n"; # => apple
|
||
|
||
/* Same as include,
|
||
cause an error if cannot be included*/
|
||
require 'vars.php';
|
||
|
||
// Also works
|
||
include('vars.php');
|
||
require('vars.php');
|
||
|
||
// Include through HTTP
|
||
include 'http://x.com/file.php';
|
||
|
||
// Include and the return statement
|
||
$result = include 'vars.php';
|
||
echo $result; # => Anything you like.
|
||
?>
|
||
```
|
||
|
||
### Functions
|
||
|
||
```php
|
||
function add($num1, $num2 = 1) {
|
||
return $num1 + $num2;
|
||
}
|
||
echo add(10); # => 11
|
||
echo add(10, 5); # => 15
|
||
```
|
||
|
||
See: [Functions](#php-functions)
|
||
|
||
### Comments
|
||
|
||
```php
|
||
# This is a one line shell-style comment
|
||
|
||
// This is a one line c++ style comment
|
||
|
||
/* This is a multi line comment
|
||
yet another line of comment */
|
||
```
|
||
|
||
### Constants
|
||
|
||
```php
|
||
const MY_CONST = "hello";
|
||
|
||
echo MY_CONST; # => hello
|
||
|
||
# => MY_CONST is: hello
|
||
echo 'MY_CONST is: ' . MY_CONST;
|
||
```
|
||
|
||
### Classes
|
||
|
||
```php
|
||
class Student {
|
||
public function __construct($name) {
|
||
$this->name = $name;
|
||
}
|
||
}
|
||
$alex = new Student("Alex");
|
||
```
|
||
|
||
See: [Classes](#php-classes)
|
||
|
||
## PHP Types
|
||
|
||
### Boolean {.row-span-2}
|
||
|
||
```php
|
||
$boolean1 = true;
|
||
$boolean2 = TRUE;
|
||
$boolean3 = false;
|
||
$boolean4 = FALSE;
|
||
|
||
$boolean5 = (boolean) 1; # => true
|
||
$boolean6 = (boolean) 0; # => false
|
||
```
|
||
|
||
Boolean are case-insensitive
|
||
|
||
### Integer {.row-span-2}
|
||
|
||
```php
|
||
$int1 = 28; # => 28
|
||
$int2 = -32; # => -32
|
||
$int3 = 012; # => 10 (octal)
|
||
$int4 = 0x0F; # => 15 (hex)
|
||
$int5 = 0b101; # => 5 (binary)
|
||
|
||
# => 2000100000 (decimal, PHP 7.4.0)
|
||
$int6 = 2_000_100_000;
|
||
```
|
||
|
||
See also: [Integers](https://www.php.net/manual/en/language.types.integer.php)
|
||
|
||
### Strings
|
||
|
||
```php
|
||
echo 'this is a simple string';
|
||
```
|
||
|
||
See: [Strings](#php-strings)
|
||
|
||
### Arrays
|
||
|
||
```php
|
||
$arr = array("hello", "world", "!");
|
||
```
|
||
|
||
See: [Arrays](#php-arrays)
|
||
|
||
### Float (Double)
|
||
|
||
```php
|
||
$float1 = 1.234;
|
||
$float2 = 1.2e7;
|
||
$float3 = 7E-10;
|
||
|
||
$float4 = 1_234.567; // as of PHP 7.4.0
|
||
var_dump($float4); // float(1234.567)
|
||
|
||
$float5 = 1 + "10.5"; # => 11.5
|
||
$float6 = 1 + "-1.3e3"; # => -1299
|
||
```
|
||
|
||
### Null
|
||
|
||
```php
|
||
$a = null;
|
||
$b = 'Hello php!';
|
||
echo $a ?? 'a is unset'; # => a is unset
|
||
echo $b ?? 'b is unset'; # => Hello php
|
||
|
||
$a = array();
|
||
$a == null # => true
|
||
$a === null # => false
|
||
is_null($a) # => false
|
||
```
|
||
|
||
### Iterables
|
||
|
||
```php
|
||
function bar(): iterable {
|
||
return [1, 2, 3];
|
||
}
|
||
function gen(): iterable {
|
||
yield 1;
|
||
yield 2;
|
||
yield 3;
|
||
}
|
||
foreach (bar() as $value) {
|
||
echo $value; # => 123
|
||
}
|
||
```
|
||
|
||
## PHP Strings
|
||
|
||
### String
|
||
|
||
```php
|
||
# => '$String'
|
||
$sgl_quotes = '$String';
|
||
|
||
# => 'This is a $String.'
|
||
$dbl_quotes = "This is a $sgl_quotes.";
|
||
|
||
# => a tab character.
|
||
$escaped = "a \t tab character.";
|
||
|
||
# => a slash and a t: \t
|
||
$unescaped = 'a slash and a t: \t';
|
||
```
|
||
|
||
### Multi-line
|
||
|
||
```php
|
||
$str = "foo";
|
||
|
||
// Uninterpolated multi-liners
|
||
$nowdoc = <<<'END'
|
||
Multi line string
|
||
$str
|
||
END;
|
||
|
||
// Will do string interpolation
|
||
$heredoc = <<<END
|
||
Multi line
|
||
$str
|
||
END;
|
||
```
|
||
|
||
### Manipulation
|
||
|
||
```php
|
||
$s = "Hello Phper";
|
||
echo strlen($s); # => 11
|
||
|
||
echo substr($s, 0, 3); # => Hel
|
||
echo substr($s, 1); # => ello Phper
|
||
echo substr($s, -4, 3);# => hpe
|
||
|
||
echo strtoupper($s); # => HELLO PHPER
|
||
echo strtolower($s); # => hello phper
|
||
|
||
echo strpos($s, "l"); # => 2
|
||
var_dump(strpos($s, "L")); # => false
|
||
```
|
||
|
||
See: [String Functions](https://www.php.net/manual/en/ref.strings.php)
|
||
|
||
## PHP Arrays
|
||
|
||
### Defining {.row-span-2}
|
||
|
||
```php
|
||
$a1 = ["hello", "world", "!"]
|
||
$a2 = array("hello", "world", "!");
|
||
$a3 = explode(",", "apple,pear,peach");
|
||
```
|
||
|
||
#### Mixed int and string keys
|
||
|
||
```php
|
||
$array = array(
|
||
"foo" => "bar",
|
||
"bar" => "foo",
|
||
100 => -100,
|
||
-100 => 100,
|
||
);
|
||
var_dump($array);
|
||
```
|
||
|
||
#### Short array syntax
|
||
|
||
```php
|
||
$array = [
|
||
"foo" => "bar",
|
||
"bar" => "foo",
|
||
];
|
||
```
|
||
|
||
### Multi array
|
||
|
||
```php
|
||
$multiArray = [
|
||
[1, 2, 3],
|
||
[4, 5, 6],
|
||
[7, 8, 9],
|
||
];
|
||
|
||
print_r($multiArray[0][0]) # => 1
|
||
print_r($multiArray[0][1]) # => 2
|
||
print_r($multiArray[0][2]) # => 3
|
||
```
|
||
|
||
### Multi type {.row-span-2}
|
||
|
||
```php
|
||
$array = array(
|
||
"foo" => "bar",
|
||
42 => 24,
|
||
"multi" => array(
|
||
"dim" => array(
|
||
"a" => "foo"
|
||
)
|
||
)
|
||
);
|
||
|
||
# => string(3) "bar"
|
||
var_dump($array["foo"]);
|
||
|
||
# => int(24)
|
||
var_dump($array[42]);
|
||
|
||
# => string(3) "foo"
|
||
var_dump($array["multi"]["dim"]["a"]);
|
||
```
|
||
|
||
### manipulation
|
||
|
||
```php
|
||
$arr = array(5 => 1, 12 => 2);
|
||
$arr[] = 56; // Append
|
||
$arr["x"] = 42; // Add with key
|
||
sort($arr); // Sort
|
||
unset($arr[5]); // Remove
|
||
unset($arr); // Remove all
|
||
```
|
||
|
||
See: [Array Functions](https://www.php.net/manual/en/ref.array.php)
|
||
|
||
### Indexing iteration
|
||
|
||
```php
|
||
$array = array('a', 'b', 'c');
|
||
$count = count($array);
|
||
|
||
for ($i = 0; $i < $count; $i++) {
|
||
echo "i:{$i}, v:{$array[$i]}\n";
|
||
}
|
||
```
|
||
|
||
### Value iteration
|
||
|
||
```php
|
||
$colors = array('red', 'blue', 'green');
|
||
|
||
foreach ($colors as $color) {
|
||
echo "Do you like $color?\n";
|
||
}
|
||
```
|
||
|
||
### Key iteration
|
||
|
||
```php
|
||
$arr = ["foo" => "bar", "bar" => "foo"];
|
||
|
||
foreach ( $arr as $key => $value )
|
||
{
|
||
echo "key: " . $key . "\n";
|
||
echo "val: {$arr[$key]}\n";
|
||
}
|
||
```
|
||
|
||
### Concatenate arrays
|
||
|
||
```php
|
||
$a = [1, 2];
|
||
$b = [3, 4];
|
||
|
||
// PHP 7.4 later
|
||
# => [1, 2, 3, 4]
|
||
$result = [...$a, ...$b];
|
||
```
|
||
|
||
### Into functions
|
||
|
||
```php
|
||
$array = [1, 2];
|
||
|
||
function foo(int $a, int $b) {
|
||
echo $a; # => 1
|
||
echo $b; # => 2
|
||
}
|
||
foo(...$array);
|
||
```
|
||
|
||
### Splat Operator
|
||
|
||
```php
|
||
function foo($first, ...$other) {
|
||
var_dump($first); # => a
|
||
var_dump($other); # => ['b', 'c']
|
||
}
|
||
foo('a', 'b', 'c' /*, ...*/ );
|
||
// or
|
||
function foo($first, string ...$other){}
|
||
```
|
||
|
||
## PHP Operators {.cols-4}
|
||
|
||
### Arithmetic
|
||
|
||
| - | - |
|
||
| ---- | -------------- |
|
||
| `+` | Addition |
|
||
| `-` | Subtraction |
|
||
| `*` | Multiplication |
|
||
| `/` | Division |
|
||
| `%` | Modulo |
|
||
| `**` | Exponentiation |
|
||
|
||
### Assignment
|
||
|
||
| - | - |
|
||
| -------- | ------------------- |
|
||
| `a += b` | Same as `a = a + b` |
|
||
| `a -= b` | Same as `a = a – b` |
|
||
| `a *= b` | Same as `a = a * b` |
|
||
| `a /= b` | Same as `a = a / b` |
|
||
| `a %= b` | Same as `a = a % b` |
|
||
|
||
### Comparison {.row-span-2}
|
||
|
||
| - | - |
|
||
| ----- | ---------------------------- |
|
||
| `==` | Equal |
|
||
| `===` | Identical |
|
||
| `!=` | Not equal |
|
||
| `<>` | Not equal |
|
||
| `!==` | Not identical |
|
||
| `<` | Less than |
|
||
| `>` | Greater than |
|
||
| `<=` | Less than or equal |
|
||
| `>=` | Greater than or equal |
|
||
| `<=>` | Less than/equal/greater than |
|
||
|
||
### Logical
|
||
|
||
| - | - |
|
||
| ----- | ------------ | --- | --- |
|
||
| `and` | And |
|
||
| `or` | Or |
|
||
| `xor` | Exclusive or |
|
||
| `!` | Not |
|
||
| `&&` | And |
|
||
| ` | | ` | Or |
|
||
|
||
### Arithmetic {.col-span-2}
|
||
|
||
```php
|
||
// Arithmetic
|
||
$sum = 1 + 1; // 2
|
||
$difference = 2 - 1; // 1
|
||
$product = 2 * 2; // 4
|
||
$quotient = 2 / 1; // 2
|
||
|
||
// Shorthand arithmetic
|
||
$num = 0;
|
||
$num += 1; // Increment $num by 1
|
||
echo $num++; // Prints 1 (increments after evaluation)
|
||
echo ++$num; // Prints 3 (increments before evaluation)
|
||
$num /= $float; // Divide and assign the quotient to $num
|
||
```
|
||
|
||
### Bitwise
|
||
|
||
| - | - |
|
||
| ---- | ------------------ | ----------------- |
|
||
| `&` | And |
|
||
| ` | ` | Or (inclusive or) |
|
||
| `^` | Xor (exclusive or) |
|
||
| `~` | Not |
|
||
| `<<` | Shift left |
|
||
| `>>` | Shift right |
|
||
|
||
## PHP Conditionals
|
||
|
||
### If elseif else
|
||
|
||
```php
|
||
$a = 10;
|
||
$b = 20;
|
||
|
||
if ($a > $b) {
|
||
echo "a is bigger than b";
|
||
} elseif ($a == $b) {
|
||
echo "a is equal to b";
|
||
} else {
|
||
echo "a is smaller than b";
|
||
}
|
||
```
|
||
|
||
### Switch
|
||
|
||
```php
|
||
$x = 0;
|
||
switch ($x) {
|
||
case '0':
|
||
print "it's zero";
|
||
break;
|
||
case 'two':
|
||
case 'three':
|
||
// do something
|
||
break;
|
||
default:
|
||
// do something
|
||
}
|
||
```
|
||
|
||
### Ternary operator
|
||
|
||
```php
|
||
# => Does
|
||
print (false ? 'Not' : 'Does');
|
||
|
||
$x = false;
|
||
# => Does
|
||
print($x ?: 'Does');
|
||
|
||
$a = null;
|
||
$b = 'Does print';
|
||
# => a is unset
|
||
echo $a ?? 'a is unset';
|
||
# => print
|
||
echo $b ?? 'b is unset';
|
||
```
|
||
|
||
### Match
|
||
|
||
```php
|
||
$statusCode = 500;
|
||
$message = match($statusCode) {
|
||
200, 300 => null,
|
||
400 => 'not found',
|
||
500 => 'server error',
|
||
default => 'known status code',
|
||
};
|
||
echo $message; # => server error
|
||
```
|
||
|
||
See: [Match](https://www.php.net/manual/en/control-structures.match.php)
|
||
|
||
### Match expressions
|
||
|
||
```php
|
||
$age = 23;
|
||
|
||
$result = match (true) {
|
||
$age >= 65 => 'senior',
|
||
$age >= 25 => 'adult',
|
||
$age >= 18 => 'young adult',
|
||
default => 'kid',
|
||
};
|
||
|
||
echo $result; # => young adult
|
||
```
|
||
|
||
## PHP Loops
|
||
|
||
### while
|
||
|
||
```php
|
||
$i = 1;
|
||
# => 12345
|
||
while ($i <= 5) {
|
||
echo $i++;
|
||
}
|
||
```
|
||
|
||
### do while
|
||
|
||
```php
|
||
$i = 1;
|
||
# => 12345
|
||
do {
|
||
echo $i++;
|
||
} while ($i <= 5);
|
||
```
|
||
|
||
### for i
|
||
|
||
```php
|
||
# => 12345
|
||
for ($i = 1; $i <= 5; $i++) {
|
||
echo $i;
|
||
}
|
||
```
|
||
|
||
### break
|
||
|
||
```php
|
||
# => 123
|
||
for ($i = 1; $i <= 5; $i++) {
|
||
if ($i === 4) {
|
||
break;
|
||
}
|
||
echo $i;
|
||
}
|
||
```
|
||
|
||
### continue
|
||
|
||
```php
|
||
# => 1235
|
||
for ($i = 1; $i <= 5; $i++) {
|
||
if ($i === 4) {
|
||
continue;
|
||
}
|
||
echo $i;
|
||
}
|
||
```
|
||
|
||
### foreach
|
||
|
||
```php
|
||
$a = ['foo' => 1, 'bar' => 2];
|
||
# => 12
|
||
foreach ($a as $k) {
|
||
echo $k;
|
||
}
|
||
```
|
||
|
||
See: [Array iteration](#php-value-iteration)
|
||
|
||
## PHP Functions
|
||
|
||
### Returning values
|
||
|
||
```php
|
||
function square($x)
|
||
{
|
||
return $x * $x;
|
||
}
|
||
|
||
echo square(4); # => 16
|
||
```
|
||
|
||
### Return types
|
||
|
||
```php
|
||
// Basic return type declaration
|
||
function sum($a, $b): float {/*...*/}
|
||
function get_item(): string {/*...*/}
|
||
|
||
class C {}
|
||
// Returning an object
|
||
function getC(): C { return new C; }
|
||
```
|
||
|
||
### Nullable return types
|
||
|
||
```php
|
||
// Available in PHP 7.1
|
||
function nullOrString(int $v) : ?string
|
||
{
|
||
return $v % 2 ? "odd" : null;
|
||
}
|
||
echo nullOrString(3); # => odd
|
||
var_dump(nullOrString(4)); # => NULL
|
||
```
|
||
|
||
See: [Nullable types](https://www.php.net/manual/en/migration71.new-features.php)
|
||
|
||
### Void functions
|
||
|
||
```php
|
||
// Available in PHP 7.1
|
||
function voidFunction(): void
|
||
{
|
||
echo 'Hello';
|
||
return;
|
||
}
|
||
|
||
voidFunction(); # => Hello
|
||
```
|
||
|
||
### Variable functions
|
||
|
||
```php
|
||
function bar($arg = '')
|
||
{
|
||
echo "In bar(); arg: '$arg'.\n";
|
||
}
|
||
|
||
$func = 'bar';
|
||
$func('test'); # => In bar(); arg: test
|
||
```
|
||
|
||
### Anonymous functions
|
||
|
||
```php
|
||
$greet = function($name)
|
||
{
|
||
printf("Hello %s\r\n", $name);
|
||
};
|
||
|
||
$greet('World'); # => Hello World
|
||
$greet('PHP'); # => Hello PHP
|
||
```
|
||
|
||
### Recursive functions
|
||
|
||
```php
|
||
function recursion($x)
|
||
{
|
||
if ($x < 5) {
|
||
echo "$x";
|
||
recursion($x + 1);
|
||
}
|
||
}
|
||
recursion(1); # => 1234
|
||
```
|
||
|
||
### Default parameters
|
||
|
||
```php
|
||
function coffee($type = "cappuccino")
|
||
{
|
||
return "Making a cup of $type.\n";
|
||
}
|
||
# => Making a cup of cappuccino.
|
||
echo coffee();
|
||
# => Making a cup of .
|
||
echo coffee(null);
|
||
# => Making a cup of espresso.
|
||
echo coffee("espresso");
|
||
```
|
||
|
||
### Arrow Functions
|
||
|
||
```php
|
||
$y = 1;
|
||
|
||
$fn1 = fn($x) => $x + $y;
|
||
|
||
// equivalent to using $y by value:
|
||
$fn2 = function ($x) use ($y) {
|
||
return $x + $y;
|
||
};
|
||
echo $fn1(5); # => 6
|
||
echo $fn2(5); # => 6
|
||
```
|
||
|
||
## PHP Classes
|
||
|
||
### Constructor
|
||
|
||
```php
|
||
class Student {
|
||
public function __construct($name) {
|
||
$this->name = $name;
|
||
}
|
||
public function print() {
|
||
echo "Name: " . $this->name;
|
||
}
|
||
}
|
||
$alex = new Student("Alex");
|
||
$alex->print(); # => Name: Alex
|
||
```
|
||
|
||
### Inheritance
|
||
|
||
```php
|
||
class ExtendClass extends SimpleClass
|
||
{
|
||
// Redefine the parent method
|
||
function displayVar()
|
||
{
|
||
echo "Extending class\n";
|
||
parent::displayVar();
|
||
}
|
||
}
|
||
|
||
$extended = new ExtendClass();
|
||
$extended->displayVar();
|
||
```
|
||
|
||
### Classes variables {.row-span-2}
|
||
|
||
```php
|
||
class MyClass
|
||
{
|
||
const MY_CONST = 'value';
|
||
static $staticVar = 'static';
|
||
|
||
// Visibility
|
||
public static $var1 = 'pubs';
|
||
|
||
// Class only
|
||
private static $var2 = 'pris';
|
||
|
||
// The class and subclasses
|
||
protected static $var3 = 'pros';
|
||
|
||
// The class and subclasses
|
||
protected $var6 = 'pro';
|
||
|
||
// The class only
|
||
private $var7 = 'pri';
|
||
}
|
||
```
|
||
|
||
Access statically
|
||
|
||
```php
|
||
echo MyClass::MY_CONST; # => value
|
||
echo MyClass::$staticVar; # => static
|
||
```
|
||
|
||
### Magic Methods
|
||
|
||
```php
|
||
class MyClass
|
||
{
|
||
// Object is treated as a String
|
||
public function __toString()
|
||
{
|
||
return $property;
|
||
}
|
||
// opposite to __construct()
|
||
public function __destruct()
|
||
{
|
||
print "Destroying";
|
||
}
|
||
}
|
||
```
|
||
|
||
### Interface
|
||
|
||
```php
|
||
interface Foo
|
||
{
|
||
public function doSomething();
|
||
}
|
||
interface Bar
|
||
{
|
||
public function doSomethingElse();
|
||
}
|
||
class Cls implements Foo, Bar
|
||
{
|
||
public function doSomething() {}
|
||
public function doSomethingElse() {}
|
||
}
|
||
```
|
||
|
||
## PHP Trait
|
||
|
||
### Trait declaration & Use case {.col-span-3}
|
||
```php
|
||
// Declare Trait allows reuse of code
|
||
// across multiple classes for common characteristics or use cases
|
||
|
||
<?php
|
||
trait Logger {
|
||
public function log($message) {
|
||
$date = new DateTime();
|
||
echo "| ". $date->format('Y-m-d H:i:s') . " | " . $message;
|
||
}
|
||
}
|
||
|
||
// Use case :
|
||
// Call trait with "use <trait name> in Class"
|
||
|
||
class User {
|
||
use Logger;
|
||
|
||
public function createUser() {
|
||
// User creation logic
|
||
$this->log("User created.");
|
||
}
|
||
}
|
||
|
||
class Product {
|
||
use Logger;
|
||
|
||
public function createProduct() {
|
||
// Product creation logic
|
||
$this->log("Product created.");
|
||
}
|
||
}
|
||
|
||
$user = new User();
|
||
$user->createUser(); // Output ex: | 2025-06-18 14:06:09 | User created.
|
||
|
||
$product = new Product();
|
||
$product->createProduct(); // Output ex: | 2025-06-18 14:06:09 | Product created.
|
||
```
|
||
|
||
## PHP Enums (PHP 8.1)
|
||
|
||
### Enum Declaration & Use case {.col-span-3}
|
||
|
||
```php
|
||
<?php
|
||
// enum is a data type that allows you to define a set of named constants,
|
||
// representing a fixed group of related values
|
||
|
||
enum Status {
|
||
case Pending;
|
||
case Approved;
|
||
case Rejected;
|
||
}
|
||
|
||
// Use case
|
||
|
||
function getStatusMessage(Status $status): string {
|
||
return match($status) {
|
||
Status::Pending => "Waiting for approval.",
|
||
Status::Approved => "Your request has been approved.",
|
||
Status::Rejected => "Your request has been rejected.",
|
||
};
|
||
}
|
||
|
||
$currentStatus = Status::Approved;
|
||
echo getStatusMessage($currentStatus); // Output : Your request has been approved.
|
||
```
|
||
|
||
## PHP Date & Time Handling
|
||
|
||
### Current date and time
|
||
```php
|
||
// DateTime in PHP handles both date and time
|
||
|
||
<?php
|
||
$now = new DateTime();
|
||
echo $now->format('Y-m-d H:i:s.u');
|
||
|
||
// Output ex: 2024-04-27 14:35:22.123456
|
||
```
|
||
|
||
|
||
### Creating specific date/time objects
|
||
```php
|
||
<?php
|
||
// Create a date object
|
||
$d = new DateTime('2024-04-27');
|
||
echo $d->format('Y-m-d');
|
||
|
||
// Output : 2024-04-27
|
||
|
||
// Create a time object
|
||
$t = new DateTime('15:30:45');
|
||
echo $t->format('H:i:s');
|
||
|
||
// Output : 15:30:45
|
||
|
||
// Create a datetime object
|
||
$dt = new DateTime('2024-04-27 15:30:45');
|
||
echo $dt->format('Y-m-d H:i:s');
|
||
|
||
// Output : 2024-04-27 15:30:45
|
||
```
|
||
|
||
### Converting between date formats
|
||
```php
|
||
<?php
|
||
// Convert a string to a DateTime object
|
||
$date_str = "2024-04-27 14:00";
|
||
$dt_obj = new DateTime($date_str);
|
||
echo $dt_obj->format('Y-m-d H:i:s');
|
||
|
||
// Output : 2024-04-27 14:00:0027
|
||
|
||
// Convert a DateTime object to a string
|
||
$formatted_str = $dt_obj->format('d/m/Y H:i');
|
||
echo $formatted_str;
|
||
|
||
// Output : 27/04/2024 14:00
|
||
```
|
||
### Timestamps and Unix time {.col-span-2}
|
||
```php
|
||
<?php
|
||
// Get current timestamp
|
||
$timestamp = time();
|
||
echo $timestamp;
|
||
|
||
// Output ex: 1750253583
|
||
|
||
// Convert timestamp back to DateTime
|
||
$dt_from_timestamp = (new DateTime())->setTimestamp($timestamp);
|
||
echo $dt_from_timestamp->format('Y-m-d H:i:s');
|
||
|
||
// Output ex : 2025-06-18 13:33:03
|
||
```
|
||
|
||
|
||
### Date difference and timedelta {.col-span-1}
|
||
```php
|
||
<?php
|
||
$date1 = new DateTime('2024-04-27');
|
||
$date2 = new DateTime('2024-05-01');
|
||
|
||
$interval = $date1->diff($date2);
|
||
echo $interval->days;
|
||
|
||
// Output : 4
|
||
|
||
// Using DateInterval for date arithmetic
|
||
$new_date = clone $date1;
|
||
$new_date->add(new DateInterval('P10D'));
|
||
echo $new_date->format('Y-m-d');
|
||
|
||
// Output : 2024-05-07
|
||
```
|
||
|
||
## Miscellaneous
|
||
|
||
### Basic error handling
|
||
|
||
```php
|
||
try {
|
||
// Do something
|
||
} catch (Exception $e) {
|
||
// Handle exception
|
||
} finally {
|
||
echo "Always print!";
|
||
}
|
||
```
|
||
|
||
### Exception in PHP 8.0 {.col-span-2}
|
||
|
||
```php {.wrap}
|
||
$nullableValue = null;
|
||
|
||
try {
|
||
$value = $nullableValue ?? throw new InvalidArgumentException();
|
||
} catch (InvalidArgumentException) { // Variable is optional
|
||
// Handle my exception
|
||
echo "print me!";
|
||
}
|
||
```
|
||
|
||
### Custom exception {.row-span-2}
|
||
|
||
```php
|
||
class MyException extends Exception {
|
||
// do something
|
||
}
|
||
```
|
||
|
||
Usage
|
||
|
||
```php
|
||
try {
|
||
$condition = true;
|
||
if ($condition) {
|
||
throw new MyException('bala');
|
||
}
|
||
} catch (MyException $e) {
|
||
// Handle my exception
|
||
}
|
||
```
|
||
|
||
### Nullsafe Operator {.row-span-2}
|
||
|
||
```php
|
||
// As of PHP 8.0.0, this line:
|
||
$result = $repo?->getUser(5)?->name;
|
||
|
||
// Equivalent to the following code:
|
||
if (is_null($repo)) {
|
||
$result = null;
|
||
} else {
|
||
$user = $repository->getUser(5);
|
||
if (is_null($user)) {
|
||
$result = null;
|
||
} else {
|
||
$result = $user->name;
|
||
}
|
||
}
|
||
```
|
||
|
||
See also: [Nullsafe Operator](https://wiki.php.net/rfc/nullsafe_operator)
|
||
|
||
### Regular expressions
|
||
|
||
```php
|
||
$str = "Visit cheatsheets.zip";
|
||
echo preg_match("/ch/i", $str); # => 1
|
||
```
|
||
|
||
See: [Regex in PHP](/regex#regex-in-php)
|
||
|
||
### fopen() mode
|
||
|
||
| - | - |
|
||
| ---- | ------------------------ |
|
||
| `r` | Read |
|
||
| `r+` | Read and write, prepend |
|
||
| `w` | Write, truncate |
|
||
| `w+` | Read and write, truncate |
|
||
| `a` | Write, append |
|
||
| `a+` | Read and write, append |
|
||
|
||
### Super Global Variables {.col-span-2}
|
||
|
||
| Variable | Description |
|
||
|--------------|:-------------------------------------------------------------|
|
||
| `$_SERVER` | Holds information about headers, paths, and script locations |
|
||
| `$_GET` | Contains data sent via URL parameters (query string) |
|
||
| `$_POST` | Contains data sent via HTTP POST method |
|
||
| `$_FILES` | Contains information about uploaded files |
|
||
| `$_COOKIE` | Contains cookie data |
|
||
| `$_SESSION` | Stores session variables |
|
||
| `$_REQUEST` | Contains data from `$_GET`, `$_POST`, and `$_COOKIE` |
|
||
| `$_ENV` | Contains environment variables |
|
||
| `$GLOBALS` | References all global variables available in the script |
|
||
|
||
{.left-text}
|
||
|
||
Super Global Variables are built-in variables always available in all scopes.
|
||
|
||
|
||
### Runtime defined Constants
|
||
|
||
```php
|
||
define("CURRENT_DATE", date('Y-m-d'));
|
||
|
||
// One possible representation
|
||
echo CURRENT_DATE; # => 2021-01-05
|
||
|
||
# => CURRENT_DATE is: 2021-01-05
|
||
echo 'CURRENT_DATE is: ' . CURRENT_DATE;
|
||
```
|
||
|
||
## Also see
|
||
|
||
- [PHP Docs](https://www.php.net/manual/en/index.php)
|
||
- [Learn X in Y minutes](https://learnxinyminutes.com/docs/php/)
|