Summary of PHP study notes for two thousand lines of code, two thousand lines of PHP study notes_PHP tutorial

A summary of PHP study notes for two thousand lines of code, two thousand lines of PHP study notes

This article summarizes various common problems in PHP learning, with more than two thousand lines of code, all of which are very practical skills. Share it with everyone for your reference. The details are as follows:

//Syntax error (syntax error) During the syntax analysis phase, the source code has not been executed, so there will be no output.

/* [Naming rules] */
It is recommended that constant names of class constants be in all uppercase letters, and words should be separated by underscores // MIN_WIDTH
It is recommended that variable names be separated by underscores // $var_name
It is recommended to use camel case naming method for function names // varName
It is recommended to use all uppercase letters for delimiters // k;
Variable attributes class CLS{public $k = 'hello';} $i = 'k'; $j = new CLS; echo $j->$i;
Variable method class CLS{public function k(){echo 'hello';}} $i='k'; $j=new CLS; $j->$i();

/* Variable variables */
* Used for business logic judgment to obtain certain specific information
  $var_name = "class_name";
  $$var_name = "PHP0913"; // $class_name = "PHP0913";$class_name has been stored in memory
  var_dump($class_name); // var_dump($$var_name);

/* variable function */
get_defined_vars //Returns an array composed of all defined variables (including environment variables, server variables and user-defined variables)


/* unset() */
* unset() only deletes the current variable name and reference, its value is not deleted
* In reference transfer, if a variable and its reference are deleted, other variables and references will exist, and the value will still exist.

   echo "<br>";
  $v3 = 'value';
  $v4 = &$v3;
  unset($v4);
  var_dump($v3, $v4);

/* The maximum validity period of the variable */
* The execution cycle of the current script. When the script execution ends, the variable disappears.


/* Predefined variables/super global variables */
$GLOBALS
$_COOKIE
$_ENV
$_FILES
$_GET
$_POST
$_REQUEST
$_SERVER
$_SESSION


/* Constant definition */
define(constant name, constant value, [case-sensitive parameter]) //true means insensitive/false means case-sensitive
const constant name = constant value // new, recommended
Constant names can use special characters
constant($name) // Get the constant name
          //Example: echo constant('-_-');


/* Constant related functions */
defined
get_defined_constants


/* Predefined constants */
__FILE__ Absolute path to the file
__LINE__ The current line number in the file
__DIR__ The directory where the file is located
__FUNCTION__ function name
__CLASS__ The name of the class
__METHOD__ method name of the class
__NAMESPACE__ The name of the current namespace


/* Integer type */
The integer occupies 4 bytes, with a total of 4*8=32 bits. The maximum value is 2147483647 and the minimum value is -2147483648. The absolute value of the minimum value is 1 greater than the maximum value.
The highest value represents positive and negative, 1 represents negative, 0 represents positive


/* Base conversion function */
Only decimal and other bases can be converted, and there are only six types.
When converting, the parameter should be a string (that is, it cannot contain octal "0" or hexadecimal "0x")
  dec
   bin
   oct
  hex
hexdec() converts hexadecimal to decimal. You can also write hex2dec()
dechex() converts decimal to hexadecimal. You can also write dec2hex()
bindec() converts binary to decimal. You can also write bin2dec()
decbin() converts decimal to binary. You can also write dex2bin()
octdec() converts octal to decimal. You can also write oct2dec()
decoct() converts decimal to octal. You can also write dec2oct()


/* Floating point number */
Floating point numbers cannot be compared! ! !
Almost all decimals, when saved, are approximate rather than exact!
Maximum value: +/- 1.8E308
The longest decimal place that PHP can save: 14 digits

/* single quoted string */
In single-quoted strings, only backslashes and single quotes can be escaped.

/* double quoted string */
Parse the string only once! ! !
eval executes a string as PHP code
Curly braces wrap variables to determine variable name boundaries.For example: "aaa{$bbb}ccc"
ASCII code can be converted into characters in double quotes
"x61" -> a // There is no need for 0 in the string, only 0x is leading in the integer type
"x49x54x43x41x53x54" -> ITCAST
Convert ASCII to character function chr()
Convert characters to ASCII function ord()
#Double quote escape list
n new line
r Enter
t horizontal tab character
\ backslash
$ dollar mark
v vertical tab
e Escape
f page change
"double quotes"
[0-7]{1,3} matches the regular expression sequence and is a character expressed in octal notation.
x[0-9A-Fa-f]{1,2} matches this regular expression sequence and is a character expressed in hexadecimal form



/* delimiter */
herodoc - functions the same as double quotes and can be parsed
$str = " . $x++;
    $fun and $fun();
  };
}

$x = "hello world";
$test = closureCreater();
$test();
$test(function(){ echo "closure test one"; });
$test(function(){ echo "closure test two"; });
$test(function() use($x){ echo "<br>".$x;});

//Save the function as an array element
$x = 'outer param.';
$arr = array();
$arr[] = function($str)use($x){ return $str.$x; };
echo $arr[0]('test fun in arr,');


/* [Array] */
Associative array: keys and values ​​are related, and the keys represent the logical meaning of the values.
Index array: The key and value are not related, and the key represents the position of the value. Usually subscripts start from 0 and are incremented by elements
count($var [,$mode]) //Count the number of array elements
  $mode is optional. When set to 1 or true, recursive statistics will be performed.
  $var is not an array, returns 1; $var is not initialized or equal to null or an empty array, returns 0

//Use of key names
Integer numeric keys do not need to be quoted ($arr[1])
String numeric keys do not need to be quoted ($arr = array('1'=>'abc'); $arr[1])
Associative array, string keys need to be quoted ($arr = array('a'=>'aaa'); $arr['a'])
Associative array, parse variables in double quotes, no quotes required ($arr = array('a'=>'aaa'); "$arr[a]")

/* [Pointer] */
current/pos returns the value of the array element currently pointed to by the internal pointer without moving the pointer.
key returns the key name of the current cell in the array without moving the pointer
next moves the internal pointer in the array forward one position and returns the value of the current cell after the move. Move first, then get value.
prev rewinds the internal pointer of the array by one bit and returns the value of the current unit after the move. First move it and then take the value.
end points the internal pointer of the array to the last element and returns the value of the last element
reset points the internal pointer of the array to the first element and returns the value of the first array element

each returns the current key/value pair in the array and moves the array pointer forward one step.
      What is returned is an array of length 4 consisting of keys and values. The subscript 0 and key represent the key, and the subscript 1 and value represent the value.
        After executing each(), the array pointer will stay at the next cell in the array
          Or stay at the last cell when the end of the array is reached.
          If you want to use each to iterate through the array again, you must use reset().

  1. The above pointer operation functions, except key(), return false if the pointer is moved out of the array. When key() is moved out, it returns null.
  2. If the pointer is illegal, next/prev operations cannot be performed, but reset/end operations can be performed.
  3. current/next/prev will also return false if it encounters an empty unit (0 or ""). But each will not!

list assigns the values ​​in the array to some variables. list() is a language structure, not a function
      Can only be used with numerically indexed arrays and assumes numerical indexing starts at 0
      /* Can be used to exchange the values ​​​​of multiple variables */ list($a, $b) = array($b, $a);
  Example: list($drink, , $power) = array('coffee', 'brown', 'caffeine');

1. When the array is copied, its pointer position will also be copied.
  Special case: If the array pointer is illegal, the copied array pointer will be reset, but the original array pointer will remain unchanged.[Pointer problem]
    Whoever writes first will open up a new value space. It has nothing to do with who the variable (array variable) value is passed to.
    The array function current() is defined as a write operation, so problems will occur.
    What foreach traverses is a copy of the array, and when it is written, a new value space will be opened.
      That is, the pointer problem only occurs when the foreach loop body writes to the original array.
      If the pointer is illegal when opening new space, the pointer will be initialized.
2. If there is a problem with the pointer position, initializing it with reset() can solve the problem.


/* [Traverse the array] */
* Find the element first, then get the key and value

foreach
  foreach (array_expression as [$key =>] & $value)
   When foreach starts executing, the pointer inside the array will automatically point to the first element.
   After obtaining the element information, move the pointer and then execute the loop body
   1. The loop structure of foreach itself, break and continue are suitable for foreach
   2. foreach supports alternative syntax for loops.
   3. $value is a variable that stores the element value. Modifying it will not change the element value of the array.
   4. $value supports reference copy of element value, just add & before $value
   5. $key does not support passing by reference
   6. What foreach traverses is a copy of the original array, and the operation on the array in the loop body is to operate on the original array.
      That is, the operation of the loop body on the array takes effect on the original array, but does not take effect on the traversal.
      First copy an array for traversal

while...list...each
while (list($key, $val) = mysql_fetch_row($result)) = each($arr) {
 echo "$key => $valn";
}



/* [Array function] */
//statistical calculation
count Counts the number of cells in an array or the number of attributes in an object
array_count_values ​​counts the number of occurrences of all values ​​in the array
array_product calculates the product of all values ​​in an array
array_sum calculates the sum of all values ​​in an array
range creates an array containing cells in the specified range

//Get the contents of the array
array_chunk splits an array into multiple
  array array_chunk(array $input, int $size[, bool $preserve_keys])
array_filter uses callback function to filter cells in array
array_slice takes a segment from an array
  array array_slice($arr, $offset [,$len [,$preserve_keys]])
array_keys returns all key names in the array
  array array_keys(array $input[, mixed $search_value[, bool $strict]] )
  If the optional parameter search_value is specified, only the key name of the value is returned. Otherwise, all keys in the input array will be returned.
array_values ​​returns all values ​​in the array, numerically indexed

array_merge merges one or more arrays
  The values ​​in one array are appended to the previous array.
  If the input array has the same string key name, the value after the key name will overwrite the previous value.
  If the array contains numeric key names, subsequent values ​​will not overwrite the original values, but will be appended to them.
  If only an array is given and the array is numerically indexed, the key names are re-indexed consecutively. 
array_merge_recursive merges one or more arrays recursively

//search
in_array checks whether a value exists in an array
  bool in_array(mixed $needle, array $haystack[, bool $strict])
array_key_exists checks whether the given key name or index exists in the array
  isset() will not return TRUE for NULL values ​​in the array, but array_key_exists() will
array_search searches the array for a given value and returns the corresponding key if successful

array_combine creates an array, using the values ​​of one array as its keys and the values ​​of another array as its values.
  Returns FALSE if the number of elements in the two arrays is different or if the arrays are empty.
array_rand randomly takes one or more units from the array and returns the key name or an array composed of key names. The subscripts are naturally sorted.
array_fill fills an array with the given values
  array_fill($start, $num, $value)
array_flip swaps keys and values ​​in an array
array_pad pads an array to the specified length with values
array_reverse returns an array with the cells in reverse order
array_unique removes duplicate values ​​from an array
array_splice removes part of an array and replaces it with other values

implode concatenates the array element values ​​into a string using a certain string
explode($delimiter, $str [,$limit]) //Use one string to split another string
  $delimiter cannot be the empty string ""

array_map applies the callback function to the unit of the given array. It can only process element values ​​and can process multiple arrays.
  If the callback parameter is set to null, multiple arrays are merged into a multi-dimensional array.
array_walk applies user functions to each member in the array. It can only process one array. Both keys and values ​​can be processed. It has the same function as foreach.
  bool array_walk ( array &$array , callback $funcname [, mixed $userdata ] )

//Stack: last in first out
Pushing and popping the stack will reallocate the index subscript
array_push pushes one or more elements to the end of the array (push)
array_pop pops the last unit of the array (pops the stack). After using this function, the array pointer will be reset (reset()).

//queue: first in first out
Queue functions reassign index subscripts
array_unshift inserts one or more cells at the beginning of the array
array_shift moves the element at the beginning of the array out of the array. Using this function will reset (reset()) the array pointer.//sort function
sort Sort an array
rsort sorts an array in reverse order
asort sorts an array and maintains index relationships
arsort sorts an array in reverse order and maintains index relationships
ksort sorts an array by key
krsort sorts the array in reverse order by key name
usort sorts the values ​​in an array using a user-defined comparison function
uksort sorts the keys in an array using a user-defined comparison function
uasort uses a user-defined comparison function to sort values ​​in an array and maintain index association
natsort sorts an array using the "natural sorting" algorithm
natcasesort uses the "natural sort" algorithm to sort an array in a case-insensitive manner
array_multisort Sort multiple arrays or multidimensional arrays
shuffle shuffle the array
  Pass parameters by reference and return a bool value.
  Reassign the index key name and delete the original key name

//Difference set
array_udiff_assoc calculates the difference set of arrays with index checking, and uses callback functions to compare data
array_udiff_uassoc calculates the difference set of the array with index checking, and uses the callback function to compare the data and index
array_udiff uses callback functions to compare data to calculate the difference of arrays
array_diff_assoc calculates the difference of an array with index checking
array_diff_key uses key name comparison to calculate the difference of an array
array_diff_uassoc computes the difference of an array using a user-supplied callback function that performs index checking
array_diff_ukey uses the callback function to compare key names and calculate the difference set of the array
array_diff calculates the difference of an array
//Intersection
array_intersect_assoc calculates the intersection of arrays with index checking
array_intersect_key calculates the intersection of arrays using key name comparison
array_intersect_uassoc calculates the intersection of arrays with index checking, and uses the callback function to compare the indexes
array_intersect_ukey uses callback functions to compare key names to calculate the intersection of arrays
array_intersect calculates the intersection of arrays
array_key_exists uses a callback function to compare key names to calculate the intersection of arrays
array_uintersect_assoc calculates the intersection of arrays with index checking and compares data with callback functions
array_uintersect calculates the intersection of arrays and uses callback functions to compare data

extract($arr [,$type [,$prefix]]) imports variables from the array into the current symbol table (accepts the combined array $arr as a parameter and uses the key name as the variable name and the value as the variable value)
compact($var [,...]) creates an array including variable names and their values ​​(the variable names become the keys and the contents of the variables become the values ​​of the keys)




/* [pseudotype] */
mixed indicates that a parameter can accept multiple (but not necessarily all) different types.
number indicates that a parameter can be integer or float.
callback callback function
void void as a return type means that the return value of the function is useless.
      void as parameter list means the function does not accept any parameters.


/* [Database operation] */
#Connection authentication
mysql_connect connects and authenticates the database
#Send SQL statements and receive execution results
mysql_query sends SQL statements
    Only a resource identifier is returned if the select, show, explain, and describe statements are successfully executed, and true is returned if other statements are successfully executed. Returns false if execution fails.
#Processing results
mysql_fetch_assoc fetches a row from the result set as an associative array
    Only one item is retrieved at a time, similar to each
  Result set record pointer
mysql_fetch_row fetches a row from the result set as an enumerated array
mysql_fetch_array fetches a row from the result set as an associative array, a numeric array, or both
  array mysql_fetch_array ( resource $result [, int $ result_type ] )
  Optional parameter result_type optional values ​​are: MYSQL_ASSOC, MYSQL_NUM and MYSQL_BOTH (default)
mysql_free_result releases result memory
#Close link
mysql_close closes the connection


/* [Classes and Objects] */
# Members:
  Class members: class constants, static properties, static methods
  Object members: non-static properties, non-static methods
  # Classes cannot contain anything else! ! !

# Class names, method names, and attribute names are not case-sensitive
# $this represents this object, self represents this class, parent represents the parent class
# Both classes and functions can be compiled in advance (only when used as the outermost layer)
# The definition of a class must be within a single PHP block and cannot be split by multiple PHP tags

//Constructor
- A class with a constructor will first call this method every time a new object is created
void __construct([ mixed $args [, $... ]] )
- When the parameters required by the constructor are instantiated by new, add parameter values ​​to the class.
- Constructors can also be called manually.
- Before version 5.3.3, methods with the same name as the class name were supported as constructors.
- When there is a conflict between the two, __construct takes precedence.

// Destruction method
- A destructor is executed when all references to an object are removed or when the object is explicitly destroyed.
void __destruct(void)
# Function: Release the resources occupied by the object
# Timing of calling
  - All resources are released at the end of the script, including objects
  - When deleting objects manually
  - When the variable holding the object is assigned a new value (any value, including null)
  - Also called when exit() is used to terminate the script.

// Static members (static keyword)
  - Declaring class members or methods as static allows direct access without instantiating the class.
  - Static members (properties or methods) belong to classes, so they cannot be accessed through $this or ->.- Static members are shared by all objects and belong to the class.
  - Static members are called with classes, and non-static members are called with objects.
# Static properties
  - Static properties cannot be accessed by objects through the -> operator.
  - Static properties can only be initialized to a character value or a constant, and expressions cannot be used. So you can initialize a static property to an integer or an array, but it cannot point to another variable or function return value, nor to an object.
# static method
  - Since static methods do not require an object to be called, the pseudo variable $this is not available in static methods.
  - Calling a non-static method using the :: method will result in an E_STRICT level error.

// Access parsing operator (::)
  - Can be used to access static members, methods and constants, and can also be used to override members and methods in a class. 
  - When accessing these static members, methods and constants from outside the class, the class name must be used. 
  - The two special keywords self and parent are used to access members or methods inside a class.

//Access analysis
- Object members are specified internally through $this and externally through the object name. Both are accessed with ->. No need to add $ when accessing properties.
  Object name->Property name Object name->Method name() $this->Property name $this->Method name()
- Class members are specified internally through self or parent and externally through the class name. They are all accessed using ::, and $ is required when accessing attributes.
  Class name::$Attribute name Class name::Method name() self::$Attribute name self::Method name()
- Special: Class members can also be accessed through objects. (not recommended)
  Object name::$class attribute name $this::$class attribute name Object name::$class method name() $this::class method name()
# To access object members, use ->, to access class members, use::

- Methods, whether static or non-static, can be accessed through a class or object.
- Static properties are accessed through classes and static methods are accessed through objects.
- $this can only be used when using an object to call non-static methods!
- Static methods cannot use $this.
- Classes can call object methods, but note that there cannot be $this inside the method.
- Non-static methods can call static properties or static methods, but not vice versa.

// class constant
- The value of a constant will always remain the same.
- There is no need to use the $ symbol when defining and using constants.
- The value of a constant must be a fixed value and cannot be the result of a variable, class attribute, or other operation (such as a function call).
# Definition: const constant name = constant value;
- No need to add access modification qualifiers such as public
- Class constants belong to the class and are accessed using class name::class constant or self::class constant

// Automatically load objects
- Automatically call the __autoload function when trying to use a class that has not been defined yet
- Automatically load the used class name file (find the file with the corresponding name based on the class name, so the class name must be consistent with the class file name)
- Every file that needs to load a class needs to have the __autoload function
- Write the __autoload function into a separate file, and then require the function file for each file that needs to use the class.
- The __autoload parameter is the class name
function __autoload($class_name) {
  require_once $_SERVER["DOCUMENT_ROOT"] . "/class/$class_name.php";
}
  // $_SERVER["DOCUMENT_ROOT"] The document root directory where the currently running script is located
- You can use the class name to deduce the file name where the class is located!
- If there are multiple autoloading functions in a project, define a common function that can complete the loading, and use spl_autoload_register to register the function before the function.
# spl_autoload_register
- Register __autoload() function
bool spl_autoload_register ([ callback $autoload_function ] )
- You can register multiple automatic loading functions, and the one registered first will be executed first.
- Once the autoload function is registered, __autoload becomes invalid.
- When registering a function, the parameter is the function name (note the quotation marks); when registering a method, the parameter is an array
# When the method of registering a class or object is an automatic loading method, the parameter must be an array:
spl_autoload_register(array(__CLASS__, '__autoload'));
__CLASS__ represents the current class name. If $this is available for the object, see the manual for details.

// Serialization (serialization)
# Data transmission is all string type
# Except resource types, all can be serialized
# When serialization stores data, it will store the data itself and the data type.
Function: 1. When transmitting data over the network; 2. When placing arrays or objects on disk
# serialization
serialize produces a storable representation of a value
string serialize (mixed $value)
- Returns a string, which contains a byte stream representing value and can be stored anywhere.
- Facilitates storing or passing values ​​in PHP without losing their type and structure.
# Deserialize
unserialize creates PHP values ​​from stored representations
mixed unserialize ( string $str [, string $callback ] )
- Operate on a single serialized variable, converting it back to a PHP value.


# File read and write operations
- file_put_contents writes a string to a file
int file_put_contents($file, $data [,$flags])
  $flags: FILE_USE_INCLUDE_PATH (overwrite), FILE_APPEND (append)
- file_get_contents reads the entire file into a string
string file_get_contents($file [, bool $use_include_path [,int $offset [,int $maxlen]]])

#Object serialization
- Only data inside the object, i.e. non-static properties, can be serialized.# The class needs to be loaded before deserializing the object, and the automatic loading mechanism can also be triggered.

__sleep serializes the properties to be serialized.
    - Commit uncommitted data, or similar cleanup operations, to partially serialize objects.
    - Returns an array containing the names of all variables in the object that should be serialized
__wakeup When deserializing, prepare the resources required by the object in advance
    - Re-establish the database connection, or perform other initialization operations
  public function __sleep() {
    return array('server', 'username', 'password', 'db');
  }
  public function __wakeup() {
    $this->connect();
  }

//Object inheritance
class subclass name extends parent class {}
If an object is an object of a subclass, it is also an object of the parent class.
Single inheritance: A class can only inherit one parent class, and cannot inherit multiple classes at the same time. But a parent class can be inherited by multiple subclasses.

instanceof determines whether an object is an object of a certain type
  Object name instanceof class name

// access control
public public (accessible to the inheritance chain, this class, and the outside)
protected protected (only inheritance chain, this class can access)
private private (accessible only to this class)
Judgment based on member definition location and access location.
# Compatibility issues
- When declaring attributes, the var keyword declares public permissions by default
- When declaring a method, omit the access modifier and default to public permissions

// override
$this represents this object, and whoever calls it represents that object.
- During inheritance, if the subclass member name conflicts with the parent class member name, the subclass member will overwrite the parent class member.
- Both properties and methods can be overridden by subclasses.
- When the methods or attributes of the parent class no longer meet the needs of the subclass, they need to be rewritten.
- It may also be rewritten due to irregular naming.

Private properties cannot be overridden, and each private property is logged. While recording the attribute name, the class will also be recorded.

If a built-in function is overridden, the parent class method can be called. For example, calling the parent class constructor parent::__construct()

# Rewrite restrictions
Access restrictions:
  Access control for members of a subclass must be equal to or weaker than that of the parent class.
Method parameter restrictions:
  The number of parameters must be the same, but the parameter names can be different.

# $this determines the principle
$this is the object that calls the method and represents the execution environment object of the method.
  - Object call
  -Transmission of environment. If the value of $this cannot be determined during the current call (static call), the object environment of the static call will be passed to the called method.
$this does not always represent this object, but is determined by the execution environment of the method.

# final
If a method in the parent class is declared final, the child class cannot override (override) the method.
If a class is declared final, it cannot be inherited.
But classes with the final keyword can still be instantiated!
#Abstract class
Keywords: abstract
Abstract classes cannot be instantiated directly. You must first inherit the abstract class and then instantiate the subclass.
An abstract class must contain at least one abstract method. Non-abstract classes cannot contain abstract methods.
If a class method is declared abstract, it cannot contain concrete functional implementations. Abstract methods cannot contain braces and method bodies.
When inheriting an abstract class, the subclass must implement all abstract methods in the abstract class.
  That is, the subclass must override all abstract methods in the abstract parent class.
In addition, the visibility of these methods must be the same (or more relaxed) as in the abstract class.
  That is, if an abstract method in an abstract class is declared protected, then the method implemented in the subclass should be declared protected or public, and cannot be defined as private.
- Ordinary methods in subclasses of abstract classes are executed in the same way as other classes.
- Function:
  1. Inheritance is an extended class that unifies public operations.
  2. Limiting structure (normative). Standardizes the structure of subclasses.

//Interface
Keywords: interface
- The way an object provides to interact with an object is the interface.
- You can use interfaces to specify which methods a class must implement, but you do not need to define the specific content of these methods.
- Defining an interface through interface is just like defining a standard class, but all methods defined in it are empty. 
- All properties and methods defined in the interface must be public, and the public keyword can be omitted.
- Constants (const) can also be defined in interfaces. Interface constants and class constants are used exactly the same.
  Can be accessed using ::. Interface name::constant name, implementation class::constant name.
  They are all fixed values ​​and can be used by subclasses or subinterfaces, but cannot be modified.
- The interface cannot define properties!
# Define interface
interface interface name {
  Interface content (collection of public method declarations)
}
#Interface implementation
- To implement an interface, you can use the implements operator.
- The class must implement all methods defined in the interface, otherwise a fatal error will be reported.
- If you want to implement multiple interfaces, you can use commas to separate the names of multiple interfaces.
- When implementing multiple interfaces, methods in the interfaces cannot have the same name.
- Interfaces can also be inherited, by using the extends operator.
class class name implements interface name {
  Implementation of interface methods
}
# Notice
  1. There is an inheritance relationship between classes and abstract classes, and there is an implementation relationship between classes and interfaces.
  2. Classes and abstract classes have single inheritance, while classes and interfaces have multiple implementations.
  3. Interfaces are not classes and limit the structure of classes.
  4. There is multiple inheritance between interfaces.Use the extends keyword.
    interface I_C extends I_A, I_B {}

// static delayed binding
self::, represents this class (the class where the current code is located)
  Always represents this class because it is determined when the class is compiled.
  That is, when a subclass calls a parent class method, self does not represent the calling subclass.
static::, represents this class (the class that calls this method)
  Used to reference a statically called class within an inheritance scope.
  The represented class is determined only at runtime.
  static:: is no longer resolved to the class in which the current method is defined, but is calculated at actual runtime.

// Object traversal (iteration)
- Objects save data through attributes, so the attributes of the object are traversed.
- foreach language structure, obtain attribute name and attribute value.
  foreach ($obj as $p_name => $p_value) {}
# Custom traversal (Iterator)
Iterator - an interface for an external iterator or class that can iterate internally over its own
Iterator::current — Returns the current element
Iterator::key — Returns the key of the current element
Iterator::next — move forward to the next element
Iterator::rewind — Return to the first element of an iterator
Iterator::valid — Check if the current position is valid

#Clone of object
//The value transfer between objects is [reference] transfer.
Clone: ​​new object = clone old object
  - All reference properties will still be a reference to the original variable. 
The __clone() method is automatically called when the object is cloned.
Note: The construction method corresponds to instantiation (new), and the cloning method corresponds to clone (clone).

// singleton mode
#三privateonepublic
Singleton pattern is used to generate a unique object for a class. The most commonly used place is database connection. After using the singleton pattern to generate an object, the object can be used by many other objects.
# Prevent a class from being instantiated multiple times
class MySQLDB {
  private static $instance = null; // Store the class instance in this property
  // The constructor is declared as private to prevent direct creation of objects
  private function __construct() {}
  public static function getInstance() {
    if(! self::$instance instanceof static) {
      self::$instance = new static;
    }
    return self::$instance;
  }
  private function __clone() {} // Prevent users from copying object instances
}

// magic method
__construct constructor
__destruct destructor method
__clone clone object
__sleep serialized object
__wakeup deserializes objects
__autoload automatically loads when the class is used but not found

__toString object is used as a string
__invoke when trying to invoke an object as a function

# Overload overload
Refers to dynamically "creating" class properties and methods
Users are free to add additional properties to objects. This feature is overloading.
All overloaded methods must be declared public.
Overloaded methods are called when a class property or method is called that is undefined or invisible in the current environment.
Parameters of overloaded magic methods cannot be passed by reference.
# Attribute overloading
- Handle inaccessible properties
Property overloading can only be done in objects.
#Property overloading is not valid for static properties
In static methods, these magic methods will not be called. So these methods cannot be declared static.
__set when assigning values ​​to inaccessible properties
  public void __set(string $name, mixed $value)
  Function: Batch management of private attributes, indirect protection of object structure
__get when reading the value of an inaccessible property
  public mixed __get(string $name)
__isset when isset() or empty() is called on an inaccessible property
  public bool __isset(string $name)
__unset when unset() is called on an inaccessible property
  public void __unset(string $name)
# Method overloading
- Handle inaccessible methods
__call is automatically called when calling an inaccessible non-static method (such as undefined, or invisible)
    public mixed __call(string $name, array $arguments)
__callStatic is automatically called when calling an inaccessible static method (such as undefined, or invisible)
    public static mixed __callStatic(string $name, array $arguments)
# The $name parameter is the name of the method to be called. The $arguments parameter is an array containing the parameters to be passed to the method.

//Type constraints
Function parameters can be specified as objects or arrays only
If it is limited to an object, add the class name before the formal parameter; if it is limited to an array, add array before the formal parameter.
Type constraints allow NULL values
Type constraints are not only used in class member methods, but can also be used in functions. 

//Three major features
Encapsulation: Hiding the internals is absorption, and only develops interfaces.
Inheritance: Members of one object are used by another object. Syntax is reflected in the sharing of codes.
Polymorphism: multiple forms.// Classes and Objects·Keywords
this represents this object
public public (accessible to the inheritance chain, this class, and the outside)
protected protected (only inheritance chain, this class can access)
private private (accessible only to this class)
parent:: represents the parent class
self:: represents this class (the class where the current code is located)
static:: represents this class (the class that calls this method)
static static members (properties, methods), can be used by all objects, and can also be directly used or modified externally. Static methods cannot access non-static members.
Final methods cannot be overloaded by subclasses, and classes cannot be inherited (methods, classes)
const class constant (property)
abstract abstract class
interface interface
extends class inheritance (sub-interface inheritance interface, other ordinary class inheritance)
implements interface implementation (class implementation interface, abstract class implementation excuse) (there can be multiple implementations and inheritances of the interface)
Iterator built-in interface (iteration)
clone clone
instance instance
instanceof whether an object belongs to a certain class

/* [Class and object related functions] */
class_alias([$original [,$alias]]) gives the class an alias
class_exists($class [,$autoload]) checks whether the class is defined
interface_exists($interface [,$autoload]) checks whether the interface has been defined
method_exists($obj, $method) checks whether the method of the class exists
property_exists($class, $property) checks whether the object or class has the property
get_declared_classes(void) returns an array consisting of the names of defined classes
get_declared_interfaces(void) returns an array containing all declared interfaces
get_class([$obj]) returns the class name of the object
get_parent_class([$obj]) returns the parent class name of the object or class
get_class_methods($class) returns an array consisting of class method names
get_object_vars($obj) returns an associative array consisting of object properties
get_class_vars($class) returns an array consisting of the default attributes of the class
is_a($obj, $class) Returns TRUE if the object belongs to this class or this class is the parent class of this object
is_subclass_of($obj, $class) Returns TRUE if this object is a subclass of this class
get_object_vars($obj) returns an associative array consisting of object properties


//Common classes
# PHP Manual -> Predefined classes
Closure closure class, the final class of anonymous function objects
stdClass standard class, usually used for object classes to save collection data
__PHP_Incomplete_Class is an incomplete class. When there is only an object but no class is found, the object is considered to be an object of the class.
Exception exception class
PDO data object class

//magic constant
__DIR__ The directory where the file is located
__LINE__ The current line number in the file
__FILE__ The full path (absolute path) and file name of the file

__CLASS__ The name of the class
__METHOD__ The method name of the class, including the class name and method name
__FUNCTION__ function name, used within a method to only represent the method name

// Reflection mechanism Reflection
Function: 1. Obtain structure information 2. Agent execution
ReflectionClass reports information about a class
ReflectionMethod reports information about a method
ReflectionClass::export output class structure report
# Agent execution
Instantiate an object of the ReflectionFunction class
  $f = new ReflectionFunction('func'); // func is function func($p)
  $f->invoke('param');


/* Page jump */
// PHP
header('Location: url')
After header() is executed, the following code will continue to execute, so it is necessary to add die after the statement to end.
Unable to give prompt, jump directly
//JS method
location.href = url
// HTML
<meta http-equiv="Refresh" content="Value representing time; url=URI to be redirected">

/* [Cookie] */
A cookie is a mechanism that stores data on a remote browser to track and identify users.
Cookies are part of the HTTP header, so the setcookie() function must be called before other information is output to the browser, similar to the restrictions on the header() function. You can use the output buffer function to delay the output of the script until all cookies or other HTTP headers have been set as required.

//Add
setcookie adds a cookie information
setcookie($name [,$value [,$expire [,$path [,$domain [,$secure [,$httponly]]]]]])
#Note: There cannot be output before the setcookie() function! Unless ob cache is turned on!
# Parameter description
$name - the identifying name of the cookie
  Use $_COOKIE['name'] to counteract the cookie named name
$value - cookie value, which can be a numeric value or a string. This value is stored on the client side and should not be used to store sensitive data.
  Assuming that the value of the $name parameter is 'name', $_COOKIE['name'] can obtain the $value
$expire - cookie lifetime (Unix timestamp, seconds)
  If the value of the $expire parameter is time()+60*60*24*7, you can set the cookie to expire after one week. If this parameter is not set, it will expire immediately after the session.
$path - The specified path of the cookie on the server side. When this value is set, only web pages or programs under the specified path in the server can access the cookie.
  If the parameter value is '/', the cookie is valid within the entire domain.
  If set to '/foo/', the cookie will be valid in the /foo/ directory and its subdirectories under the domain.
  The default value is the current directory and its subdirectories where the cookie is set.
$domain - Specifies the URL name of the server where this cookie belongs. The default is the URL of the server that created this cookie.
  If the cookie is to be valid in all subdomains of a domain name such as abc.com, the entry should be set to '.abc.com'.$secure - The security identification constant of the cookie that indicates whether the cookie is only transmitted through a secure HTTPS connection. If this value is set, it means that it can only be transmitted between the client and the server under certain circumstances.
  When set to true, the cookie is only set on secure connections. The default value is false.

// read
- When the browser makes a request, it will carry all cookie information under the current domain name to the server.
- Any cookie sent from the client will be automatically stored in the $_COOKIE global array.
- If you want to set multiple values ​​for a cookie variable, you need to add the [] symbol after the cookie name. That is, multiple pieces of data are saved to the same variable in the form of an array.
  //Set to $_COOKIE['user']['name']. Note that the name of user[name] does not have quotation marks.
  setcookie('user[name]', 'shocker');
- $_COOKIE can also be an index array

// delete
Method 1: Set its value to an empty string
  setcookie('user[name]', '');
Method 2: Set the target cookie to "expired" status.
  //Set the cookie's lifetime to expire. The lifetime is the same as the browser and will be deleted when the browser is closed.
  setcookie('usr[name]', '', time()-1);

# Notice:
1. Cookies can only store string data
2. $_COOKIE is only used to receive cookie data, not to set or manage cookie data.
  Operating on $_COOKIE will not affect cookie data.
  $_COOKIE will only save the cookie data carried by the browser during the request.
3. Cookie life cycle:
  Temporary cookies: deleted when the browser is closed
  Persistent cookies: The $expire parameter is a timestamp, indicating the expiration time.
4. Valid directory
  Cookies are only valid in specified directories. The default is the current directory and its subdirectories.
  Cookies for subdirectories are not available in its parent directory or sibling directories.
5. Cookie distinguishes domain names
  By default, the current domain name and its subdomain names are valid.
6. Obtained through document.cookie in js, the type is string
7. Browsers have no limit on the total number of COOKIEs, but the number of COOKIEs per domain name and the size of each COOKIE are limited, and different browsers have different restrictions.

/* 【session】 */
1. Open the session mechanism
  session_start()
  Note: There must be no output before the session_start() function! Unless ob cache is turned on.
2. Operation data
  Operate on $_SESSION array
3. The browser saves the SessionID, which takes effect for all directories and subdirectories under the current domain name by default. That is, the default path value of the cookie is set to '/'
4. The server saves session data
  Default saving method: Each session will generate a session data file, the file name is: sess_plus SessionID
5. Session can store any type of data except resources.
  The data is serialized and then saved to a file.
6. The element subscript of $_SESSION cannot be an integer!
  Because only element values ​​are serialized.
  Array subscripts within elements do not have this requirement.
7. Life cycle
  The browser is closed by default
    Because the cookie variable SessionID saved by the browser is temporary
    However, the session data file on the server side does not necessarily disappear (you need to wait for the session's garbage collection mechanism to process it)
  The life cycle of the PHPSESSID variable in the cookie can be extended. (not recommended)
  php.ini configuration session.gc_maxlifetime
8. Delete data
  The $_SESSION variable will still disappear when the script ends. When the session mechanism is turned on, the $_SESSION variable will be created.
  $_SESSION and the file that saves session data are two spaces.
  unset($_SESSION['key']) only deletes the element in the array, and will not immediately respond to the file that saves the session data.
    Wait until the script ends before the $_SESSION data is written to the file.
  session_destroy() destroys the file that saves session data and does not write content to the file.
    The $_SESSION variable is not deleted and will not be deleted until unset or the script ends.
  How to completely delete a session? 3 parts need to be deleted
    unset($_SESSION);
      After deleting the $_SESSION variable, the data file has not been changed. If you use unset alone, you need to empty $_SESSION = array() first
    session_destroy();
    setcookie('PHPSESSID', '', time()-1); //The insurance policy is to invalidate its life cycle
  During the entire script cycle, the data file is only read once and written once.

// Rewrite the session storage mechanism
#session storage method
session.save_handler = user|files|memcache
# Problems caused by too many data files can be solved by saving them in the molecular directory
session.save_path option in the PHP configuration file, and the data storage directory needs to be created manually.
Prepend the level before this configuration option. The principle of distributing subdirectories uses the corresponding letters of the session ID to allocate subdirectories. Subdirectories still need to be created manually.
session.save_path = "2; F:/PHPJob/Temp"
#Multi-server data sharing issues
#Data storage operations:
  Initialize $open, release resources $close, read $read, write $write, destroy storage media $destroy (this operation is triggered when session_destroy is called), and garbage collection $gc
# The length of the session ID is variable. Different setting methods result in session IDs of different lengths.
session.hash_function allows the user to specify the hashing algorithm used to generate session IDs.
  '0' means MD5 (128 bits), '1' means SHA-1 (160 bits).
session.hash_bits_per_character allows the user to define how many bits are stored per character when converting binary hash data into a readable format.
  Possible values ​​are '4' (0-9, a-f), '5' (0-9, a-v), and '6' (0-9, a-z, A-Z, "-", ",").The total hash length is 128 bits, and the session ID length is 128/possible values, 4->32, 5->26, 6->22
# Custom data storage operation method
# Note: Don’t worry about how PHP serializes, deserializes, gets data and writes data, only do operations related to data storage.
session_set_save_handler sets user-defined session data storage function
  bool session_set_save_handler(callable $open, callable $close, callable $read, callable $write, callable $destroy, callable $gc)
Execution order: open, close, read, write, destroy, gc
# Set the processor first, then open the session

# Commonly used functions
session_start starts or resumes the session mechanism
session_id gets or sets the current session ID
session_destroy destroys all data of the current session (destroy data files)
session_name gets or sets the current session name (cookie variable name, default is PHPSESSID)
session_save_path gets or sets the current session data file save path
session_set_save_handler sets user-defined session data storage function
session_unset releases all session variables (clears $_SESSION array elements)
session_encode encodes the current session data into a string
session_decode interprets strings into session data
session_write_close writes session data and closes the session
session_register_shutdown closes the session
session_set_cookie_params sets session cookie variables and must be used before session_start().
  session_set_cookie_params(0,"/webapp/"); //Set session survival time
session_get_cookie_params gets the session cookie variables. Returns an array containing cookie information for the current session

# Configure php.ini
ini_set($varname, $newvalue);
  //The configuration of this function only takes effect for the current script
  //Not all php.ini settings can be set by this function
ini_get($varname) //Get information about a certain configuration item
ini_get_all([str $extension]) //Returns an array of all configuration item information

# session extension configuration
session.name specifies the session name to use as the name of the cookie. It can only consist of alphanumeric characters and defaults to PHPSESSID.
session.save_path defines the parameters passed to the storage handler.
  If the default files file processor is selected, this value is the path to the created file. The default is /tmp.
  The optional N parameter determines the directory depth in which session files are distributed.
  To use the N parameter, these directories must be created before use. There is a small shell script called mod_files.sh in the ext/session directory that can be used to do this.
  If the N parameter is used and N is greater than 0, automatic garbage collection will not be performed.
session.save_handler defines the name of the handler used to store and retrieve data associated with the session. The default is files.
  If the user defines the memory, the value is changed to user.
  ini_set('session.save_handler', 'user');//This setting only takes effect for the current script.
session.auto_start specifies whether the session module automatically starts a session when a request starts. Default is 0 (do not start).
session.gc_probability and session.gc_divisor together define the probability of starting the gc (garbage collection garbage collection) process when each session is initialized. This probability is calculated using gc_probability/gc_divisor. For example 1/100 means there is a 1% probability of starting the gc process in each request. session.gc_divisor defaults to 100. session.gc_probability defaults to 1./* [Image generation and processing] */GD library
// Canvas generation
# Create new canvas
imagecreate creates a new palette-based image
  resource imagecreate(int $x_size, int $y_size)
imagecreatetruecolor creates a new true color image
# Create a canvas based on an existing file or URL
imagecreatefromgd2 Create a new image from a GD2 file or URL
imagecreatefromgd2part Creates an image from a given GD2 file or part of a URL
imagecreatefromgd creates a new image from a GD file or URL
imagecreatefromgif creates a new image from a file or URL
imagecreatefromjpeg creates a new image from a file or URL
imagecreatefrompng Create a new image from a file or URL
imagecreatefromstring creates an image from an image stream in a string
imagecreatefromwbmp Create a new image from a file or URL
imagecreatefromxbm creates a new image from a file or URL
imagecreatefromxpm creates a new image from a file or URL
// color assignment
imagecolorallocate assigns a color to an image
  int imagecolorallocate(resource $image, int $red, int $green, int $blue)
imagecolorallocatealpha assigns color + alpha to an image
imagecolordeallocate cancels the allocation of image color
imagecolortransparent defines a color as transparent
imagecolorat gets the color index value of a pixel
imagecolorclosest Gets the index value of the color closest to the specified color
imagecolorclosestalpha Gets the color closest to the specified color plus transparency
imagecolorclosesthwb Gets the black and white index of the hue closest to the given color
imagecolorexact gets the index value of the specified color
imagecolorexactalpha Gets the index value of the specified color plus transparency
imagecolormatch makes the palette version of colors in an image more closely match the true color version
imagecolorresolve Gets the index value of the specified color or the closest possible replacement value
imagecolorresolvealpha Gets the index value of the specified color + alpha or the closest alternative possible
imagecolorset sets the color for the specified palette index
imagecolorsforindex gets the color of an index
imagecolorstotal Gets the number of colors in the palette of an image
// area filling
imagefill area filling
  bool imagefill(resource $image, int $x, int $y, int $color)
imagefilledarc draws an elliptical arc and fills it
imagefilledellipse draws an ellipse and fills it
imagefilledpolygon draws a polygon and fills it
imagefilledrectangle draws a rectangle and fills it
imagefilltoborder fills the area to the border of the specified color
imagesettile sets the texture used for filling
// Graphic creation
imagearc draws elliptical arc
imagechar draws a character horizontally
imagecharup draws a character vertically
imagedashedline draw a dotted line
imageellipse draws an ellipse
imageline draws a line segment
imagepolygon draws a polygon
imagerectangle draws a rectangle
imagesetpixel draws a single pixel
imagesx gets image width
imagesy gets image height
//Brush settings
imagesetbrush sets the brush image used for drawing lines
imagesetstyle sets the style of line drawing
imagesethickness sets the width of the line drawing
// Graphic copy
imagecopy copies part of an image
imagecopymerge copies and merges part of an image
imagecopymergegray copies and merges part of an image in grayscale
imagecopyresampled resamples copy part of the image and resizes it
imagecopyresized copies part of the image and resizes it
//Character creation
imagestring draws a line of string horizontally
imagestringup draws a line of string vertically
imagepsslantfont tilts a font
imagefontheight gets the font height
imagefontwidth gets the font width
imagettfbbox Get the range of text using TrueType font
imageloadfont loads a new font
imagepsencodefont changes the character encoding vector in the font
imagepsextendfont expands or condenses fonts
// Export canvas as image
imagegif Output images in GIF format to a browser or file
imagepng Outputs images in PNG format to a browser or file
imagejpeg Output images in JPEG format to a browser or file
imagewbmp Output images in WBMP format to a browser or file
Sending "Content-type: image/image format" through header() can cause the PHP script to output the image directly.header("Content-type: image/gif"); imagegif($im);
imagegd Output GD images to a browser or file
imagegd2 Output GD2 images to a browser or file
// Release canvas resources
imagedestroy destroy image
//Image information
image_type_to_extension gets the file suffix of the image type
getimagesize gets the image size
imagesx gets image width
imagesy gets image height
imageistruecolor checks whether the image is a true color image
imagetypes returns the image types supported by the current PHP version
//Image settings
imagerotate rotates an image by a given angle
imagealphablending sets the color blending mode of the image
imageantialias Whether to use the anti-aliasing (antialias) function
imagefilter applies a filter to an image
imagegammacorrect applies gamma correction to GD images
imageinterlace Activate or disable interlacing

/* [Thumbnail] [Watermark] */
imagecopyresampled resamples copy part of the image and resizes it
  bool imagecopyresampled ( resource $dst_image , resource $src_image , int $dst_x , int $dst_y , int $src_x , int $src_y , int $dst_w , int $dst_h , int $src_w , int $src_h )
imagecopymerge copies and merges part of an image
  bool imagecopymerge ( resource $dst_im , resource $src_im , int $dst_x , int $dst_y , int $src_x , int $src_y , int $src_w , int $src_h , int $pct )
getimagesize gets the image size