జెనరేటర్లు yield కీవర్డ్ను ఉపయోగించి, ఒకేసారి మెమరీలో పూర్తి శ్రేణిని రూపొందించకుండా, ఒక సమయంలో ఒక విలువను (నిష్క్రియంగా) ఉత్పత్తి చేయడం ద్వారా పెద్ద డేటాసెట్ల సందర్భంలో స్మృతి-సమర్థవంతమైన పద్ధతిలో పునరావృత్తం చేయడానికి సూచనను అందిస్తాయి. అవి పెద్ద లేదా స్ట్రీమింగ్ డేటాకు ఆదర్శంగా ఉన్నాయి.
{
= [];
( = ; < ; ++) { [] = ; }
;
}
{
( = ; < ; ++) {
;
}
}
(() ) {
();
}
yield ఒక ఫంక్షన్ను జెనరేటర్ గా చేస్తుంది: ఇది నిష్క్రియంగా విలువలను ఉత్పత్తి చేస్తుంది, ఒక్కో పునరావృత్తికి ఒకటి, వాటి మధ్య దాని స్థితిని నిర్వహిస్తుంది — కాబట్టి అది ఎన్ని విలువలను ఉత్పత్తి చేసినా మెమరీ స్థిరంగా ఉంటుంది.
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);
}
పెద్ద ఫైల్ను జెనరేటర్ను ఉపయోగించి పంక్తి-చేత-పంక్తి చదవడం స్థిర మెమరీని ఉపయోగిస్తుంది — file() (ఇది మొత్తం ఫైల్ను శ్రేణిలో లోడ్ చేస్తుంది) తో అసాధ్యం.
function fetchRows(PDOStatement $stmt): Generator {
while ($row = $stmt->fetch()) {
yield $row['id'] => $row; // yield key => value, streaming DB rows
}
}
జెనరేటర్లు స్ట్రీమింగ్ డేటాబేస్ ఫలితాలకు గ్రేట్ — పెద్ద ఫలితసెట్ను మెమరీలో లోడ్ చేయకుండా సమయానికి ఒక పంక్తిని ప్రాసెస్ చేయండి.
జెనరేటర్లు పెద్ద డేటాసెట్ల మెమరీ-సమర్థవంతమైన ప్రక్రియ కోసం PHP యొక్క ఒక ముఖ్యమైన ఫీచర్ — మరియు వాటిని అర్థం చేసుకోవడం మెమరీని అయిష్టపర్చకుండా డేటా స్కేలింగ్ నిర్వహించే అనువర్తనాలను నిర్మించడానికి విలువైనది.
వారు పరిష్కరించే ప్రధాన సమస్య ఏమిటంటే, పెద్ద డేటా (మిలియన్ల రికార్డ్లు, పెద్ద ఫైల్ యొక్క పంక్తులు, పెద్ద డేటాబేస్ ఫలితసెట్) యొక్క పూర్తి శ్రేణిని నిర్మించడం భారీ మెమరీని వినియోగించుకోవచ్చు మరియు అనువర్తనాన్ని క్రാష్ చేయవచ్చు, అయితే జెనరేటర్లు నిష్క్రియంగా, ఒక సమయంలో ఒక విలువను ఉత్పత్తి చేస్తాయి, డేటాసెట్ పరిమాణం సంబంధం లేకుండా మెమరీ స్థిరంగా ఉంటుంది.
సర్వाধిక ప్రభావితమైన యూజ్ కేసులు ఆచరణాత్మక మరియు సాధారణ: పెద్ద ఫైల్లను పంక్తి-చేత-పంక్తి చదవడం (మల్టీ-గిగాబైట్ CSV లేదా లాగ్ను చిన్న మెమరీ ఉపయోగించి ప్రాసెస్ చేయడం, ప్రతిదీ లోడ్ చేసే ఫంక్షన్లతో అసాధ్యం), డేటాబేస్ ఫలితాలను స్ట్రీమింగ్ చేయడం (పెద్ద ప్రశ్న ఫలితాలను పంక్తి-చేత-పంక్తి నిర్వహించడం), మరియు పెద్ద లేదా అనంతమైన సీక్వెన్సుల ప్రక్రియ.
yield, నిష్క్రియ మూల్యాంకనం మరియు జెనరేటర్ల కోసం ఎప్పుడు చేరుకోవాలో అర్థం చేసుకోవడం (మీరేమైనా పెద్ద శ్రేణిని మెమరీలో నిర్మించాలనుకున్న సమయ), పెద్ద వాల్యూమ్లను సున్నితంగా నిర్వహించే స్కేలబుల్ డేటా-ప్రాసెసింగ్ కోడ్ రాయడానికి అనుమతిస్తుంది — బ్యాచ్ జాబ్లు, ఇంపోర్ట్లు/ఎక్స్పోర్ట్లు, రిపోర్ట్ జెనరేషన్ మరియు డేటా పైపులైన్లలో ఆచరణాత్మక వాస్తవ-ప్రపంచ అవసరం.
చిన్న డేటాసెట్ల కోసం అవసరం లేనప్పటికీ, జెనరేటర్లు పెద్ద పরిమాణంలో డేటాను ప్రాసెస్ చేసే మెమరీ-చేతన PHP కోసం అవసరమైన జ్ఞానం, స్కేలబుల్ డేటా-హ్యాండ్లింగ్ కోడ్ను నిర్మించగల డెవలపర్లను పెద్ద వర్కలోడ్ల కింద విఫలమైన లేదా నెమ్మదితరమైన అనువర్తనాలను కలిగి ఉన్న వారి నుండి వేరు చేస్తుంది, పనితీరు-సున్నితమైన, డేటా-గहन PHP అనువర్తనాల కోసం ఇది సిన్యర్-లెవెల్ జ్ఞానాన్ని విలువైనదిగా చేస్తుంది.