PHP中如何实现函数特定对象参数不可被内部修改？

PHP 本身没有原生语法支持示例中"immutable"形式的参数修饰符，对象默认按引用传递是语言层面的固定设计，但可以通过下面两种可落地的变通方案实现需求，两种方案都满足「仅针对特定函数的特定参数生效、标识清晰无歧义」的要求，不存在注释和逻辑不一致的问题。

方案1：防御性克隆（修改不影响外部原对象，无异常） #

核心逻辑是对标记为不可变的参数，在方法入口处主动克隆一份副本，方法内部所有操作都作用在副本上，完全不触碰外部原对象。可以通过PHP原生的Attribute（PHP 8.0及以上版本支持）做显式标记，代码可读性极强。

<?php
// 定义不可变参数的标记属性
#[Attribute(Attribute::TARGET_PARAMETER)]
class Immutable {}

class Foo {
    private $a;
    public function getA() {
        return $this->a;
    }
    public function setA($a) {
        $this->a = $a;
    }   
}

class Bar {
    // 通过__call魔术方法自动处理标记为Immutable的参数，无需每个方法手动写克隆逻辑
    public function __call($name, $arguments) {
        $ref = new ReflectionMethod(Bar::class, $name);
        foreach ($ref->getParameters() as $idx => $param) {
            // 识别加了Immutable标记的参数，替换为克隆副本
            if (!empty($param->getAttributes(Immutable::class))) {
                if (is_object($arguments[$idx])) {
                    $arguments[$idx] = clone $arguments[$idx];
                }
            }
        }
        return call_user_func_array([$this, $name], $arguments);
    }

    public function test1(Foo $f1, Foo $f2) {
        $f1->setA(2);
        $f2->setA(2);
    }
    
    // 给$f2添加Immutable标记，明确标识该参数在方法内的修改不会影响外部原对象
    public function test2(Foo $f1, #[Immutable] Foo $f2) {
        $f1->setA($f2->getA());
    }
    
    public function test3(Foo $f1, #[Immutable] Foo $f2) {
        $f1->setA(3);
        $f2->setA(3); // 这里修改的是克隆副本，外部原$f2不会发生变化
    }
}

// 功能测试
$foo1 = new Foo();
$foo1->setA(1);
$foo2 = new Foo();
$foo2->setA(1);

$bar = new Bar();
$bar->test1($foo1, $foo2);
var_dump($foo1->getA(), $foo2->getA()); // 输出int(2) int(2)，两个对象都被正常修改

$foo1->setA(1);
$foo2->setA(1);
$bar->test2($foo1, $foo2);
var_dump($foo1->getA(), $foo2->getA()); // 输出int(1) int(1)，$f2未被修改

$foo1->setA(1);
$foo2->setA(1);
$bar->test3($foo1, $foo2);
var_dump($foo1->getA(), $foo2->getA()); // 输出int(3) int(1)，$f2保持原值不变

方案优缺点 #

• 优点：实现简单，不会抛出异常打断业务流程，标记属于PHP原生语法范畴，比注释可靠性高，仅对加了标记的参数生效，无全局影响。
• 缺点：如果对象包含嵌套资源、引用类型属性，默认的浅克隆可能出现拷贝不完全的问题，需要对应类实现__clone方法完成深拷贝逻辑。

方案2：不可变代理（修改时直接抛出异常） #

如果希望一旦尝试修改标记为不可变的参数就直接抛出错误，提前发现非法修改逻辑，可以给被标记的参数套一层不可变代理，拦截所有写操作。

<?php
#[Attribute(Attribute::TARGET_PARAMETER)]
class Immutable {}

// 通用不可变代理类
class ImmutableProxy {
    private object $target;
    public function __construct(object $target) {
        $this->target = $target;
    }
    // 拦截所有方法调用，写方法直接抛出异常
    public function __call($name, $arguments) {
        if (str_starts_with($name, 'set')) {
            throw new RuntimeException("Attempt to modify immutable parameter");
        }
        return call_user_func_array([$this->target, $name], $arguments);
    }
    // 如需拦截公开属性直接修改，可额外实现__set、__unset方法抛异常
}

class Foo {
    private $a;
    public function getA() {
        return $this->a;
    }
    public function setA($a) {
        $this->a = $a;
    }   
}

class Bar {
    public function __call($name, $arguments) {
        $ref = new ReflectionMethod(Bar::class, $name);
        foreach ($ref->getParameters() as $idx => $param) {
            if (!empty($param->getAttributes(Immutable::class))) {
                if (is_object($arguments[$idx])) {
                    // 将原对象替换为不可变代理
                    $arguments[$idx] = new ImmutableProxy($arguments[$idx]);
                }
            }
        }
        return call_user_func_array([$this, $name], $arguments);
    }

    public function test2(Foo $f1, #[Immutable] Foo $f2) {
        $f1->setA($f2->getA()); // 读操作正常执行
    }
    public function test3(Foo $f1, #[Immutable] Foo $f2) {
        $f1->setA(3);
        $f2->setA(3); // 此处直接抛出RuntimeException，提示非法修改不可变参数
    }
}

方案优缺点 #

• 优点：能第一时间发现非法修改逻辑，避免隐式Bug，标记清晰无歧义。
• 缺点：需要根据项目自身的方法命名规则调整代理拦截逻辑，比如部分写操作方法不以set开头的场景，需要额外配置拦截规则；如果类存在公开可写属性，还需要在代理类中实现__set、__unset方法拦截属性修改操作。

补充：PHP 8.2 新增的readonly属性、readonly类是针对类定义层面的全局不可变约束，一旦声明所有实例都不可修改，无法实现「仅在特定方法的参数维度临时标记为不可变」的效果，不符合需求。

如果不想使用__call魔术方法做自动处理，也可以手动在方法入口对标记参数做克隆/代理替换，逻辑完全一致。

内容的提问来源于stack exchange，提问作者cr001