Лучшая практика: магические методы PHP __set и __get
Возможный дубликат:
Магические методы - лучшая практика в PHP?
Это простые примеры, но представьте, что в вашем классе больше свойств, чем двух.
Что будет лучшей практикой?
а) Использование __get и __set
class MyClass {
private $firstField;
private $secondField;
public function __get($property) {
if (property_exists($this, $property)) {
return $this->$property;
}
}
public function __set($property, $value) {
if (property_exists($this, $property)) {
$this->$property = $value;
}
}
}
$myClass = new MyClass();
$myClass->firstField = "This is a foo line";
$myClass->secondField = "This is a bar line";
echo $myClass->firstField;
echo $myClass->secondField;
/* Output:
This is a foo line
This is a bar line
*/
б) Использование традиционных сеттеров и геттеров
class MyClass {
private $firstField;
private $secondField;
public function getFirstField() {
return $this->firstField;
}
public function setFirstField($firstField) {
$this->firstField = $firstField;
}
public function getSecondField() {
return $this->secondField;
}
public function setSecondField($secondField) {
$this->secondField = $secondField;
}
}
$myClass = new MyClass();
$myClass->setFirstField("This is a foo line");
$myClass->setSecondField("This is a bar line");
echo $myClass->getFirstField();
echo $myClass->getSecondField();
/* Output:
This is a foo line
This is a bar line
*/
В этой статье: http://blog.webspecies.co.uk/2011-05-23/the-new-era-of-php-frameworks.html
Автор утверждает, что использование магических методов не очень хорошая идея:
Прежде всего, тогда было очень популярно использовать магические функции PHP (__get, __call и т. Д.). На первый взгляд, с ними все в порядке, но на самом деле они действительно опасны. Они делают API-интерфейсы неясными, автоматическое заполнение невозможно, а главное - медленными. Вариант использования для них состоял в том, чтобы взломать PHP, чтобы делать то, что он не хотел. И это сработало. Но случилось плохое.
Но я хотел бы услышать больше мнений по этому поводу.
9 ответов
Я был именно в вашем случае в прошлом. И я пошел на магические методы.
Это была ошибка, последняя часть вашего вопроса говорит обо всем:
- это медленнее (чем геттеры / сеттеры)
- отсутствует автозаполнение (и это на самом деле серьезная проблема), а также управление типами в IDE для рефакторинга и просмотра кода (в Zend Studio/PhpStorm это может быть выполнено с помощью
@propertyаннотации phpdoc, но это требует их поддержания: довольно больно) - документация (phpdoc) не соответствует тому, как предполагается использовать ваш код, и просмотр вашего класса также не дает много ответов. Это смущает.
- добавлено после редактирования: наличие геттеров для свойств более соответствует "реальным" методам, где
getXXX()не только возвращает частную собственность, но и делает настоящую логику. У вас такое же наименование. Например, у вас есть$user->getName()(возвращает частную собственность) и$user->getToken($key)(Вычисленный). В тот день, когда ваш получатель получит больше, чем получатель, и ему понадобится немного логики, все по-прежнему непротиворечиво.
Наконец, и это самая большая проблема ИМО: это волшебство. И магия очень, очень плоха, потому что вы должны знать, как работает магия, чтобы правильно ее использовать. Вот проблема, с которой я столкнулся в команде: каждый должен понимать магию, а не только ты.
Геттеры и сеттеры - это трудная задача (я их ненавижу), но они того стоят.
Вам нужно использовать магию, только если объект действительно "магический". Если у вас есть классический объект с фиксированными свойствами, используйте сеттеры и геттеры, они работают нормально.
Если ваш объект имеет динамические свойства, например, он является частью уровня абстракции базы данных, а его параметры устанавливаются во время выполнения, тогда вам действительно нужны магические методы для удобства.
Я использую __get (и общедоступных свойств) настолько, насколько это возможно, потому что они делают код намного более читабельным. Для сравнения:
этот код недвусмысленно говорит о том, что я делаю:
echo $user->name;
этот код заставляет меня чувствовать себя глупо, что мне не нравится:
function getName() { return $this->_name; }
....
echo $user->getName();
Разница между ними особенно очевидна, когда вы обращаетесь к нескольким свойствам одновременно.
echo "
Dear $user->firstName $user->lastName!
Your purchase:
$product->name $product->count x $product->price
"
а также
echo "
Dear " . $user->getFirstName() . " " . $user->getLastName() . "
Your purchase:
" . $product->getName() . " " . $product->getCount() . " x " . $product->getPrice() . " ";
Будь то $a->b должен действительно что- то сделать или просто вернуть значение - это ответственность вызываемого абонента. Для звонящего, $user->name а также $user->accountBalance должен выглядеть одинаково, хотя последний может включать сложные вычисления. В моих классах данных я использую следующий небольшой метод:
function __get($p) {
$m = "get_$p";
if(method_exists($this, $m)) return $this->$m();
user_error("undefined property $p");
}
когда кто-то звонит $obj->xxx и класс имеет get_xxx определенный, этот метод будет вызываться неявно. Таким образом, вы можете определить метод получения, если он вам нужен, сохраняя при этом интерфейс единообразным и прозрачным. В качестве дополнительного бонуса это обеспечивает элегантный способ запомнить вычисления:
function get_accountBalance() {
$result = <...complex stuff...>
// since we cache the result in a public property, the getter will be called only once
$this->accountBalance = $result;
}
....
echo $user->accountBalance; // calculate the value
....
echo $user->accountBalance; // use the cached value
Итог: php - это динамический язык сценариев, используйте его таким образом, не притворяйтесь, что вы делаете Java или C#.
Я делаю смесь ответа Эдема и вашего второго кода. Таким образом, у меня есть преимущества общих методов получения / установки (завершение кода в вашей IDE), простота кодирования, если я хочу, исключения из-за несуществующих свойств (отлично подходит для обнаружения опечаток: $foo->naem вместо $foo->name), только для чтения свойства и составные свойства.
class Foo
{
private $_bar;
private $_baz;
public function getBar()
{
return $this->_bar;
}
public function setBar($value)
{
$this->_bar = $value;
}
public function getBaz()
{
return $this->_baz;
}
public function getBarBaz()
{
return $this->_bar . ' ' . $this->_baz;
}
public function __get($var)
{
$func = 'get'.$var;
if (method_exists($this, $func))
{
return $this->$func();
} else {
throw new InexistentPropertyException("Inexistent property: $var");
}
}
public function __set($var, $value)
{
$func = 'set'.$var;
if (method_exists($this, $func))
{
$this->$func($value);
} else {
if (method_exists($this, 'get'.$var))
{
throw new ReadOnlyException("property $var is read-only");
} else {
throw new InexistentPropertyException("Inexistent property: $var");
}
}
}
}
Я голосую за третье решение. Я использую это в своих проектах, и Symfony тоже использует что-то вроде этого:
public function __call($val, $x) {
if(substr($val, 0, 3) == 'get') {
$varname = strtolower(substr($val, 3));
}
else {
throw new Exception('Bad method.', 500);
}
if(property_exists('Yourclass', $varname)) {
return $this->$varname;
} else {
throw new Exception('Property does not exist: '.$varname, 500);
}
}
Таким образом, у вас есть автоматические методы получения (вы также можете писать методы установки), и вам нужно писать новые методы, только если есть особый случай для переменной-члена.
Вам следует использовать stdClass, если вы хотите использовать магические члены, если вы пишете класс - определите, что он содержит.
Второй пример кода - гораздо более правильный способ сделать это, потому что вы получаете полный контроль над данными, которые передаются class, Есть случаи, когда __set а также __get полезны, но не в этом случае.
Лучшей практикой будет использование традиционных методов получения и установки из-за самоанализа или рефлексии. В PHP есть способ (в точности как в Java) получить имя метода или всех методов. Такая вещь будет возвращать "__get" в первом случае и "getFirstField", "getSecondField" во втором (плюс сеттеры).
Подробнее об этом: http://php.net/manual/en/book.reflection.php
Сейчас я возвращаюсь к установщикам и получателям, но я также помещаю получатели и установщики в магические методы __get и __set. Таким образом, у меня есть поведение по умолчанию, когда я делаю это
$ Class-> вар;
Это просто вызовет получатель, который я установил в __get. Обычно я просто использую геттер напрямую, но есть некоторые случаи, когда это проще.