late static binding php
Позднее статическое связывание в PHP (Часть I)
Позднее Статическое Связывание (Late Static Binding, LSB) является бурно темой обсуждений последние три года в кругах разработчиков PHP (и наконец мы его получили в PHP 5.3). Но зачем оно нужно? В данной статье, как раз и будет рассматриваться, как позднее статическое связывание может значительно упростить ваш код.
На встрече разработчиков PHP, которая проходила в Париже в ноябре 2005 года, тема позднего статического связывания официально обсуждалась основной командой разработчиков. Они согласились реализовать его, наряду со многими другими темами, которые стояли на повестке дня. Детали должны были быть согласованы в ходе открытых дискуссий.
С тех пор как позднее статическое связывание было объявлено как грядущая фишка, прошло два года. И вот наконец LSB стало доступно для использования в PHP 5.3. Но это событие прошло незаметно для разработчиков использующих PHP, из заметок только страничка в мануале.
Если кратко, новая функциональность позднего статического связывания, позволяет объектам все также наследовать методы у родительских классов, но помимо этого дает возможность унаследованным методам иметь доступ к статическим константам, методам и свойствам класса потомка, а не только родительского класса. Давайте рассмотрим пример:
Этот код выдаст такой результат:
Класс Ale унаследовал метод getName(), но при этом self все еще указывает на класс в котором оно используется (в данном случае это класс Beer). Это осталось и в PHP 5.3, но добавилось слово static. И снова рассмотрим пример:
Новое ключевое слово static указывает, что необходимо использовать константу унаследованного класса, вместо константы которая была определена в классе где объявлен метод getStaticName(). Слово static было добавлено, чтобы реализовать новый функционал, а для обратной совместимости self работает также как и в предыдущих версиях PHP.
Внутренне, основное отличие (и, собственно, причина почему связывание назвали поздним) между этими двумя способами доступа, в том, что PHP определят значение для self::NAME во время «компиляции» (когда симовлы PHP преобразуются в машинный код, который будет обрабатываться движком Zend), а для static::NAME значение будет определено в момент запуска (в тот момент, когда машинный код будет выполнятся в движке Zend).
Это еще один инструмент для PHP-разработчиков. Во второй части рассмотрим как его можно использовать во благо.
Позднее статическое связывание в PHP (Часть II: Практика)
Первую часть читайте здесь.
Теперь приступим к практике. Наиболее показательным примером использования LSB, по-моему, является случай, когда у вас есть набор классов выполняющих похожие действия. В терминах веб-разработки мы часто встречаемся с такими задачами при обращениях к таблицам базы данных, особенно в ORM системах. Все ваши объекты для работы с таблицами будут похожи по сути, но при этом будут иметь собственный функционал ( и, соответственно, свои подклассы).
Допустим, у нас в системе есть класс Storable, который реализует (как вы догадались) (прим. переводчика: я не догадался 🙂 ) паттерн Storable. Мы определяем классы, которые наследуются от класса Storable и задаем имена таблиц в конструкторах. Вот как это выглядит:
Можете пропустить подробности конструктора, он приведен только для того, чтобы вы представляли как работает класс Storable. Как вы уже успели понять, это сэкономит нам немного времени и позволит не тратить его на такие мелочи как простые запросы SELECT, INSERT и UPDATE.
В нашей системе, помимо основной таблицы Статьи (ArticleEntry), будут использоваться еще несколько таблиц, которые содержат мета-данные (в отношении многие-к-одному), например: теги, вложения. Мне также нужен простой способ удаления данных из под-таблиц, прежде чем обновлять данные в основной таблице (проще удалить мета-данные и создать заново, чем беспокоится о синхронизации данных). Итак, чтобы смоделировать код наиболее приближенный к схеме базы данных, я остановился на такой реализации:
Весь фокус в методе purge(). Свойство $this->tableName является защищенным свойством, которое мы получили от класса Storable. Вот пример использования:
У меня есть куча таких мелких классов для работы с таблицами мета-данных. К сожалению, поскольку наша система использует PHP версии 5.2, я не мог использовать функциональность LSB описанную в первой части статьи. И чтобы удалять мета-данные, я должен писать:
Если посмотрите выше, как определен метод purge(), то увидите, что tableName он получает из класса Storable, который получает его из конструкторов классов-потомков. Помимо этих тривиальных (но абсолютно необходимых) данных, а также получения объекта базы данных в $this->db, мы не достигли ничего создавая объект класса articleentryattachment. Код был бы намного понятнее и чище ( и конечно эффективнее), если бы можно было бы вызвать метод purge() статически. Рассмотрим такой код:
Первое, что, я надеюсь, вы заметили, это то что ArticleEntryAttachment стал намного проще. Теперь нет необходимости переопределять конструктор для подклассов, потому, что конструктор родительского класса самодостаточен. И теперь можно использовать метод purge() (используя LSB):
Поскольку, теперь purge() может получать имя таблицы, которое определяется в момент выполнения, мы можем сделать его статическим. В итоге, код — чище, выполнение — эффективней, поддержка (например, добавление новых под-классов) — пустяковая, потому как избыточность полностью убрана. Спасибо разработчикам PHP за то что это стало возможным!
Позднее статическое связывание в PHP
Рассмотрим следующий пример:
C:\> php php-late-static-binding.php
My name A!
My name A!
My name A!
My name B!
Так что же здесь происходит? А вот что: когда мы в методе getNameSB() класса А определяем return static::$name мы говорим компилятору PHP, что нам нужно значение из контекста дочернего класса, а не из контекста родительского. Проще говоря, свойство берется не из того места где оно определено изначально, а из того места где оно переопределено, т.е. из дочернего класса. Вот это как раз и называется поздним статическим связыванием в PHP.
Таким образом, если Вам надо получить статические свойства (методы) из родительского класса для дочернего класса Вам необходимо использовать позднее статическое связывание в PHP, реализуемое посредством ключевого слова static.
Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!
Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.
Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления
Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.
Порекомендуйте эту статью друзьям:
Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):
Комментарии ( 0 ):
Для добавления комментариев надо войти в систему.
Если Вы ещё не зарегистрированы на сайте, то сначала зарегистрируйтесь.
Copyright © 2010-2021 Русаков Михаил Юрьевич. Все права защищены.
Late static binding php
I have implemented enum using late static binding.
interface IEnum <
/**
* Only concrete class should implement this function that should behave as
* an enum.
*
* This method should return the __CLASS__ constant property of that class
*
* @return string __CLASS__
*/
public static function who ();
>
abstract class Enum <
// use of late static binding to get the class.
$class = static:: who ();
class Fruits extends Enum implements IEnum <
public static function who () <
return __CLASS__ ;
>
>
// user input from dropdown menu of fruits list
$input = 3 ;
echo B :: constructor (); // B
?>
Just a quick reminder to always check your syntax. While I love LSB, I thought it wasn’t working:
static::$sKey = not set
…until I realized that I’d completely forgotten to make it a variable variable:
static::$$sKey = is set
…of course this applies anywhere in PHP, but because of the (current) newness late static bindings, I’ve seen lots of code with this particular snafu in it from others.
In the above example (#3) in order to make it work, you can change the child’s method from ‘private’ to ‘protected’ (or public) and it will be called through ‘static’.
class B extends A <
/* foo() will be copied to B, hence its scope will still be A and
* the call be successful */
>
class C extends A <
protected function foo () < //note the change here
echo ‘hello world!’ ;
>
>
I discovered an interesting thing. The class name string must be accessed directly from «flat» variable. Late static binding code that get’s it’s variable from array that is passed by class instance, throws an syntax error. Bug?
public static function numbers ()
<
return 123 ;
>
$arr = array( ‘class’ => ‘A’ );
This function can be used as a workaround for late static binding in PHP >= 5.1.0. There was another similar version of this function elsewhere, but used eval.
At least as of PHP 5.3.0a2 there’s a function get_called_class(), which returns the class on which the static method is called.
class a <
static public function test () <
print get_called_class ();
>
>
a :: test (); // «a»
b :: test (); // «b»
You can pass arguments to your constructor through your getInstance method, assuming you are running php5.
This would pass the params to your constructor. Love for php.
PHP5.3 unavailable, yet in the need for ‘static’, I did the following.
Any objections? Personally I hate using the the eval() statement.
Here is a small workaround I made for the static inheritance issue. It’s not perfect, but it works.
// Init
$backTrace = debug_backtrace ();
$class = false ;
public static function staticClassName () <
// Get real name
$staticName = self :: getStatic ();
?>
There are two issues with this workaround :
— if you call a static method from global env, you need to declare the name of the class BEFORE calling the method, otherwise the workaround won’t work (see 3rd and 4th examples). But I assume good programming makes few calls to static methods from global scope, so this shouldn’t be long to fix if you use it.
— the workaround fails to access to private or protected static vars, as it uses get_class_vars(). If you find any better solution, let us know.
Позднее статическое связывание — PHP: Погружаясь в классы
Подобное поведение можно рассматривать как ограничение. Фактически оно игнорирует факт наследования. Позднее связывание же открывает доступ к некоторым возможностям, которые широко эксплуатируются в некоторых других языках, таких как Ruby. Прежде чем вдаваться в технические детали, нужно немного разобраться с тем, какую роль играют статические свойства и методы в классах.
Данные в статических свойствах относятся к классу в целом. Они «описывают» его. Самый распространённый пример из веба — это связь сущности с таблицей в базе данных, где она хранится:
Почему эту информацию нужно хранить в статическом свойстве? Потому что она не принадлежит конкретному объекту. Представьте, что вы просто хотите узнать из кода, в какую таблицу будут сохраняться пользователи. Если бы эта информация не была статической, то пришлось бы создавать объект только ради того, чтобы узнать ответ на наш вопрос. Это бессмысленно.
Для сохранения сущности в базу данных обычно используются библиотеки ORM (Object-Relationship Mapping), которые, в том числе, знают, как сохранять сущности в базу и как извлечь их. Большинство из них построено на наследовании. Любая сущность должна наследоваться от специального базового класса, который содержит в себе общую логику для работы с базой данных:
Для сохранения пользователя в базу, недостаточно знать, что сохранять, нужно ещё понимать, куда сохранять. И эта информация записана в статическое свойство.