function sum() {
    $args = func_get_args();
    return array_sum($args);
}

echo sum(1, 2, 3, 4); // 輸出 10

function sum(...$numbers) {
    return array_sum($numbers);
}

echo sum(1, 2, 3, 4); // 輸出 10

function multiply($multiplier, ...$numbers) {
    return array_map(function($number) use ($multiplier) {
        return $number * $multiplier;
    }, $numbers);
}

print_r(multiply(2, 1, 2, 3, 4)); // 輸出 [2, 4, 6, 8]

// ? 問題：參數(shù)類型不可控
function concatenate(...$strings) {
    return implode('', $strings);
}

// 傳遞非字符串參數(shù)
echo concatenate('a', 1, 'b', true, null); // 輸出 'a1b1'
// 可能產(chǎn)生意外結(jié)果：true轉(zhuǎn)為'1'，null轉(zhuǎn)為''

// ? 問題：多個(gè)固定參數(shù)與可變參數(shù)混用時(shí)順序混亂
function query($table, ...$conditions) {
    // $conditions 可能包含不同類型的值
    // 難以確定每個(gè)條件的具體含義
}

query('users', 'id > 5', ['status' => 'active'], 'LIMIT 10');
// 條件格式不統(tǒng)一，難以解析

// ? 問題：頻繁調(diào)用時(shí)性能開銷
function processMany(...$items) {
    // 每次調(diào)用都需要?jiǎng)?chuàng)建參數(shù)數(shù)組
    return array_map('strtoupper', $items);
}

// 在大循環(huán)中調(diào)用性能差
for ($i = 0; $i < 10000; $i++) {
    processMany('a', 'b', 'c'); // 重復(fù)創(chuàng)建參數(shù)數(shù)組
}

// ? 問題：不能將引用變量直接傳遞給可變參數(shù)
function incrementValues(&...$values) {
    foreach ($values as &$value) {
        $value++;
    }
}

$a = 1; $b = 2;
// incrementValues($a, $b); // 語法錯(cuò)誤

// ? 問題：可變參數(shù)與默認(rèn)值參數(shù)的位置沖突
function problematic($required, $optional = 'default', ...$rest) {
    // 當(dāng)只傳遞兩個(gè)參數(shù)時(shí)，$optional 會(huì)被使用
    // 但傳遞三個(gè)參數(shù)時(shí)，第二個(gè)參數(shù)會(huì)進(jìn)入$rest
}

problematic('a');           // $optional = 'default', $rest = []
problematic('a', 'b');      // $optional = 'b', $rest = []
problematic('a', 'b', 'c'); // $optional = 'b', $rest = ['c']
// 語義不清晰

// ? 使用類型聲明約束參數(shù)類型
function concatenateStrings(string ...$strings): string {
    return implode('', $strings);
}

// 自動(dòng)類型轉(zhuǎn)換仍然發(fā)生
echo concatenateStrings('a', '1', 'b'); // 'a1b'

// ? 使用嚴(yán)格類型模式
declare(strict_types=1);

function strictConcatenate(string ...$strings): string {
    return implode('', $strings);
}

// strictConcatenate('a', 1, 'b'); // TypeError

class ParameterValidator {
    /**
     * 驗(yàn)證并標(biāo)準(zhǔn)化可變參數(shù)
     */
    public static function validateVariadic(array $args, array $rules): array {
        $validated = [];
        
        foreach ($rules as $index => $rule) {
            if (!isset($args[$index])) {
                if (isset($rule['default'])) {
                    $validated[$index] = $rule['default'];
                } elseif ($rule['required'] ?? false) {
                    throw new InvalidArgumentException("參數(shù){$index}缺失");
                }
                continue;
            }
            
            $value = $args[$index];
            
            // 類型檢查
            if (isset($rule['type'])) {
                $type = $rule['type'];
                $isValid = false;
                
                switch ($type) {
                    case 'string':
                        $isValid = is_string($value);
                        if (!$isValid && ($rule['cast'] ?? false)) {
                            $value = (string)$value;
                            $isValid = true;
                        }
                        break;
                    case 'int':
                        $isValid = is_int($value);
                        if (!$isValid && ($rule['cast'] ?? false)) {
                            $value = (int)$value;
                            $isValid = true;
                        }
                        break;
                    case 'array':
                        $isValid = is_array($value);
                        break;
                    case 'callable':
                        $isValid = is_callable($value);
                        break;
                    default:
                        $isValid = $value instanceof $type;
                }
                
                if (!$isValid) {
                    throw new InvalidArgumentException(
                        "參數(shù){$index}必須是{$type}類型"
                    );
                }
            }
            
            // 值驗(yàn)證
            if (isset($rule['validator'])) {
                if (!$rule['validator']($value)) {
                    throw new InvalidArgumentException(
                        "參數(shù){$index}驗(yàn)證失敗"
                    );
                }
            }
            
            // 值轉(zhuǎn)換
            if (isset($rule['transformer'])) {
                $value = $rule['transformer']($value);
            }
            
            $validated[$index] = $value;
        }
        
        // 處理額外的參數(shù)
        if (isset($rule['allow_extra']) && $rule['allow_extra']) {
            $extraArgs = array_slice($args, count($rules));
            $validated['__extra'] = $extraArgs;
        }
        
        return $validated;
    }
}

// 使用示例
function safeQuery(...$args) {
    $rules = [
        0 => ['type' => 'string', 'required' => true],
        1 => ['type' => 'array', 'default' => []],
        2 => ['type' => 'int', 'default' => 10, 'validator' => fn($v) => $v > 0]
    ];
    
    $validated = ParameterValidator::validateVariadic($args, $rules);
    
    [$table, $conditions, $limit] = array_values($validated);
    
    return "SELECT * FROM {$table} WHERE " . 
           implode(' AND ', $conditions) . 
           " LIMIT {$limit}";
}

// ? 使用 PHP 8 命名參數(shù)
function queryBuilder(
    string $table,
    array $fields = ['*'],
    array $conditions = [],
    int $limit = 100,
    int $offset = 0
) {
    // 實(shí)現(xiàn)
}

// 清晰的使用方式
queryBuilder(
    table: 'users',
    fields: ['id', 'name', 'email'],
    conditions: ['status' => 'active'],
    limit: 50
);

// ? 結(jié)合可變參數(shù)
function advancedQuery(
    string $table,
    array ...$joins  // 可變參數(shù)在最后
) {
    $query = "SELECT * FROM {$table}";
    
    foreach ($joins as $join) {
        [$type, $table2, $on] = $join;
        $query .= " {$type} JOIN {$table2} ON {$on}";
    }
    
    return $query;
}

advancedQuery('users', ['INNER', 'profiles', 'users.id = profiles.user_id']);

// ? 使用參數(shù)對(duì)象封裝復(fù)雜參數(shù)
class QueryParameters {
    private string $table;
    private array $fields;
    private array $conditions;
    private int $limit;
    private int $offset;
    
    public function __construct(array $config = []) {
        $defaults = [
            'table' => '',
            'fields' => ['*'],
            'conditions' => [],
            'limit' => 100,
            'offset' => 0
        ];
        
        $config = array_merge($defaults, $config);
        
        $this->table = $config['table'];
        $this->fields = $config['fields'];
        $this->conditions = $config['conditions'];
        $this->limit = $config['limit'];
        $this->offset = $config['offset'];
    }
    
    // 流暢接口
    public static function create(): self {
        return new self();
    }
    
    public function table(string $table): self {
        $this->table = $table;
        return $this;
    }
    
    public function fields(array $fields): self {
        $this->fields = $fields;
        return $this;
    }
    
    public function where(string $field, $value): self {
        $this->conditions[$field] = $value;
        return $this;
    }
    
    public function limit(int $limit): self {
        $this->limit = $limit;
        return $this;
    }
    
    public function build(): string {
        // 構(gòu)建查詢
        $fields = implode(', ', $this->fields);
        $where = '';
        
        if (!empty($this->conditions)) {
            $conditions = [];
            foreach ($this->conditions as $field => $value) {
                $conditions[] = "{$field} = '{$value}'";
            }
            $where = 'WHERE ' . implode(' AND ', $conditions);
        }
        
        return "SELECT {$fields} FROM {$this->table} {$where} " .
               "LIMIT {$this->limit} OFFSET {$this->offset}";
    }
}

// 使用
$query = QueryParameters::create()
    ->table('users')
    ->fields(['id', 'name', 'email'])
    ->where('status', 'active')
    ->where('age', '>', 18)
    ->limit(50)
    ->build();

// ? 使用數(shù)組參數(shù)代替可變參數(shù)
function processItems(array $items, array $options = []) {
    $defaults = [
        'processor' => 'strtoupper',
        'filter' => null,
        'limit' => null
    ];
    
    $options = array_merge($defaults, $options);
    
    // 應(yīng)用過濾器
    if ($options['filter']) {
        $items = array_filter($items, $options['filter']);
    }
    
    // 應(yīng)用限制
    if ($options['limit']) {
        $items = array_slice($items, 0, $options['limit']);
    }
    
    // 應(yīng)用處理器
    return array_map($options['processor'], $items);
}

// 清晰的使用方式
$result = processItems(
    ['apple', 'banana', 'cherry'],
    [
        'processor' => 'strtoupper',
        'filter' => fn($item) => strlen($item) > 5,
        'limit' => 2
    ]
);

class VariadicOptimizer {
    private static $cache = [];
    
    /**
     * 緩存可變參數(shù)的處理結(jié)果
     */
    public static function memoize(callable $func, ?int $ttl = null) {
        return function(...$args) use ($func, $ttl) {
            $key = self::generateKey($func, $args);
            
            if (isset(self::$cache[$key]) && 
                (!$ttl || (time() - self::$cache[$key]['time']) < $ttl)) {
                return self::$cache[$key]['value'];
            }
            
            $result = $func(...$args);
            self::$cache[$key] = [
                'value' => $result,
                'time' => time()
            ];
            
            return $result;
        };
    }
    
    /**
     * 預(yù)解析參數(shù)模式
     */
    public static function createParser(array $signature) {
        $cacheKey = md5(serialize($signature));
        
        if (!isset(self::$cache[$cacheKey])) {
            self::$cache[$cacheKey] = self::compileParser($signature);
        }
        
        return self::$cache[$cacheKey];
    }
    
    private static function compileParser(array $signature) {
        // 根據(jù)簽名生成優(yōu)化的參數(shù)解析器
        $code = 'return function(...$args) {';
        $code .= '$result = [];';
        
        foreach ($signature as $index => $param) {
            $code .= "if (isset(\$args[$index])) {";
            $code .= "\$result['$param'] = \$args[$index];";
            $code .= "} else {";
            $code .= "\$result['$param'] = null;";
            $code .= "}";
        }
        
        $code .= 'return $result;';
        $code .= '};';
        
        return eval($code);
    }
    
    private static function generateKey(callable $func, array $args): string {
        $funcId = is_string($func) ? $func : spl_object_hash($func);
        return $funcId . ':' . md5(serialize($args));
    }
}

// 使用示例
$optimizedSum = VariadicOptimizer::memoize(function(...$numbers) {
    return array_sum($numbers);
});

// 第一次計(jì)算并緩存
echo $optimizedSum(1, 2, 3, 4); // 10
// 相同參數(shù)直接返回緩存
echo $optimizedSum(1, 2, 3, 4); // 10 (從緩存獲取)

class EfficientVariadic {
    /**
     * 避免在循環(huán)中重復(fù)創(chuàng)建參數(shù)數(shù)組
     */
    public static function batchProcess(array $items, callable $processor) {
        $results = [];
        
        // 批量處理而不是逐個(gè)調(diào)用
        foreach ($items as $item) {
            if (is_array($item)) {
                // 如果已經(jīng)是數(shù)組，直接傳遞
                $results[] = $processor(...$item);
            } else {
                $results[] = $processor($item);
            }
        }
        
        return $results;
    }
    
    /**
     * 使用生成器處理大數(shù)據(jù)集
     */
    public static function streamProcess(iterable $items, callable $processor) {
        foreach ($items as $item) {
            yield $processor(...(array)$item);
        }
    }
}

// 使用
$items = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

$results = EfficientVariadic::batchProcess($items, function(...$numbers) {
    return array_sum($numbers);
});

class PatternMatcher {
    /**
     * 根據(jù)參數(shù)模式執(zhí)行不同邏輯
     */
    public static function match(array $patterns, ...$args) {
        foreach ($patterns as $pattern => $handler) {
            if (self::matchesPattern($pattern, $args)) {
                return $handler(...$args);
            }
        }
        
        throw new InvalidArgumentException('沒有匹配的模式');
    }
    
    private static function matchesPattern(string $pattern, array $args): bool {
        $expectedCount = substr_count($pattern, '*');
        
        if ($expectedCount !== count($args)) {
            return false;
        }
        
        // 簡(jiǎn)單的類型模式匹配
        $patternParts = explode('|', $pattern);
        
        foreach ($args as $index => $arg) {
            $expectedType = $patternParts[$index] ?? '*';
            
            if ($expectedType !== '*') {
                switch ($expectedType) {
                    case 'string':
                        if (!is_string($arg)) return false;
                        break;
                    case 'int':
                        if (!is_int($arg)) return false;
                        break;
                    case 'array':
                        if (!is_array($arg)) return false;
                        break;
                    case 'callable':
                        if (!is_callable($arg)) return false;
                        break;
                    default:
                        // 類名檢查
                        if (!($arg instanceof $expectedType)) return false;
                }
            }
        }
        
        return true;
    }
}

// 使用
$result = PatternMatcher::match([
    'string|int' => function($str, $int) {
        return str_repeat($str, $int);
    },
    'array|callable' => function($array, $callable) {
        return array_map($callable, $array);
    }
], 'hello', 3); // 返回 'hellohellohello'

class FunctionOverload {
    private static $handlers = [];
    
    /**
     * 注冊(cè)重載處理函數(shù)
     */
    public static function register(string $name, callable $handler, array $signature) {
        self::$handlers[$name][serialize($signature)] = $handler;
    }
    
    /**
     * 調(diào)用重載函數(shù)
     */
    public static function call(string $name, ...$args) {
        if (!isset(self::$handlers[$name])) {
            throw new BadFunctionCallException("函數(shù){$name}未定義");
        }
        
        // 根據(jù)參數(shù)數(shù)量和類型選擇處理器
        $signature = self::detectSignature($args);
        
        foreach (self::$handlers[$name] as $sig => $handler) {
            $expectedSig = unserialize($sig);
            
            if (self::signatureMatches($expectedSig, $signature)) {
                return $handler(...$args);
            }
        }
        
        throw new InvalidArgumentException("沒有匹配的函數(shù)簽名");
    }
    
    private static function detectSignature(array $args): array {
        $signature = [];
        
        foreach ($args as $arg) {
            if (is_object($arg)) {
                $signature[] = get_class($arg);
            } else {
                $signature[] = gettype($arg);
            }
        }
        
        return $signature;
    }
    
    private static function signatureMatches(array $expected, array $actual): bool {
        if (count($expected) !== count($actual)) {
            return false;
        }
        
        foreach ($expected as $i => $type) {
            if ($type === 'mixed') {
                continue;
            }
            
            if ($actual[$i] !== $type) {
                // 嘗試類型轉(zhuǎn)換匹配
                if (!self::isConvertible($actual[$i], $type)) {
                    return false;
                }
            }
        }
        
        return true;
    }
    
    private static function isConvertible(string $from, string $to): bool {
        $conversions = [
            'integer' => ['double', 'string'],
            'double' => ['string'],
            'string' => ['integer', 'double', 'array']
        ];
        
        return isset($conversions[$from]) && in_array($to, $conversions[$from]);
    }
}

// 使用
FunctionOverload::register('add', function(int $a, int $b) {
    return $a + $b;
}, ['integer', 'integer']);

FunctionOverload::register('add', function(string $a, string $b) {
    return $a . $b;
}, ['string', 'string']);

echo FunctionOverload::call('add', 1, 2);   // 3
echo FunctionOverload::call('add', 'a', 'b'); // 'ab'

class VariadicDecorator {
    /**
     * 添加前置處理
     */
    public static function before(callable $func, callable $before): callable {
        return function(...$args) use ($func, $before) {
            $args = $before(...$args);
            if (!is_array($args)) {
                $args = [$args];
            }
            return $func(...$args);
        };
    }
    
    /**
     * 添加后置處理
     */
    public static function after(callable $func, callable $after): callable {
        return function(...$args) use ($func, $after) {
            $result = $func(...$args);
            return $after($result, ...$args);
        };
    }
    
    /**
     * 添加參數(shù)驗(yàn)證
     */
    public static function validate(callable $func, array $rules): callable {
        return function(...$args) use ($func, $rules) {
            $validated = [];
            
            foreach ($rules as $i => $rule) {
                if (!isset($args[$i])) {
                    if (isset($rule['default'])) {
                        $validated[$i] = $rule['default'];
                    } elseif ($rule['required'] ?? false) {
                        throw new InvalidArgumentException("參數(shù){$i}缺失");
                    }
                    continue;
                }
                
                $value = $args[$i];
                
                // 類型檢查
                if (isset($rule['type'])) {
                    settype($value, $rule['type']);
                }
                
                // 驗(yàn)證器
                if (isset($rule['validator']) && !$rule['validator']($value)) {
                    throw new InvalidArgumentException("參數(shù){$i}驗(yàn)證失敗");
                }
                
                $validated[$i] = $value;
            }
            
            return $func(...$validated);
        };
    }
    
    /**
     * 柯里化可變參數(shù)函數(shù)
     */
    public static function curry(callable $func, ...$args): callable {
        return function(...$moreArgs) use ($func, $args) {
            return $func(...array_merge($args, $moreArgs));
        };
    }
}

// 使用示例
$validatedSum = VariadicDecorator::validate(
    function(...$numbers) {
        return array_sum($numbers);
    },
    [
        ['type' => 'int', 'required' => true],
        ['type' => 'int', 'default' => 0],
        ['type' => 'int', 'default' => 0]
    ]
);

echo $validatedSum('10', '20', '30'); // 60

class ArgumentParser {
    /**
     * 解析命名參數(shù)風(fēng)格的可變參數(shù)
     */
    public static function parseNamed(array $args, array $defaults = []): array {
        $result = $defaults;
        
        foreach ($args as $arg) {
            if (is_array($arg) && isset($arg[0], $arg[1])) {
                // ['key', 'value'] 格式
                $result[$arg[0]] = $arg[1];
            } elseif (is_string($arg) && strpos($arg, '=') !== false) {
                // 'key=value' 格式
                [$key, $value] = explode('=', $arg, 2);
                $result[$key] = $value;
            } else {
                // 其他格式作為位置參數(shù)
                $result['_'][] = $arg;
            }
        }
        
        return $result;
    }
    
    /**
     * 智能參數(shù)分組
     */
    public static function groupArguments(array $args, array $patterns): array {
        $groups = [];
        $currentGroup = null;
        
        foreach ($args as $arg) {
            $matched = false;
            
            foreach ($patterns as $pattern => $groupName) {
                if (self::matchesPattern($arg, $pattern)) {
                    $currentGroup = $groupName;
                    $groups[$currentGroup][] = $arg;
                    $matched = true;
                    break;
                }
            }
            
            if (!$matched && $currentGroup) {
                $groups[$currentGroup][] = $arg;
            }
        }
        
        return $groups;
    }
    
    private static function matchesPattern($arg, string $pattern): bool {
        if ($pattern === '*') {
            return true;
        }
        
        if (strpos($pattern, ':') !== false) {
            [$type, $value] = explode(':', $pattern, 2);
            
            switch ($type) {
                case 'type':
                    return gettype($arg) === $value;
                case 'prefix':
                    return is_string($arg) && strpos($arg, $value) === 0;
                case 'regex':
                    return is_string($arg) && preg_match($value, $arg);
                default:
                    return false;
            }
        }
        
        return false;
    }
}

// 使用
$args = ['--verbose', 'file.txt', '--output=result.txt', '--force', 'arg1', 'arg2'];
$groups = ArgumentParser::groupArguments($args, [
    'type:string|prefix:--' => 'options',
    'regex:/\.txt$/' => 'files',
    '*' => 'arguments'
]);

print_r($groups);

class VariadicFunctionTest {
    /**
     * 測(cè)試可變參數(shù)函數(shù)
     */
    public static function testVariadic(callable $func, array $testCases) {
        $results = [];
        
        foreach ($testCases as $name => $testCase) {
            $args = $testCase['args'] ?? [];
            $expected = $testCase['expected'] ?? null;
            $expectException = $testCase['expectException'] ?? false;
            $exceptionType = $testCase['exceptionType'] ?? Exception::class;
            
            try {
                $result = $func(...$args);
                
                if ($expectException) {
                    $results[$name] = [
                        'status' => 'FAIL',
                        'message' => '期望拋出異常但未拋出'
                    ];
                } elseif ($result === $expected) {
                    $results[$name] = [
                        'status' => 'PASS',
                        'result' => $result
                    ];
                } else {
                    $results[$name] = [
                        'status' => 'FAIL',
                        'message' => "期望: " . var_export($expected, true) . 
                                    ", 實(shí)際: " . var_export($result, true)
                    ];
                }
            } catch (Throwable $e) {
                if ($expectException && $e instanceof $exceptionType) {
                    $results[$name] = [
                        'status' => 'PASS',
                        'message' => '正確拋出異常: ' . $e->getMessage()
                    ];
                } else {
                    $results[$name] = [
                        'status' => 'ERROR',
                        'message' => '意外異常: ' . $e->getMessage()
                    ];
                }
            }
        }
        
        return $results;
    }
    
    /**
     * 性能測(cè)試
     */
    public static function benchmarkVariadic(callable $func, array $argumentSets, int $iterations = 1000): array {
        $results = [];
        
        foreach ($argumentSets as $setName => $args) {
            $start = microtime(true);
            
            for ($i = 0; $i < $iterations; $i++) {
                $func(...$args);
            }
            
            $end = microtime(true);
            $time = ($end - $start) / $iterations * 1000; // 毫秒
            
            $results[$setName] = [
                'time_ms' => $time,
                'memory_avg' => memory_get_usage(true) / 1024 // KB
            ];
        }
        
        return $results;
    }
}

// 使用示例
$testResults = VariadicFunctionTest::testVariadic(
    function(...$numbers) {
        return array_sum($numbers);
    },
    [
        'empty_args' => [
            'args' => [],
            'expected' => 0
        ],
        'single_arg' => [
            'args' => [5],
            'expected' => 5
        ],
        'multiple_args' => [
            'args' => [1, 2, 3, 4],
            'expected' => 10
        ],
        'invalid_arg' => [
            'args' => ['a', 'b'],
            'expected' => 0 // 字符串會(huì)被轉(zhuǎn)換為0
        ]
    ]
);

// 1. 優(yōu)先使用類型聲明
function safeVariadic(int ...$numbers): int {
    return array_sum($numbers);
}

// 2. 提供清晰的默認(rèn)值
function withDefaults(
    string $required,
    string $optional = 'default',
    int $count = 10,
    ...$extra
) {
    // $extra 只用于額外參數(shù)
}

// 3. 使用參數(shù)對(duì)象處理復(fù)雜情況
class ComplexParameters {
    public function __construct(
        public string $name,
        public array $options = [],
        public ?callable $callback = null
    ) {}
}

function processComplex(ComplexParameters $params) {
    // 處理邏輯
}

// 4. 文檔注釋要詳細(xì)
/**
 * 處理多個(gè)項(xiàng)目
 * 
 * @param string $action 要執(zhí)行的操作
 * @param mixed ...$items 要處理的項(xiàng)，類型取決于$action
 * @return array 處理結(jié)果
 * 
 * @example processItems('upper', 'a', 'b', 'c') 返回 ['A', 'B', 'C']
 */
function processItems(string $action, ...$items) {
    // 實(shí)現(xiàn)
}

class VariadicPatternChooser {
    public static function choosePattern($useCase): string {
        $patterns = [
            'simple_sum' => '使用 ...$numbers 和類型聲明',
            'complex_config' => '使用參數(shù)對(duì)象',
            'command_line' => '使用數(shù)組參數(shù) + 選項(xiàng)解析',
            'api_endpoint' => '使用請(qǐng)求對(duì)象',
            'utility_function' => '使用 ...$args + 智能解析',
            'performance_critical' => '避免可變參數(shù)，使用固定參數(shù)'
        ];
        
        return $patterns[$useCase] ?? '使用 ...$args 但要詳細(xì)文檔';
    }
    
    public static function getExample($pattern): callable {
        switch ($pattern) {
            case 'simple_sum':
                return function(int ...$numbers): int {
                    return array_sum($numbers);
                };
                
            case 'complex_config':
                return function(Config $config) {
                    // 使用配置對(duì)象
                };
                
            case 'command_line':
                return function(array $args) {
                    // 解析命令行參數(shù)
                    $options = [];
                    $arguments = [];
                    
                    foreach ($args as $arg) {
                        if (strpos($arg, '--') === 0) {
                            $option = substr($arg, 2);
                            if (strpos($option, '=') !== false) {
                                [$key, $value] = explode('=', $option, 2);
                                $options[$key] = $value;
                            } else {
                                $options[$option] = true;
                            }
                        } else {
                            $arguments[] = $arg;
                        }
                    }
                    
                    return [$options, $arguments];
                };
                
            default:
                return function(...$args) {
                    // 默認(rèn)實(shí)現(xiàn)
                    return $args;
                };
        }
    }
}

// ? 避免：參數(shù)順序敏感
function ambiguous(...$args) {
    // 假設(shè)第一個(gè)是字符串，第二個(gè)是數(shù)組...
    $string = $args[0] ?? '';
    $array = $args[1] ?? [];
    // 容易出錯(cuò)
}

// ? 推薦：使用命名參數(shù)或數(shù)組
function clear(array $params) {
    $string = $params['string'] ?? '';
    $array = $params['array'] ?? [];
}

// ? 避免：混合類型
function mixedTypes(...$args) {
    // 參數(shù)可能是任何類型
    foreach ($args as $arg) {
        if (is_string($arg)) {
            // 處理字符串
        } elseif (is_array($arg)) {
            // 處理數(shù)組
        }
        // 類型判斷復(fù)雜
    }
}

// ? 推薦：統(tǒng)一類型或使用聯(lián)合類型（PHP 8+）
function unifiedTypes(string|array ...$items) {
    foreach ($items as $item) {
        // 類型明確
    }
}

// ? 避免：在性能關(guān)鍵循環(huán)中使用
for ($i = 0; $i < 1000000; $i++) {
    processVariadic('a', 'b', 'c'); // 每次創(chuàng)建參數(shù)數(shù)組
}

// ? 推薦：預(yù)編譯或批量處理
$batch = array_fill(0, 1000000, ['a', 'b', 'c']);
processBatch($batch);