Wydajność dostępu do pól klasy
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.
