php self что это
ЗлостныйКодер
Программирование, Алгоритмы, С++, C#, Java, Python и другие вещи
четверг, 19 декабря 2013 г.
Обычна нужна, чтобы инициализировать поля в конструкторе, ну и не только:
$self используется в том, же самом ключе, но уже для СТАТИЧЕСКИХ свойств:
Результат:
self::STAT: S
self::$stat: Static
Strict Standards: Accessing static property Klass::$stat as non static in htdocs\test\testReference.php on line ..
Notice: Undefined property: Klass::$stat in C:\xampp\htdocs\test\testReference.php on line 50
$this->stat:
$this->publ: Public
Видно, что php умный и кидает предупреждения глупым программистам. Не делайте так.
Второе главное отличие состоит в том, что
self не использует таблицу виртуальных методов, то есть:
(взято с StackOverflow)
Hello, I’m Ludwig the geek
Goodbye from Ludwig the person
Пояснение:
Метод sayHello использует this, поэтому виртуальная таблица вызовет Geek::getTitle()
Метод sayGoodbye использует self, поэтому виртуальная таблица будет не задействована и будет вызван parent::getTitle()
Решение:
Используем вместо self, static keyword:
public function sayGoodbye() <
echo «Goodbye from «. static::getTitle() ;
Готовимся к собеседованию по PHP: ключевое слово «static»
Не секрет, что на собеседованиях любят задавать каверзные вопросы. Не всегда адекватные, не всегда имеющие отношение к реальности, но факт остается фактом — задают. Конечно, вопрос вопросу рознь, и иногда вопрос, на первый взгляд кажущийся вам дурацким, на самом деле направлен на проверку того, насколько хорошо вы знаете язык, на котором пишете.
Попробуем разобрать «по косточкам» один из таких вопросов — что значит слово «static» в PHP и зачем оно применяется?
Ключевое слово static имеет в PHP три различных значения. Разберем их в хронологическом порядке, как они появлялись в языке.
Значение первое — статическая локальная переменная
Однако всё меняется, если мы перед присваиванием поставим ключевое слово static:
Подводные камни статических переменных
Разумеется, как всегда в PHP, не обходится без «подводных камней».
Камень первый — статической переменной присваивать можно только константы или константные выражения. Вот такой код:
с неизбежностью приведет к ошибке парсера. К счастью, начиная с версии 5.6 стало допустимым присвоение не только констант, но и константных выражений (например — «1+2» или «[1, 2, 3]»), то есть таких выражений, которые не зависят от другого кода и могут быть вычислены на этапе компиляции
Камень второй — методы существуют в единственном экземпляре.
Тут всё чуть сложнее. Для понимания сути приведу код:
Такое поведение может быть неожиданным для неподготовленного к нему разработчика и послужить источником ошибок. Нужно заметить, что наследование класса (и метода) приводит к тому, что всё-таки создается новый метод:
Вывод: динамические методы в PHP существуют в контексте классов, а не объектов. И только лишь в рантайме происходит подстановка «$this = текущий_объект»
Значение второе — статические свойства и методы классов
В объектной модели PHP существует возможность задавать свойства и методы не только для объектов — экземпляров класса, но и для класса в целом. Для этого тоже служит ключевое слово static:
Для доступа к таким свойствам и методам используются конструкции с двойным двоеточием («Paamayim Nekudotayim»), такие как ИМЯ_КЛАССА::$имяПеременной и ИМЯ_КЛАССА:: имяМетода().
Само собой разумеется, что у статических свойств и статических методов есть свои особенности и свои «подводные камни», которые нужно знать.
Особенность вторая — static не аксиома!
Обратное не совсем верно:
И кстати, всё написанное выше относится только к методам. Использование статического свойства через «->» невозможно и ведет к фатальной ошибке.
Значение третье, кажущееся самым сложным — позднее статическое связывание
Разработчики языка PHP не остановились на двух значениях ключевого слова «static» и в версии 5.3 добавили еще одну «фичу» языка, которая реализована тем же самым словом! Она называется «позднее статическое связывание» или LSB (Late Static Binding).
Понять суть LSB проще всего на несложных примерах:
Ключевое слово self в PHP всегда значит «имя класса, где это слово написано». В данном случае self заменяется на класс Model, а self::$table — на Model::$table.
Такая языковая возможность называется «ранним статическим связыванием». Почему ранним? Потому что связывание self и конкретного имени класса происходит не в рантайме, а на более ранних этапах — парсинга и компиляции кода. Ну а «статическое» — потому что речь идет о статических свойствах и методах.
Немного изменим наш код:
Теперь вы понимаете, почему PHP ведёт себя в этой ситуации неинтуитивно. self был связан с классом Model тогда, когда о классе User еще ничего не было известно, поэтому и указывает на Model.
Для решения этой дилеммы был придуман механизм связывания «позднего», на этапе рантайма. Работает он очень просто — достаточно вместо слова «self» написать «static» и связь будет установлена с тем классом, который вызывает данный код, а не с тем, где он написан:
Это и есть загадочное «позднее статическое связывание».
Нужно отметить, что для большего удобства в PHP кроме слова «static» есть еще специальная функция get_called_class(), которая сообщит вам — в контексте какого класса в данный момент работает ваш код.
Позднее статическое связывание в 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-разработчиков. Во второй части рассмотрим как его можно использовать во благо.
$_SERVER
(PHP 4 >= 4.1.0, PHP 5, PHP 7, PHP 8)
$_SERVER — Информация о сервере и среде исполнения
Описание
Индексы
Абсолютный путь к исполняемому скрипту.
‘ SERVER_ADMIN ‘ Эта переменная получает своё значение (для Apache) из директивы конфигурационного файла сервера. Если скрипт запущен на виртуальном хосте, это будет значение, определённое для данного виртуального хоста. ‘ SERVER_PORT ‘ Порт на компьютере сервера, используемый сервером для соединения. Для установок по умолчанию, значение будет ‘ 80 ‘; используя SSL, например, это значение будет таким, какое сконфигурировано для соединений безопасного HTTP.
Примеры
Результатом выполнения данного примера будет что-то подобное:
Примечания
Смотрите также
User Contributed Notes 45 notes
Just a PHP file to put on your local server (as I don’t have enough memory)
That will give you the result of each variable like (if the file is server_indices.php at the root and Apache Web directory is in E:\web) :
No need to list all possible keys of the array.
The javascript block would define an event handler function and bind it to the form’s submit event. This event handler would load via an tag an external file, with the submitted username and password as parameters.
For example, with a PHP script, we can have this:
Will show something like 1492897785
However, a lot of vars are still vulnerable from environment injection.
I created a gist here ( https://gist.github.com/Pierstoval/f287d3e61252e791a943dd73874ab5ee ) with my PHP configuration on windows with PHP7.0.15 on WSL with bash, the results are that the only «safe» vars are the following:
All the rest can be overriden with environment vars, which is not very cool actually because it can break PHP applications sometimes.
An even *more* improved version.
You have missed ‘REDIRECT_STATUS’
Very useful if you point all your error pages to the same file.
ErrorDocument 404 /error-msg.php
ErrorDocument 500 /error-msg.php
ErrorDocument 400 /error-msg.php
ErrorDocument 401 /error-msg.php
ErrorDocument 403 /error-msg.php
# End of file.
Guide to absolute paths.
Data: __FILE__
Data type: String
Purpose: The absolute pathname of the running PHP file, including the filename.
Caveat: This is not the file called by the PHP processor, it’s what is running. So if you are inside an include, it’s the include.
Caveat: Symbolic links are pre-resolved, so don’t trust comparison of paths to be accurate.
Caveat: Don’t assume all operating systems use ‘/’ for the directory separator.
Works on web mode: Yes
Works on CLI mode: Yes
Data: __DIR__
Data type: String
Purpose: The absolute pathname to the running PHP file, excluding the filename
Caveat: This is not the file called by the PHP processor, it’s what is running. So if you are inside an include, it’s the include.
Caveat: Symbolic links are pre-resolved, so don’t trust comparison of paths to be accurate.
Caveat: Don’t assume all operating systems use ‘/’ for the directory separator.
Works on web mode: Yes
Works on CLI mode: Yes
If the browser sends an HTTP request header of:
X-Debug-Custom: some string
[ ‘HTTP_X_DEBUG_CUSTOM’ ]; // «some string»
?>
There are better ways to identify the HTTP request headers sent by the browser, but this is convenient if you know what to expect from, for example, an AJAX script with custom headers.
Works in PHP5 on Apache with mod_php. Don’t know if this is true from other environments.
They are still accessible, but only if the request was a POST request. When it is, it’ll be available as:
$_SERVER[‘CONTENT_LENGTH’]
$_SERVER[‘CONTENT_TYPE’]
So near, and yet so far …
$_SERVER has nearly everything you need to know about the current web page environment. Something which would have been handy is easy access to the protocol and the actual web root.
For practical purposes, I normally include something like the following in my scripts:
Depending on what you want to do the content of this variable, put in On or Off.
This happens, for example, when calling the page through a call to stream_context_create() with a HTTP header of ‘request_fulluri’ set to 1.
Apparently, request_fulluri is useful when using some proxy servers.
One quick (and improvable) way to detect it would be to compare the start of the REQUEST_URI with REQUEST_SCHEME:
A way to get the absolute path of your page, independent from the site position (so works both on local machine and on server without setting anything) and from the server OS (works both on Unix systems and Windows systems).
[«_SERVER»]=>
array(24) <
[«MANPATH»]=>
string(48) «/usr/share/man:/usr/local/share/man:/usr/X11/man»
[«TERM»]=>
string(11) «xterm-color»
[«SHELL»]=>
string(9) «/bin/bash»
[«SSH_CLIENT»]=>
string(20) «127.0.0.1 41242 22»
[«OLDPWD»]=>
string(60) «/Library/WebServer/Domains/www.example.com/private»
[«SSH_TTY»]=>
string(12) «/dev/ttys000»
[«USER»]=>
string(5) «username»
[«MAIL»]=>
string(15) «/var/mail/username»
[«PATH»]=>
string(57) «/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/usr/X11/bin»
[«PWD»]=>
string(56) «/Library/WebServer/Domains/www.example.com/www»
[«SHLVL»]=>
string(1) «1»
[«HOME»]=>
string(12) «/Users/username»
[«LOGNAME»]=>
string(5) «username»
[«SSH_CONNECTION»]=>
string(31) «127.0.0.1 41242 10.0.0.1 22»
[«_»]=>
string(12) «/usr/bin/php»
[«__CF_USER_TEXT_ENCODING»]=>
string(9) «0x1F5:0:0»
[«PHP_SELF»]=>
string(10) «Shell.php»
[«SCRIPT_NAME»]=>
string(10) «Shell.php»
[«SCRIPT_FILENAME»]=>
string(10) «Shell.php»
[«PATH_TRANSLATED»]=>
string(10) «Shell.php»
[«DOCUMENT_ROOT»]=>
string(0) «»
[«REQUEST_TIME»]=>
int(1247162183)
[«argv»]=>
array(1) <
[0]=>
string(10) «Shell.php»
>
[«argc»]=>
int(1)
>
Guide to URL paths.
Ответ 1
Короткий ответ
Полный ответ
Вот пример подавления полиморфного поведения с помощью self функций-членов:
Ответ 2
public function __construct($name) <
public function getName() <
public function getTitle() <
public function sayHello() <
echo «Hello, I’m «.$this->getTitle().»
«;
public function sayGoodbye() <
echo «Goodbye from «.self::getTitle().»
«;
class Geek extends Person <
public function __construct($name) <
public function getTitle() <
$geekObj = new Geek(«Ludwig»);
Hello, I’m Ludwig the geek
Goodbye from Ludwig the person
Ответ 3
НЕ ИСПОЛЬЗУЙТЕ self. используйте static::
Есть еще один аспект self. о котором стоит упомянуть. Досадно, что self:: относится к области видимости в точке определения, а не в точке выполнения. Рассмотрим простой класс с двумя методами:
public static function status() <
protected static function getStatus() <
echo «Person is alive»;
class Deceased extends Person <
protected static function getStatus() <
echo «Person is deceased»;
$this-> относится к текущему объекту (экземпляру класса), тогда как static:: относится непосредственно к классу.
Ответ 4
Классы и объекты, концептуально
public function sayHello() <
Важно отметить, что класс является статической структурой. Это означает, что Person однажды определяется как класс и всегда будет одним и тем же везде, куда бы вы ни посмотрели.
С другой стороны, объект — это то, что называется экземпляром класса. Это означает, что мы берем «план» класса и используем его для создания динамической копии. Эта копия теперь специально привязана к переменной, в которой она хранится. Следовательно, любые изменения в экземпляре являются локальными для этого экземпляра.
Поэтому мы говорим, что класс — это глобальная структура, а объект — это локальная структура.
Определение состояния
Итак, давайте немного углубимся в то, что на самом деле содержит класс. Класс содержит 5 типов « элементов » :
Свойства — воспринимайте их как переменные, которые будет содержаться в каждом экземпляре.
Статические свойства — воспринимайте их как переменные, которые раздел я ются на уровне класса. Это означает, что они никогда не копируются каждым экземпляром.
Методы — это функции, которые будут содержаться в каждом экземпляре (и работать над экземплярами).
public function bar() <>
Статические методы — это функции, общие для всего класса. Они не работают с экземплярами, только со статическими свойствами.
public static function bar() <>
Константы — класс разрешает использование констант. Не будем углубляться, но добавим для полноты:
Итак, по сути, мы храним информацию о классе и контейнере объекта, используя « подсказки » о статике, которые определяют, является ли информация общей (и, следовательно, статической) или нет (и, следовательно, динамической).
Состояние и методы
Интересным здесь является то, как выполняются статические вызовы. Поэтому давайте поговорим о том, как мы получаем доступ к состоянию.
Состояние доступа
Итак, теперь, когда мы сохранили это состояние, нам нужно получить к нему доступ. Это может оказаться немного сложным, поэтому давайте разделим это на две точки зрения: снаружи экземпляра/класса (скажем, из обычного вызова функции или из глобальной области видимости) и внутри экземпляра/класса (из метода объекта).
Снаружи экземпляра/класса
С внешней стороны экземпляра/класса наши правила довольно просты и предсказуемы. У нас есть два оператора, и каждый из них сразу говорит нам, имеем ли мы дело с экземпляром или статическим классом:
Важно отметить, что вызов Person->foo не имеет смысла (поскольку Person — это класс, а не экземпляр). Следовательно, это ошибка синтаксического анализа.
Кроме того, мы можем таким же образом вызвать статический метод объекта:
Внутри экземпляра/класса
Здесь все немного меняется. Используются те же операторы, но их смысл становится другим.
public function bar() <
Так мы и ожидаем. Но смысл :: оператора меняется. Это зависит от контекста вызова текущей функции:
В статическом контексте.
public function bar() <
public function baz() <
В контексте экземпляра.
Краткие ключевые слова
Поскольку связывать все вместе, используя имена классов, довольно не профессионально, PHP предоставляет 3 основных «сокращенных» ключевых слова, чтобы упростить определение области видимости.
Примеры
Самый простой способ понять это — рассмотреть несколько примеров. Выберем класс:
public function __construct() <
public function getName() <
public function getId() <
class Child extends Person <
public function __construct($age) <
public function getName() <
Здесь мы также рассматриваем наследование. Не обращайте внимания на то, что это плохая объектная модель, но давайте посмотрим, что происходит, когда мы экспериментируем с этим:
var_dump($billy->getName()); // child: Billy
Обратите внимание, что мы каждый раз выполняем метод экземпляра Person::getName(). Но мы используем parent::getName(), чтобы сделать это в одном из случаев (дочерний случай). Именно это и делает данный подход мощным.
Мы будем очень благодарны
если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.