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

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


Итак...


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


static $foo = 3;

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


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

Теперь по порядку.


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


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


static $var = foo();

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


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, впереди еще ООП, статические поля, методы.
Ну конечно если это хоть кому-то будет интересно и жестко не заминусуется.

Поделиться публикацией
AdBlock похитил этот баннер, но баннеры не зубы — отрастут

Подробнее
Реклама

Комментарии 28

    +2

    О чем пост? Разве на php.net это не написано?

      +5
      Да, конечно на php.net это написано.
      Просто не так подробно, и не так понятно (как мне кажется). Эта статья написана чтобы подробно и доступным языком постараться объяснить документацию (даже в тегах поставил документация), чтобы прочитав можно было освежить в памяти забытое, или разобраться в теме если в ней плаваешь.
        –5

        Да давайте весь сайт превратим в сборище документаций разных проектов, а тех кто будет противиться заминусуем, верно? Я думал смысл хабра в том, что-бы люди делились опытом и писали то, чего нет в документации, а не наоборот.

      0
      Ух, помню времена, когда был только новичком в программировании, и первый мой язык был — php. Если со статическими переменными в функциях всё было более-менее понятно, то в классах постоянно путался со статическими переменными/методами. Прочитал не одну статью, но полное понимание пришло всё же на практике, когда начал писать свой класс для работы с внешним апи. Либо я туповат, либо это действительно с первого (и со второго) взгляда выглядит не так-то просто и однозначно
        0
        то в классах постоянно путался со статическими переменными/методами

        *со статическими свойствами
        +3
        «Могут быть присвоены только константы и константные выражения» -> Может быть инициализирована только…
          0
          Да, точно, немного корявое выражение получилось, но смысл думаю будет понятно там далее по тексту идет пояснение.

          Видимо вот этот абзац из документации меня сбил
          Начиная с PHP 5.6 стало возможным присвоить этим переменным значения, являющиеся результатом выражения, но нельзя использовать для этого функцию, так это вызовет ошибку разбора.


          +3

          Кто ставит плюсы? Хватит проталкивать в ленту слабые статьи лишь потому-что на более сложные у вас не хватает мотивации/концентрации не знаю еще чего, как что-то серьезное — так сразу теряется в ленте, как очередной кусок документации/статьяпрореакт — так сразу куча активности и комментов и плюсов, даже если написано плохо или уже было 100 раз до этого другими словами

            +2

            Я ставлю.
            Лично мне понравилась доступность изложения и то, как автор раскрывает специфичные моменты.
            Вообще я не вижу ничего криминального в разнообразии ленты — можно выбрать что почитать. А вот лично вы, с вашими намеками про недостаток «мотивации/концентрации» на прочтение сложных статей, фактически уже хамите всему сообществу хабра. Лично мне хватает и концентрации и мотивации и прочего на прочтение больших и сложных статей. Когда интересно и полезно.

              +2

              В правде нет ничего хамского, посмотрите статистику под любой более менее сложной/длинной статьей и КО статьями которые уже были везде и не один раз. Конечно проще одно и то же проходить 100 раз чем выучить что-то новое, но какой смысл?

            0
            В чем-то была замечана аномалия их поведения?
            Честно, так и не понял, что хотел автор донести. Если глянуть на самый первый комментарий, то человек прав.
            Ваши 4 характеристики знакомы всем, кто хотя бы раз использовал эти статические свойства в классах.
            А если не использовали, то дорога на php.net, а не сюда
              +1
              В чем-то была замечана аномалия их поведения?

              Я не говорию что это неправильное поведение, или ошибочное, именно странное
              Вот хотя бы этот пример для меня странный, две функции практически одинаковые (разница в них при беглом, да даже и при внимательном осмотре, не должна повлиять на их поведение), с одинкаовыми параметрами передаными, но возвращают разные результаты.
              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
              
                +1
                два эксепшена этому столику
                зачем вообще писать дважды «static $var =»?
                хотите получить неопределённость? вы её и получили
                статическая переменная создаётся при создании функции, присваивания внутри потому и ограничены тем, что интерпретатор может сразу посчитать
                  0
                  Это же не реальный код. Конечно нет смысла дважды ее объявлять в двух строках подряд.
                  Смысл в том что функции одинаковые по сути, но ведут себя по разному, это мне показалось странным. В документации написано что может быть присвоена однажды, но оказывается есть такой нюанс, про него ничего не написано. Стоит ли про это писать в документации — конечно нет, потому что такое использование неприемлимо. Исчезла ли от этого странность в работе — тоже нет.
                    0
                    А ещё из буханки хлеба можно сделать троллейбус.
                    Странность только в том, что не бросается исключение.
                      0

                      Это две странные функции, и обе они ведут себя странно. Зачем стрелять себе в ногу, тем более дважды?

                    0
                    Вообще, ни чего странно тут нет, все логично (за исключением того, что программист решил несколько раз объявить static $var).
                    При компиляции конструкция static обрабатывается по порядку и последующая инициализация переписывает предыдущую. При выполнении static уже не обрабатывается (можно считать что в райнтайме этих строк уже нет совсем), поэтому, при первом вызове staticVarWrong $var = 5, а в staticVarRight $var = 0;
                      0

                      Именно, нюанс в том, что инициализируется переменная при объявлении функции (условный компайлтайм), при первом require/include или прямом запуске файла, а не при первом вызове функции. Нет никакого счётчика вызовов.

                        0
                        Ну я так и сказал. =)
                        При выполнении static уже не обрабатывается
                          0

                          А я написал "именно" :)

                  +2

                  AlexLeonov еще 4 года назад написал исчерпывающую статью на тему static, в которой написано на порядок больше инфы, чем здесь.

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

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


                      function fake(){
                          static $r='qwerty';
                          $t = 'asdfgh';
                      }

                      line     #* E I O op                 fetch          ext  return  operands
                      ---------------------------------------------------------------------------
                         3     0  E >   BIND_STATIC                                    !0, 'r'
                         4     1        ASSIGN                                         !1, 'asdfgh'
                         5     2      > RETURN                                         null

                      Строка 3 — привязываем статическую переменную $r к области видимости функции.
                      Строка 4 — присваиваем обычной переменной $t значение.


                      Обратите внимание, что присвоение значения переменной $r в коде отсутствует.

                        0
                        Тоже хотел написать, что по логике результатов скорее просто обрабатывается последнее выражение static, но вы не только предположили но и доказали, благодарю.
                        0
                        Сложно, и не понятно это баг или фича?)
                          0
                          Особенность работы компилятора. Но как уже выше писали, в целом конечно это выстрел себе в ногу
                          0
                          Я бы еще добавил во второй пункт пример когда клонируется уже запущенная (как минимум один раз) функция. Тогда в клоне переменная уже будет определена и равна значению на момент клона. Для новичков это может быть не совсем очевидно.

                          $one = function ($i) {
                          	static $var = 0;
                          	$var += $i;
                          
                          	var_dump($var);
                          };
                          
                          $one(1); //1
                          $one(5); //6
                          
                          $two = clone($one);
                          
                          $one(5); //11
                          
                          $two(5); //11
                          $two(5); //16
                          
                            0

                            Никаких "уже запущенная (как минимум один раз) функция". Перенесите clone на две строки вверх и $two(5) выведет 5. После вашей первой строки $var уже проинициализировна нулём, хотя ни разу ещё не вызывалась, и при клонировании это значение тоже склонируется.

                          Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

                          Самое читаемое