Php приватные свойства объектов

С помощью специальных модификаторов можно задать область видимости для свойств и методов класса. В PHP есть три таких модификатора:

public : к свойствам и методам, объявленным с данным модификатором, можно обращаться из внешнего кода и из любой части программы
protected : свойства и методы с данным модификатором доступны из текущего класса, а также из классов-наследников
private : свойства и методы с данным модификатором доступны только из текущего класса

Рассмотрим на примере. Например, у нас есть следующий класс:

class Person < private $privateA ="private"; public $publicA = "public"; protected $protectedA = "protected"; private function getPrivateMethod() < echo "private method 
"; > protected function getProtectedMethod() < echo "protected method 
"; > public function getPublicMethod() < echo "public method 
"; > function test() < $this->getPrivateMethod(); $this->getProtectedMethod(); $this->getPublicMethod(); echo "$this->privateA 
"; echo "$this->protectedA 
"; echo "$this->publicA 
"; > >

Класс определяет три свойства и три метода с разными модификаторами доступа. Из любого метода этого класса мы можем обратиться к любом методу и любому свойству. Если метод не имеет модификатора доступа, то по умолчанию его видимость аналогична модификатору public .

Теперь создадим класс, производный от класса Person:

class Employee extends Person < function test() < //echo $this->privateA; // нельзя, так как privateA - private в классе-родителе echo $this->protectedA; echo $this->publicA; //$this->getPrivateMethod(); // нельзя, так как private в классе-родителе $this->getProtectedMethod(); $this->getPublicMethod(); > >

Классу-наследнику доступны все свойства и методы с модификаторами public и protected , но недоступны методы и свойства с модификатором private .

Теперь рассмотрим использование класса Person во внешнем коде:

$person = new Person; // $person->getPrivateMethod(); // недоступно, так как private // $person->getProtectedMethod(); // недоступно, так как protected $person->getPublicMethod(); // echo $person->privateA; // недоступно, так как private // echo $person->protectedA; // недоступно, так как protected echo $person->publicA;

При использовании объектов данного класса нам доступны только публичные методы и свойства, а свойства и методы с модификаторами private и protected не доступны.

Доступ к методам и свойствам объекта

Стоит отметить, что в PHP в классе можно обращаться в переменным и методам с модификаторами private и protected объекта этого же класса:

class Account< private $sum = 0; function __construct($sum)< $this->sum = $sum; > function getSumFrom($otherAccount, $money) < $otherAccount ->sum -= $money; $this -> sum += $money; > function prinSum()< echo "На счете $this->sum у.е.
"; > > $acc1 = new Account(100); $acc2 = new Account(400); $acc1->getSumFrom($acc2, 200); $acc1->prinSum(); // На счете 300 у.е.

Класс Account представляет условный класс банковского счета. В приватной переменной $sum хранится сумма на счете.

В методе getSumFrom() в качестве параметра получаем объект этого же класса Account и сумму перевода. И поскольку объект представляет тот же класс Account, то мы можем обратиться к его свойствам и методам с модификаторами private и protected:

И таким образом, выполнить условный денежный перевод с счета на счет.

Источник

Получаем доступ к приватным свойствам объектов в PHP без рефлексии

Несколько недель назад я работал над проблемой в ProxyManager. Проблема была проста: ReflectionClass и ReflectionProperty очень, очень, и ооочень медленные!
Причиной этого исследования является моя попытка оптимизировать «hydrator» для работы с большими объемами данных без накладных расходов на инициализацию.

PHP 5.4 выручай!

PHP 5.4 дал нам новое API для замыканий и метод Closure#bind() .
Closure#bind() в принципе позволяет получить экземпляр замыкания с областью видимости данного класса, или объекта. Изящно! Вот так можно добавить API к существующим объектам!
Давайте же нарушим инкапсуляцию объектов в соответствии с нашими потребностями.
Методы доступа к приватным свойствам уже объяснялись в документации, но я все равно приведу пример.
Украдем приватное свойство Kitchen#yummy :

Fatal error: Cannot access private property Kitchen::$yummy in [. ] on line [. ]

Closure::bind vs Reflection: быстродействие

yummy; >, null, 'Kitchen'); > setAccessible(true); >

На только что скомпилированном PHP 5.5 (Ubuntu 13.04 amd64 box), первый тест занял 0.325 секунд, а второй 0.658.

Рефлексия здесь гораздо медленнее.(На 49%)

Но это совсем не интересно, так как никому не потребуется инициализировать 100000 раз одно и то же, по крайней мере мне точно. Что на самом деле интересно — так это доступ к приватным свойствам. Я протестировал и это тоже:

yummy; >, null, 'Kitchen'); for ($i = 0; $i < 100000; $i += 1) < $sweetsThief($kitchen); >setAccessible(true); for ($i = 0; $i < 100000; $i += 1) < $sweetsThief->getValue($kitchen); >

Первый тест занял ~ 0.110 секунд, а второй ~ 0.199!
Это гораздо быстрее рефлексии, впечатляет!(На 55%)

Доступ к приватным свойствам по ссылкам

Есть еще одно преимущество, используя замыкания вместо рефлексии мы можем работать с свойствами объекта по ссылкам!

yummy; >, null, $kitchen); $cake = & $sweetsThief($kitchen); $cake = 'lie'; var_dump('the cake is a ' . $sweetsThief($kitchen));

Универсальный метод доступа

Учитывая выше сказанное, мы можем написать простую обертку для получения любого свойства любого объекта:

$property; >, $object, $object)->__invoke(); return $value; >; $kitchen = new Kitchen(); $cake = & $reader($kitchen, 'cake'); $cake = 'sorry, I ate it!'; var_dump($kitchen);

Рабочий пример.
У нас есть доступ к любому свойству, в любом месте, и даже по ссылке. Ура! Мы нарушили правила еще раз!

Заключение

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

Дисклеймер: используйте данную возможность с осторожностью!

Источник

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».

Источник

Получаем доступ к приватным методам и свойствам в PHP

При использовании сторонних библиотек бывает необходимо исправить логику работы определенных её частей или же в ней не хватает необходимого Вам функционала. Конечно хорошим решением является расширение функционала библиотеки и отправка Pull Request автору. Однако далеко не все на них реагируют, а если и реагируют, то достаточно долго. При попытке исправить ситуацию своими силами, не вмешиваясь в библиотеку можно столкнуться с тем, что автор закрыл доступ к свойствам не позаботившисть об открытом методе для получения значения свойства(getter). Эту проблему можно решить относительно легко с помощью замыкания и не прибегая к Reflection.

Начиная с PHP 5.4, замыкания получили методы, позволяющие контролировать анонимные функции после их создания. Нас, в первую очередь, интересует метод call, который связывает замыкание с контекстом выполнения, и вызывает его с заданными параметрами.

Итак, если у нас PHP 5.4 или выше и есть экземпляр объекта, то мы без проблем можем получить доступ к закрытым свойствам и методам, например так:

\n"; > > // Берем экземпляр объекта подопытного $foo = new Foo(); // Создаем замыкание, которое вызовет приватный метод // и вернет значение приватного свойства $closure = function () < $this->testFunc('. '); return $this->test; >; // Выполняем замыкание, переопределив контекст выполнения echo $closure->call($foo) . PHP_EOL;

Результат выполнения:

Источник