PHP学习

基本语法

变量名需要加$
java中的.被->代替
拼接用的.

开始

<? 
$age = 18;
echo ”我今年{$age}岁“
?>

• PHP 中单引号包裹的字符串不会解析变量，会原样输出字符串内容，双引号会解析变量。
• 注释使用：# 或 // 或 /* */
• 命名：变量名区分大小写。关键字，函数和类的名称不区分大小写。

变量

$a = 100; // 全局变量
define("SITE_URL", "/");	// 常量
function multiply ($value) {	// 函数参数
	$b = 'aaa'	// 局部变量
	static $count = 0;	// 静态变量
	global $c = 10	// 全局变量
    $value = $value * 10;
    unset($a);	// 删除变量(注意不能删除全局变量)
    isset($a);	// 判断变量是否存在（注意不能判断全局变量）
    return $value;
   }

特殊变量

$a = 'name';  // $a 的值是字符串 'name'
$$a = '张三';  // 相当于定义了 $name = '张三'
echo $name;   // 输出：张三
echo $$a;     // 输出：张三（与上面等价）
//首先解析 $a 的值，将其作为一个新的变量名;然后 $$a 就等同于这个新变量名所对应的变量

常量

PHP_EOL 换行符

定义常量：define("USERAPP","我是常量");

const SITE_NAME = "我是常量";
优先使用 const：语法更简洁，支持类常量和数组，有作用域限制，编译时解析效率更高。
仅在特殊场景使用 define()：如需要在条件语句中定义常量，或兼容旧版本 PHP（5.6 以下）。
两者定义的常量均为全局有效（类常量除外），且一旦定义不能被修改或删除。

魔术常量

__LINE__：返回文件的当前行号。
__FILE__：返回正在执行的PHP文件的完整路径和名称。
__DIR__：返回文件的目录。
__FUNCTION__：返回当前函数的名称。
__CLASS__：返回当前类的名称。
__METHOD__：返回当前类方法的名称。
__NAMESPACE__：返回当前命名空间的名称。
__TRAIT__：返回当前使用的trait的名称。

数据类型

字符串（）：‘Hello world!’
整数（）：123
浮点数（）：1.234
布尔值（）：true
数组（）： array(“Red”, “Green”, “Blue”)
对象（）： new greeting
资源（）：fopen(“note.txt”, “r”);
NULL（）：null

DOF定界符

<?php
echo <<<EOF
123
EOF;
?>

数组

索引数组:

$colors = array("Red", "Green", "Blue");

关联数组:

$ages = array("Peter"=>22, "Clark"=>32, "John"=>28);

多维数组：
a[
b[],c[]
]

合并数组：
使用+
在索引相同时，谁在+前面，谁就是头。

使用array_merge( $a,$b)
在索引相同时，优先数据最新的。

函数：

字符串

数据类型转换

数字转字符串：strval(xxx); (string)xxx; 【注意：布尔类型，true为1，false为null】
字符串转int：intval(xxx);(int)xxx;(integer)xxx;
字符串转浮点型：floatval(xxx);(float)xxx;(double)xxx;
字符串转布尔：boolval(xxx);(bool)xxx;(boolean)xxx;【注意：只有0和空为false】

运算符

算数运算符：+ - * / %
赋值运算符：= += -= *= /= %= **.=【连接字符串】**
递增/递减运算符：$a++ $a-- ++$a --$a先+后返回
逻辑运算符：and or && || ! xor【一样一个】
字符串运算符：.【级联】 .=【串联分配】
数组运算符：+ == === != <> !==
空合并运算符：??【判断一个变量是否未定义或者为null，如果未定义或为nul，则返回指定的默认值;否则返回该变量的值】
组合比较符：<=>【值为1 0 -1，就是看比较值的结果】
等于比较== ===【双等：只比较值；三等：深度比较类型】

条件语句

if else语句：

<?php
if(条件一){
    xxx
} elseif(条件一){
    exxx
} else{
    xxx
}
?>

switch…Case语句

<?php
switch($today){
    case "Mon":
        xxxx
        break;
    default:
        xxx
        break;
}
?>

循环语句

while循环：

while（条件）{ 
    //要执行的代码
}

do…while 循环:

do {
    //要执行的代码
}
while（条件）;

for 循环:

for（initialization;condition;increment）{ 
    //要执行的代码
}

foreach 循环:

foreach（$array as $key => $value）{ 
    //要执行的代码
}

导入

include
require

函数的基本创建

    declare(strict_types=1);    // 严格模式，因为php是没有强数据类型的，所以可以通过declare进行约束，必须强类型
    function aa(int $a, string $b){
        echo "我是$b, 我的年龄是$a.岁\n";
    }
    aa(18, 16)

时间

内置函数：

内置对象：

$dateyest1 = new DateTime('2024-12-24');
$dateyest2 = new DateTime('2024-11-24');

$dateyest1->modify('-1 day');    // 减去一天
$dateyest1->add(new DateInterval('P1D'));    // 加上一天
$dateyest1->sub(new DateInterval('P1D'));    // 减去一天
echo $dateyest1->format('Y-m-d');    // 格式化日期
$dateyest3 = $dateyest1->diff($dateyest2);    // 计算两个日期之间的差异

echo $dateyest3->format('%a');    // 输出相差的天数

面向对象

权限：

public
private
protected

get/set

    public function getName(){
        return $this->name;
    }
    public function setName($name){
        $this->name = $name;
    }

构造方法

构造方法（Constructor） ：是类中的一种特殊方法，用于在创建类的实例（对象）时自动执行，主要的主要作用是初始化对象的属性或执行必要的准备工作。

public function __construct($name, $age) {
    // 初始化属性
      $this->name = $name;
      $this->age = $age; 
  }
$person = new Person("张三", 25);  // 调用

析构函数

析构函数（Destructor）： 是类中的特殊方法，与构造方法相反，它会在对象被销毁（从内存中释放）时自动执行，主要用于释放资源、清理操作（如关闭数据库连接、释放文件句柄等）。

    // 析构方法：关闭文件（释放资源）
    public function __destruct() {
      if ($this->file) {
          fclose($this->file);
          echo "文件已关闭（析构函数执行）<br>";
      }
  }

静态

静态变量（Static Variables） ：是在函数或类中使用 static 关键字声明的变量，其特点是值不会随函数 / 方法的调用结束而销毁，而是会保留上次执行后的结果，下次调用时直接使用该值。

public static $cat	// 创建
self::$cat	// 函数内调用
类名::$cat	// 函数外调用

parent::$cat	// 访问父类

继承

继承： 是面向对象编程（OOP）的核心特性之一，允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码复用和扩展。子类可以复用父类的功能，同时可以添加新功能或重写父类的方法。

class Child extends Parent {
   // 代码部分
}

**重写：**子类可以定义与父类同名的方法，覆盖父类的实现（需保持方法签名兼容）。若需调用父类的原方法，使用 parent::方法名()。

class Animal {
    public function makeSound() {
        echo "动物发出声音<br>";
    }
}

class Cat extends Animal {
    // 重写父类的 makeSound 方法
    public function makeSound() {
        parent::makeSound(); // 调用父类的方法
        echo "猫咪喵喵叫<br>"; // 新增子类逻辑
    }
}

final： 固定某个类或方法的实现，防止被修改或扩展，确保代码的稳定性。

• 修饰类 → 禁止被继承
• 修饰方法 → 禁止被重写

多态

多态（Polymorphism） ：是面向对象编程（OOP）的核心特性之一，指不同类的对象对同一方法调用做出不同响应的能力。简单来说，就是 “同一操作作用于不同对象，产生不同结果”。

// 父类：定义统一的方法接口
class Animal {
    // 父类的抽象方法（也可以是普通方法）
    public function makeSound() {
        echo "动物发出声音<br>";
    }
}

// 子类1：重写父类方法
class Dog extends Animal {
    public function makeSound() {
        echo "汪汪汪<br>";
    }
}

// 子类2：重写父类方法
class Cat extends Animal {
    public function makeSound() {
        echo "喵喵喵<br>";
    }
}
$dog = new Dog();
$cat = new Cat();
makeAnimalSound($dog);  // 输出：汪汪汪
makeAnimalSound($cat);  // 输出：喵喵喵

方法的重载： 动态处理未定义的方法调用，通过魔术方法实现对不同参数的灵活响应。
PHP 通过两个魔术方法实现 “重载” 效果，用于处理对不存在的方法的调用：

• __call()：当调用对象中不存在的非静态方法时触发
• __callStatic()：当调用类中不存在的静态方法时触发
  这两个方法会接收两个参数：
• • 第一个参数：被调用的方法名（字符串）
• • 第二个参数：调用方法时传递的参数数组

接口与抽象类

接口：是纯粹的行为规范，使用 interface 关键字声明。
抽象类：是包含抽象方法的类，使用 abstract 关键字声明。它不能被直接实例化，只能作为父类被继承，子类必须实现其所有抽象方法。
抽象方法：是一种只有声明（方法名、参数、返回值类型）而没有具体实现的方法，必须包含在抽象类中，用于强制子类实现特定的功能。

interface Runnable {
    public function run();
}
aa implements Runnable {
	 public function run(){};
}

// 抽象类
abstract class Animal {
    // 普通属性
    protected $name;
    
    // 构造方法（普通方法）
    public function __construct($name) {
        $this->name = $name;
    }
    
    // 抽象方法（子类必须实现）
    abstract public function makeSound();
    
    // 普通方法（有具体实现）
    public function eat() {
        echo "{$this->name}在吃东西<br>";
    }
}

// 子类继承抽象类，必须实现抽象方法
class Dog extends Animal {
    public function makeSound() {
        echo "{$this->name}汪汪叫<br>";
    }
}

$dog = new Dog("旺财");
$dog->makeSound(); // 输出：旺财汪汪叫
$dog->eat();       // 输出：旺财在吃东西

trait

Trait ：是一种代码复用机制，用于解决单继承限制（一个类只能继承一个父类），允许在多个不相关的类中共享方法。它既不是类也不是接口，更像是 “方法集合”，可以被类 “引入” 并直接使用其中的方法。

trait AA{}
use AA

命名空间

命名空间（Namespace） :是一种用于解决命名冲突的机制，它通过将代码元素（如变量、函数、类等）划分到不同的逻辑分组中，避免同名标识符之间的冲突。

用 namespace 定义，use 导入，as 指定别名

注意：

• 必须是第一行

    namespace ch1\test\ms\index;
    $a = 100;
    function add(){
        return '我无敌';
    }
    const MNAM = '更好';

    echo add();
    echo \ch1\test\ms\index\add();