Moja pierwsza klasa - rejestr Opcje

[q.michal]

Czesc wszystkim,

Poznaje PHP i w ramach nauki napisalem swoja 1 klase do obslugi rejestru. Bede wdzieczny za wszelka krytyke.

[PHP] pobierz, plaintext 
final class Registry {
        private $name;
        private $registry;
 
        /**
         * Disables object cloning
         *
         * @return      void            does not return any value
         */
        private function __clone() {
                throw new Exception('Cloning Registry object is not allowed!');
        }
 
        /**
         * Class constructor
         *
         * @param       string          instance name
         * @return      void            does not return any value
         */
        private function __construct($name) {
                $this->name = $name;
                $this->registry = array();
        }
 
        /**
         * Adds an element to the registry
         *
         * @param       string          location in the registry, in which to store the value
         * @param       mixed           value to be stored in the registry
         * @param       boolean         specifies whether the existing element should be overwritten or not
         * @return      boolean         TRUE on success, FALSE otherwise
         */
        public function addValue($index, $value, $overwrite = false) {
                if($this->isRegistered($index) && !$overwrite) {
                        return false;
                }
                $this->registry[$index] = $value;
                return true;
        }
 
        /**
         * Adds multiple elements to the registry
         *
         * @param       array           associative array containing elements to add to the registry
         * @param       boolean         specified whether the existing elements should be overwritten or not
         * @return      boolean         TRUE on success, FALSE otherwise
         */
        public function addValues($values, $overwrite = false) {
                if(!is_array($values)) {
                        return false;
                }
                foreach($values as $index => $value) {
                        if(!$this->addValue($index, $value, $overwrite)) {
                                return false;
                        }
                }
                return true;
        }
 
        /**
         * Flushes (removes all elements from) the registry
         *
         * @return      void            does not return any value
         */
        public function flushRegistry() {
                $this->registry = array();
        }
 
        /**
         * Returns the global Registry object, creating it only if it does not exist already
         *
         * @param       string          instance name
         * @return      object          the QRegistry object
         */
        public static function getInstance($name = 'main') {
                static $instance;
                if(!isset($instance[$name])) {
                        $instance[$name] = new Registry();
                }
                return $instance[$name];
        }
 
        /**
         * Returns all elements stored in registry
         *
         * @return      array           associative array containing all registered values
         */
        public function getRegistry() {
                return $this->registry;
        }
 
        /**
         * Returns the Registry instance name
         *
         * @return      string          instance name
         */
        public function getRegistryName() {
                return $this->name;
        }
 
        /**
         * Retrieves a value from the registry
         *
         * @param       string          location in the registry, in which the value is stored
         * @param       mixed           the default value to return when element is not found
         * @return      mixed           the value of requested item
         */
        public function getValue($index, $default = NULL) {
                if(!$this->isRegistered($index)) {
                        return $default;
                }
                return $this->registry[$index];
        }
 
        /**
         * Retrieves multiple values from the registry
         *
         * @param       array           array containing the names of the requested elements
         * @param       mixed           the default value to return when element is not found
         * @return      array           associative array containing values of the requested items
         */
        public function getValues($indexes, $default = NULL) {
                $results = array();
                if(!is_array($indexes)) {
                        return $results;
                }
                foreach($indexes as $index) {
                        $results[$index] = $this->getValue($index, $default);
                }
                return $results;
        }
 
        /**
         * Checks if container contains an item with the specified index
         *
         * @param       string          location in the registry
         * @return      boolean         TRUE if index is a named value in the registry, FALSE otherwise
         */
        public function isRegistered($index) {
                return array_key_exists($index, $this->registry);
        }
 
        /**
         * Removes given registered element
         *
         * @param       string          location in the registry
         * @return      boolean         TRUE on success, FALSE otherwise
         */
        public function removeValue($index) {
                if(!$this->isRegistered($index)) {
                        return false;
                }
                unset($this->registry[$index]);
                return true;
        }
 
        /**
         * Removes multiple given registered elements
         *
         * @param       array           array containing the names of the requested elements
         * @return      boolean         TRUE on success, FALSE otherwise
         */
        public function removeValues($indexes) {
                if(!is_array($indexes)) {
                        return false;
                }
                foreach($indexes as $index) {
                        if(!$this->removeValue($index)) {
                                return false;
                        }
                }
                return true;
        }
 
}
[PHP] pobierz, plaintext 

Ten post edytował q.michal 14.02.2016, 18:06:41

[com]

no poco tam wepchałeś singleton, który stracił sens singletona.

Wyrzuć ten konstruktor, ten przykład który Ci dałem miał zobrazować kiedy się go używa a konstruktor robi się prywatny własnie po to żeby go nie używać wiec też go nie używaj. Uparłeś się żeby go mieć i nauczysz się złych praktyk w ten sposób.

[PHP] pobierz, plaintext 
$rega = Registry::getInstance('a');
$regb = Registry::getInstance('b');
var_dump($rega === $regb); // bool false
$rega->addValue(0,'test');
var_dump($rega->getRegistry(), $regb->getRegistry()); 
/* 
array(1) {
  [0]=>
  string(4) "test"
}
array(0) {
}*/
[PHP] pobierz, plaintext 

Robiąc mały test, dla singletona spodziewasz się że $rega === $regb oraz że $regb->getRegistry() i $rega->getRegistry() zwróci
array(1) {
[0]=>
string(4) "test"
}, bo na tym polega antywzorzec singleton, a u Ciebie on nie ma sensu bo to są dwa rożne obiekty, ale zamiast jawnego konstruktora maja metodę Instance (IMG:style_emoticons/default/wink.gif)

tak działa singleton:
http://ideone.com/RUd4EU