Mari kita mendalami setiap teknik pengoptimuman dan fahami cara ia menyumbang kepada prestasi yang lebih baik.
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:
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]) < $ttl;
}
private function maintainCacheSize(): void {
if (count($this->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:
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:
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:
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:
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.
Atas ialah kandungan terperinci Pengoptimuman Prestasi PHP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
