Magic methods అనేవి __ ఆధిక్షేపణతో ఉండే ప్రత్యేక మెథడ్లు, వాటిని PHP ఒక ఆబ్జెక్ట్పై నిర్దిష్ట చర్యలకు సన్నిహితంగా కాల్ చేస్తుంది — నిర్వచించని ప్రపర్టీని యాక్సెస్ చేయడం, నిర్వచించని మెథడ్ను కాల్ చేయడం, లేదా ఒక ఆబ్జెక్ట్ను స్ట్రింగ్కు మార్చడం వంటివాటికి. అవి ఆబ్జెక్ట్ ప్రవర్తనను హుక్ చేయడానికి మరియు అనుకూలీకరించటానికి మిమ్మల్ని అనుమతిస్తాయి.
{
{ }
{ }
}
class Container {
private array $data = [];
public function __get($name) { // called on reading an INACCESSIBLE/undefined property
return $this->data[$name] ?? null;
}
public function __set($name, $value) { // called on writing one
$this->data[$name] = $value;
}
public function __isset($name): bool { return isset($this->data[$name]); }
}
$c = new Container();
$c->foo = "bar"; // triggers __set('foo', 'bar')
echo $c->foo; // triggers __get('foo') → "bar"
__get/__set ఉనికిలో లేని లేదా యాక్సెస్కు అందుబాటులో లేని ప్రపర్టీల యాక్సెస్ను ఇంటర్సెప్ట్ చేస్తాయి — డైనమిక్ ప్రపర్టీలను ఎనేబుల్ చేస్తాయి (ORMs, config objects ద్వారా ఉపయోగించబడుతుంది).
class Api {
public function __call($method, $args) { // called for UNDEFINED method calls
return $this->request($method, $args); // e.g. dynamic API methods
}
public static function __callStatic($method, $args) { /* static version */ }
}
$api->getUsers(); // no getUsers() method → __call('getUsers', [])
__call/__callStatic నిర్వచించని మెథడ్లకు కాల్లను ఇంటర్సెప్ట్ చేస్తాయి — fluent/dynamic APIs కోసం ఉపయోగించబడుతుంది (ఉదా. Laravel యొక్క query builder, facades).
class Money {
public function __construct(private float $amount) {}
public function __toString(): string { // when the object is used as a string
return '$' . number_format($this->amount, 2);
}
}
echo new Money(9.5); // "$9.50" — __toString called automatically
class Multiplier {
public function __invoke($x) { return $x * 2; } // makes the object CALLABLE
}
$double = new Multiplier();
$double(5); // 10 — __invoke called
Magic methods ఆబ్జెక్ట్ ప్రవర్తనను కస్టమైజ్ చేయడానికి PHP లో ఒక ముఖ్యమైన ఫీచర్, మరియు వాటిని అర్థం చేసుకోవడం వాటిని సముచితంగా ఉపయోగించడానికి మరియు — ప్రత్యేకించి — PHP ఫ్రేమ్వర్క్లు వాటి "magic"ను ఎలా సాధిస్తాయో అర్థం చేసుకోవడానికి విలువైనది. __get/__set (డైనమిక్ ప్రపర్టీ యాక్సెస్), __call/__callStatic (డైనమిక్ మెథడ్ హ్యాండ్లింగ్), __toString (స్ట్రింగ్ కన్వర్సన్), మరియు __invoke (callable objects) వంటి మెథడ్లు ఆబ్జెక్ట్లను వాటి స్పష్టంగా నిర్వచించని ఆపరేషన్లకు తెలివిగా ప్రతిస్పందించటానికి అనుమతిస్తాయి.
ఇది చాలా ఫ్రేమ్వర్క్ సౌకర్యం వెనుక ఉన్న యంత్రం: Laravel's Eloquent ORM మోడల్ ఆయుట్రిబ్యూట్ల కోసం __get/__set ఉపయోగిస్తుంది, దీని query builder and facades fluent dynamic methods కోసం __call/__callStatic ఉపయోగిస్తాయి, మరియు config/collection objects ఇవన్నీ ఉపయోగిస్తాయి.
Magic methods లను గుర్తించడం ఈ ఫ్రేమ్వర్క్లు ఎలా పనిచేస్తాయో అర్థం చేసుకోవడానికి సహాయ చేస్తుంది మరియు ఇదే విధమైన నమ్యమైన APIs బిల్డ్ చేయటానికి మిమ్మల్ని అనుమతిస్తుంది.
ముఖ్యమైన magic methods, ప్రతిదానిని ట్రిగర్ చేసేది, మరియు వాటి సాధారణ ఫ్రేమ్వర్క్ ఉపయోగాలను తెలుసుకోవడం PHP ఎక్స్ప్రెసివ్ రాయటానికి మరియు ఫ్రేమ్వర్క్లను ఆ ఆధారంగా సమర్థవంతంగా ఉపయోగించటానికి/విస్తరించటానికి ఆచరణాత్మక జ్ఞానం. (హెచ్చరిక: magic methods స్పష్టత మరియు IDE సపోర్ట్కు నష్టపరిచేస్తాయి — వాటిని ఎక్కువగా ఉపయోగించడం కోడ్ను అర్థం చేసుకోవడం కష్టతరం చేస్తుంది, కాబట్టి వాటిని డిఫాల్ట్గా కాకుండా నిజమైన డైనమిక్ ప్రవర్తన కోసం ఉద్దేశ్యపూర్వకంగా ఉపయోగించడం ఉత్తమం.)