PHP Singleton or static cross-scripts - php

Question

so I have some classes which only need to be initialized once to fill them with data. Now I want to access them seperately with AJAX but without having them initialized again. I read about singleton in PHP, but I wonder if it's possible to have the same instance of the class in multiple scripts, which can be called seperatedly. Example:
<?php
class Example {
private $instance;
private $A;
public function __construct() {}
public function __clone() {}
public function singleton() {
if (self::$instance === null) {
self::$instance = new Example;
return self::$instance;
}
public function setA($val) {
$this->A = $val;
}
public function getA() {
return $this->A;
}
}
?>
script_a.php:
<?php
include_once('example.class.php');
Example::singleton()->setA(10);
?>
script_b.php:
<?php
include_once('example.class.php');
echo Example::singleton()->getA();
// Would this output 10?
?>
I also read that static functions will be deleted from memory at the end of the script execution, does this also apply for singleton? If so, is there a way to make the above happen?

Answer 1

Singleton does not preserve state over multiple requests - you should use sessions for that. Once you use session then there is no point in using singleton pattern.
A very simple solution:
script_a.php:
<?php
session_start();
$_SESSION['A'] = 10;
?>
script_b.php:
<?php
session_start();
if(isset($_SESSION['A'])) {
echo $_SESSION['A'];
// do the rest of processing
}
?>
Sessions are ok if not sharing data between multiple clients (good for single client - multiple requests).
Another way of preserving state over multiple requests that is shared across clients is caching (you can cache scalars, arrays, db connections or objects) and for that check more on this link

Answer 2

No, the Singleton pattern does not do anything cross-script. Singletons in PHP are mainly useful to get either a pre-initialized or self-initializing instance of a class only once instead of either passing objects through constructors or creating potentially dozens of identical copies of a class when only one is really needed.
eg:
class MySingleton {
private static myInstance = NULL;
private function __construct() {}
public static getInstance($arg) {
if( is_null(self::myInstance) ) {
echo "INIT HERE!";
self::myInstance = new MySingleton();
}
return self::myInstance();
}
}
class myClass {
public $single;
public function __construct() {
$this->single = MySingleton::getInstance();
}
}
$one = new myClass(); // INIT HERE is echoed
$two = new myClass();
$one->single->someVar = 'foo';
echo $two->single->someVar; // foo
$two->single->someVar = 'bar';
echo $one->single->someVar; // bar
Essentially most people in the PHP world use singletons for their database classes so that they only ever have to open a single connection to the database per script. There is some contention among the old farts that there are problems inherent in this approach where prepared statements can interfere with each other [which is true] and using SQL variables can be problematic. [also true] But so long as you're aware that you must fully complete a SQL statement before calling another object method that uses the singleton then you should be fine.

Answer 3

You can use APC cache for that:
class Singleton {
private $a;
private static $key = 'my_unique_singleton_key';
// this functions must be private for a real Singletone
private function __construct() {}
private function __clone() {}
private function __wakeup() {}
// automatically save object during the script shutdown
private function __destruct() {
apc_add(self::$key, self::getInstance());
}
public static function getInstance() {
static $instance;
if (null === $instance) {
if (apc_exists(self::$key)) {
$instance = apc_fetch(self::$key);
} else {
$instance = new self();
apc_add(self::$key, $instance);
}
}
return $instance;
}
public function setA($val) {
$this->a = $val;
}
public function getA() {
return $this->a;
}
}
This can be used simple as that:
echo Singleton::getInstance()->getA();