PHP基础课程文档总结

jiangxiaochen_

已于 2024-05-14 18:13:55 修改

阅读量313

点赞数 4

文章标签： php

于 2024-03-03 20:39:54 首次发布

本文链接：https://blog.csdn.net/jiangxiaochen_/article/details/136437744

版权

1.基础语法

HPH网站基本访问流程

浏览器发起访问（输入域名）—DNS 解析域名—服务器电脑—服务网站

1.语法

echo （输出语句）

var_dump （返回变量的数据类型和值，一般用于调试时使用）

echo gettype （$a）（只获取数据类型）

2.变量

变量以$符号开头，后面是变量名

$a = x；

3.数据类型

把null负值给一个变量，则清空变量值

PHP换行符

echo PHP_EOL;

EOF定界符

语法：<<<EFO

EFO；

开始和结束都独占一行，开始的字母可以是任意字母，但是结束字母也要跟开始字母相同，否则会报错；

属性：

1.EFO里面可以解析HTML代码

2.函数符号，不能解析

遍历数组

foreach($bianlian as $Key => $value)
{
       要执行的代码
}

全局变量 global 用法

<?php
    $sun="全局变量";
 function text(){
    global $sun;
    echo $sum;
 }
    
 text();

?>

static 作用域

语法：

static $text=0;

每次函数调用时，该变量会保留前一次被调用的值；（局部变量）

isset () 判断变量是否存在

is_null () 判断一个变量是否为空值，前提是变量要被定义

empty() 对于未被定义的变量也会返回true，使用empty()之前也要确保变量被定义

unset 删除变量

超级全局变量

$GLOBALS 包含全部变量的全局组合数组

$_SERVER 包含信息(header) 路径(path) 脚本位置等信息的数组

空白运算符

语法：？？（相当于HTML里面的 || 或）

判断一个变量是否为未被定义或者为null，如果未被定义则返回指定的默认值，否则返回该变量的值

组合比较符

语法：$a <=> $b

$a 大于 $b 则返回 1

$a 等于 $b 则返回 0

$a 小于 $b 则返回 -1

只会比较里面的值，不比较数据类型

逻辑运算符

字符串相关函数

strlen()：用于获取字符串的长度。
strpos()：用于查找字符串中某个子串第一次出现的位置。
substr()：用于截取字符串的一部分
strtolower()：将字符串转换为小写。
strtoupper()：将字符串转换为大写。
trim()：去除字符串两端的空格或指定字符。
explode()：将字符串按指定分隔符拆分成数组。
implode()：将数组元素连接成字符串，使用指定的分隔符。
htmlspecialchars()：将特殊字符转换为HTML实体。
str_replace(要找的函数，要替换的函数，去哪个字符串里面找)：将字符串中的某一个字符串替换为另一个字符串
strrev():将字符串反转
substr(字符串名字，开始，结束):截取字符串的一部分
mb_substr(): 截取字符串（中文）

数组相关函数

1.array(); 创建数组
2.rand(arr,[number]); 从数组中随机的选出一个或多个元素，并返回键名
3.replace(arr1,[arr2]); 使用后面数组的值替换第一个数组的值
4.merge(arr1,arr2,arr3); 将一个或多个数组合并为一个新数组
5.slice(arr,start,[length],[preserve]); 返回数组中选定的部分，也叫截取数组
6.splice(arr1,start,[length],[arr2]); 把数组中指定元素的值去掉，并用其他值替代

7.product(arr); 计算数组中所有值的乘积
8.sum(arr); 返回数组中所有值的和
9.value(arr); 返回数组中所有的值
10.count(arr,mode); 返回数组中元素的数目,第二个参数可设置1或0，默认是0不计算多维数组中的所有元素，1递归的计算数组中的所有元素个数。
11.shift(arr); 删除数组第一个元素。返回被删除元素
12.unshift(arr,val1,val2); 在数组开头插入一个或多个元素。返回新数组中元素的个数
13.pop(arr); 出栈，删除数组末尾最后一个元素。返回被删除的数组
14.push(arr,arr2,arr3); 入栈，向数组末尾插入一个或多个元素。返回新数组元素的个数
15.unique(arr); 删除数组中重复的值，返回过滤后的数组

16.key_exists(key,arr); 检查指定的键名是否存在于数组中

17.keys(arr); 返回数组中所有的键名

18.search(val,arr,[false/true]); 在数组中搜索给定的值，并返回相应的键名

时间戳函数

mktime(时，分，秒，月，日，年): 生成一个时间戳

DateTime对象

//增加减少时间间隔

$datetime -> modify('+1 day'); 加一天

$datetime -> modify('+1 hour'); 加一个小时

//设置日期部分

$datetime ->setDate(年，月，日);

//设置时间部分

$datetime ->setTime(时，分，秒)；

//格式化时间戳

echo $dateTime -> format("Y-m-d H:i:s");\

//获取时间戳

$timestamp = $dateTime -> gatTimestamp();

2.常量

1.常量值被定义后，在脚本的其他任何地方都不能被改变。

2.命名规则和变量类似，严格区分大小写，但无需$符

const和define的区别

1.const不能在条件语句中定义常量

2.const用于类成员变量的定义，define不可以用于类成员变量的定义，可用于全局常量。

3.const可在类中使用，define不能

案列：

<?php
class ceshi {
    const Ceshi = '小猫';
    public function cc()
    {
        define('XM','吃鱼！');
        echo self::Ceshi;
    }
}
$c = new ceshi;
$c->cc();
echo '----';
echo XM;

运行结果：

常量和变量的区别

1.常量前面没有美元符号($)，而且不能有

2.常量可以不用理会变量的作用域在任何地方定义和访问

3.常量一旦定义就不能重新定义或取消定义

4.常量的值只能是标量（字符串、整数、浮点数、布尔值、数组）

获取所有的常量：

get_defined_constants()
 get_defined_constants(true)
 get_defined_constants(true)["user"]

魔术常量

它的值随着它在代码中的位置改变而改变

__LINE__ （文件中的当前行号）

echo '这是第 " ' . __LINE__ . ' " 行';

__FILE__ （文件的完整路径和文件名，包含（盘符）根目录）

echo '该文件的完整路径为 " ' . __FILE__ . ' " ';

__METHOD__ （包含了：命名空间类名函数名）

class MyClass {
 public function myMethod() {
 echo __METHOD__; // 输出：MAOSHU\MyClass::myMethod
 }
 }
 $obj = new MyClass();
 $obj->myMethod();

包含文件

在当前文件内引入其他PHP文件、HTML文件或文本文件等，一般用于包含公共方法，公共页面 等，例如header footer sider等网页通用部分

include 和 require 语句

require 生成一个致命错误（E_COMPILE_ERROR），在错误发生后脚本会停止执行

include 生成一个警告（E_WARNING），在错误发生后脚本会继续执行

include_once 和 require_once 语句

和上面的一样，但他只会调用一次，防止重复调用

3.面向对象

1.面向对象是一种编程思想和方法，它将程序中的数据和操作数据的方法封装在一起，形成"对象"，并通过对象之间的交互和消息传递来完成程序的功能。

2.面向对象编程(OOP)强调数据的封装、继承、多态和动态绑定等特性，使得程序具有更好的可扩展性、可维护性和可重用性。

面向对象编程的三个主要特性

1.封装：指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。 通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装。

2.继承：指可以创建一个新的类，该类继承（extends）了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。

3.多态：指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象的统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。在 PHP 中，多态可以通过实现接口（interface）和使用抽象类（abstract class）来实现。

关键字 public、private、protected

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

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

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

__construct 构造函数

1.构造函数是一种特殊的方法，在创建一个新对象时，它会被自动调用。

2.它可以用来初始化对象的属性或执行其他必要的操作

3.没有返回值

案列：

<?php


class Animal
{
    public $name;
    public $birth;
    public $age;

    public function __construct($name, $birth)
    {
        $this->name = $name;
        $this->birth = $birth;
        $days = (time() - strtotime($this->birth)) / 3600 / 24;
        $this->age = floor($days);
    }

    public function eat()
    {
        echo $this->name . " 在吃饭.";
    }
}
$cat = new Animal("猫仔","2023-05-23");
echo $cat->name;
echo ' -- ';
echo $cat->birth;
echo ' -- ';
echo $cat->age;

运行结果：

__destruct 析构函数

1.析构函数是一种特殊的方法，它在对象被销毁时自动调用

2.它可以用来执行一些清理操作，例如释放资源或关闭数据库连接。

3.当对象不再被引用或脚本执行结束时，析构函数会被自动调用。

static 静态变量和 self

「静态」指的是无需对类进行实例化，就可以直接调用这些属性和方法 所有对静态变量进行的操作都会对所有对象起作用

public static $cat = "小猫";
 echo self::$cat;

类常量

静态属性与类常量相似，唯一的区分是类常量不可以更改，静态属性可以更改使用场景：所有的对象共用一个属性

const XIAOMAO= "小猫";
 echo self::XIAOMAO;

static 静态方法

1.可以调用静态方法、静态变量

2.可以调用非静态方法、非静态变量

public function eat() {
 echo $this->name." 在吃饭.";
 }
 public static function say() {
 echo (new self)->eat();
 }

类的继承（extends）

指可以创建一个新的类，该类继承（extends）了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。

注意：继承不一定能访问

案例：

class Animal {
    protected $name;
    public function __construct($name) {
        $this->name = $name;
    }
    public function eat() {
        echo $this->name . " 在吃饭.";
    }
}
class Cat extends Animal {
    public function meow() {
        echo $this->name . " 在喵呜.";
    }
}
$cat = new Cat("Tom");
$cat->eat();  // 继承自父类 Animal 的方法
echo  PHP_EOL;
$cat->meow();  // 子类 Cat 自己的方法

运行代码：

方法和属性重写

如果从父类继承的方法或属性不能满足子类的需求，可以对其进行改写

final 关键字

1.防止类被继承

2.防止类的方法被重写

如果在一个类前加final，那么这个类就不能被继承；

final class myClass {
 // 类的内容
}

如果在一个方法前加final，那么这个方法就不能被重写

final public function eat() {
 echo $this->name . " 在吃饭.";
}

注意：final不能用于属性

调用父类方法

parent::

parent::__construct()

静态延迟绑定 static

是指在运行时根据实际调用的类来确定静态方法或属性的绑定

语法： static::$name

案例：

class Animal {
    protected static $name="小动物";
    public static function eat() {
        echo self::$name. " 在吃饭.";
        echo ' ---- ';
        echo static::$name. " 在吃饭.";
    }
}
class Cat extends Animal {
    protected static $name="小猫";
}
Animal::eat();
echo PHP_EOL;
Cat::eat();

运行代码：

类的多态

1.多态性允许不同类的对象对相同的消息作出不同的响应。

2.多态性通过方法重写（覆盖）和方法重载来实现。

3.需要注意的是，多态性只适用于继承关系的类。子类必须重写父类的方法才能实现多态性。

案例：

class Animal {
    protected $name="动物";
    public function makeSound() {
        echo "$this->name 在吼叫。";
    }
}
class Dog extends Animal {
    protected $name="小狗";
    public function makeSound() {
        echo "$this->name 在汪汪。";
    }
}
class Cat extends Animal {
    protected $name="小猫";
    public function makeSound() {
        echo "$this->name 在喵喵。";
    }
}
$animal = new Animal();
$dog = new Dog();
$cat = new Cat();
$animal->makeSound();
echo PHP_EOL;
$dog->makeSound();
echo PHP_EOL;
$cat->makeSound();

运行代码：

方法重载

1.方法重写是指子类重写父类的方法，以改变方法的实现细节。

2.方法重载是指在同一个类中根据参数个数或类型不同来实现不同功能。

案例：

//    $args = func_get_args(); //返回函数组成的数组
//    $numArgs = func_num_args(); //返回数组数量
class Animal {
    public function makeSound() {
        echo "动物在吼叫";
    }
}
class Cat extends Animal {
    public function makeSound() {
        // $args = func_get_args();
        $numArgs = func_num_args();
        switch($numArgs){
            case 2:
                echo '执行参数个数为2的事件';
                break;
            case 3:
                echo '执行参数个数为3的事件';
                break;
            default:
                echo '执行默认事件';
        }
    }
}
// $animal = new Animal();
$cat = new Cat();
$cat->makeSound("测试","2");

运行代码：

接口和抽象类

interface(接口)

implements （实现）

接口是指一组方法的集合，不是类，不能被实例化。

1.可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容

2.只可以使用public

案例：

interface Animals {
    const XIAO = "小猫";
    public function eat();
    public function sleep($hours);
    public static function jump();
}
class Cat implements Animals {
    public function eat() {
        echo "Cat 在吃饭.";
    }
    public function sleep($hours) {
        echo "Cat 要睡 $hours 小时.";
    }
    public static function jump(){
        echo '跳跳跳';
    }
}
$cat = new Cat();
$cat->eat();
echo PHP_EOL;
$cat->sleep(18);
echo PHP_EOL;
echo Cat::XIAO;
echo Cat::jump();

运行代码：

抽象类

1.抽象类是一种特殊的类，只能被继承，不能被实例化

2.抽象类用于定义一组相关的方法，但这些方法的具体实现由继承它的子类来完成。

3.子类继承抽象类后，必须实现抽象类中的所有抽象方法。

4.抽象类可以包含抽象方法和普通方法

语法：

abstract class Animals{
 }

抽象方法

1.抽象方法是没有具体实现的方法，只有方法的声明，而不需要方法体。

2.抽象方法只能存在于抽象类中。

3.可以使用protected，但不能使用private私有。

语法：

abstract public function xxx();
 abstract protected function xxx();

案例：

abstract class Animals
{
    abstract public function eat();
    abstract protected function sleep($hours);
    public function play()
    {
        echo '玩耍';
    }
}
class Cat extends Animals
{
    public function eat()
    {
        echo "Cat 在吃饭 ";
    }
    protected function sleep($hours)
    {
        echo "Cat 要睡 $hours 小时.";
    }
}
$cat = new Cat();
$cat->eat();
//$cat->sleep(12);
echo PHP_EOL;
$cat->play();

运行代码：

抽象类与接口的区别

1. 抽象类可以包含非抽象方法的实现，而接口只能包含方法的声明，没有方法的实现。

2. 类只能继承一个抽象类，但可以实现多个接口。

3. 抽象类可以有构造函数，而接口不能有构造函数。

4. 抽象类中的方法可以有public、protected和private访问修饰符，而接口中的方法只能是 public。

5. 子类继承抽象类时，必须实现抽象类中的所有抽象方法，否则子类也必须声明为抽象类。子类实现接口时，必须实现接口中的所有方法。

trait 代码复用

1.解决类的单一继承问题

2.可同时使用多个trait，用逗号隔开

3.把常用的、通用的代码抽离出来，写成trait

语法：

 trait A{
 }
 trait B{
 }
 class C {
 use A,B;
 }

和类的继承非常像，但是trait里面不能有类常量，且trait不能被实例化

特点：

1.trait中可使用抽象方法

2.trait中可使用静态属性和静态方法

3.trait中可使用其他trait

4.trait中可使用parent

案例：

class MainClass{
    public function main()
    {
        echo '这是主方法的'.__METHOD__;
    }
}
trait Animal {
    public function eat() {
        parent::main();
        echo $this->name . " 在吃饭.";
        echo __TRAIT__;
    }
}
class Cat extends MainClass {
    use Animal;
    protected $name;
    public function __construct($n) {
        $this->name = $n;
    }
    public function meow() {
        echo $this->name . " 在喵呜.";
        echo __TRAIT__;
    }
}
$cat = new Cat("Tom");
//var_dump($cat);
$cat->eat();  // 继承自父类 Animal 的方法
echo PHP_EOL;
$cat->meow();  // 子类 Cat 自己的方法

运行代码：

同名冲突

当一个类同时引入了多个Trait，并且这些Trait中存在同名方法时，就会产生方法冲突

insteadof （替换）

as （别名）

案例：

trait A
{
    public function eat(){
        echo '这是A的';
    }
}
trait B
{
    public function eat(){
        echo '这是B的';
    }
}
class T{
    use A,B{
        A::eat insteadof B;
        B::eat as Beat;
    }
}
$t = new T;
$t->eat();
echo PHP_EOL;
$t->Beat();

运行代码：

网络请求

1.主要用到了 $_GET 和表单 $_POST 超全局变量，分别对应两种不同的请求方式

2.GET请求和POST请求是两种常用的HTTP请求方法，用于从客户端向服务器发送数据

GET请求：

通过URL（网址）参数将数据附加在URL上发送给服务器。这些参数以键值对的形式出现在URL 的末尾，使用问号"?"将URL和参数分隔开。

POST请求：

将数据作为请求的主体发送给服务器，而不是附加在URL上。这使得POST请求更适合发送敏感数据或超长大段内容，例如表单中的密码、博客文本内容等。

区别

1‘GET参数对任何人都是可见的，POST参数对任何人都是不可见的

2.GET对发送信息的量也有限制，不适合大型的变量值

3.POST对发送信息的量没有限制

超全局变量

语法： $_REQUEST

 $_REQUEST 变量包含了$_GET 、$_POST 和 $_COOKIE 的内容
$_SERVER 获取请求方式

htmlspecialchars()函数

用于将字符串中的特殊字符转换为HTML实体，以避免在HTML文档中引起解析错误或安全漏洞。

1." （双引号）成为 "

2.' （单引号）成为 '

3.< （小于）成为 <

4.> （大于）成为 >

jiangxiaochen_

关注

4
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
PHP基础课程文档总结

浏览器发起访问（输入域名）—DNS 解析域名—服务器电脑—服务网站。
复制链接

扫一扫

PHP基础课程文档总结

1.基础语法

PHP换行符

全局变量 global 用法

组合比较符

逻辑运算符

字符串相关函数

数组相关函数

时间戳函数

DateTime对象

2.常量

const和define的区别

常量和变量的区别

魔术常量

包含文件

include 和 require 语句

include_once 和 require_once 语句

3.面向对象

面向对象编程的三个主要特性

关键字 public、private、protected

__construct 构造函数

__destruct 析构函数

static 静态变量 和 self

类常量

static 静态方法

类的继承（extends）

方法和属性重写

final 关键字

调用父类方法

静态延迟绑定 static

类的多态

方法重载

接口和抽象类

抽象类

抽象方法

抽象类与接口的区别

trait 代码复用

同名冲突

网络请求

GET请求：

POST请求：

区别

超全局变量

“相关推荐”对你有帮助么？

static 静态变量和 self