Przedstawiona teoria dotyczy wielu języków interpretowanych… m.in PHP i Python.

Jeżeli posiadasz złożone klasy zawierające wiele pól (czy to statycznych i dynamiczny) i w swoich metodach wykorzystujesz je dosyć często, np w ten sposób:

	public static function fetchAll($query = null, $args = array())
	{
		$sql = 'SELECT ' . static::$_columns . ' FROM ' . static::$_table . (isset(static::$_joinLeft[static::$_table]) ? static::$_joinLeft[static::$_table] : null);

		if ($query) {
			$sql .= ' WHERE ' . $query;
		}

		$collection = array();

		if (empty(self::$_selectQuery[static::$_table]) || self::$_selectQuery[static::$_table] != $sql) {
			self::$_selectStatement[static::$_table] = Database::getInstance(static::$_database)->prepare($sql);
			self::$_selectQuery[static::$_table] = $sql;
		}

		foreach($args as $k => $v) {
			self::$_selectStatement[static::$_table]->bindValue($k+1, $v);
		}

		self::$_selectStatement[static::$_table]->execute();

		// --

 		return $collection;
	}

to w takim przypadku system będzie każdorazowo musiał odpytać do pamięci o to pole. Niestety ale tak to działa. Można znacznie przyspieszyć wykonywanie tego kodu poprzez stworzenie lokalnej wartości, tak aby nie było konieczności każdorazowego odwoływania się do klasy. Zrobiłem szybki test w którym stworzyłem 4 klasy:

class A {

	public static $_a = 4;

	public function a() {

		$a = self::$_a;
		$b = self::$_a;
		$c = self::$_a;
		$d = self::$_a;
		$e = self::$_a;
		$f = self::$_a;

	}
}

class B {

	public static $_a = 4;

	public function a() {

		$local = self::$_a;
		$a = $local;
		$b = $local;
		$c = $local;
		$d = $local;
		$e = $local;
		$f = $local;

	}
}

class C {

	public $_a = 4;

	public function a() {

		$a = $this->_a;
		$b = $this->_a;
		$c = $this->_a;
		$d = $this->_a;
		$e = $this->_a;
		$f = $this->_a;

	}
}

class D {

	public $_a = 4;

	public function a() {

		$local = $this->_a;
		$a = $local;
		$b = $local;
		$c = $v;
		$d = $v;
		$e = $local;
		$f = $local;

	}
}

Jak widać nie robią one nic niesamowitego, ale robią w zasadzie to samo… tylko, że w różny sposób:

Test polegał na utworzeniu instancji i wywołaniu na każdej instancji 1 mln razy metody a()

Wyniki są następujące:

dla Windows

A: static 1.1116s
B: static with local 0.6764s
C: dynamic 0.9799s
D: dynamic with local 0.6258s

Jak widać, poprzez utworzenie zwykłej zmiennej, która ma dostęp lokalny uzyskujemy prawie 2x przyspieszenie wykonywania kodu.