Точка знаний PHP-1

The string can be used as a set of characters, and each character can be accessed independently. Only applicable to single byte characters (letters, numbers, half angle punctuation), not available for Chinese characters (under utf8, 3 bytes in Chinese)
$str = "abcd";
echo $str[3];   // d
echo $str{0};   // a
//Another way
You can also use str_split to divide all characters into arrays.
$strarr = str_spill ($STR); // also not suitable for Chinese
Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
)
function mb_str_split($str){
    Return preg_split ('/ (?  Bo
    [1] = > guest
)

$a = 'a';
$a = (unset) $a; // at this time, $a is null
//Another way
$a = 'a';
unset($a);
dd($a);
// wrong report
PHP Notice:  Undefined variable: a in test.php on line 39

Notice: Undefined variable: a in test.php on line 39

$a = null;
$varExists = array_key_exists('a', get_defined_vars());
if($varExists){
        Echo 'variable a exists';
}

Delayed static binding is to allow the called class to be referenced in the context of a static inheritance.
Delayed binding means that static:: is no longer the class where the current method is defined, but the class where the actual runtime is.
(the general meaning is that after the subclass inherits the parent class, a static method or variable is used in the parent class, such as static:: a(), but method a does not exist in the parent class,
It exists in the subclass, so it is correct to write like this, and no error will be reported because the static decorated a will be bound to the specific subclass during execution
As long as the subclass has this method)
Note: it can be used for (but not limited to) static method calls.
Self::, representing this class (the class of the current code)
    Always represents this class, because it has been determined at class compilation time.
    That is, the subclass calls the parent method, but self does not represent the subclass called.
Parent:: represents the parent class
Static::, representing this class (the class that calls this method)
    Class used to reference static calls within the scope of inheritance.
    At run time, the class represented is determined.
    Static:: is no longer resolved to the class where the current method is defined, but is calculated at actual run time.
In addition to the simple use of static delay binding, there is also a forward call,
Forward_static_call_array (), which can only be called in the method, will forward the invocation information (but much more, similar to the eighth point in this section, PHP reflection).
The general examples are as follows:

class A {
    public static function fooStatic() {
        static::who();
    }
    public static function who() {
        echo __CLASS__."aaa\n";
    }
}
class B extends A {
    public static function testStatic() {
        A::fooStatic();
        B::fooStatic();
        C::fooStatic();
        parent::fooStatic();
        self::fooStatic();
    }
    public static function who() {
        echo __CLASS__."bbb\n";
    }
}
class C extends B {
    public static function who() {
        echo __CLASS__."ccc\n";
    }
}
C::testStatic();
Let's get the answer together:

$a = ['a', 'b', 'c'];
$b = ['5' => 'test'];
$c = [1, 2, 3];

$arrayMerge   = array_merge($a, $b);
$arrayPlus    = $a + $b;
$arrayCombine = array_combine($a, $c);
array_push($a, $b);
// $arrayMerge
Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => test
)
// $arrayPlus
Array
(
    [0] => a
    [1] => b
    [2] => c
    [5] => test
)
// $arrayCombine
Array
(
    [a] => 1
    [b] => 2
    [c] => 3
)
// array_push
Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => Array
        (
            [5] => test
        )

)

Internal pointer to array:
Current / POS returns the value of the array unit currently pointed to by the internal pointer, and does not move the pointer.
Key returns the key name of the current unit in the array without moving the pointer
Next moves the internal pointer in the array one bit forward and returns the value of the current cell after the move. First move, then value.
Prev returns the internal pointer of the array to one bit, and returns the value of the current cell to be moved first and then the value.
End points the internal pointer of the array to the last cell and returns the value of the last cell
Reset points the array's internal pointer to the first cell and returns the value of the first array cell
Each returns the current key / value pair in the array and moves the array pointer one step forward.
            The returned array is a 4-length array composed of key and value. The subscript 0 and key represent key, and the subscript 1 and value represent value
After each() is executed, the array pointer stays at the next cell in the array or at the last cell when it hits the end of the array. If you want to traverse the array with each, you must use reset().
1. The above pointer operation function, except key(), returns false if the pointer moves out of the array. The key () move out returns null.
2. If the pointer is illegal, the next / prev operation cannot be performed, and the reset / end operation can be performed
3. Current / next / prev will also return false if it encounters an empty cell (0 or ""). And each won't!

List assigns values in an array to variables. List () is a language structure, not a function.
Arrays that can only be used for numeric indexes and assume that numeric indexes start at 0
/*Can be used to exchange values of multiple variables*/ 
list($a, $b) = array($b, $a);
For example: list ($drive, $power) = array ('coffee ',' Brown ',' Cafe ');
1. Copy the array, and its pointer position will also be copied.
    Special case: if the array pointer is illegal, the copied array pointer will be reset, while the original array pointer will not be changed.
    [pointer problem]
        Whoever writes first will open up a new value space. It has nothing to do with who the value of the variable (array variable) is passed to.
        The array function current() is defined as a write operation, so there is a problem.
        Foreach traverses the copy of the array, and when it is written, it will open up a new value space.
            That is, when the foreach loop body writes to the original array, the pointer problem will occur.
            If the pointer is illegal when a new space is opened, the pointer is initialized.
2. If there is a problem with the pointer position, reset() can be initialized once.

#Data transfer is of string type
#Serializable except for resource types
#When serialization stores data, it stores data itself and data types
Functions: 1. When transferring data on the network; 2. To place arrays or objects on the disk
Serialization
Serialize produces a representation of a storable value
string serialize ( mixed $value )
-Returns a string containing a byte stream representing value that can be stored anywhere.
-It is good for storing or passing PHP values without losing its type and structure.
#Deserialization
Unserialize creates PHP values from stored representations
mixed unserialize ( string $str [, string $callback ] )
-Operate on a single serialized variable and convert it back to the value of PHP.

class Order{
    public function getBasicInfo($orderId, $write = false)
    {
    }
}
$detailServiceInstance = new Order();
$functionName = 'getBasicInfo';
$params [0] = 1000001; // or $params ['orderid '] = 1000001
$params [1] = true; // or $params ['write '] = true
call_user_func_array([$detailServiceInstance, $functionName], $params);

Through this class, we can directly get all kinds of information about specific methods in a class, such as the number of parameters, parameter name, whether there is a default value, etc. The code is as follows:

$object = new Order();
$functionName = 'getBasicInfo';
$reflectionObj = new \ReflectionMethod($object, $functionName);
//After passing the above code, you can directly obtain relevant information through $reflectionobj, as follows
$reflectionobj - > ispublic(); // you can judge whether the method is public, and isprivate, isprotected, isstatic, etc
$reflectionobj - > getparameters(); // you can get all the parameters of the method. It is an array. You can obtain specific parameters for foreach
foreach($reflectionObj->getParameters() as $arg) {
    if(array_key_exists($arg->name, $params)) {
        $callParams[$arg->name] = $params[$arg->name];
    } else {
        $paramVal = null;
        If ($Arg - > isoptional()) {// or use isdefaultvalueavailable to check if a default value is available
            $paramVal = $arg->getDefaultValue();
        }
        $callParams[$arg->name] = $paramVal;
    }
}
Specific parameters: https://www.php.net/manual/zh/class.reflectionmethod.php

move_uploaded_file($tmp_name, $savePath);

You will see:
PHP Strict Standards:  Only variables should be passed by reference in - on line 3

Strict Standards: Only variables should be passed by reference in - on line 3
d
From: https://www.php.net/manual/zh/function.array-pop.php

The behavior of the function passing parameters by reference changes when it is called by value passing. Previously, the function will accept the parameters passing by value, and now it will throw a fatal error. Previously, any function expecting to pass a reference but passing a constant or literal value when it is called needs to assign the value to a variable before the call.
The above comes from: PHP manual appendix porting from PHP 5.2. X to PHP 5.3. X
https://www.php.net/manual/zh/migration53.incompatible.php

error_reporting(E_STRICT);
$testArr = ['a','b','c','c','d'];
$popValue = array_pop(array_unique($testArr));  
//The above code will report an error and must be used
$testArr = ['a','b','c','c','d'];
$testArr = array_unique($testArr)
$popValue = array_pop($testArr);