Pengoptimuman Prestasi PHP

Mari kita mendalami setiap teknik pengoptimuman dan fahami cara ia menyumbang kepada prestasi yang lebih baik.

Pengurusan Memori dan Pengendalian Sumber

Pengurusan memori dalam PHP adalah penting kerana pengurusan yang lemah boleh menyebabkan kebocoran memori dan prestasi yang merosot. Berikut ialah pecahan terperinci:

function processLargeFile($filePath) {
    // Using fopen in 'r' mode for memory efficiency
    $handle = fopen($filePath, 'r');
    if (!$handle) {
        throw new RuntimeException('Failed to open file');
    }

    try {
        while (!feof($handle)) {
            // Using yield instead of storing all lines in memory
            yield fgets($handle);
        }
    } finally {
        // Ensure file handle is always closed, even if an exception occurs
        fclose($handle);
    }
}

// Example of processing a 1GB file with minimal memory usage
function processGiantLogFile($logPath) {
    $stats = ['errors' => 0, 'warnings' => 0];

    foreach (processLargeFile($logPath) as $line) {
        // Process one line at a time instead of loading entire file
        if (strpos($line, 'ERROR') !== false) {
            $stats['errors']++;
        } elseif (strpos($line, 'WARNING') !== false) {
            $stats['warnings']++;
        }

        // Free up memory after processing each line
        unset($line);
    }

    return $stats;
}

Perkara penting tentang pengurusan ingatan:

• Menggunakan penjana (hasil) menghalang memuatkan keseluruhan fail ke dalam memori
• Blok akhirnya memastikan sumber sentiasa dibebaskan
• Memproses data dalam ketulan mengurangkan jejak memori
• Pembolehubah tidak tetap dengan jelas apabila tidak diperlukan lagi membantu kutipan sampah

Struktur Data Pintar dan Caching

Struktur data dan caching yang cekap boleh meningkatkan prestasi secara mendadak dengan mengurangkan pengiraan yang tidak perlu dan panggilan pangkalan data:

class DataProcessor {
    private array $cache = [];
    private int $maxCacheSize;
    private array $cacheTimestamps = [];

    public function __construct(int $maxCacheSize = 1000) {
        $this->maxCacheSize = $maxCacheSize;
    }

    public function processData(string $key, callable $heavyOperation, int $ttl = 3600) {
        // Check if cached data exists and is still valid
        if ($this->isValidCacheEntry($key, $ttl)) {
            return $this->cache[$key];
        }

        $result = $heavyOperation();

        // Implement cache cleanup before adding new items
        $this->maintainCacheSize();

        // Store result with timestamp
        $this->cache[$key] = $result;
        $this->cacheTimestamps[$key] = time();

        return $result;
    }

    private function isValidCacheEntry(string $key, int $ttl): bool {
        if (!isset($this->cache[$key]) || !isset($this->cacheTimestamps[$key])) {
            return false;
        }

        return (time() - $this->cacheTimestamps[$key]) cache) >= $this->maxCacheSize) {
            // Remove oldest entries first (LRU implementation)
            asort($this->cacheTimestamps);
            $oldestKey = array_key_first($this->cacheTimestamps);

            unset($this->cache[$oldestKey]);
            unset($this->cacheTimestamps[$oldestKey]);
        }
    }
}

// Usage example
$processor = new DataProcessor(100);
$result = $processor->processData('expensive_calculation', function() {
    // Simulating expensive operation
    sleep(2);
    return 'expensive result';
}, 1800); // Cache for 30 minutes

Pelaksanaan ini termasuk:

• Tamat tempoh cache berasaskan masa (TTL)
• Strategi pengusiran cache LRU (Paling Kurang Digunakan)
• Penguatkuasaan had ingatan
• Pembersihan cache automatik

Pengoptimuman Operasi Rentetan

Operasi rentetan dalam PHP boleh menjadi intensif memori. Begini cara mengoptimumkannya:

class StringOptimizer {
    public function efficientConcatenation(array $strings): string {
        // Use implode instead of concatenation
        return implode('', $strings);
    }

    public function buildLargeHtml(array $data): string {
        // Use output buffering for large string building
        ob_start();

        echo '<div>



<p>Key optimization points:</p>

<ul>
<li>Using implode() instead of string concatenation</li>
<li>Output buffering for building large strings</li>
<li>Using strtr() for multiple replacements</li>
<li>Precompiling regex patterns</li>
<li>Using sprintf() for format strings</li>
</ul>

<h2>
  
  
  Database Query Optimization
</h2>

<p>Efficient database operations are crucial for application performance:<br>
</p>

<pre class="brush:php;toolbar:false">class DatabaseOptimizer {
    private PDO $pdo;
    private array $queryCache = [];

    public function __construct(PDO $pdo) {
        $this->pdo = $pdo;
        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
    }

    public function batchInsert(array $records, string $table): void {
        // Build bulk insert query
        $columns = array_keys($records[0]);
        $placeholders = '(' . implode(',', array_fill(0, count($columns), '?')) . ')';
        $values = str_repeat($placeholders . ',', count($records) - 1) . $placeholders;

        $query = sprintf(
            'INSERT INTO %s (%s) VALUES %s',
            $table,
            implode(',', $columns),
            $values
        );

        // Flatten array for bulk insert
        $params = [];
        foreach ($records as $record) {
            foreach ($record as $value) {
                $params[] = $value;
            }
        }

        // Execute bulk insert
        $stmt = $this->pdo->prepare($query);
        $stmt->execute($params);
    }

    public function optimizedSelect(string $table, array $conditions = [], array $fields = ['*']): array {
        $query = sprintf(
            'SELECT %s FROM %s',
            implode(',', $fields),
            $table
        );

        if ($conditions) {
            $where = [];
            $params = [];
            foreach ($conditions as $column => $value) {
                $where[] = "$column = ?";
                $params[] = $value;
            }
            $query .= ' WHERE ' . implode(' AND ', $where);
        }

        // Cache prepared statement
        $cacheKey = md5($query);
        if (!isset($this->queryCache[$cacheKey])) {
            $this->queryCache[$cacheKey] = $this->pdo->prepare($query);
        }

        $stmt = $this->queryCache[$cacheKey];
        $stmt->execute($params ?? []);

        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }
}

// Usage example
$optimizer = new DatabaseOptimizer($pdo);

// Batch insert
$records = [
    ['name' => 'John', 'email' => 'john@example.com'],
    ['name' => 'Jane', 'email' => 'jane@example.com']
];
$optimizer->batchInsert($records, 'users');

// Optimized select
$users = $optimizer->optimizedSelect(
    'users',
    ['status' => 'active'],
    ['id', 'name', 'email']
);

Teknik pengoptimuman pangkalan data utama:

• Caching penyata yang disediakan
• Sisipan pukal bukannya berbilang sisipan tunggal
• Pendapatan semula medan terpilih
• Pengindeksan yang betul (dikendalikan pada peringkat pangkalan data)
• Pengurusan transaksi untuk operasi kelompok

Operasi Tatasusunan dan Pengoptimuman Gelung

Pengendalian tatasusunan yang cekap adalah penting untuk aplikasi PHP:

class ArrayOptimizer {
    public function processArray(array $data, callable $callback): array {
        // Pre-allocate result array
        $result = [];
        $count = count($data);

        // Reserve memory
        $result = array_fill(0, $count, null);

        // Process in chunks for memory efficiency
        foreach (array_chunk($data, 1000) as $chunk) {
            foreach ($chunk as $key => $item) {
                $result[$key] = $callback($item);
            }

            // Free up memory
            unset($chunk);
        }

        return $result;
    }

    public function efficientSearch(array $haystack, $needle): bool {
        // Use isset for array keys
        if (isset($haystack[$needle])) {
            return true;
        }

        // Use in_array with strict comparison
        return in_array($needle, $haystack, true);
    }

    public function arrayIntersectOptimized(array $array1, array $array2): array {
        // Convert second array to hash map for O(1) lookup
        $map = array_flip($array2);

        return array_filter(
            $array1,
            fn($item) => isset($map[$item])
        );
    }
}

// Usage examples
$optimizer = new ArrayOptimizer();

// Process large array
$data = range(1, 10000);
$result = $optimizer->processArray($data, fn($item) => $item * 2);

// Efficient search
$haystack = range(1, 1000);
$found = $optimizer->efficientSearch($haystack, 500);

// Optimized array intersection
$array1 = range(1, 1000);
$array2 = range(500, 1500);
$intersection = $optimizer->arrayIntersectOptimized($array1, $array2);

Titik pengoptimuman tatasusunan utama:

• Pra-peruntukan tatasusunan apabila saiz diketahui
• Memproses dalam bahagian untuk kecekapan ingatan
• Menggunakan fungsi tatasusunan yang betul (tatasusunan_kunci_wujud, ditetapkan)
• Melaksanakan algoritma carian yang cekap
• Menggunakan array_flip untuk operasi carian O(1)

Ralat Pengendalian dan Pembalakan

Pengendalian ralat dan pengelogan yang betul adalah penting untuk mengekalkan kestabilan aplikasi:

class ErrorHandler {
    private const MAX_LOG_SIZE = 10485760; // 10MB
    private const MAX_LOG_FILES = 5;
    private string $logPath;
    private array $logLevels = [
        'DEBUG' => 0,
        'INFO' => 1,
        'WARNING' => 2,
        'ERROR' => 3,
        'CRITICAL' => 4
    ];

    public function __construct(string $logPath) {
        $this->logPath = $logPath;
    }

    public function handleError(Throwable $e, string $level = 'ERROR'): void {
        // Check log file size
        if (file_exists($this->logPath) && filesize($this->logPath) > self::MAX_LOG_SIZE) {
            $this->rotateLogFile();
        }

        // Format error message
        $message = sprintf(
            "[%s] [%s] %s: %s in %s:%d\nStack trace:\n%s\n",
            date('Y-m-d H:i:s'),
            $level,
            get_class($e),
            $e->getMessage(),
            $e->getFile(),
            $e->getLine(),
            $e->getTraceAsString()
        );

        // Write to log file
        error_log($message, 3, $this->logPath);

        // Handle critical errors
        if ($this->logLevels[$level] >= $this->logLevels['ERROR']) {
            // Notify administrators or monitoring service
            $this->notifyAdministrators($message);
        }
    }

    private function rotateLogFile(): void {
        // Rotate log files
        for ($i = self::MAX_LOG_FILES - 1; $i >= 0; $i--) {
            $oldFile = $this->logPath . ($i > 0 ? '.' . $i : '');
            $newFile = $this->logPath . '.' . ($i + 1);

            if (file_exists($oldFile)) {
                rename($oldFile, $newFile);
            }
        }
    }

    private function notifyAdministrators(string $message): void {
        // Implementation depends on notification system
        // Could be email, Slack, monitoring service, etc.
    }
}

// Usage example
$errorHandler = new ErrorHandler('/var/log/application.log');

try {
    // Some risky operation
    throw new RuntimeException('Something went wrong');
} catch (Throwable $e) {
    $errorHandler->handleError($e, 'ERROR');
}

Ciri pengendalian ralat utama:

• Log putaran fail untuk mengurus ruang cakera
• Tahap log yang berbeza untuk pelbagai jenis ralat
• Pengelogan surih tindanan untuk nyahpepijat
• Pemberitahuan pentadbir untuk ralat kritikal
• Pemformatan mesej ralat yang betul

Setiap pengoptimuman ini menyumbang kepada penciptaan aplikasi PHP yang mantap dan berprestasi. Ingat untuk sentiasa mengukur dan memprofilkan aplikasi anda untuk mengenal pasti tempat pengoptimuman ini akan memberi impak yang paling besar.