PHP可变参数函数处理详细解析与解决方案

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]

// ❌ 问题：参数类型不可控
function concatenate(...$strings) {
    return implode('', $strings);
}

// 传递非字符串参数
echo concatenate('a', 1, 'b', true, null); // 输出 'a1b1'
// 可能产生意外结果：true转为'1'，null转为''

// ❌ 问题：多个固定参数与可变参数混用时顺序混乱
function query($table, ...$conditions) {
    // $conditions 可能包含不同类型的值
    // 难以确定每个条件的具体含义
}

query('users', 'id > 5', ['status' => 'active'], 'LIMIT 10');
// 条件格式不统一，难以解析

// ❌ 问题：频繁调用时性能开销
function processMany(...$items) {
    // 每次调用都需要创建参数数组
    return array_map('strtoupper', $items);
}

// 在大循环中调用性能差
for ($i = 0; $i < 10000; $i++) {
    processMany('a', 'b', 'c'); // 重复创建参数数组
}

// ❌ 问题：不能将引用变量直接传递给可变参数
function incrementValues(&...$values) {
    foreach ($values as &$value) {
        $value++;
    }
}

$a = 1; $b = 2;
// incrementValues($a, $b); // 语法错误

// ❌ 问题：可变参数与默认值参数的位置冲突
function problematic($required, $optional = 'default', ...$rest) {
    // 当只传递两个参数时，$optional 会被使用
    // 但传递三个参数时，第二个参数会进入$rest
}

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

// ✅ 使用类型声明约束参数类型
function concatenateStrings(string ...$strings): string {
    return implode('', $strings);
}

// 自动类型转换仍然发生
echo concatenateStrings('a', '1', 'b'); // 'a1b'

// ✅ 使用严格类型模式
declare(strict_types=1);

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

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

class ParameterValidator {
    /**
     * 验证并标准化可变参数
     */
    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("参数{$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(
                        "参数{$index}必须是{$type}类型"
                    );
                }
            }
            
            // 值验证
            if (isset($rule['validator'])) {
                if (!$rule['validator']($value)) {
                    throw new InvalidArgumentException(
                        "参数{$index}验证失败"
                    );
                }
            }
            
            // 值转换
            if (isset($rule['transformer'])) {
                $value = $rule['transformer']($value);
            }
            
            $validated[$index] = $value;
        }
        
        // 处理额外的参数
        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 命名参数
function queryBuilder(
    string $table,
    array $fields = ['*'],
    array $conditions = [],
    int $limit = 100,
    int $offset = 0
) {
    // 实现
}

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

// ✅ 结合可变参数
function advancedQuery(
    string $table,
    array ...$joins  // 可变参数在最后
) {
    $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']);

// ✅ 使用参数对象封装复杂参数
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 {
        // 构建查询
        $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();

// ✅ 使用数组参数代替可变参数
function processItems(array $items, array $options = []) {
    $defaults = [
        'processor' => 'strtoupper',
        'filter' => null,
        'limit' => null
    ];
    
    $options = array_merge($defaults, $options);
    
    // 应用过滤器
    if ($options['filter']) {
        $items = array_filter($items, $options['filter']);
    }
    
    // 应用限制
    if ($options['limit']) {
        $items = array_slice($items, 0, $options['limit']);
    }
    
    // 应用处理器
    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 = [];
    
    /**
     * 缓存可变参数的处理结果
     */
    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;
        };
    }
    
    /**
     * 预解析参数模式
     */
    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) {
        // 根据签名生成优化的参数解析器
        $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);
});

// 第一次计算并缓存
echo $optimizedSum(1, 2, 3, 4); // 10
// 相同参数直接返回缓存
echo $optimizedSum(1, 2, 3, 4); // 10 (从缓存获取)

class EfficientVariadic {
    /**
     * 避免在循环中重复创建参数数组
     */
    public static function batchProcess(array $items, callable $processor) {
        $results = [];
        
        // 批量处理而不是逐个调用
        foreach ($items as $item) {
            if (is_array($item)) {
                // 如果已经是数组，直接传递
                $results[] = $processor(...$item);
            } else {
                $results[] = $processor($item);
            }
        }
        
        return $results;
    }
    
    /**
     * 使用生成器处理大数据集
     */
    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 {
    /**
     * 根据参数模式执行不同逻辑
     */
    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;
        }
        
        // 简单的类型模式匹配
        $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 = [];
    
    /**
     * 注册重载处理函数
     */
    public static function register(string $name, callable $handler, array $signature) {
        self::$handlers[$name][serialize($signature)] = $handler;
    }
    
    /**
     * 调用重载函数
     */
    public static function call(string $name, ...$args) {
        if (!isset(self::$handlers[$name])) {
            throw new BadFunctionCallException("函数{$name}未定义");
        }
        
        // 根据参数数量和类型选择处理器
        $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("没有匹配的函数签名");
    }
    
    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) {
                // 尝试类型转换匹配
                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);
        };
    }
    
    /**
     * 添加参数验证
     */
    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("参数{$i}缺失");
                    }
                    continue;
                }
                
                $value = $args[$i];
                
                // 类型检查
                if (isset($rule['type'])) {
                    settype($value, $rule['type']);
                }
                
                // 验证器
                if (isset($rule['validator']) && !$rule['validator']($value)) {
                    throw new InvalidArgumentException("参数{$i}验证失败");
                }
                
                $validated[$i] = $value;
            }
            
            return $func(...$validated);
        };
    }
    
    /**
     * 柯里化可变参数函数
     */
    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 {
    /**
     * 解析命名参数风格的可变参数
     */
    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 {
                // 其他格式作为位置参数
                $result['_'][] = $arg;
            }
        }
        
        return $result;
    }
    
    /**
     * 智能参数分组
     */
    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 {
    /**
     * 测试可变参数函数
     */
    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) . 
                                    ", 实际: " . 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;
    }
    
    /**
     * 性能测试
     */
    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 // 字符串会被转换为0
        ]
    ]
);

// 1. 优先使用类型声明
function safeVariadic(int ...$numbers): int {
    return array_sum($numbers);
}

// 2. 提供清晰的默认值
function withDefaults(
    string $required,
    string $optional = 'default',
    int $count = 10,
    ...$extra
) {
    // $extra 只用于额外参数
}

// 3. 使用参数对象处理复杂情况
class ComplexParameters {
    public function __construct(
        public string $name,
        public array $options = [],
        public ?callable $callback = null
    ) {}
}

function processComplex(ComplexParameters $params) {
    // 处理逻辑
}

// 4. 文档注释要详细
/**
 * 处理多个项目
 * 
 * @param string $action 要执行的操作
 * @param mixed ...$items 要处理的项，类型取决于$action
 * @return array 处理结果
 * 
 * @example processItems('upper', 'a', 'b', 'c') 返回 ['A', 'B', 'C']
 */
function processItems(string $action, ...$items) {
    // 实现
}

class VariadicPatternChooser {
    public static function choosePattern($useCase): string {
        $patterns = [
            'simple_sum' => '使用 ...$numbers 和类型声明',
            'complex_config' => '使用参数对象',
            'command_line' => '使用数组参数 + 选项解析',
            'api_endpoint' => '使用请求对象',
            'utility_function' => '使用 ...$args + 智能解析',
            'performance_critical' => '避免可变参数，使用固定参数'
        ];
        
        return $patterns[$useCase] ?? '使用 ...$args 但要详细文档';
    }
    
    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) {
                    // 使用配置对象
                };
                
            case 'command_line':
                return function(array $args) {
                    // 解析命令行参数
                    $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) {
                    // 默认实现
                    return $args;
                };
        }
    }
}

// ❌ 避免：参数顺序敏感
function ambiguous(...$args) {
    // 假设第一个是字符串，第二个是数组...
    $string = $args[0] ?? '';
    $array = $args[1] ?? [];
    // 容易出错
}

// ✅ 推荐：使用命名参数或数组
function clear(array $params) {
    $string = $params['string'] ?? '';
    $array = $params['array'] ?? [];
}

// ❌ 避免：混合类型
function mixedTypes(...$args) {
    // 参数可能是任何类型
    foreach ($args as $arg) {
        if (is_string($arg)) {
            // 处理字符串
        } elseif (is_array($arg)) {
            // 处理数组
        }
        // 类型判断复杂
    }
}

// ✅ 推荐：统一类型或使用联合类型（PHP 8+）
function unifiedTypes(string|array ...$items) {
    foreach ($items as $item) {
        // 类型明确
    }
}

// ❌ 避免：在性能关键循环中使用
for ($i = 0; $i < 1000000; $i++) {
    processVariadic('a', 'b', 'c'); // 每次创建参数数组
}

// ✅ 推荐：预编译或批量处理
$batch = array_fill(0, 1000000, ['a', 'b', 'c']);
processBatch($batch);