Generators என்பது yield keyword ஐ பயன்படுத்தி ஒரே நேரத்தில் முழு array ஐ memory இல் உருவாக்குவதற்கு பதிலாக ஒரு நேரத்தில் ஒரு value (lazily) உற்பத்தி செய்வதன் மூலம் பெரிய datasets களை iterate செய்வதற்கான memory-efficient வழி. அவை பெரிய அல்லது streaming data க்கு ஆதரவாக உள்ளன.
{
= [];
( = ; < ; ++) { [] = ; }
;
}
{
( = ; < ; ++) {
;
}
}
(() ) {
();
}
yield ஒரு function ஐ generator ஆக செய்கிறது: இது lazily values ஐ உற்பத்தி செய்கிறது, ஒரு iteration க்கு ஒன்று, அவற்றுக்கு இடையே அதன் state ஐ keep செய்கிறது — அதனால் memory எத்தனை values ஐ உற்பத்தி செய்தாலும் constant ஆக இருக்கும்.
function readLines(string $file): Generator {
$handle = fopen($file, 'r');
while (($line = fgets($handle)) !== false) {
yield $line; // yield one line at a time — never load the whole file
}
fclose($handle);
}
foreach (readLines('huge-10gb.csv') as $line) { // processes a 10GB file with tiny memory
process($line);
}
ஒரு huge file ஐ line by line ஆக generator மூலம் படிப்பது constant memory ஐ பயன்படுத்துகிறது — file() மூலம் சாத்தியமில்லை (இது முழு file ஐ array ஆக load செய்கிறது).
function fetchRows(PDOStatement $stmt): Generator {
while ($row = $stmt->fetch()) {
yield $row['id'] => $row; // yield key => value, streaming DB rows
}
}
Generators streaming database results க்கு சிறந்தவை — ஒரு huge result set ஐ memory இல் load செய்வதற்கு பதிலாக rows ஐ ஒரு நேரத்தில் process செய்யுங்கள்.
Generators என்பது பெரிய datasets களை memory-efficient முறையில் process செய்வதற்கான PHP இன் ஒரு முக்கியமான feature — மேலும் அவற்றை புரிந்துகொள்வது memory ஐ exhaust செய்யாமல் data ஐ scale இல் handle செய்கிற applications ஐ உருவாக்குவதற்கு மதிப்புள்ளது.
அவை solve செய்யும் core problem என்பது பெரிய data இன் முழு array ஐ உருவாக்குவது (millions of records, ஒரு huge file இன் lines, ஒரு பெரிய database result set) enormous memory ஐ consume செய்து application ஐ crash செய்யக்கூடும், அதேசமயம் generators values ஐ lazily, ஒரு நேரத்தில் ஒன்று உற்பத்தி செய்கிறது, dataset size எவ்வளவு பெரியதாக இருந்தாலும் memory constant ஆக keep செய்கிறது.
பெரும்பாலான impactful use cases practical மற்றும் common: பெரிய files ஐ line by line படிப்பது (multi-gigabyte CSV அல்லது log ஐ tiny memory மூலம் process செய்வது, everything ஐ load செய்யும் functions மூலம் சாத்தியமில்லை), streaming database results (பெரிய query results ஐ row by row handle செய்வது), மற்றும் பெரிய அல்லது infinite sequences ஐ process செய்வது.
yield, lazy evaluation, மற்றும் எப்போது generators களுக்கு reach செய்ய வேண்டும் என்பதை புரிந்துகொள்வது (எந்த நேரத்தில் நீங்கள் memory இல் பெரிய array ஐ உருவாக்க வேண்டுமோ அந்த நேரம்) scalable data-processing code ஐ எழுத உங்களை allow செய்கிறது جो بڑی amounts ஐ gracefully handle செய்கிறது — batch jobs, imports/exports, report generation, மற்றும் data pipelines இல் ஒரு frequent real-world need.
பெரிய datasets க்கு தேவைப்படாமல் இருந்தாலும், generators என்பது memory-conscious PHP க்கு essential knowledge ஆகும் جو பெரிய amounts of data ஐ process செய்கிறது, scalable data-handling code ஐ உருவாக்க முடிகிற developers களை identify செய்கிறது அவர்களிடமிருந்து அவர்களின் applications பெரிய workloads கீழ் fail அல்லது slow down செய்யும் developers களை distinguish செய்கிறது, performance-sensitive, data-intensive PHP applications க்கு valuable senior-level knowledge ஆக செய்கிறது.