ग्लोबल्स

Question

का उपयोग किए बिना PHP में फ़ंक्शंस के बीच साझा चर मेरे पास एक memcache सर्वर के साथ बातचीत करने के लिए एक कक्षा है। मेरे पास डेटा डालने, हटाने और पुनर्प्राप्त करने के लिए अलग-अलग फ़ंक्शन हैं। मूल रूप से प्रत्येक कार्य memcache_connect() के लिए एक कॉल, तथापि कि अनावश्यक था, उदा .:

mc->insert() 
mc->get() 
mc->delete() 

बनाया तीन मेम्कैश कनेक्शन होगा। मैं इस के चारों ओर वर्ग के लिए एक निर्माण बनाने के द्वारा काम किया:

function __construct() { 
    $this->mem = memcache_connect(...); 
} 

और फिर $this->mem का उपयोग कर जहाँ भी संसाधन की जरूरत थी, इसलिए तीन कार्यों में से प्रत्येक का उपयोग एक ही memcache_connect संसाधन।

यह ठीक है, लेकिन अगर मैं तो यह अभी भी दो memcache_connect कॉल कर रहा है, अन्य वर्गों के अंदर वर्ग फोन उदा .:

class abc 
{ 
    function __construct() { 
     $this->mc = new cache_class; 
    } 
}  
class def 
{ 
    function __construct() { 
     $this->mc = new cache_class; 
    } 
} 

जब यह केवल जरूरतों एक।

मैं इसे ग्लोबल्स के साथ कर सकता हूं लेकिन अगर मुझे ऐसा नहीं करना है तो मैं उनका उपयोग नहीं करना चाहूंगा।

उदाहरण वैश्विक कार्यान्वयन:

$resource = memcache_connect(...); 

class cache_class 
{ 
    function insert() { 
     global $resource; 
     memcache_set($resource , ...); 
    } 
    function get() { 
     global $resource; 
     return memcache_get($resource , ...); 
    } 

} 

तो कोई फर्क नहीं पड़ता कि कितनी बार वर्ग कहा जाता है वहाँ केवल memcache_connect करने के लिए एक कॉल किया जाएगा।

क्या ऐसा करने का कोई तरीका है या क्या मुझे ग्लोबल्स का उपयोग करना चाहिए? एम सी उदाहरण में

Answer 1

मैं मेम्कैश का ही उदाहरण प्राप्त करने के लिए सिंगलटन पद्धति का उपयोग कर किसी अन्य वर्ग कोड होगा।

class MemCache 
{ 
    private static $instance = false; 
    private function __construct() {} 

    public static function getInstance() 
    { 
    if(self::$instance === false) 
    { 
     self::$instance = memcache_connect(); 
    } 

    return self::$instance; 
    } 
} 

और उपयोग - - इस तरह

$mc = MemCache::getInstance(); 
memcache_get($mc, ...) 
... 

Answer 2

पास:

class abc 
{ 
    function __construct($mc) { 
     $this->mc = $mc; 
    } 
}  
class def 
{ 
    function __construct($mc) { 
     $this->mc = $mc; 
    } 
} 

$mc = new cache_class; 
$abc = new abc($mc); 

आदि

Answer 3

मैं तुम्हें यहाँ स्थिर गुणों के लिए देख रहे है।

class mc { 
    private static $instance; 

    public static function getInstance() { 
     if (self::$instance== null) { 
      self::$instance= new self; 
     } 
     return self::$instance; 
    } 

    private function __construct() { 
     $this->mem = memcache_connect(...); 
    } 
} 

यह एक मूल सिंगलटन पैटर्न लागू करता है। ऑब्जेक्ट कॉल mc::getInstance() बनाने के बजाय। singletons पर एक नज़र डालें।

Answer 4

आपको निर्भरता इंजेक्शन का उपयोग करना चाहिए। सिंगलटन पैटर्न और स्थैतिक संरचनाओं को बुरी आदत माना जाता है क्योंकि वे अनिवार्य रूप से ग्लोबल्स होते हैं (और अच्छे कारण के लिए - वे आपको किसी भी वर्ग के उपयोग के लिए तत्काल करते हैं जो आप किसी अन्य के विपरीत करते हैं)।

यहां कुछ ऐसा है जो आपको आसान रखरखाव के लिए करना चाहिए।

class MemCache { 
    protected $memcache; 

    public function __construct(){ 
     $this->memcache = memcache_connect(); 
    } 
} 

class Client { 
    protected $MemCache; 

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

    public function getMemCache(){ 
     return $this->MemCache; 
    } 
} 

$MemCache = new MemCache(); 
$Client = new Client($MemCache); 
$MemCache1 = $Client->getMemCache(); 

// $MemCache and $MemCache1 are the same object. 
// memcache_connect() has not been called more than once.