Files

1200 lines
20 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
---
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/)