CODEWITHSUNDEEP
phpclassobjectreference
user784446
user784446

Reputation: 495

PHP class reference

To be clear, I don't want to instantiate the same class multiple times. I only want to instantiate it once, and keep track of any changes made to that instance via some reference. Is this possible, and if so how can it be done? Thanks!

Upvotes: 2

Views: 4583

Answers (4)

Treffynnon
Treffynnon

Reputation: 21553

You can use the Singleton pattern for this. The PHP manual has a good example and description:

The Singleton ensures that there can be only one instance of a Class and provides a global access point to that instance.

Class:

<?php
class Example
{
    private static $instance;    
    private function __construct() {
    }

    public static function singleton() {
        if (!isset(self::$instance)) {
            echo 'Creating new instance.';
            $className = __CLASS__;
            self::$instance = new $className;
        }
        return self::$instance;
    }

    public function __clone() {
        trigger_error('Clone is not allowed.', E_USER_ERROR);
    }

    public function __wakeup() {
        trigger_error('Unserializing is not allowed.', E_USER_ERROR);
    }
}

Usage:

$singleton = Example::singleton();

It is worth also noting these objections to the singleton pattern from the PHP manual:

The Singleton pattern is one of the more controversial patterns. Critics argue that Singletons introduce Global State into an application and tightly couple the Singleton and its consuming classes. This leads to hidden dependencies and unexpected side-effects, which in turn leads to code that is harder to test and maintain.

Critics further argue that it is pointless to use a Singleton in a Shared Nothing Architecture like PHP where objects are unique within the Request only anyways. It is easier and cleaner to create collaborator object graphs by using Builders and Factory patterns once at the beginning of the Request.

Singletons also violate several of the "SOLID" OOP design principles and the Law of Demeter. Singletons cannot be serialized. They cannot be subtyped (before PHP 5.3) and won't be Garbage Collected because of the instance being stored as a static attribute of the Singleton.

See as well: Who needs singletons?

Upvotes: 3

hakre
hakre

Reputation: 197787

To be clear, I don't want to instantiate the same class multiple times. I only want to instantiate it once, and keep track of any changes made to that instance via some reference. Is this possible, and if so how can it be done? Thanks!

Sure this is possible. You can do this literally:

First of all, as you don't want to instantiate the class multiple times, just instantiate it once:

$instance = new Class();

Then you want to keep track of changes made to that instance. I don't specifically know what you mean. Probably you mean to only keep that one instance. You just can do so, as you have only instantiated once, you can refer to that instance with the $instance variable.

Additionally you can "reference" that $instance as well in some other variable:

$reference = $instance;

You can now access the single instance of Class with the $instance and the $reference variable.

If you need to monitor the instance, I suggest you create a Decorator that does the job:

$decorator = new ClassDecorator(new Class());

The decorator can then work as an interceptor before anything reaches Class.

To find out if the inner state of a class has changed or not, you can make use of the serialize and unserialize functions as well:

$instance = new Class();
$snapshot = serialize($instance);

...
# more code, $instance is changed or not, we don't know
...

$changed = $snapshot != serialize($instance);

Hope this is helpful.

Upvotes: 1

Michal Borek
Michal Borek

Reputation: 4624

You can create Singleton pattern 

class Something {
    private static $instance; 

    private function __construct() {

    }

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

    public function someMethod() {
             return "abc";
    }       

}

When you want to use it you call Something::getInstance()->someMethod()

Read more about singleton pattern.

Upvotes: 2

klaustopher
klaustopher

Reputation: 6941

What you are trying to do is called the Singleton Pattern .. See http://en.wikipedia.org/wiki/Singleton_pattern

Upvotes: 0

Related Questions