php

语言

发布日期: 2021-07-08

文章字数: 11.3k

阅读时长: 45 分

php基础

简述

PHP（全称：PHP：Hypertext Preprocessor，即”PHP：超文本预处理器”）是一种通用开源脚本语言。

一个php文件可以包括以下内容：

php文件可以包含文本、HTML、JavaScript代码和PHP代码
php代码在服务器上执行，结果以纯HTML形式返回给浏览器
php文件默认文件扩展名是.php

php使用：

PHP 可以生成动态页面内容
PHP 可以创建、打开、读取、写入、关闭服务器上的文件
PHP 可以收集表单数据
PHP 可以发送和接收 cookies
PHP 可以添加、删除、修改您的数据库中的数据
PHP 可以限制用户访问您的网站上的一些页面
PHP 可以加密数据

基本语法

格式

php脚本以 <?php 开始，以 ?大于号结束

注释同Java

变量命名

变量以$符开始，后门跟变量名称。

变量名必须以字母或下划线开始

变量名只能包含字母、数字和下划线。

变量名不能包含空格

php变量声明以$开始

static的关键字的使用:

当一个函数完成时，它的所有变量通常都会被删除。

然而，有时候您希望某个局部变量不要被删除。

要做到这一点，请在您第一次声明变量时使用 static 关键字：

数据类型

php有5种数据类型：String(字符串)、Integer(整型)、Float(浮点型)、Boolean(布尔型)、Array(数组) Object(对象)、NULL(空值)

常量

常量是一个简单的标识符，在脚本中不能改变。(在整个脚本中都能使用)

一个常量由英文字母、下划线和数字组成，数字不能作为首字母出现，不需要加$修饰。

设置常量：使用define()函数

bool define ( string $name , mixed $value [, bool $case_insensitive = false ] )

　　该函数有三个参数:

name：必选参数，常量名称，即标志符。

value：必选参数，常量的值。

case_insensitive ：可选参数，如果设置为 TRUE，该常量则大小写不敏感。默认是大小写敏感的。

<?php 
// 常量
define("CL", "这是一个全局常量", true);
echo CL; // 默认false，变量名区分大小写
echo cl; // true不区分大小写
?>

预定义常量

PHP预定义了许多常量，这些常量无需使用define()函数定义，可直接在程序中使用。

FILE(FILE前后分别是两个下画线)：当前正在处理的脚本文件名，若使用在一个被引用的文件中（include或require），那么　　它的值就是被引用的文件，而不是引用它的那个文件。
LINE(LINE前后分别是两个下画线)：正在处理的脚本文件的当前行数。
PHP_VERSION：当前PHP预处理器的版本，如5.4.16。
PHP_OS: PHP所在的操作系统的类型。如Linux。
TRUE：表示逻辑真。FALSE：表示逻辑假。NULL：表示没有值或值不确定。
DIRECTORY_SEPARATOR: 表示目录分隔符，UNIX或Linux操作系统环境时的值为“ / ”, Window操作系统环境时的值为 “ \ ”。

<?php
echo __FILE__;
echo "<br/>";
echo __LINE__;
echo "<br/>";
echo PHP_VERSION;
echo "<br/>";
echo PHP_OS;
echo "<br/>";
echo DIRECTORY_SEPARATOR;
?>

整型

整数类型：保存整数数值(范围限制)，4个字节存储数据

php中提供四种整型定义方式：

$a = 120 //十进制
$a = 0b110 //二进制
$a = 0120 //八进制
$a = 0x120 //十六进制

使用echo输出时。默认输出为十进制

下面5个函数可以进行转换：

decbin() 十进制转二进制
decoct() 十进制转八进制
dechex() 十进制转十六进制
bindec() 二进制转十进制
bin2hex()二进制转十六进制

字符串

用于存储并处理变量

<?php
$name='晓莎K';
//双引号里面有变量，会输出变量的值
$str="这是 $name 的blog。";
//单引号里面有变量，会把变量作为字符串处理
$str1='这是 $name 的blog';
echo $str;
echo $str1;

$str后双引号与单引号有区别，如上

一些字符串的操作函数：

addcslashes — 以 C 语言风格使用反斜线转义字符串中的字符
addslashes — 使用反斜线引用字符串
bin2hex — 函数把包含数据的二进制字符串转换为十六进制值
chop — rtrim 的别名
chr — 返回指定的字符
chunk_split — 将字符串分割成小块
convert_cyr_string — 将字符由一种 Cyrillic 字符转换成另一种
convert_uudecode — 解码一个 uuencode 编码的字符串
convert_uuencode — 使用 uuencode 编码一个字符串
count_chars — 返回字符串所用字符的信息
crc32 — 计算一个字符串的 crc32 多项式
crypt — 单向字符串散列
echo — 输出一个或多个字符串
explode — 使用一个字符串分割另一个字符串
fprintf — 将格式化后的字符串写入到流
get_html_translation_table — 返回使用 htmlspecialchars 和 htmlentities 后的转换表
hebrev — 将逻辑顺序希伯来文（logical-Hebrew）转换为视觉顺序希伯来文（visual-Hebrew）
hebrevc — 将逻辑顺序希伯来文（logical-Hebrew）转换为视觉顺序希伯来文（visual-Hebrew），并且转换换行符
hex2bin — 转换十六进制字符串为二进制字符串
html_entity_decode — Convert HTML entities to their corresponding characters
htmlentities — 将字符转换为 HTML 转义字符
htmlspecialchars_decode — 将特殊的 HTML 实体转换回普通字符
htmlspecialchars — 将特殊字符转换为 HTML 实体
implode — 将一个一维数组的值转化为字符串
join — 别名 implode
lcfirst — 使一个字符串的第一个字符小写
levenshtein — 计算两个字符串之间的编辑距离
localeconv — Get numeric formatting information
ltrim — 删除字符串开头的空白字符（或其他字符）
md5_file — 计算指定文件的 MD5 散列值
md5 — 计算字符串的 MD5 散列值
metaphone — Calculate the metaphone key of a string
money_format — 将数字格式化成货币字符串
nl_langinfo — Query language and locale information
nl2br — 在字符串所有新行之前插入 HTML 换行标记
number_format — 以千位分隔符方式格式化一个数字
ord — 转换字符串第一个字节为 0-255 之间的值
parse_str — 将字符串解析成多个变量
print — 输出字符串
printf — 输出格式化字符串
quoted_printable_decode — 将 quoted-printable 字符串转换为 8-bit 字符串
quoted_printable_encode — 将 8-bit 字符串转换成 quoted-printable 字符串
quotemeta — 转义元字符集
rtrim — 删除字符串末端的空白字符（或者其他字符）
setlocale — 设置地区信息
sha1_file — 计算文件的 sha1 散列值
sha1 — 计算字符串的 sha1 散列值
similar_text — 计算两个字符串的相似度
soundex — Calculate the soundex key of a string
sprintf — Return a formatted string
sscanf — 根据指定格式解析输入的字符
str_contains — Determine if a string contains a given substring
str_ends_with — Checks if a string ends with a given substring
str_getcsv — 解析 CSV 字符串为一个数组
str_ireplace — str_replace 的忽略大小写版本
str_pad — 使用另一个字符串填充字符串为指定长度
str_repeat — 重复一个字符串
str_replace — 子字符串替换
str_rot13 — 对字符串执行 ROT13 转换
str_shuffle — 随机打乱一个字符串
str_split — 将字符串转换为数组
str_starts_with — Checks if a string starts with a given substring
str_word_count — 返回字符串中单词的使用情况
strcasecmp — 二进制安全比较字符串（不区分大小写）
strchr — 别名 strstr
strcmp — 二进制安全字符串比较
strcoll — 基于区域设置的字符串比较
strcspn — 获取不匹配遮罩的起始子字符串的长度
strip_tags — 从字符串中去除 HTML 和 PHP 标记
stripcslashes — 反引用一个使用 addcslashes 转义的字符串
stripos — 查找字符串首次出现的位置（不区分大小写）
stripslashes — 反引用一个引用字符串
stristr — strstr 函数的忽略大小写版本
strlen — 获取字符串长度
strnatcasecmp — 使用“自然顺序”算法比较字符串（不区分大小写）
strnatcmp — 使用自然排序算法比较字符串
strncasecmp — 二进制安全比较字符串开头的若干个字符（不区分大小写）
strncmp — 二进制安全比较字符串开头的若干个字符
strpbrk — 在字符串中查找一组字符的任何一个字符
strpos — 查找字符串首次出现的位置
strrchr — 查找指定字符在字符串中的最后一次出现
strrev — 反转字符串
strripos — 计算指定字符串在目标字符串中最后一次出现的位置（不区分大小写）
strrpos — 计算指定字符串在目标字符串中最后一次出现的位置
strspn — 计算字符串中全部字符都存在于指定字符集合中的第一段子串的长度。
strstr — 查找字符串的首次出现
strtok — 标记分割字符串
strtolower — 将字符串转化为小写
strtoupper — 将字符串转化为大写
strtr — 转换指定字符
substr_compare — 二进制安全比较字符串（从偏移位置比较指定长度）
substr_count — 计算字串出现的次数
substr_replace — 替换字符串的子串
substr — 返回字符串的子串
trim — 去除字符串首尾处的空白字符（或者其他字符）
ucfirst — 将字符串的首字母转换为大写
ucwords — 将字符串中每个单词的首字母转换为大写
vfprintf — 将格式化字符串写入流
vprintf — 输出格式化字符串
vsprintf — 返回格式化字符串
wordwrap — 打断字符串为指定数量的字串

运算符

算术运算符：

a.b a并置b，即把俩个字符串连接起来

赋值运算符：

a.=b a等于a并置b，即连接俩个字符串

递增/递减运算符：

比较运算符：

===绝对等于，值跟类型都得相同才返回true。

==等于，值相同就返回true

逻辑运算符：

三元运算符：

判断expr1，成立执行expr2，不成立执行expr3

控制语句

条件控制语句、循环控制语句

<?php
//foreach的例子
$a1=['a','b','c'];
foreach ($a1 as $v){
    echo $v.'---';
}
?>

php数组

数组是一个能在单个变量中存储多个值的特殊变量。

php中，array()函数用于创建数组，print_r(数组)函数用于输出数组

php中有三种数组类型：

*数值数组* - 带有数字 ID 键的数组
*关联数组* - 带有指定的键的数组，每个键关联一个值
*多维数组* - 包含一个或多个数组的数组

php中的多个数组排序内置函数

sort() - 对数组进行升序排列
rsort() - 对数组进行降序排列
asort() - 根据关联数组的值，对数组进行升序排列
ksort() - 根据关联数组的键，对数组进行升序排列
arsort() - 根据关联数组的值，对数组进行降序排列
krsort() - 根据关联数组的键，对数组进行降序排列

数组的操作

数组合并(array_merge)

$array3 = array_merge($array1,$array2);

增加数组元素

array_push() 函数向第一个参数的数组尾部添加一个或多个元素（入栈），然后返回新数组的长度。

array_push($array1,’d’,’e’);

print_r($array1);
下表为空自动添加参数

$array1[]=’d’;
有键值的

$array1[‘a4’]=’javasciprt’；

添加到指定位置

array_splice(数组，位置，删除几个，增加元素）

删除某一个元素

array_splice(数组，位置，删除一个元素）

销毁指定的元素

unset($array1[0]);

将数组最后一个单元弹出（出栈）

array_pop():

常用的数组函数

is_array 判断是否为数组
count 数组的元素数目
array_search — 在数组中搜索给定的值，如果成功则返回相应的键名
array_key_exists()在给定的 key 存在于数组中时返回 TRUE
array_unshift() 将传入的单元插入到 array 数组的开头。注意单元是作为整体被插入的，因此传入单元将保持同样的顺序。所有的数值键名将修改为从零开始重新计数，所有的文字键名保持不变
array_shift() 将array 的第一个单元移出并作为结果返回，将 array 的长度减一并将所有其它单元向前移动一位。所有的数字键名将改为从零开始计数，文字键名将不变。
array_unique() 接受 array 作为输入并返回没有重复值的新数组。注意键名保留不变。 array_unique() 先将值作为字符串排序，然后对每个值只保留第一个遇到的键名，接着忽略所有后面的键名。这并不意味着在未排序的 array 中同一个值的第一个出现的键名会被保留。
in_array — 检查数组中是否存在某个值如果找到指定的值则返回 TRUE，否则返回 FALSE 。in_array()是区分大小写的。

下面给出一些实践：

<?php
//声明数组的三种方式
$array1=array('a','b','c');
$array2=array('a1'=>'php','a2'=>'python','a3'=>'java');
$array5=['a11','b222','c333'];
print_r($array1);echo '<br>';
print_r($array2);echo '<br>';
print_r($array5);
echo '<br>';
echo $array1[1];
echo '<br>';
echo $array2['a2'];

?>

<?php
//数组长度
echo '<br>';
echo count($array1);
echo '<br>';
echo count($array2);
//遍历数组
echo '<br>';
foreach ($array1 as $k=>$v){
    echo $k.'-----'.$v.'<br>';
}
echo '<br>';
foreach ($array1 as $v){
    echo $v;
}
echo '<br>';
foreach ($array2 as  $k=>$value){
    echo $k."------".$value.'<br>';
}
echo '<br>';
for($i=0;$i<=count($array1);$i++){
    echo $array1[$i];
}
?>

<?php
//数组的合并
echo '<br>';
$array3=array_merge($array1,$array2);
print_r($array3);
//数组添加元素
echo '<br>';
array_push($array1,'d','e');
print_r($array1);
echo '<br>';
$array1[]='f';
print_r($array1);
echo '<br>';
$array2['a4']='go';
print_r($array2);
//更改数组
echo '<br>';
echo '<br>';
$array1[0]='x';
$array2['a1']='php1';
print_r($array1);
echo '<br>';
print_r($array2);
//在指定位置插入
echo '<br>';echo '<br>';
//array_splice(数组，指定位置3，删除几个元素0，插入元素)
array_splice($array1,5,2,'g');
print_r($array1);
echo '<br>';echo '<br>';
$array4=array('1','2','3');
array_splice($array4,1,1,'4');
print_r($array4);

//销毁指定元素
echo '<br>';echo '<br>';
unset($array1[5]);
print_r($array1);
echo '<br>';
unset($array2['a4']);
print_r($array2);
//数组中最后一个元素出栈
echo '<br>';echo '<br>';
array_pop($array1);
print_r($array1);
//数组的一些函数
echo '<br>';echo '<br>';
echo array_search('php1',$array2);
echo '<br>';echo '<br>';
echo array_key_exists('a1',$array2);//判断给定的key值是否存在

?>

php函数

php真正力量来自于他的函数，它拥有超过1000个内建函数

函数是可以在程序中重复使用的语句块。，页面加载时函数不会立即执行，函数只有在被调用时才会执行。

我们也可以自定义函数，函数声明以单词’function’开头。

函数名能够以字母或者下划线开头(而非数字)

函数名对大小写不敏感。

函数名应该能反应其所执行的任务

php函数参数

php默认参数值

如果我们调用没有参数的函数，他会保留默认值

php函数返回值

使用’return’是函数返回值

匿名函数

匿名函数就是没有名字的函数。

将一个匿名函数”赋值”给一个变量——此时该变量就代表该匿名函数了！

回调函数

回调函数是指调用函数的时候将另一个函数作为参数传递到调用的函数中，而不是传递一个普通的变量作为参数

使用回调函数是为了可以将一段自己定义的功能传到函数内部使用

一些例子：

<?php

//无参数的函数

/*function getName(){
    return '晓莎K';
}
echo getName();*/

//有参数的函数

/*function getName($name){//形式参数
    return $name;
}
echo getName("晓莎K");//实际参数*/

//形式参数有默认值

/*function getName($name='hhh'){//形式参数
    return $name;
}
echo getName("晓莎111K");*/

//没有形式参数的匿名函数

/*$callfunction=function (){
  return 'KKK';
};
echo $callfunction();*/

//有参数的匿名函数

/*$callfunction=function ($name){
  return $name;
};
 echo $callfunction('KKKK');
*/

//回调函数
function getName($name){
    return $name;
}
echo call_user_func('getName','xiaoshaK');
?>

php变量作用域

变量作用域是指变量能够被引用的那段脚本

php三种不同的变量作用域：

local（局部）
global（全局）
static（静态）

函数之外声明的变量拥有 Global 作用域，只能在函数以外进行访问。

函数内部声明的变量拥有 LOCAL 作用域，只能在函数内部进行访问。

global 关键词用于在函数内访问全局变量。

在函数内的变量前使用此关键字

PHP 同时在名为 $GLOBALS[变量名] 的数组中存储了所有的全局变量。下标存有变量名。

这个数组在函数内也可以访问，并能够用于直接更新全局变量。

通常，当函数完成/执行后，会删除所有变量。不过，有时我需要不删除某个局部变量。

要想变量保留，需要在首次声明变量时使用 static 关键词：

类与对象

php面向对象

在面向对象程序设计中，对象是一个由信息及对信息进行处理的描述组成的整体，是对现实世界的抽象。

对象的三个主要特性：

对象的行为：可以对对象施加那些操作，开灯，关灯就是行为。
对象的形态：当施加那些方法是对象如何响应，颜色，尺寸，外型。
对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。

面向对象内容

类：

定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。

对象：

类的实例

成员变量：

定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可称为对象的属性。

成员函数：

定义在类的内部，用于访问对象的数据

继承:

继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。

在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

多态：

多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。

不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

封装：

封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。

重载：

简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

构造函数：

主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。

析构函数：

析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做”清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

变量 $this代表自身的对象。

PHP_EOL为换行符。

销毁 MyDestructableClass

几个例子：

<?php
class Person{
    //成员变量
    var $name;
    var $age;
    var $gender;
    //成员函数
    function setName($name){
        $this->name=$name;
    }
    function getName(){
        return $this->name;
    }
}
//类的实例化 p1就是一个对象
//$this 表示对象本身
$p1 = new Person();
$p1->setName('晓莎K');

echo $p1->name;
echo $p1->getName();

?>

<?php
class Person{
    //成员变量
    var $name;
    var $age;
    var $gender;
    //构造函数
    function __construct($name){
        $this->name=$name;
    }
    //析构函数
    function __destruct(){
        echo $this->name;
    }
}
$p1 = new Person('晓莎K');
?>

<?php
class Person{
    var $name;
    var $age;
    function __construct($name,$age){
        $this->name=$name;
        $this->age=$age;
    }
    function getUser(){
        return "名字是 $this->name 年龄是 $this->age 岁";
    }

}
/*$p1 = new Person('晓莎K','18');
echo $p1->getUser();*/
class P1 extends Person{
    //重写getuser
    function getUser()
    {
        return "名字是 $this->name";
    }
    function run(){
        return " $this->name 在跑步";
    }

}

$p2 = new P1('KK','20');
echo $p2->getUser();
echo $p2->run();

访问控制

PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。

public（公有）：公有的类成员可以在任何地方被访问。
protected受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
private（私有）：私有的类成员则只能被其定义所在的类访问。

<?php
class Person{
    public $name;
    public $age;
    public function __construct($name,$age){
        $this->name=$name;
        $this->age=$age;
    }
    public function getUser(){
        return "名字是 $this->name 年龄是 $this->age 岁";
    }

}
$p1 = new Person('晓莎K','18');
echo $p1->name;
echo $p1->getUser();

/*class P1 extends Person{
    //重写getuser
    function getUser()
    {
        return "名字是 $this->name";
    }
    function run(){
        return " $this->name 在跑步";
    }

}

$p2 = new P1('KK','20');
echo $p2->getUser();
echo $p2->run();
*/

<?php

class Person{
    public $a="public 共有的";
    protected $b="protected 受保护的";
    private $c="private 私有的";

    public function print1(){
        //在类中的函数可以访问   三种属性
        echo $this->a.'<br>';
        echo $this->b.'<br>';
        echo $this->c.'<br>';
    }

    public function a1(){
        echo "public";
        $this->a2();
        $this->a3();
    }
    protected function a2(){
        echo "protected";
    }
    private function a3(){
        echo "privite";
    }
}
$p1= new Person();
//$p1->print1();
//在类外只能访问到public，protected和private不能被访问到
echo $p1->a1();

<?php

class Person
{
    protected $name;
    protected $age;

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

    protected function getUser()
    {
        return "名字是 $this->name 年龄是 $this->age 岁";
    }

}


class P1 extends Person{
    public function a1(){
        echo $this->name.'访问受保护的';
        echo $this->getUser();
        echo parent::getUser();
    }


}

$p2 = new P1('KK','20');
$p2->a1();

<?php

class Person
{
    private $name;
    private $age;

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

    private function getUser()
    {
        return "名字是 $this->name 年龄是 $this->age 岁";
    }

}


class P1 extends Person{
    public function a1(){
        echo $this->name.'私有的';//私有只能在被其所定义的类内访问
        echo $this->getUser();//私有只能在被其所定义的类内访问
    }


}

$p2 = new P1('KK','20');
$p2->a1();

接口和抽象类

接口：

对接口的使用是通过关键字implements，声明接口用interface
接口不能定义成员变量（包括类静态变量），能定义常量
子类必须实现接口定义的所有方法
接口只能定义不能实现该方法
接口没有构造函数
接口中的方法和实现它的类默认都是public类型的

<?php

interface Person{
    //用interface声明一个接口
    //接口中  所有的方法都是公共有的 方法可以允许有参数
    //接口中  可以使用常量  但是不能使用变量
    const NAME="这是一个常量";
    public function getName();
    public function  setName($name);

}
interface P{
    public function run();
}

//类可以有多个接口
class P1 implements Person,P {
    public function setName($name)
    {
        echo "setName".$name;
    }
    public function getName()
    {
        echo "getName";
    }
    public function run()
    {
        echo "run";
    }

}
$a = new P1();
$a->setName('晓莎K');
$a->getName();
$a->run();
?>

抽象类：

对抽象类的使用是通过关键字extends
不能被实例化，可以定义子类必须实现的方法
子类必须定义父类中的所有抽象方法，这些方法的访问控制必须和父类中一样（或者更为宽松）
如一个类中有一个抽象方法，则该类必须定义为抽象类
抽象类可以有构造函数
抽象类中的方法可以使用private,protected,public来修饰。
一个类可以同时实现多个接口，但一个类只能继承于一个抽象类。

<?php
//声明抽象类abstract
//抽象类里面允许有   抽象方法和方法   抽象方法不能有具体的内容  必须为空 允许有参数
//抽象类不能实例化  抽象类不能new对象出来
//子类中必须实现每一个抽象方法
abstract class people{

    abstract protected function getName();

    abstract protected function setName($name);

    public function run(){
        echo "run";
    }

}
//类只能继承一个抽象类
//必须把抽象类里面的方法  实现
//如果抽象类是protected  子类定义方法的时候  可以是  protected  public  不能使 public
class  P1 extends people{
    public $name;
    function __construct($name){
        $this->name=$name;

    }
    public function getName()
    {
        echo "getName".$this->name;
    }
    public function setName($name)
    {
        echo "setName".$name;
    }
    public function run()
    {
        parent::run(); // TODO: Change the autogenerated stub
    }
}
$a = new P1('晓莎K');
$a->getName();
echo $a->setName('KKKK');
$a->run();

?>

关键字

static关键字

声明类属性或方法为 static(静态)，就可以不实例化类而直接访问。
静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。
由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。
静态属性不可以由对象通过 -> 操作符来访问。

<?php

//静态方法 静态变量

class Person{
    public  static $name="晓莎K";
    public static function getString(){
        return "getString".self::$name;
        //return "getString".$this->name=$name; 不能使用this
    }
}
//不需要实例化(不需要new对象)  直接进行访问
echo Person::$name;
echo Person::getString();

final关键字

如果父类中的方法被声明为 final，则子类无法覆盖该方法。

如果一个类被声明为 final，则不能被继承。

<?php

//final 子类不能重写父类有此关键字的函数
class Person{
    public   $name="晓莎K";
    final public  function getString(){
        return "这个是父类的方法";

    }
}

class c1 extends Person{
    public function getString()
    {
        return "这个是字类的方法";
    }
}

$a = new Person();
echo $a->getString();

parent关键字

<?php
header("Content-Type:text/html;charset=UTF-8");

class Person{

    public $userName='我是老爸';
    public $age='58';

    protected function play(){

        echo '老爸,需要有人陪着打麻将！';
    }
}

class Student extends Person{
    public $userName='我是学生';
    public $age='16';

    public function play(){
        parent::play();
        echo '学生不能打麻将！';

    }
}

$xiaoming = new Student();
$xiaoming->play();   //老爸,需要有人陪着打麻将！学生不能打麻将！

?>

php超级全局变量

$GLOBALS　　一个包含了全部变量的全局组合数组。变量的名字就是数组的键。
$_SERVER　　一个包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组
$_REQUEST　　用于收集HTML表单提交的数据。它可以获取 cookie get post
$_POST　　广泛应用于收集表单数据，在HTML form标签的指定该属性：”method=”post”。
$_GET　　广泛应用于收集表单数据，在HTML form标签的指定该属性：”method=”get”。
$_FILES　　
$_ENV　　
$_COOKIE　　
$_SESSION

<?php 
// php预定义方法
echo "\n", $GLOBALS['y'];
echo "\n", $_SERVER['PHP_SELF'];
echo "\n", $_SERVER['SERVER_NAME'];
echo "\n", $_SERVER['HTTP_HOST'];
?>

<form method="post" enctype="multipart/form-data">
    <input name="file" type="file">
    <input name="sub" value="提交" type="submit">
</form>

<?php
print_r($_FILES['file']['name']);
?>

php文件

include文件操作

服务器端包含 (SSI) 用于创建可在多个页面重复使用的函数、页眉、页脚或元素。

include （或 require）语句会获取指定文件中存在的所有文本/代码/标记，并复制到使用 include 语句的文件中。

PHP include 和 require 语句

通过 include 或 require 语句，可以将 PHP 文件的内容插入另一个 PHP 文件（在服务器执行它之前）。

include 和 require 语句是相同的，除了错误处理方面：

require 会生成致命错误（E_COMPILE_ERROR）并停止脚本

include 只生成警告（E_WARNING），并且脚本会继续

因此，如果您希望继续执行，并向用户输出结果，即使包含文件已丢失，那么请使用 include。否则，在框架、CMS 或者复杂的 PHP 应用程序编程中，请始终使用 require 向执行流引用关键文件。这有助于提高应用程序的安全性和完整性，在某个关键文件意外丢失的情况下。

包含文件省去了大量的工作。这意味着您可以为所有页面创建标准页头、页脚或者菜单文件。然后，在页头需要更新时，您只需更新这个页头包含文件即可。

function.php

<?php

include 'function.php';

echo fun1();

index.php

<?php

include 'function.php';

echo fun1();

访问index，调用了function

include header和footer同，不演示例子了

php操作文件

PHP 拥有的多种函数可供创建、读取、上传以及编辑文件。

PHP readfile() 函数

readfile() 函数读取文件，并把它写入输出缓冲。

PHP Open File - fopen()

打开文件的更好的方法是通过 fopen() 函数。此函数为您提供比 readfile() 函数更多的选项。

fopen() 的第一个参数包含被打开的文件名，第二个参数规定打开文件的模式。

模式：

PHP 读取文件 - fread()

fread() 函数读取打开的文件。

fread() 的第一个参数包含待读取文件的文件名，第二个参数规定待读取的最大字节数。

PHP 关闭文件 - fclose()

fclose() 函数用于关闭打开的文件。

注释：用完文件后把它们全部关闭是一个良好的编程习惯。您并不想打开的文件占用您的服务器资源。

fclose() 需要待关闭文件的名称（或者存有文件名的变量）

PHP 读取单行文件 - fgets()

fgets() 函数用于从文件读取单行。

调用 fgets() 函数之后，文件指针会移动到下一行。

PHP 检查 End-Of-File - feof()

feof() 函数检查是否已到达 “end-of-file” (EOF)。

feof() 对于遍历未知长度的数据很有用。

feof() 函数检查是否已到达文件末尾(EOF)

PHP 读取单字符 - fgetc()

fgetc() 函数用于从文件中读取单个字符

PHP 创建文件 - fopen()

fopen() 函数也用于创建文件。在php中创建文件与打开文件所用函数相同

PHP 写入文件 - fwrite()

fwrite() 函数用于写入文件。

fwrite() 的第一个参数包含要写入的文件的文件名，第二个参数是被写的字符串。

php覆盖(Overwriting)

如果现在 “newfile.txt” 包含了一些数据，我们可以展示在写入已有文件时发生的的事情。所有已存在的数据会被擦除并以一个新文件开始。

文件的复制删除重命名

php文件重命名：函数rename()。

php文件复制：函数copy();

php文件删除：函数unlink();

文件的判断

file_exists() 判断文件是否存在

is_file() 是否为文件。

<?php
/*读取文件
 * $myfile= fopen('12306top100.txt','r');
var_dump($myfile);
echo fread($myfile,filesize('12306top100.txt'));
fclose($myfile);*/

/*读取文件
 * $myfile= fopen('12306top100.txt','r');
//echo fgets($myfile);
//echo fgets($myfile);
//echo fgets($myfile);
while (!feof($myfile)){//检查是否已到达末尾
    echo md5(fgets($myfile))."<br>";
}*/

/*
//创建文件 写入内容

$myfile = fopen('1.txt','a');//w模式 写 如果文件不存在创建文件  a模式 在原有的基础上增加内容，如果文件不存在同样会创建文件
fwrite($myfile,"bbbb \r\n");
fclose($myfile);//关闭文件

*/

//重命名
//rename('1.txt','1-1.txt');
//复制
//copy('1.txt','2.txt');
    //将1.txt复制到2.txt，如果2.txt不存在 则创建后复制
/*//删除文件
unlink('1.txt');*/

/*if(file_exists('2.txt')){
    echo "文件存在";
}else{
    echo "文件不存在";
}*/

//判断是否是文件
if(is_file('error')){
    echo "是文件";
}else{
    echo "不是文件";
}

php获取文件属性

当我们在程序中操作文件时，可能会使用到文件的一些常见属性，比如文件的大小、类型、修改时间、访问时间以及权限等等。

PHP 中提供了非常全面的用来获取这些属性的内置函数，如下

<?php

$myfile="1.txt";
file_exists($myfile) or die("文件不存在<br>");//or前  如果存在后不会执行or后   如果存在就会执行
echo $myfile."存在"."大小为".filesize($myfile)."kb<br>";
//判断是否可读
if(is_readable($myfile)){
    echo "文件可读<br>";
}else{
    echo "文件不可读<br>";
}
//判断是否可执行
if(is_executable($myfile)){
    echo "文件可执行<br>";
}else{
    echo "文件不可执行<br>";
}
//判断是否可写
if(is_writable($myfile)){
    echo "文件可写<br>";
}else{
    echo "文件不可写<br>";
}
//获取文件创建时间
echo "文件创建时间为".date("Y-m-d H:i:s",filectime($myfile))."<br>";
//获取文件修改时间
echo "文件修改时间为".date("Y-m-d H:i:s",filemtime($myfile))."<br>";
//获取文件上次访问时间
echo "文件访问时间为".date("Y-m-d H:i:s",fileatime($myfile))."<br>";

php目录操作

新建目录：mkdir(路径，权限，递归创建)
删除目录：rmdir()
移动（改名）：rename()
获取目录内容：

//打开目录

目录句柄 = opendir()
//读取目录

文件名 = readdir(目录句柄)

依次读取文件名，同时向下移动文件句柄指针，读取不到则返回false
//关闭目录

closedir()
当前目录. 上级目录用..

<?php
/*$name="myhack";
//mkdir($name);//新建名为name的目录
//rename($name,'晓莎K');//更改目录的名字
rmdir('晓莎K');//删除目录*/
/*
//遍历目录
$path=".";//当前路径
$dh= opendir($path);//打开目录
//读取打开目录的文件名，没有文件m
//echo readdir($dh);//依次读取文件名，同时向下移动文件句柄指针，读取不到则返回false
//echo readdir($dh);
//echo readdir($dh);

//输出目录和文件名
while(($file=readdir($dh))!==false){
    if(is_dir($file)&& $file!="." && $file!=".."){
        echo "目录 $file"."<br>";
    }else{
        if ($file!="." && $file!=".."){
            echo "文件 $file"."<br>";
        }
    }
}*/

/*//我们直接输出时发现输出的全是文件,即使是目录他也是显示文件，所以我们需要使用绝对路径$dirpath
$path="c:/";//c盘路径
$dh= opendir($path);
//输出目录和文件名
while(($file=readdir($dh))!==false){
    $dirpath="$path$file";
    if(is_dir($dirpath)&& $file!="." && $file!=".."){
        echo "目录 $dirpath"."<br>";
    }else{
        if ($dirpath!="." && $dirpath!=".."){
            echo "文件 $dirpath"."<br>";
        }
    }
}*/

//遍历c盘目录  如果是目录 继续遍历 如果是文件输出  相当于是递归操作了
$path="e:/";//x盘路径
function tree($path){
    $dh= opendir($path);//打开目录
    while(($file=readdir($dh))!==false){//当目录打开时
        $dirpath="$path$file";//绝对路径
        if(is_dir($dirpath)&& $file!="." && $file!=".."){//绝对路径是目录且打开目录不是相对路径
            echo "目录 $dirpath"."<br>";
            if(is_readable($dirpath)){//有访问权限
                tree($dirpath);//继续遍历目录
            }else{
                echo "无权限访问"."<br>";
            }

        }else{//不是目录
            if ($file!="." && $file!=".."){//打开目录不是相对路径
                echo "文件 $dirpath"."<br>";//输出文件
            }
        }
    }
    closedir($dh);//关闭目录  减少资源占用
}
tree($path);//调用函数 函数在加载页面是不会执行 只有在调用时才会执行

命名空间

命名空间可以解决以下俩类问题：

用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突。

为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，以提高源代码的可读性。

命名空间（可以理解为创建文件夹）

定义：命名空间namespace，是指人为的将内存进行分隔，让不同内存区域的同名结构共存，从而解决在大型项目中可能出现的重名结构的问题
语法：namespace 空间名
作用：不同的空间可以有同名的结构，如：类
空间元素：函数，常量，类，不包括变量！！

子空间（子文件夹）

定义：命名空间内部再划分一个命名空间，让每个小空间独立起来
语法:

namespace 空间名

namespace 空间名\子空间

命名空间访问

非限定名称访问：直接访问空间元素的名字（只访问自己命名空间的元素）

限定名称访问：使用自己当前的子空间名字+ \ + 元素名字

完全限定名称访问：\ + 全局空间 + \ + 元素名字

demo3/demo1.php

<?php
const NAME='晓莎K';
$name='aaaa';
include 'demo2.php';//变量被覆盖  常量未被覆盖
echo NAME;
echo $name;

demo3/demo2.php

<?php
const NAME = '晓莎K2';
$name = 'bbbb';

demo3/demo3.php

<?php

namespace mydemo;
include 'demo4.php';
const NAME='K_a'."<br>";
function getName(){
    return 'getName-a'."<br>";
}
class Dog{
    static function run(){
        return 'Dog_a'."<br>";
    }
}

echo NAME;//非限定名称 本空间名访问
echo getName();//非限定名称 本空间名访问
echo Dog::run();//非限定名称 本空间名访问

echo b\NAME;//限定名称  子空间名\元素
echo b\getName();//限定名称 子空间名\元素
echo b\Dog::run();//限定名称 子空间名\元素

//完全限定名称
echo "<hr>";
echo \mydemo\NAME;
echo \mydemo\getName();
echo \mydemo\Dog::run();
echo \mydemo\b\NAME;
echo \mydemo\b\getName();
echo \mydemo\b\Dog::run();

demo3/demo4.php

<?php

namespace mydemo\b;
const NAME='K_b'."<br>";
function getName(){
    return 'getName-b'."<br>";
}
class Dog{
    static function run(){
        return 'Dog_b'."<br>";
    }
    public function say(){
        return 'say_b';
}
}

命名空间的引入

空间引入方式：use关键字

引入类：use 空间名\类名

引入函数：use function 空间名\函数名

引入常量：use const 空间名\常量名
当引入元素时重名，通过 as 来起别名

use 空间名\类名 as 别名
引入多个元素

use 空间名{

类名，

function 函数名，

const 常量

}
引入空间

use 空间名

demo3/demo5.php

<?php

namespace one;
include 'demo4.php';

//echo \mydemo\b\NAME;
//use 引用整个命名空间
use \mydemo\b as aa;
echo aa\NAME;

//引入一个类
use mydemo\b\Dog;
$a=new Dog();
echo $a->say();

//引入常量
use const mydemo\b\NAME;
echo NAME;

//引入一个函数
use function mydemo\b\getName;
echo getName();

demo3/demo6.php

<?php

namespace KKK;
include 'demo7.php';
function getName(){
    return __NAMESPACE__."__getName";

}
echo \KKK\a\getName();

demo3/demo7.php

<?php

namespace KKK\a;
function getName(){
    return __NAMESPACE__."__getName";

}

正则表达式

正则表达式是用于描述字符排列和匹配模式的一种语法规则。它主要用于字符串的模式分割、匹配、查找及替换操作。到目前为止，我们前面所用过的精确（文本）匹配也是一种正则表达式。

在PHP中，正则表达式一般是由正规字符和一些特殊字符（类似于通配符）联合构成的一个文本模式的程序性描述。

正则表达式较重要和较有用的角色是验证用户数据的有效性检查。

PHP中，正则表达式有三个作用：

匹配，也常常用于从字符串中析取信息。

用新文本代替匹配文本。

将一个字符串拆分为一组更小的信息块。

正则表达式基本语法

PCRE库函数中，正则匹配模式使用分隔符与元字符组成。分隔符可以是非数字、非反斜线、非空格的任意字符。经常使用的分隔符是**正斜线(/)、hash符号(#) 以及取反符号(~)**。

元字符是用于构造规则表达式的具有特殊含义的字符。

如果要在正则表达式中包含元字符本身，必须在其前加上”\”进行转义。

元字符说明

* 0次、1次或多次匹配其前的原子

+ 1次或多次匹配其前的原子

? 0次或1次匹配其前的原子

| 匹配两个或多个选择

^ 匹配字符串串首的原子

$ 匹配字符串串尾的原子

[] 匹配方括号中的任一原子

[^] 匹配除方括号中的原子外的任何字符

{m} 表示其前原子恰好出现m次

{m,n} 表示其前原子至少出现m次，至多出现n次(n>m)

{m,} 表示其前原子出现不少于m次

() 整体表示一个原子

. 匹配除换行之外的任何一个字符

\ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。

边界限制

在某些情况下，需要对匹配范围进行限定，以获得更准确的匹配结果。

“^”和“$”分别指定字符串的开始和结束。

重复匹配

正则表达式中有一些用于重复匹配某些原子的元字符：“?”、“*”、“+”。他们主要的不同是重复匹配的次数不同。

元字符“?”表示0次或1次匹配紧接在其前的原子。

元字符“*”:表示0次、1次或多次匹配紧接在其前的原子。

元字符“+”:表示1次或多次匹配紧接在其前的原子。

x|y 匹配 x 或 y。

[xyz] 字符集合。匹配所包含的任意一个字符。

[^xyz] 负值字符集合。匹配未包含的任意字符。

[a-z] 字符范围。匹配指定范围内的任意字符。

[^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。

\b 匹配一个单词边界，也就是指单词和空格间的位置。

\B 匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。

\cx 匹配由 x 指明的控制字符。

\d 匹配一个数字字符。

\D 匹配一个非数字字符。

\f 匹配一个换页符。

\n 匹配一个换行符。

\r 匹配一个回车符。

\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。

\S 匹配任何非空白字符。

\t 匹配一个制表符。

\v 匹配一个垂直制表符。

\w 匹配包括下划线的任何单词字符。

\W 匹配任何非单词字符包括下划线。

\xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。

\num 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。

\n 标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。

\nm 标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。

\nml 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。

\un 匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。

<?php
$name="www.baidu.com dab19e82e1f9a681ee73346d3e7a575e AAAA www.baidu.com dab19e82e1f9a681ee73346d3e7a575e AAAA";
if(preg_match_all('/[a-z0-9]{32}/',$name,$p)){
    print_r($p);
    echo "匹配";
}else{
    echo "匹配失败";
}

php与mysql

demo4/demo1.php

<?php
$servername = "localhost";
$username = "root";
$password ="123456";
//创建链接
$conn=new mysqli($servername,$username,$password);
if($conn->connect_error){//判断是否成功连接
    echo "mysql_error".$conn->connect_error;
}else{
    echo "mysql_connect successful"."<br>";
}
//创建数据库
$sql="CREATE DATABASE mydata";
if ($conn->query($sql)===TRUE)//判断sql语句是否成功执行
{
    echo "Database created";
}
else
{
    echo "Error creating database: " .$conn->error;
}

demo4/demo2.php

<?php
$servername = "localhost";
$username = "root";
$password ="123456";
$dbname = "mydata";
//创建链接
$conn=new mysqli($servername,$username,$password,$dbname);
if($conn->connect_error){
    echo "mysql_error".$conn->connect_error."<br>";
}else{
    echo "mysql_connect successful"."<br>";
}
//创建表
$sql="CREATE TABLE users (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(30) NOT NULL,
password VARCHAR(30) NOT NULL,
email VARCHAR(50)
);";
if ($conn->query($sql)===TRUE)//判断sql语句是否成功执行
{
    echo "table created";
}
else
{
    echo "Error creating table: " .$conn->error;
}

demo4/demo3.php

<?php
$servername = "localhost";
$username = "root";
$password ="123456";
$dbname = "mydata";
//创建链接
$conn=new mysqli($servername,$username,$password,$dbname);
if($conn->connect_error){
    echo "mysql_error".$conn->connect_error."<br>";
}else{
    echo "mysql_connect successful"."<br>";
}
//向数据库中插入内容
$sql="INSERT INTO users (username,password,email) VALUES ('xiaoshaK','123456','admin@xiaoshaK.com')";
if ($conn->query($sql)===TRUE)//判断sql语句是否成功执行
{
    echo "INSERT created";
}
else
{
    echo "Error INSERT INTO table: " .$conn->error;
}

demo4/demo4.php

<?php
$servername = "localhost";
$username = "root";
$password ="123456";
$dbname = "mydata";
//创建链接
$conn=new mysqli($servername,$username,$password,$dbname);
if($conn->connect_error){
    echo "mysql_error".$conn->connect_error."<br>";
}else{
    echo "mysql_connect successful"."<br>";
}
//查询
$sql="SELECT * FROM users where id=".$_GET['id'];

$result = $conn->query($sql);
if($conn->query($sql)){

}else{
    echo "mysqli error".$conn->error."<br>";
}

if ($result->num_rows>0)////判断是否查询到结果
{
    while($row = $result->fetch_assoc()) {
        echo "id: ". $row["id"]. " - Name: ". $row["username"]. " " . $row["password"]."".$row["email"]. "<br>";
    }
}
else
{
    echo "result 0";
}

demo4/demo5.php

<?php
$servername = "localhost";
$username = "root";
$password ="123456";
$dbname = "mydata";
//创建链接
$conn=new mysqli($servername,$username,$password,$dbname);
if($conn->connect_error){
    echo "mysql_error".$conn->connect_error."<br>";
}else{
    echo "mysql_connect successful"."<br>";
}
//删除数据
$sql="delete  FROM users where id=".$_GET['id'];

if($conn->query($sql)){
    
}else{
    echo "mysqli error".$conn->error."<br>";
}

if ($conn->num_rows<=0)//sql语句正确执行  输出新建成功
{
echo "删除成功";
}
else
{
    echo "删除失败";
}
$conn->close();//关闭

demo4/demo6.php

<?php
$servername = "localhost";
$username = "root";
$password ="123456";
$dbname = "mydata";
//创建链接
$conn=new mysqli($servername,$username,$password,$dbname);
if($conn->connect_error){
    echo "mysql_error".$conn->connect_error."<br>";
}else{
    echo "mysql_connect successful"."<br>";
}
//更新数据库的内容
$sql="update users set username='KKK'where id=1";
if ($conn->query($sql)===TRUE)//sql语句正确执行  输出新建成功
{
    echo " Updated！";
}
else
{
    echo "Error update : " .$conn->error;
}

晓莎K

http://0x00xiaoshaK.github.io/2021/07/08/60-zhi-day4/

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源晓莎K !

php

mysql

mysql数据库温习

2021-07-12 数据库

mysql

60之day3

htmldivcss博客编写

2021-07-07 博客编写

htmldivcss

php基础

php基础

简述

基本语法

格式

变量命名

数据类型

常量

预定义常量

整型

字符串

运算符

控制语句

php数组

php中的多个数组排序内置函数

数组的操作

数组合并(array_merge)

增加数组元素

添加到指定位置

删除某一个元素

销毁指定的元素

将数组最后一个单元弹出（出栈）

常用的数组函数

php函数

php函数参数

php默认参数值

php函数返回值

匿名函数

回调函数

php变量作用域

类与对象

面向对象内容

访问控制

接口和抽象类

接口：

抽象类：

关键字

static关键字

final关键字

parent关键字

php超级全局变量

php文件

include文件操作

php操作文件

PHP readfile() 函数

PHP Open File - fopen()

PHP 读取文件 - fread()

PHP 关闭文件 - fclose()

PHP 读取单行文件 - fgets()

PHP 检查 End-Of-File - feof()

PHP 读取单字符 - fgetc()

PHP 创建文件 - fopen()

PHP 写入文件 - fwrite()

php覆盖(Overwriting)

文件的复制 删除 重命名

文件的判断

php获取文件属性

php目录操作

命名空间

正则表达式

正则表达式基本语法

边界限制

重复匹配

php与mysql

文件的复制删除重命名