我感觉php似乎在解构自己，让php能用php解释清楚

>?php

class CustomArray implements ArrayAccess, Traversable, Iterator, Serializable, Countable {
    private $container = [];
    private $position = 0;

    public function __construct(array $initialData = []) {
        $this->container = $initialData;
        $this->rewind();
    }

    // ArrayAccess methods
    public function offsetExists($offset): bool {
        return isset($this->container[$offset]);
    }

    public function offsetGet($offset): mixed {
        return isset($this->container[$offset]) ? $this->container[$offset] : null;
    }

    public function offsetSet($offset, $value): void {
        if (is_null($offset)) {
            $this->container[] = $value;
        } else {
            $this->container[$offset] = $value;
        }
    }

    public function offsetUnset($offset): void {
        unset($this->container[$offset]);
    }

    // Traversable and Iterator methods
    public function current(): mixed {
        return $this->container[$this->position];
    }

    public function key(): mixed {
        return $this->position;
    }

    public function next(): void {
        ++$this->position;
    }

    public function rewind(): void {
        $this->position = 0;
    }

    public function valid(): bool {
        return isset($this->container[$this->position]);
    }

    // Serializable method
    public function serialize(): string {
        return serialize($this->container);
    }

    public function unserialize(string $data): void {
        $this->container = unserialize($data);
        $this->rewind();
    }

    // Countable method
    public function count(): int {
        return count($this->container);
    }

    // Additional utility methods
    public function add($value): void {
        $this->container[] = $value;
    }

    public function remove(int $index): void {
        array_splice($this->container, $index, 1);
    }

    public function toArray(): array {
        return $this->container;
    }

    // Print container content for debugging
    public function printContainer(): void {
        print_r($this->container);
    }

    // Magic method to convert object to string
    public function __toString(): string {
        return json_encode($this->container);
    }

    // Convert to array for compatibility with PHP array functions
    public function toCompatibleArray(): array {
        return $this->container;
    }

    // More utility methods
    public function map(callable $callback): self {
        $newContainer = array_map($callback, $this->container);
        return new self($newContainer);
    }

    public function filter(callable $callback): self {
        $newContainer = array_filter($this->container, $callback);
        return new self($newContainer);
    }

    public function reduce(callable $callback, $initial = null) {
        return array_reduce($this->container, $callback, $initial);
    }

    public function keys(): self {
        $keys = array_keys($this->container);
        return new self($keys);
    }

    public function values(): self {
        $values = array_values($this->container);
        return new self($values);
    }

    public function merge(self ...$arrays): self {
        $merged = $this->toArray();
        foreach ($arrays as $array) {
            $merged = array_merge($merged, $array->toArray());
        }
        return new self($merged);
    }

    public function slice(int $start, int $length = null): self {
        $sliced = array_slice($this->container, $start, $length);
        return new self($sliced);
    }

    public function pop() {
        return array_pop($this->container);
    }

    public function shift() {
        return array_shift($this->container);
    }

    public function push(...$values): int {
        return array_push($this->container, ...$values);
    }

    public function unshift(...$values): int {
        return array_unshift($this->container, ...$values);
    }

    public function inArray($needle, bool $strict = false): bool {
        return in_array($needle, $this->container, $strict);
    }

    public function search($needle, bool $strict = false) {
        return array_search($needle, $this->container, $strict);
    }
}

// 使用 CustomArray
$list = new CustomArray(["one", "two", "three"]);

// Using ArrayAccess
var_dump(isset($list[1])); // 检查索引 1 是否存在
var_dump($list[1]);         // 获取索引 1 的值
unset($list[1]);            // 删除索引 1 的值
var_dump(isset($list[1])); // 再次检查索引 1 是否存在
$list[1] = "new value";    // 设置索引 1 的新值
var_dump($list[1]);         // 获取索引 1 的新值

// Using Iterator
echo "\nIterator 输出:\n";
foreach ($list as $key => $value) {
    echo "$key => $value\n";
}

// Using Serializable
$serializedList = serialize($list);
echo "\n序列化后的字符串:\n";
echo $serializedList . "\n";

$unserializedList = unserialize($serializedList);
echo "\n反序列化后的内容:\n";
$unserializedList->printContainer();

// Using Countable
echo "\nCountable 输出:\n";
echo "Size: " . count($list) . "\n";

// 兼容 PHP 数组函数
echo "\n使用 PHP 数组函数:\n";
$arrayFunctions = [
    'array_map',
    'array_filter',
    'array_reduce',
    'array_keys',
    'array_values',
    'array_merge',
    'array_slice',
    'array_pop',
    'array_shift',
    'array_push',
    'array_unshift',
    'in_array',
    'array_search',
];

foreach ($arrayFunctions as $func) {
    try {
        $result = call_user_func($func, $list->toCompatibleArray(), ...['A value' => 'B value']);
        if (!is_object($result)) {
            echo "$func 输出:\n";
            print_r($result);
        } else {
            echo "$func 输出 (对象):\n";
            $result->printContainer();
        }
    } catch (\Throwable $e) {
        echo "$func 抛出异常: " . $e->getMessage() . "\n";
    }
}

// 使用新增的实用方法
echo "\n使用新增的实用方法:\n";
$mappedList = $list->map(function($item) { return strtoupper($item); });
echo "Mapped List:\n";
$mappedList->printContainer();

$filtered = $mappedList->filter(function($item) { return strlen($item) > 3; });
echo "Filtered List:\n";
$filtered->printContainer();

$reduced = $filtered->reduce(function($carry, $item) { return $carry . ', ' . $item; }, '');
echo "Reduced Result: $reduced\n";

$keys = $list->keys();
echo "Keys:\n";
$keys->printContainer();

$values = $list->values();
echo "Values:\n";
$values->printContainer();

$merged = $list->merge(new CustomArray(['four', 'five']));
echo "Merged List:\n";
$merged->printContainer();

$sliced = $merged->slice(1, 3);
echo "Sliced List:\n";
$sliced->printContainer();

$popped = $merged->pop();
echo "Popped Value: $popped\n";
echo "After Pop:\n";
$merged->printContainer();

$shifted = $merged->shift();
echo "Shifted Value: $shifted\n";
echo "After Shift:\n";
$merged->printContainer();

$pushedCount = $merged->push('six', 'seven');
echo "Pushed Count: $pushedCount\n";
echo "After Push:\n";
$merged->printContainer();

$unshiftedCount = $merged->unshift('zero', 'one');
echo "Unshifted Count: $unshiftedCount\n";
echo "After Unshift:\n";
$merged->printContainer();

$containsOne = $merged->inArray('one');
echo "Contains 'one': " . ($containsOne ? 'true' : 'false') . "\n";

$searchIndex = $merged->search('three');
echo "Search 'three': " . ($searchIndex !== false ? $searchIndex : 'not found') . "\n";