PHP代码重构与设计改善

PHP代码重构与设计改善

重构是改善既有代码设计而不改变外部行为的过程。今天说说PHP代码重构的常见模式和技巧。

提取方法是最常用的重构手法。

```php
// 重构前
class OrderProcessor
{
public function process(array $order): array
{
$total = 0;
foreach ($order['items'] as $item) {
$total += $item['price'] * $item['quantity'];
}
if ($order['coupon'] !== null) {
$total = $total * 0.9;
}
if ($total > 100) {
$total = $total * 0.95;
}
$order['total'] = $total;
$log = date('Y-m-d H:i:s') . " 订单金额: $total\n";
file_put_contents('/tmp/orders.log', $log, FILE_APPEND);
return $order;
}
}

// 重构后
class OrderProcessorRefactored
{
public function process(array $order): array
{
$total = $this->calculateTotal($order);
$order['total'] = $total;
$this->logProcessing($order);
return $order;
}

private function calculateTotal(array $order): float
{
$total = $this->calculateItemsTotal($order['items']);
$total = $this->applyCoupon($total, $order['coupon'] ?? null);
$total = $this->applyBulkDiscount($total);
return $total;
}

private function calculateItemsTotal(array $items): float
{
$total = 0;
foreach ($items as $item) {
$total += $item['price'] * $item['quantity'];
}
return $total;
}

private function applyCoupon(float $total, ?string $coupon): float
{
return $coupon !== null ? $total * 0.9 : $total;
}

private function applyBulkDiscount(float $total): float
{
return $total > 100 ? $total * 0.95 : $total;
}

private function logProcessing(array $order): void
{
$log = date('Y-m-d H:i:s') . " 订单金额: {$order['total']}\n";
file_put_contents('/tmp/orders.log', $log, FILE_APPEND);
}
}
?>

替换条件逻辑为多态。

```php
interface FeeStrategy
{
public function calculate(float $amount): float;
}

class NormalFee implements FeeStrategy
{
public function calculate(float $amount): float { return $amount * 0.01; }
}

class VipFee implements FeeStrategy
{
public function calculate(float $amount): float { return $amount * 0.005; }
}

class PremiumFee implements FeeStrategy
{
public function calculate(float $amount): float { return 0; }
}

class FeeCalculator
{
public function __construct(private FeeStrategy $strategy) {}

public function calculate(float $amount): float
{
return $this->strategy->calculate($amount);
}
}
?>

引入参数对象。

```php
// 重构前
function searchUsers(string $name, string $email, int $age, string $status, int $page, int $perPage): array
{
return [];
}

// 重构后
class SearchCriteria
{
public function __construct(
public ?string $name = null,
public ?string $email = null,
public ?int $age = null,
public ?string $status = null,
public int $page = 1,
public int $perPage = 20,
) {}
}

function searchUsers(SearchCriteria $criteria): array
{
return [];
}

$criteria = new SearchCriteria(name: '张三', status: 'active');
searchUsers($criteria);
?>

分解复杂条件。

```php
// 重构前
if ($user['status'] === 'active' && $user['balance'] > 0 && !$user['frozen'] && $user['verified']) {
// 处理
}

// 重构后
function canProcessPayment(array $user): bool
{
return $user['status'] === 'active'
&& $user['balance'] > 0
&& !$user['frozen']
&& $user['verified'];
}

if (canProcessPayment($user)) {
// 处理
}
?>

重构的核心原则是每次只改一点，保持测试通过。提取方法、替换条件为多态、引入参数对象，这些是常用的重构手法。好的代码不是一次写出来的，是不断重构打磨出来的。