Access static var php

Странные они, статические переменные в PHP

Дисклеймер: данная статья не явит вам какого то откровения и не откроет третий глаз, но позволит разобраться в не очень очевидном вопросе более детально. Мне по крайней мере при ее написании она в этом помогла. Если вы матерый волк в php то можете не читать, опытным человекам думаю не повредит пробежать глазами, освежить так сказать в памяти, остальным будет норм.

Статические переменные, в php это особый вид переменных, которые объявляются при помощи ключевого слова static.

От обычных переменных они отличаются тем что (далее в статье эти пункты будут рассмотрены более подробно):

1. могут быть присвоены только константы и константные выражения
2. время жизни статической переменной не ограничено временем жизни области видимости в которой она была объявлена
3. могут быть определены в скрипте лишь однажды
4. не уничтожаются до конца выполнения скрипта

1. Могут быть присвоены только константы и константные выражения

Это значит что в статическую переменную не может быть присвоен результат работы какой-либо функции или метода, или вообще что-либо что еще не известно на этапе компиляции. То есть вот такое объявление не сработает

а вот так вполне возможно

static $var = 'some str'; static $varInt = 3 + 5;

2. Время жизни статической переменной не ограничено временем жизни области видимости в которой она объявлена

Постараюсь объяснить что тут я имел в виду. Возможно допущу какие-то неточности в терминологии, но суть постараюсь передать как можно точнее. Сравним с обычной переменной. Если внутри функции объявить переменную, то она по умолчанию является локальной переменной, то есть она объявлена в локальной области видимости (области видимости этой функции). В этом случае контекстом данной функции будет локальная область видимости. После того как функция отработала и вернула результат, ее область видимости или ее контекст, со всеми переменными внутри нее будет уничтожена.

Если же мы внутри функции объявляем статическую переменную, то она также объявляется в локальной области видимости, но ее контекстом будет не локальная область видимости, а сама функция.

(Далее самый трудный момент для объяснения, передаю только суть, без подробностей, как объявляются функции в php сколько им выделяется памяти и что в этой памяти лежит). Получается так, при вызове функции, для нее интерпретатором создается локальная область видимости именно в ней объявляются все локальные переменные и ф-ции, и к ней как к своему контексту они и привязаны. Объявляя же переменную в локальной области видимости с помощью static, этой переменной в качестве контекста назначается сама функция, и эта переменная будет существовать до тех пор пока существует сама функция. Это нечто похожее на js, когда функция является объектом, в который можно присваивать произвольные свойства и методы. Тут так же только функция в php является объектом не для php, а для более низкого ЯП.

function echoStaticVar() < static $var = 0; $var++; var_dump($var); >; echoStaticVar(); //1 echoStaticVar(); //2 echoStaticVar(); //3

Видно что после прекращения работы функции сборщик не уничтожает переменную $var как это было бы с обычной переменной.

А вот пример который наглядно покажет что статическая переменная принадлежит функции (или хранится в функции, или ее контекстом является функция уж извините не знаю как это правильно назвать).

$one = function ($i) < static $var = 0; $var += $i; var_dump($var); >; $two = $one; $one(1); //1 $one(5); //6 $one(5); //11 $two(5); //16 $two(5); //21

Все работает, как и ожидается, потому что при присвоении $two = $one; не копируется сама функция, а просто обе эти переменные будут ссылаться на одну и ту же область памяти. Соответственно и статическая переменная $var будет одна и для $one и для $two

Немного поменяем пример, а именно не присвоим, а клонируем

//вместо $two = $one; //клонируем $two = clone($one);

$one = function ($i) < static $var = 0; $var += $i; var_dump($var); >; $two = clone($one); $one(1); //1 $one(5); //6 $one(5); //11 $two(5); //5 $two(5); //10

Теперь получилось что $one и $two ссылаются не на одну и ту же функцию с одной статической переменной $var, а на две разные функции, лежащие в разный областях памяти, и имеющие каждая по своей статической переменной $var. Это не особо очевидный момент, по этому на нем можно споткнуться, если вы конечно вообще пишите код в процедурном стиле, что уже наверное считается дурным тоном, но это не точно).

Что можно с этим сделать — это классический пример счетчика вызова функции.
Но в связи с распространением ООП в таком виде статические переменные встречаются редко, так как в основном приходится оперировать классами и методами (о реализации static в них напишу отдельную статью)

3. могут быть определены в скрипте лишь однажды

Это значит что если статическая переменная уже объявлена, и ей присвоено значение, то последующие присвоения не перезапишут уже присвоенное значение, а вернут существующее.

function staticVar($i) < static $var = 0; $var += $i; var_dump($var); >; staticVar(1); //1 staticVar(5); //6 staticVar(5); //11

Видно, что если бы в функции staticVar статической переменной $var каждый раз бы переприсваивалось значение то мы бы всегда получали в результате 1. Но так как при повторном присвоении она не перезаписывается, мы получаем то что мы получаем.
Правда тут есть одно но, которое может все испортить. В рамках одной функции (точнее при первом вызове функции), такую переменную можно перезаписать сколько угодно раз (при последующих все будет работать как и заявлено). Мне это поведение показалось странным и забавным, особенно если поиграться с примерами.

function staticVar($i) < static $var = 0; static $var = 5; $var += $i; var_dump($var); >; staticVar(1); //6 staticVar(5); //11 staticVar(5); //16

Тут переменная $var в первом вызове функции staticVar в первой ее строке была присвоена, потом перезаписана во второй строке. Но уже в дальнейших вызовах ни в первой ни во второй строке она не была переприсвоена, а вернула то что уже было в предыдущем вызове

function staticVar($i) < static $var = 0; //присвоена static $var = 5; //вернулось значение присвоенное ранее $var += $i; static $var = 0; //вернулось значение присвоенное ранее var_dump($var); >; staticVar(1); //1 staticVar(5); //6 staticVar(5); //11

Еще страннее при первом вызове staticVar в первой строке она была присвоена, потом во второй строке переприсвоена (но неуспешно), затем с ней было произведено действие сложения, и уже после этого при попытки ее переприсвоить даже в рамках первого вызова функции она вернула уже лежащее в ней значение.

function staticVarWrong($i) < static $var = 0; static $var = 5; $var += $i; var_dump($var); >; //результат один staticVarWrong(1); //6 staticVarWrong(5); //11 staticVarWrong(5); //16 function staticVarRight($i) < static $var = 0; static $var = 5; $var += $i; static $var = 0; //разница только в этом var_dump($var); >; //результат другой staticVarRight(1); //1 staticVarRight(5); //6 staticVarRight(5); //11

То есть получается в практически одинаковый методах, разное поведение. Причем исходя из описания того как должны себя вести статические переменные то правильный результат получается именно в staticVarRight. В staticVarWrong получается (исходя из поведения функции) что во второй строке функции переменная была переопределена.
Меня это довольно сильно позабавило.

4. не уничтожаются до конца выполнения скрипта

Не вижу особого смысла объяснять этот пункт, тем более что из примеров все видно. Пока работает скрипт и пока существует функция для которой объявлена статическая переменная, эта переменная существует.

Как планируется — это первая статья по static, впереди еще ООП, статические поля, методы.
Ну конечно если это хоть кому-то будет интересно и жестко не заминусуется.

Источник

Access static var php

INSIDE CODE and OUTSIDE CODE

class Item
/**
* This is INSIDE CODE because it is written INSIDE the class.
*/
public $label ;
public $price ;
>

/**
* This is OUTSIDE CODE because it is written OUTSIDE the class.
*/
$item = new Item ();
$item -> label = ‘Ink-Jet Tatoo Gun’ ;
$item -> price = 49.99 ;

?>

Ok, that’s simple enough. I got it inside and out. The big problem with this is that the Item class is COMPLETELY IGNORANT in the following ways:
* It REQUIRES OUTSIDE CODE to do all the work AND to know what and how to do it — huge mistake.
* OUTSIDE CODE can cast Item properties to any other PHP types (booleans, integers, floats, strings, arrays, and objects etc.) — another huge mistake.

Note: we did it correctly above, but what if someone made an array for $price? FYI: PHP has no clue what we mean by an Item, especially by the terms of our class definition above. To PHP, our Item is something with two properties (mutable in every way) and that’s it. As far as PHP is concerned, we can pack the entire set of Britannica Encyclopedias into the price slot. When that happens, we no longer have what we expect an Item to be.

INSIDE CODE should keep the integrity of the object. For example, our class definition should keep $label a string and $price a float — which means only strings can come IN and OUT of the class for label, and only floats can come IN and OUT of the class for price.

class Item
/**
* Here’s the new INSIDE CODE and the Rules to follow:
*
* 1. STOP ACCESS to properties via $item->label and $item->price,
* by using the protected keyword.
* 2. FORCE the use of public functions.
* 3. ONLY strings are allowed IN & OUT of this class for $label
* via the getLabel and setLabel functions.
* 4. ONLY floats are allowed IN & OUT of this class for $price
* via the getPrice and setPrice functions.
*/

protected $label = ‘Unknown Item’ ; // Rule 1 — protected.
protected $price = 0.0 ; // Rule 1 — protected.

public function getLabel () < // Rule 2 - public function.
return $this -> label ; // Rule 3 — string OUT for $label.
>

public function getPrice () < // Rule 2 - public function.
return $this -> price ; // Rule 4 — float OUT for $price.
>

public function setLabel ( $label ) // Rule 2 — public function.
/**
* Make sure $label is a PHP string that can be used in a SORTING
* alogorithm, NOT a boolean, number, array, or object that can’t
* properly sort — AND to make sure that the getLabel() function
* ALWAYS returns a genuine PHP string.
*
* Using a RegExp would improve this function, however, the main
* point is the one made above.
*/

if( is_string ( $label ))
$this -> label = (string) $label ; // Rule 3 — string IN for $label.
>
>

public function setPrice ( $price ) // Rule 2 — public function.
/**
* Make sure $price is a PHP float so that it can be used in a
* NUMERICAL CALCULATION. Do not accept boolean, string, array or
* some other object that can’t be included in a simple calculation.
* This will ensure that the getPrice() function ALWAYS returns an
* authentic, genuine, full-flavored PHP number and nothing but.
*
* Checking for positive values may improve this function,
* however, the main point is the one made above.
*/

if( is_numeric ( $price ))
$this -> price = (float) $price ; // Rule 4 — float IN for $price.
>
>
>

?>

Now there is nothing OUTSIDE CODE can do to obscure the INSIDES of an Item. In other words, every instance of Item will always look and behave like any other Item complete with a label and a price, AND you can group them together and they will interact without disruption. Even though there is room for improvement, the basics are there, and PHP will not hassle you. which means you can keep your hair!

If you have problems with overriding private methods in extended classes, read this:)

The manual says that «Private limits visibility only to the class that defines the item». That means extended children classes do not see the private methods of parent class and vice versa also.

As a result, parents and children can have different implementations of the «same» private methods, depending on where you call them (e.g. parent or child class instance). Why? Because private methods are visible only for the class that defines them and the child class does not see the parent’s private methods. If the child doesn’t see the parent’s private methods, the child can’t override them. Scopes are different. In other words — each class has a private set of private variables that no-one else has access to.

A sample demonstrating the percularities of private methods when extending classes:

abstract class base <
public function inherited () <
$this -> overridden ();
>
private function overridden () <
echo ‘base’ ;
>
>

class child extends base <
private function overridden () <
echo ‘child’ ;
>
>

$test = new child ();
$test -> inherited ();
?>

Output will be «base».

If you want the inherited methods to use overridden functionality in extended classes but public sounds too loose, use protected. That’s what it is for:)

A sample that works as intended:

abstract class base <
public function inherited () <
$this -> overridden ();
>
protected function overridden () <
echo ‘base’ ;
>
>

class child extends base <
protected function overridden () <
echo ‘child’ ;
>
>

$test = new child ();
$test -> inherited ();
?>
Output will be «child».

Источник