CODEWITHSUNDEEP
php
Joe Scotto
Joe Scotto

Reputation: 10867

What is the point of using self::$_instance = new self()

I'm working on learning OOP PHP and have come across this:

//Store the single instance
private static $_instance;

/*
    Get an instance of the database
    @return database
*/
public static function getInstance () {
    if (!self::$_instance) {
        self::$_instance = new self();
    }
    return self::$_instance;
}

What is the point of setting $_instance to a new self()? I know that all this line is doing is creating a new instance of the class it's in but why would one need to do this? Is there any reason this would ever be needed? I don't ever even call it again in the class. Thanks for any help in advanced.

Upvotes: 3

Views: 6763

Answers (3)

prophp
prophp

Reputation: 121

work example

class Singleton
{
    public $data;

    private static $instance = null;

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


    public static function getInstance()
    {
        if (is_null(self::$instance))
            self::$instance = new self;

        return self::$instance;
    }


    //no clone
    private function __clone() {}
    //no serialize
    private function __wakeup() {}
}


$singleton = Singleton::getInstance();

echo $singleton->data;
echo '<br>';

$singleton2 = Singleton::getInstance();

echo $singleton2->data;
echo '<br>';

Upvotes: 1

Borealid
Borealid

Reputation: 98469

This is the Singleton pattern.

It is used when you have an object that requires initialization and/or tear-down work and that work should be performed just once.

The instance cache forces there to only be one instance of the class, ever.

Upvotes: 0

Evert
Evert

Reputation: 99523

The idea is that whenever you call getInstance() throughout your code, you will always get the same instance.

This is useful in some cases where you only want to get access to the same object. Often objects like this might have a private constructor, which effectively forces you to always act on the same instance (also known as a singleton).

Generally people say 'Singletons are evil'. They are good to avoid because they can cause major design issues. In some cases they can still be a good idea though.

Upvotes: 7

Related Questions