mirror of
https://github.com/php/doc-ru.git
synced 2025-07-22 18:26:31 +00:00
Обновление перевода (#644)
This commit is contained in:
Mikhail Alferov
@ -2,52 +2,51 @@
|
||||
<!-- EN-Revision: 88890f831cb49dc2b2be942039b1938217b1cc54 Maintainer: shein Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<appendix xml:id="types.comparisons" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<title>Таблица сравнения типов в PHP</title>
|
||||
<title>Таблицы сравнения типов PHP</title>
|
||||
<para>
|
||||
Следующие таблицы демонстрируют работу PHP с
|
||||
<link linkend="language.types">типами переменных</link> и
|
||||
<link linkend="language.operators.comparison">операторами сравнения</link>, как в
|
||||
случае свободного, так и в случае строгого сравнения. Также эта информация относится
|
||||
Следующие таблицы показывают работу PHP
|
||||
с <link linkend="language.types">типами переменных</link>
|
||||
и <link linkend="language.operators.comparison">операторами сравнения</link>
|
||||
как для свободных, так и для строгих сравнений. Эта информация также относится
|
||||
к разделу документации по <link linkend="language.types.type-juggling">приведению
|
||||
типов</link>. Вдохновением на создание этого раздела мы обязаны различным комментариям
|
||||
пользователей и работе над
|
||||
<link xlink:href="&url.blueshoes.comparisons;">BlueShoes</link>.
|
||||
типов</link>. Написать этот раздел разработчиков PHP воодушивили комментарии пользователей и работа
|
||||
над фреймворком <link xlink:href="&url.blueshoes.comparisons;">BlueShoes</link>.
|
||||
</para>
|
||||
<para>
|
||||
До осмотра таблиц, важно знать и понимать типы переменных и их значения.
|
||||
К примеру, <literal>"42"</literal> - <type>string</type>,
|
||||
в то время как <literal>42</literal> - <type>int</type>. &false; -
|
||||
<type>bool</type>, а <literal>"false"</literal> - <type>string</type>.
|
||||
Перед тем как начать пользоваться таблицами, важно понять типы и их значения.
|
||||
Наример, <literal>«42»</literal> — строка (<type>string</type>),
|
||||
а <literal>42</literal> — целое число (<type>int</type>). Значение &false; —
|
||||
логическое значение (<type>bool</type>), а <literal>«false»</literal> — строка (<type>string</type>).
|
||||
</para>
|
||||
<note>
|
||||
<para>
|
||||
HTML-формы не передают целые, дробные числа или булевые переменные: они всегда
|
||||
передают строки. Для проверки является ли строка числом, используйте функцию
|
||||
<function>is_numeric</function>.
|
||||
HTML-формы не передают целые, дробные числа или булевые переменные: они
|
||||
передают только строки. Выяснить, числовая ли строка,
|
||||
можно через функцию <function>is_numeric</function>.
|
||||
</para>
|
||||
</note>
|
||||
<note>
|
||||
<para>
|
||||
Использование <literal>if ($x)</literal>, если <varname>$x</varname> не
|
||||
определена, сгенерирует ошибку уровня <constant>E_NOTICE</constant>.
|
||||
Вместо этого используйте функцию <function>empty</function> или
|
||||
<function>isset</function> и/или инициализируйте переменную.
|
||||
Выражение <literal>if ($x)</literal>, если переменная <varname>$x</varname>
|
||||
не определена, сгенерирует ошибку уровня <constant>E_NOTICE</constant>.
|
||||
Вместо этого пользуются языковыми конструкциями <function>empty</function>
|
||||
или <function>isset</function>, и/или инициализируют переменную.
|
||||
</para>
|
||||
</note>
|
||||
<note>
|
||||
<para>
|
||||
Некоторые арифметические операции могут вернуть значение,
|
||||
представленное константой <constant>NAN</constant> (Not A Number,
|
||||
не-число). Любое строгое или нестрогое сравнение этого значения
|
||||
с каким-либо другим, включая его самого, но исключая &true;, вернёт &false; (т.е.
|
||||
Бывают арифметические операции, возвращающие значение,
|
||||
которое представляет константа <constant>NAN</constant> (Not A Number,
|
||||
нечисло). Любое строгое или нестрогое сравнение этого значения
|
||||
с любым другим, включая его самого, но исключая &true;, вернёт &false; (т. е.
|
||||
<literal>NAN != NAN</literal> и <literal>NAN !== NAN</literal>).
|
||||
Примерами операций, возвращающих <constant>NAN</constant>, являются
|
||||
Примеры операций, возвращающих <constant>NAN</constant>, —
|
||||
<literal>sqrt(-1)</literal>, <literal>asin(2)</literal> и <literal>acosh(0)</literal>.
|
||||
</para>
|
||||
</note>
|
||||
<para>
|
||||
<table>
|
||||
<title>Сравнение типов <varname>$x</varname> и результатов функций PHP, связанных с типами</title>
|
||||
<title>Сравнение типов переменной <varname>$x</varname> и результатов функций PHP, связанных с типами</title>
|
||||
<tgroup cols="6">
|
||||
<thead>
|
||||
<row>
|
||||
@ -211,7 +210,7 @@
|
||||
|
||||
<para>
|
||||
<table xml:id="types.comparisions-loose">
|
||||
<title>Гибкое сравнение с помощью <literal>==</literal></title>
|
||||
<title>Гибкое сравнение через оператор <literal>==</literal></title>
|
||||
<tgroup cols="12">
|
||||
<thead>
|
||||
<row>
|
||||
@ -419,7 +418,7 @@
|
||||
|
||||
<para>
|
||||
<table xml:id="type.comparisons-strict">
|
||||
<title>Жёсткое сравнение с помощью <literal>===</literal></title>
|
||||
<title>Жёсткое сравнение через оператор <literal>===</literal></title>
|
||||
<tgroup cols="12">
|
||||
<thead>
|
||||
<row>
|
||||
|
||||
@ -14,10 +14,10 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<para>
|
||||
Собирает динамический модуль для Apache. FILE - это опциональный путь к инструменту
|
||||
"Apache apxs", который используется для apxs по умолчанию. Убедитесь в том,
|
||||
что вы указали версию apxs, которая действительно установлена
|
||||
в вашей системе, а не ту, которая находится в исходниках Apache.
|
||||
Собирает динамический модуль для Apache. FILE — это опциональный путь к инструменту
|
||||
Apache apxs, который используется для apxs по умолчанию. Убедитесь в том,
|
||||
что указали версию apxs, которая действительно установлена
|
||||
в системе, а не ту, которая находится в исходниках Apache.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@ -62,7 +62,7 @@
|
||||
<para>
|
||||
Отключает сборку CLI-версии PHP (опция также вызывает <link linkend="configure.without-pear">--without-pear</link>).
|
||||
Больше информации можно получить в разделе
|
||||
<link linkend="features.commandline">Использование PHP в командной строке</link>.
|
||||
<link linkend="features.commandline">Работа с PHP из командной строки</link>.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
|
||||
@ -2,20 +2,20 @@
|
||||
<!-- EN-Revision: 25338384fe801da952d3d864e9174dd590837e24 Maintainer: rjhdby Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<chapter xml:id="features.commandline" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<title>Использование PHP в командной строке</title>
|
||||
<titleabbrev>Использование PHP в командной строке</titleabbrev>
|
||||
<title>Работа с PHP из командной строки</title>
|
||||
<titleabbrev>Работа с PHP из командной строки</titleabbrev>
|
||||
|
||||
<!--Introduction: {{{-->
|
||||
<section xml:id="features.commandline.introduction">
|
||||
<title>Введение</title>
|
||||
|
||||
<para>
|
||||
Основная цель этого &cli.sapi; -
|
||||
Основная цель этого &cli.sapi; —
|
||||
разработка консольных приложений на PHP.
|
||||
Имеется довольно много различий между
|
||||
Есть довольно много различий между
|
||||
&cli.sapi; и другими видами <acronym>SAPI</acronym>, которые
|
||||
будут рассмотрены в этой главе.
|
||||
Стоит отметить, что &cli.sapi; и <acronym>CGI</acronym> -
|
||||
Стоит отметить, что &cli.sapi; и <acronym>CGI</acronym> —
|
||||
различные <acronym>SAPI</acronym>-интерфейсы, хотя в их поведении много общего.
|
||||
</para>
|
||||
|
||||
@ -517,7 +517,7 @@ string(15) "doesntmakesense"
|
||||
<entry>
|
||||
<para>
|
||||
Парсит и исполняет файл, указанный в опции <option>-f</option>.
|
||||
Этот параметр необязателен и может быть опущен - достаточно
|
||||
Этот параметр необязателен и может быть опущен — достаточно
|
||||
просто указать имя запускаемого файла.
|
||||
</para>
|
||||
</entry>
|
||||
@ -1113,7 +1113,7 @@ $ some_application | some_filter | php | sort -u > final_output.txt
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Вторая зарегистрированная глобальная переменная - это
|
||||
Вторая зарегистрированная глобальная переменная — это
|
||||
<varname>$argc</varname>, содержащая количество элементов
|
||||
в массиве <varname>$argv</varname>
|
||||
(а <emphasis role="strong">не</emphasis> количество аргументов,
|
||||
|
||||
163
features/gc.xml
163
features/gc.xml
@ -6,28 +6,28 @@
|
||||
|
||||
<para>
|
||||
В этом разделе описываются достоинства нового механизма сборки мусора
|
||||
(также называемого Garbage Collection или GC), являющегося частью PHP 5.3.
|
||||
(Garbage Collection или GC), который появился в PHP 5.3.
|
||||
</para>
|
||||
|
||||
<sect1 xml:id="features.gc.refcounting-basics">
|
||||
<title>Основы подсчёта ссылок</title>
|
||||
<para>
|
||||
Переменная PHP хранится в контейнере, называемом "zval". Контейнер zval,
|
||||
помимо типа и значения переменной, также содержит два дополнительных элемента.
|
||||
Первый называется "is_ref" и представляет булево значение, указывающее,
|
||||
является переменная частью "набора ссылок" или нет. Благодаря этому элементу PHP
|
||||
знает как отличать обычные переменные от ссылок. Так как PHP содержит
|
||||
Переменная PHP хранится в контейнере, называемом zval. Контейнер zval,
|
||||
кроме типа и значения переменной, также содержит два дополнительных бита информации.
|
||||
Первый называется is_ref и представляет логическое значение, указывающее,
|
||||
включена ли переменная в «набор ссылок» или нет. За счёт элемента is_ref PHP
|
||||
знает, как отличать обычные переменные от ссылок. Поскольку PHP разрешает
|
||||
пользовательские ссылки, которые можно создать оператором &, контейнер zval
|
||||
также содержит внутренний механизм подсчёта ссылок для оптимизации использования памяти.
|
||||
Эта вторая часть дополнительной информации, называемая "refcount" (счётчик ссылок), содержит
|
||||
количество имён переменных (также называемых символами), которые указывают на данный контейнер zval.
|
||||
также содержит внутренний механизм подсчёта ссылок для оптимизации работы памяти.
|
||||
Вторая часть дополнительной информации называется refcount (счётчик ссылок) и содержит
|
||||
количество имён переменных (или другое название — символов), которые указывают на этот контейнер zval.
|
||||
Все имена переменных хранятся в таблице имён, отдельной для каждой
|
||||
области видимости переменных. Такая область видимости существует для главного скрипта,
|
||||
а также для каждой функции и метода.
|
||||
каждой функции и метода.
|
||||
</para>
|
||||
<para>
|
||||
Контейнер zval создаётся при создании новой переменной, которой
|
||||
присваивается константа, например:
|
||||
Контейнер zval создаётся при объявлении новой переменной, которой
|
||||
присваивается константное значение, например:
|
||||
<example>
|
||||
<title>Создание нового контейнера zval</title>
|
||||
<programlisting role="php">
|
||||
@ -40,13 +40,14 @@ $a = "new string";
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
В данном примере создаётся новый символ <literal>a</literal> в текущей области видимости
|
||||
В этом примере создаётся новый символ <literal>a</literal> в текущей области видимости
|
||||
и новый контейнер переменной с типом <type>string</type> и значением <literal>new string</literal>.
|
||||
Бит "is_ref" по умолчанию задаётся равным &false;, т. к. не создано ни одной пользовательской
|
||||
ссылки. Значение же "refcount" задаётся равным <literal>1</literal>, т. к. только одно имя переменной
|
||||
указывает на данный контейнер. Обратите внимание, что ссылки (т. е. "is_ref" равно &true;) с "refcount" равным <literal>1</literal>
|
||||
обрабатываются так, как если бы они не были ссылками (то есть как "is_ref" было бы &false;). Если у вас установлен <link xlink:href="&url.xdebug;">Xdebug</link>, то
|
||||
вы можете вывести эту информацию, вызвав функцию <function>xdebug_debug_zval</function>.
|
||||
Бит is_ref по умолчанию задаётся равным &false;, т. к. не создано ни одной пользовательской
|
||||
ссылки. Значение же refcount задаётся равным <literal>1</literal>, т. к. только одно имя переменной
|
||||
указывает на этот контейнер. Обратите внимание, что ссылки (т. е. is_ref равно &true;) с refcount равным <literal>1</literal>
|
||||
обрабатываются так, как если бы они не были ссылками (то есть как is_ref было бы &false;).
|
||||
Если установлен <link xlink:href="&url.xdebug;">Xdebug</link>,
|
||||
можете вывести эту информацию, вызвав функцию <function>xdebug_debug_zval</function>.
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
@ -95,8 +96,8 @@ a: (refcount=2, is_ref=0)='new string'
|
||||
<varname>a</varname> и <varname>b</varname> ссылаются на один
|
||||
и тот же контейнер переменной. PHP достаточно умён, чтобы
|
||||
не копировать контейнер, пока в этом нет необходимости. Как только
|
||||
"refcount" станет равным нулю, контейнер уничтожается.
|
||||
"refcount" уменьшается на единицу при уходе переменной
|
||||
refcount станет равным нулю, контейнер уничтожается.
|
||||
refcount уменьшается на единицу при уходе переменной
|
||||
из области видимости (например, в конце функции) или при
|
||||
удалении этой переменной (например при вызове <function>unset</function>).
|
||||
</para>
|
||||
@ -135,10 +136,10 @@ a: (refcount=1, is_ref=0)='new string'
|
||||
<title>Составные типы данных</title>
|
||||
|
||||
<para>
|
||||
Все несколько усложняется с составными типами данных, такими как массивы (<type>array</type>) и
|
||||
объекты (<type>object</type>). В отличие от скалярных (<type>scalar</type>) значений, массивы и объекты
|
||||
хранят свои свойства в собственных таблицах имён.
|
||||
Это значит, что следующий пример создаст сразу три zval контейнера:
|
||||
Всё несколько усложняется с составными типами данных, например с массивами (<type>array</type>) и
|
||||
объектами (<type>object</type>). В отличие от скалярных (<type>scalar</type>) значений, массивы и объекты
|
||||
хранят свойства в своих таблицах имён.
|
||||
То есть следующий пример создаст сразу три zval-контейнера:
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
@ -171,7 +172,7 @@ a: (refcount=1, is_ref=0)=array (
|
||||
</para>
|
||||
<para>
|
||||
Результат — три контейнера: <varname>a</varname>, <varname>meaning</varname> и <varname>number</varname>.
|
||||
Похожие правила применяются и для увеличения и уменьшения "refcounts".
|
||||
Похожие правила применяются и для увеличения и уменьшения refcounts.
|
||||
Ниже мы добавляем ещё один элемент массива и устанавливаем ему значение уже существующего элемента:
|
||||
</para>
|
||||
<para>
|
||||
@ -206,16 +207,16 @@ a: (refcount=1, is_ref=0)=array (
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
Вышеприведённый вывод Xdebug показывает, что и старый и новый элементы массива
|
||||
сейчас указывают на контейнер, чей "refcount" равен <literal>2</literal>.
|
||||
Хотя показано два контейнера со значением <literal>'life'</literal>, на самом
|
||||
деле это один контейнер. Функция <function>xdebug_debug_zval</function> не выводит информации об этом,
|
||||
Из вывода Xdebug видно, что и старый и новый элементы массива
|
||||
сейчас указывают на контейнер, чей refcount равен <literal>2</literal>.
|
||||
Хотя показано два контейнера со значением <literal>'life'</literal>,
|
||||
но это один контейнер. Функция <function>xdebug_debug_zval</function> не выводит информации об этом,
|
||||
но вы можете проверить это также отобразив указатели памяти.
|
||||
</para>
|
||||
<para>
|
||||
Удаление элемента из массива происходит точно так же, как и удаление имени переменной
|
||||
из области видимости: уменьшается "refcount" контейнера, на который ссылается элемент массива.
|
||||
Опять же, при достижении "refcount" нуля, контейнер удаляется из памяти.
|
||||
Элемент удаляется из массива аналогично удалению имени переменной
|
||||
из области видимости: уменьшается refcount-контейнер, на который ссылается элемент массива.
|
||||
При достижении нуля в бите refcount, контейнер удаляется из памяти.
|
||||
Пример:
|
||||
</para>
|
||||
<para>
|
||||
@ -243,7 +244,7 @@ a: (refcount=1, is_ref=0)=array (
|
||||
</para>
|
||||
<para>
|
||||
Ситуация станет интереснее, если добавить массив новым элементом в самого себя.
|
||||
В следующем примере мы также используем оператор присваивания по ссылке, чтобы
|
||||
В следующем примере использован оператор присваивания по ссылке, чтобы
|
||||
PHP не создал копию массива.
|
||||
</para>
|
||||
<para>
|
||||
@ -278,15 +279,15 @@ a: (refcount=2, is_ref=1)=array (
|
||||
</para>
|
||||
<para>
|
||||
Можно увидеть, что переменная с массивом (<varname>a</varname>), так же как и второй элемент
|
||||
(<varname>1</varname>) сейчас указывают на контейнер с "refcount" равным <literal>2</literal>.
|
||||
Символы "..." в выводе означают рекурсию и, в нашем случае,
|
||||
(<varname>1</varname>) сейчас указывают на контейнер с refcount равным <literal>2</literal>.
|
||||
Символы «...» в выводе означают рекурсию и, в этом случае,
|
||||
указывают на оригинальный массив.
|
||||
</para>
|
||||
<para>
|
||||
Как и ранее, удаление переменной уменьшает счётчик ссылок контейнера на единицу.
|
||||
Если мы применим unset к переменной <varname>$a</varname> после вышеприведённого примера,
|
||||
то счётчик ссылок контейнера, на который указывают <varname>$a</varname> и элемент "1",
|
||||
изменится с "2" на "1":
|
||||
Если применить конструкцию unset к переменной <varname>$a</varname> после этого примера,
|
||||
счётчик ссылок контейнера, на который указывают переменная <varname>$a</varname> и элемент 1,
|
||||
изменится с 2 на 1:
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
@ -314,9 +315,9 @@ a: (refcount=2, is_ref=1)=array (
|
||||
<title>Суть проблемы</title>
|
||||
<para>
|
||||
Хотя во всех областях видимости больше нет имени переменной, ссылающейся на
|
||||
данную структуру, она не может быть очищена, т. к. элемент массива "1" по-прежнему
|
||||
данную структуру, она не может быть очищена, т. к. элемент массива с ключом 1 по-прежнему
|
||||
ссылается на этот массив. Т. к. теперь нет никакой возможности пользователю
|
||||
удалить эти данные, то мы получили утечку памяти.
|
||||
удалить эти данные, случится утечка памяти.
|
||||
К счастью, PHP удалит эти данные при завершении запроса, но до этого момента
|
||||
данные будут занимать ценное место в памяти. Такая ситуация часто бывает, когда
|
||||
реализуются алгоритмы парсинга или другие, где есть дочерние элементы,
|
||||
@ -324,13 +325,13 @@ a: (refcount=2, is_ref=1)=array (
|
||||
потому что они всегда неявно используются по ссылке.
|
||||
</para>
|
||||
<para>
|
||||
Эта не проблема, если такое случается раз или два, но если
|
||||
существуют тысячи или даже миллионы таких утечек памяти, то они уже становятся
|
||||
проблемой. Особенно в долгоработающих скриптах, таких как демоны, где запрос
|
||||
не заканчивается никогда, или в больших наборах модульных тестов.
|
||||
Не проблема, если такое случается раз или два, но если
|
||||
существуют тысячи или даже миллионы таких утечек памяти, то они уже станут проблемой.
|
||||
Особенно в долгоработающих скриптах, например, демонах, где запрос
|
||||
не заканчивается, или в крупных наборах модульных тестов.
|
||||
Последний случай вызвал проблемы при запуске модульных тестов для
|
||||
компонента Template из библиотеки ez Components. В некоторых
|
||||
случаях может потребоваться свыше 2 Гб памяти, которая не всегда
|
||||
компонента Template из библиотеки ez Components. Иногда
|
||||
может потребоваться больше 2 ГБ памяти, которая не всегда
|
||||
есть на тестовом сервере.
|
||||
</para>
|
||||
</sect2>
|
||||
@ -339,21 +340,21 @@ a: (refcount=2, is_ref=1)=array (
|
||||
<sect1 xml:id="features.gc.collecting-cycles">
|
||||
<title>Сбор циклических ссылок</title>
|
||||
<para>
|
||||
Обычно механизмы подсчёта ссылок в памяти, например, используемый в PHP ранее,
|
||||
Обычно механизмы подсчёта ссылок в памяти, например, которые работали в PHP ранее,
|
||||
не решают проблему утечки памяти из-за циклических ссылок.
|
||||
Начиная с версии 5.3.0, в PHP реализован синхронный механизм из исследования
|
||||
"<link xlink:href="&url.gc-paper;">Concurrent Cycle Collection in Reference Counted Systems</link>",
|
||||
Начиная с версии 5.3.0 в PHP реализован синхронный механизм из исследования
|
||||
«<link xlink:href="&url.gc-paper;">Concurrent Cycle Collection in Reference Counted Systems</link>»,
|
||||
в котором рассматривается этот вопрос.
|
||||
</para>
|
||||
<para>
|
||||
Полное описание работы алгоритма выходит за рамки данного раздела, поэтому
|
||||
приведены только основы. Прежде всего мы должны задать несколько основных правил.
|
||||
Если счётчик ссылок увеличивается, то контейнер всё ещё используется и не является мусором.
|
||||
Полное описание работы алгоритма выходит за рамки этого раздела, поэтому
|
||||
приведены только основы. Вначале нужно задать основные правила.
|
||||
Если счётчик ссылок увеличивается, то контейнер всё ещё нужен и не будет считаться мусором.
|
||||
Если счётчик уменьшается до нуля, то zval может быть удалён.
|
||||
Исходя из этих правил утечки памяти с циклическими ссылками могут получиться только
|
||||
С такими правилами утечки памяти с циклическими ссылками могут получиться только
|
||||
при уменьшении счётчика ссылок до ненулевого значения.
|
||||
Затем, в выделенных контейнерах можно найти мусор проверив возможность уменьшения
|
||||
всех счётчиков ссылок на единицу и определив те контейнеры, у которых счётчик станет равным нулю.
|
||||
Затем, в выделенных контейнерах можно найти мусор, проверив, можно ли уменьшить
|
||||
все счётчики ссылок на единицу, и определив те контейнеры, у которых счётчик станет равным нулю.
|
||||
</para>
|
||||
<para>
|
||||
<mediaobject>
|
||||
@ -365,31 +366,31 @@ a: (refcount=2, is_ref=1)=array (
|
||||
</para>
|
||||
<para>
|
||||
Для избежания постоянной проверки на мусор с циклическими ссылками при каждом уменьшении счётчика ссылок,
|
||||
алгоритм добавляет все возможные корни (zval контейнеры) в "корневой буфер" (помечая
|
||||
их как "фиолетовые"). Это также гарантирует попадание любого корня в буфер только один раз.
|
||||
алгоритм добавляет все возможные корни (zval контейнеры) в «корневой буфер» (помечая
|
||||
их как «фиолетовые»). Это также гарантирует попадание любого корня в буфер только один раз.
|
||||
Механизм сборки мусора стартует только тогда, когда наполняется буфер (смотрите шаг A
|
||||
на рисунке выше).
|
||||
</para>
|
||||
<para>
|
||||
На шаге B алгоритм производит поиск в глубину по всем возможным корням для
|
||||
На шаге B алгоритм ищет в глубину по всем возможным корням для
|
||||
однократного уменьшения счётчика ссылок на единицу у всех контейнеров
|
||||
(помечая их как "серые"). На шаге C алгоритм снова производит поиск в глубину
|
||||
(помечая их как «серые»). На шаге C алгоритм снова ищет в глубину
|
||||
для проверки счётчиков ссылок. Если он находит счётчик с нулевым значением, то
|
||||
контейнер помечается как "белый" (на рисунке отображено синим). Если же счётчик больше нуля, то
|
||||
происходит поиск в глубину от этого контейнера с обратным увеличением счётчиков на единицу
|
||||
и повторной пометкой как "чёрный" на их контейнерах. На последнем шаге D алгоритм проходит по
|
||||
контейнер помечается как «белый» (на рисунке отображено синим). Если счётчик больше нуля, то
|
||||
поиск идёт в глубину от этого контейнера с обратным увеличением счётчиков на единицу
|
||||
и повторной пометкой как «чёрный» на их контейнерах. На последнем шаге D алгоритм проходит по
|
||||
корневому буферу и удаляет из него корни контейнеров, заодно проверяя какие контейнеры
|
||||
помечены как "белые". Эти контейнеры будут освобождены из памяти.
|
||||
помечены как «белые». Эти контейнеры будут освобождены из памяти.
|
||||
</para>
|
||||
<para>
|
||||
Теперь, когда вы имеете представление о работе алгоритма, рассмотрим его
|
||||
Теперь, когда есть представление о работе алгоритма, рассмотрим его
|
||||
интеграцию в PHP. По умолчанию сборщик мусора всегда включён.
|
||||
Для изменения этой опции используется параметр
|
||||
<link linkend="ini.zend.enable-gc">zend.enable_gc</link> в &php.ini;.
|
||||
</para>
|
||||
<para>
|
||||
Если сборщик мусора включён, алгоритм поиска циклических ссылок выполняется каждый раз,
|
||||
когда корневой буфер наполняется 10,000 корнями (вы можете поменять это значение,
|
||||
когда корневой буфер наполняется 10 000 корнями (можно поменять это значение,
|
||||
изменив константу <constant>GC_THRESHOLD_DEFAULT</constant> в файле
|
||||
<literal>Zend/zend_gc.c</literal> в исходном коде PHP и пересобрав PHP).
|
||||
Если сборщик мусора выключен, алгоритм никогда не будет запущен. Тем не менее,
|
||||
@ -408,11 +409,11 @@ a: (refcount=2, is_ref=1)=array (
|
||||
время.
|
||||
</para>
|
||||
<para>
|
||||
Помимо изменения параметра <link linkend="ini.zend.enable-gc">zend.enable_gc</link>,
|
||||
механизм сборки мусора также можно запустить и остановить вызвав функции
|
||||
<function>gc_enable</function> и <function>gc_disable</function> соответственно.
|
||||
Вызов этих функций имеет тот же эффект, что и включение/выключение механизма с
|
||||
помощью настроек конфигурации.
|
||||
Кроме изменения параметра <link linkend="ini.zend.enable-gc">zend.enable_gc</link>,
|
||||
механизм сборки мусора можно запустить и остановить, последовательно вызвав функции
|
||||
<function>gc_enable</function> и <function>gc_disable</function>.
|
||||
Вызов этих функций имеет тот же эффект, что и включение/выключение механизма
|
||||
в настройках конфигурации.
|
||||
Кроме того, можно запустить сборку мусора, даже если корневой буфер ещё не заполнен.
|
||||
Для этого вы можете вызвать функцию <function>gc_collect_cycles</function>, которая
|
||||
также возвращает количество циклических ссылок собранных алгоритмом.
|
||||
@ -420,13 +421,13 @@ a: (refcount=2, is_ref=1)=array (
|
||||
<para>
|
||||
Причиной включения и выключения механизма сборки, а также его ручного запуска,
|
||||
может стать то, что некоторые части вашего приложения могут быть требовательными
|
||||
ко времени. В этих случаях вы, возможно, не захотите постороннего вмешательства
|
||||
ко времени. В этих случаях, возможно, не захочется постороннего вмешательства
|
||||
сборщика мусора. Разумеется, выключая сборщик мусора в определённых
|
||||
местах вашего приложения вы рискуете получить утечку памяти, т. к.
|
||||
местах приложения, есть риск получить утечку памяти, т. к.
|
||||
потенциально некоторые корни могут не поместиться в ограниченный
|
||||
корневой буфер. Более целесообразно будет вызвать <function>gc_collect_cycles</function>
|
||||
непосредственно перед вызовом <function>gc_disable</function> для освобождения памяти и уже
|
||||
записанных корней в буфере. Это очистит буфер и позволит использовать больше места
|
||||
корневой буфер. Более целесообразно будет вызвать функцию <function>gc_collect_cycles</function>
|
||||
прямо перед вызовом функции <function>gc_disable</function> для освобождения памяти и уже
|
||||
записанных корней в буфере. Это очистит буфер и даст больше места
|
||||
для хранения корней, пока механизм будет выключен.
|
||||
</para>
|
||||
</sect1>
|
||||
@ -498,7 +499,7 @@ for ( $i = 0; $i <= 100000; $i++ )
|
||||
задаётся ссылкой на сам объект. Когда в скрипте в следующей итерации цикла переопределяется
|
||||
переменная <varname>$a</varname>, то происходит типичная утечка памяти.
|
||||
В данном случае пропадают два контейнера zval (контейнер объекта и контейнер свойства объекта),
|
||||
но определяется только один корень - удалённая переменная.
|
||||
но определяется только один корень — удалённая переменная.
|
||||
Как только пройдут 10 000 итераций (максимально в корневом буфере
|
||||
будет 10 000 корней), то запустится механизм сборки мусора и
|
||||
память, занимаемая этими корнями, будет освобождена.
|
||||
@ -544,7 +545,7 @@ echo memory_get_peak_usage(), "\n";
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
Мы запустим скрипт два раза: с включённой опцией
|
||||
Запустим скрипт два раза: с включённой опцией
|
||||
<link linkend="ini.zend.enable-gc">zend.enable_gc</link> и без неё.
|
||||
</para>
|
||||
<para>
|
||||
@ -561,11 +562,11 @@ time php -dzend.enable_gc=1 -dmemory_limit=-1 -n example2.php
|
||||
</para>
|
||||
<para>
|
||||
На тестовой машине первая команда примерно выполняется 10.7 секунд, а
|
||||
вторая примерно 11.4 секунды. Это примерно на 7% медленнее. Однако,
|
||||
максимальное использование памяти скриптом уменьшилось на 98% с 931 Мб до 10 Мб.
|
||||
вторая примерно 11.4 секунды. Это примерно на 7 % медленнее. Однако,
|
||||
максимальное использование памяти скриптом уменьшилось на 98 % с 931 МБ до 10 МБ.
|
||||
Этот тест не очень научный, но он действительно демонстрирует преимущество
|
||||
по использованию памяти, обеспечиваемое сборщиком мусора. Также хорошо то, что
|
||||
замедление для этого скрипта всегда примерно 7%, тогда как экономия памяти
|
||||
замедление для этого скрипта всегда примерно 7 %, тогда как экономия памяти
|
||||
увеличивается все больше и больше при нахождении нового мусора.
|
||||
</para>
|
||||
</sect2>
|
||||
@ -574,7 +575,7 @@ time php -dzend.enable_gc=1 -dmemory_limit=-1 -n example2.php
|
||||
<title>Внутренняя статистика сборщика мусора</title>
|
||||
<para>
|
||||
Можно получить немного больше информации о том, как механизм сборки
|
||||
мусора выполняется в PHP. Но для этого вам необходимо пересобрать PHP
|
||||
мусора выполняется в PHP. Но для этого необходимо пересобрать PHP
|
||||
для включения теста производительности и кода для дополнительного сбора данных. Необходимо
|
||||
установить переменную окружения <literal>CFLAGS</literal> в значение
|
||||
<literal>-DGC_BENCH=1</literal> до выполнения команды <literal>./configure</literal>
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem>
|
||||
<para>
|
||||
<link linkend="install.windows.commandline">Использование PHP в командной строке Windows</link>
|
||||
<link linkend="install.windows.commandline">Работа с PHP из командной строки Windows</link>
|
||||
</para>
|
||||
</listitem>
|
||||
<listitem>
|
||||
|
||||
@ -1577,7 +1577,9 @@ Etc/GMT+n и Etc/GMT-n обратные общепринятым.
|
||||
<!ENTITY note.open-basedir.func '<note xmlns="http://docbook.org/ns/docbook"><para>На поведение этой функции влияет значение директивы <link linkend="ini.open-basedir">open_basedir</link>.</para></note>'>
|
||||
|
||||
|
||||
<!ENTITY note.language-construct '<note xmlns="http://docbook.org/ns/docbook"><simpara>Поскольку это языковая конструкция, а не функция, она не может вызываться при помощи <link linkend="functions.variable-functions">переменных функций</link> или <link linkend="functions.named-arguments">именованных аргументов</link>.</simpara>
|
||||
<!ENTITY note.language-construct '<note xmlns="http://docbook.org/ns/docbook"><simpara>Поскольку это языковая конструкция, а не функция,
|
||||
её нельзя вызывать как <link linkend="functions.variable-functions">переменную функцию</link>
|
||||
или передавать как <link linkend="functions.named-arguments">именованный аргумент</link>.</simpara>
|
||||
</note>'>
|
||||
|
||||
<!-- Common pieces in features/safe-mode.xml
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
<simpara>
|
||||
Оператором называется нечто, принимающее одно или более значений (или выражений,
|
||||
если говорить на жаргоне программирования), и вычисляющее новое
|
||||
значение (таким образом, вся конструкция может рассматриваться как выражение).
|
||||
значение (так, всю конструкцию можно рассматривать как выражение).
|
||||
</simpara>
|
||||
<para>
|
||||
Операторы можно сгруппировать по количеству принимаемых ими значений. Унарные
|
||||
@ -15,15 +15,15 @@
|
||||
или <literal>++</literal> (<link linkend="language.operators.increment">инкремент</link>).
|
||||
Бинарные операторы принимают два значения; это, например, знакомые
|
||||
всем <link linkend="language.operators.arithmetic">арифметические операторы</link>
|
||||
<literal>+</literal> (плюс) и <literal>-</literal> (минус), большинство поддерживаемых в
|
||||
PHP операторов входят именно в эту категорию. Ну и, наконец, есть всего один
|
||||
<literal>+</literal> (плюс) и <literal>-</literal> (минус), бо́льшая часть поддерживаемых
|
||||
в PHP операторов входит в эту категорию. И на последок, существует всего один
|
||||
<link linkend="language.operators.comparison.ternary">тернарный оператор</link>,
|
||||
<literal>? :</literal>, принимающий три значения, обычно его так и называют -- "тернарный
|
||||
оператор" (хотя, возможно, более точным названием было бы "условный оператор").
|
||||
<literal>? :</literal>, принимающий три значения, обычно о нём говорят просто — «тернарный
|
||||
оператор» (хотя, возможно, более точным названием было бы «условный оператор»).
|
||||
</para>
|
||||
<para>
|
||||
Полный список PHP-операторов вы можете найти в разделе
|
||||
"<link linkend="language.operators.precedence">Порядок выполнения операторов</link>".
|
||||
Весь список PHP-операторов перечислен в разделе
|
||||
«<link linkend="language.operators.precedence">Приоритет оператора</link>».
|
||||
В этом разделе также описан порядок выполнения операторов и их ассоциативность, которые
|
||||
точно определяют, как вычисляются выражения с несколькими разными операторами.
|
||||
</para>
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
<!-- EN-Revision: 52407313885d27a4e891e08dd2e2481bcc39e244 Maintainer: sergey Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<sect1 xml:id="language.operators.assignment">
|
||||
<title>Оператор присваивания</title>
|
||||
<title>Операторы присваивания</title>
|
||||
<simpara>
|
||||
Базовый оператор присваивания обозначается символом «=». Кажется,
|
||||
что это оператор «равно». Это не так.
|
||||
@ -39,7 +39,7 @@ $a = ($b = 4) + 5; // Значение переменной $a равно 9, а
|
||||
$a = 3;
|
||||
$a += 5; // устанавливает для переменной $a значение 8, как если бы было написано: $a = $a + 5;
|
||||
$b = "Привет";
|
||||
$b .= "-привет!"; // устанавливает переменной $b значение "Привет-привет!", как и $b = $b . "-привет!";
|
||||
$b .= "-привет!"; // устанавливает переменной $b значение «Привет-привет!», как и $b = $b . "-привет!";
|
||||
|
||||
]]>
|
||||
</programlisting>
|
||||
@ -91,7 +91,7 @@ print "$b\n"; // также печатает 4, так как переменна
|
||||
</para>
|
||||
<para>
|
||||
Оператор <link linkend="language.oop5.basic.new">new</link>
|
||||
автоматически возвращает ссылку, поэтому присвоение результата операции
|
||||
автоматически возвращает ссылку, поэтому присваивание результата операции
|
||||
<link linkend="language.oop5.basic.new">new</link> по ссылке вызывает ошибку.
|
||||
</para>
|
||||
<para>
|
||||
@ -115,7 +115,7 @@ Parse error: syntax error, unexpected 'new' (T_NEW) in …
|
||||
</para>
|
||||
<para>
|
||||
Подробно о ссылках рассказано
|
||||
в разделе «<link linkend="language.references">Подробно о ссылках</link>».
|
||||
в разделе «<link linkend="language.references">Объяснение ссылок</link>».
|
||||
</para>
|
||||
</sect2>
|
||||
<sect2 xml:id="language.operators.assignment.arithmetic">
|
||||
|
||||
@ -5,9 +5,9 @@
|
||||
<title>Операторы сравнения</title>
|
||||
<simpara>
|
||||
Операторы сравнения, как это видно из их названия, разрешают сравнивать между собой
|
||||
два значения. Возможно вам будет интересно также ознакомиться с разделом
|
||||
<link linkend="types.comparisons">Сравнение типов</link>, в котором приведено большое
|
||||
количество соответствующих примеров.
|
||||
два значения. Могут также оказаться интересными для знакомства
|
||||
<link linkend="types.comparisons">таблицы сравнения типов</link>,
|
||||
поскольку в них показаны примеры сравнений, связанных с разными типами.
|
||||
</simpara>
|
||||
<table>
|
||||
<title>Операторы сравнения</title>
|
||||
@ -111,12 +111,12 @@
|
||||
<para>
|
||||
Если оба операнда —
|
||||
<link linkend="language.types.numeric-strings">строки, содержащие числа</link>
|
||||
или один операнд — числом, а другой — <link linkend="language.types.numeric-strings">строка, содержащая числа</link>,
|
||||
или один операнд — число, а другой — <link linkend="language.types.numeric-strings">строка, содержащая числа</link>,
|
||||
то сравнение выполняется численно.
|
||||
Эти правила также справедливы для оператора <link linkend="control-structures.switch">switch</link>.
|
||||
Тип не преобразовывается при сравнениях вида
|
||||
<literal>===</literal> или <literal>!==</literal>, поскольку это включает сравнение
|
||||
типа и значения.
|
||||
типа, а также значения.
|
||||
</para>
|
||||
<warning>
|
||||
<para>
|
||||
@ -460,17 +460,17 @@ if (empty($_POST['action'])) {
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
// на первый взгляд, следующий код должен вывести 'true'
|
||||
// кажется, что следующий код выведет «true»
|
||||
echo (true ? 'true' : false ? 't' : 'f');
|
||||
|
||||
// однако он выводит 't' до PHP 8.0.0
|
||||
// однако он выводит «t» до PHP 8.0.0
|
||||
// это потому, что тернарные выражения левоассоциативны
|
||||
|
||||
// это намного более очевидная версия вышеприведённого кода
|
||||
// следующая запись — более очевидная версия того же кода, который показан выше
|
||||
echo ((true ? 'true' : false) ? 't' : 'f');
|
||||
|
||||
// здесь видно, что первое выражение вычисляется в 'true', которое
|
||||
// в свою очередь вычисляется в (bool)true, таким образом возвращая истинную ветвь
|
||||
// здесь видно, что первое выражение оценивается как строковое «true», которое
|
||||
// оценивается как логическое (bool) true, поэтому возвращает истинную ветвь
|
||||
// второго тернарного выражения.
|
||||
|
||||
]]>
|
||||
@ -480,7 +480,7 @@ echo ((true ? 'true' : false) ? 't' : 'f');
|
||||
</note>
|
||||
<note>
|
||||
<para>
|
||||
Цепочка коротких тернарных операторов (<literal>?:</literal>) стабильна и ведёт себя разумно.
|
||||
Цепочка коротких тернарных операторов (<literal>?:</literal>), однако, стабильна и ведёт себя обоснованно.
|
||||
Она будет оценивать первый аргумент, который оценивается как не ложное значение.
|
||||
Обратите внимание, что неопределённые значения все равно вызовут предупреждение.
|
||||
<example>
|
||||
@ -502,7 +502,7 @@ echo 0 ?: 0 ?: 0 ?: 3, PHP_EOL; // 3
|
||||
<sect2 xml:id="language.operators.comparison.coalesce">
|
||||
<title>Оператор объединения с null</title>
|
||||
<para>
|
||||
Другой полезный сокращённый оператор — оператор "??" (null coalescing).
|
||||
Другой полезный сокращённый оператор — это оператор объединения с NULL — «??» (null coalescing).
|
||||
<example>
|
||||
<title>Присваивание значения по умолчанию</title>
|
||||
<programlisting role="php">
|
||||
@ -523,25 +523,27 @@ if (isset($_POST['action'])) {
|
||||
</programlisting>
|
||||
</example>
|
||||
Выражение <literal>(expr1) ?? (expr2)</literal> вычисляется так:
|
||||
<replaceable>expr2</replaceable>, если <replaceable>expr1</replaceable> равен
|
||||
&null; и <replaceable>expr1</replaceable> в противном случае.
|
||||
<replaceable>expr2</replaceable>, если <replaceable>expr1</replaceable> равно
|
||||
&null;, иначе <replaceable>expr1</replaceable>.
|
||||
</para>
|
||||
<para>
|
||||
На практике, этот оператор не вызывает предупреждения или ошибки, если левый операнд не
|
||||
существует, как и <function>isset</function>. Это очень полезно для ключей массива.
|
||||
Этот оператор не вызывает предупреждения или ошибки, если левый операнд
|
||||
не существует, точно как языковая конструкция <function>isset</function>.
|
||||
Это очень полезно для ключей массива.
|
||||
</para>
|
||||
<note>
|
||||
<simpara>
|
||||
Пожалуйста помните, что этот оператор является выражением, и он приравнивается к
|
||||
выражению, а не значению переменной. Это может быть важным, если вы хотите
|
||||
Обратите внимание, оператор объединения с NULL — это выражение,
|
||||
и он оценивается не как переменная, а как результат вычисления выражения.
|
||||
Это важно, если нужно
|
||||
вернуть значение по ссылке. Выражение <literal>return $foo ?? $bar;</literal> в
|
||||
функции возвращающей ссылку будет не работать, а выводить предупреждение.
|
||||
функции, возвращающей ссылку, будет не работать, а выводить предупреждение.
|
||||
</simpara>
|
||||
</note>
|
||||
<note>
|
||||
<para>
|
||||
У оператора null coalescing низкий приоритет. Это означает, что при смешивании его с другими операторами
|
||||
(такими как конкатенация строк или арифметические операторы), скорее всего, потребуются круглые скобки.
|
||||
У оператора объединения с NULL низкий приоритет. То есть при смешивании его с другими операторами
|
||||
(например, с операторами конкатенации строк или арифметическими операторами), скорее всего, потребуются круглые скобки.
|
||||
</para>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
@ -558,7 +560,7 @@ print 'Mr. ' . ($name ?? 'Anonymous');
|
||||
</note>
|
||||
<note>
|
||||
<para>
|
||||
Обратите внимание, что этот оператор позволяет использовать простую вложенность:
|
||||
Обратите внимание, оператор объединения с NULL разрешает простую вложенность:
|
||||
<example>
|
||||
<title>Вложенный оператор null coalescing</title>
|
||||
<programlisting role="php">
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
</warning>
|
||||
<simpara>
|
||||
Любое сообщение об ошибке, сгенерированное выражением, доступно
|
||||
в элементе массива <literal>"message"</literal>, возвращаемого функцией <function>error_get_last</function>.
|
||||
в элементе массива <literal>«message»</literal>, возвращаемого функцией <function>error_get_last</function>.
|
||||
Результат этой функции будет меняться при каждой ошибке, поэтому его необходимо проверить заранее.
|
||||
</simpara>
|
||||
<para>
|
||||
|
||||
@ -4,12 +4,12 @@
|
||||
<sect1 xml:id="language.operators.execution">
|
||||
<title>Операторы исполнения</title>
|
||||
<para>
|
||||
PHP поддерживает один оператор исполнения: обратные кавычки (``). Обратите
|
||||
внимание, что это не одинарные кавычки! PHP попытается выполнить строку,
|
||||
заключённую в обратные кавычки, как консольную команду, и вернёт
|
||||
полученный вывод (то есть он не просто выводится на экран, а, например, может
|
||||
быть присвоен переменной). Использование обратных кавычек аналогично
|
||||
использованию функции <function>shell_exec</function>.
|
||||
PHP поддерживает один оператор исполнения: обратные машинописные апострофы или обратные кавычки (``).
|
||||
Обратите внимание, что это не одинарные кавычки! PHP попытается выполнить строку,
|
||||
заключённую в обратные апострофы, как консольную команду, и вернёт
|
||||
полученный вывод (то есть он не просто будет сброшен в вывод;
|
||||
его можно присвоить переменной). Использовать оператор обратных апострофов —
|
||||
то же, что вызывать функцию <function>shell_exec</function>.
|
||||
<informalexample><programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@ -23,7 +23,7 @@ echo "<pre>$output</pre>";
|
||||
</para>
|
||||
<note>
|
||||
<para>
|
||||
Обратные кавычки недоступны, в случае, если
|
||||
Обратные кавычки недоступны, если
|
||||
отключена функция <function>shell_exec</function>.
|
||||
</para>
|
||||
</note>
|
||||
@ -40,7 +40,7 @@ echo "<pre>$output</pre>";
|
||||
<member><link linkend="ref.exec">Функции для выполнения программ</link></member>
|
||||
<member><function>popen</function></member>
|
||||
<member><function>proc_open</function></member>
|
||||
<member><link linkend="features.commandline">Использование PHP в командной строке</link></member>
|
||||
<member><link linkend="features.commandline">Работа с PHP из командной строки</link></member>
|
||||
</simplelist>
|
||||
</para>
|
||||
</sect2>
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 52407313885d27a4e891e08dd2e2481bcc39e244 Maintainer: sergey Status: ready -->
|
||||
<!-- EN-Revision: 02302a754aa0b2ea9a783f792e2c2c6c54230829 Maintainer: sergey Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<sect1 xml:id="language.operators.increment">
|
||||
<title>Операторы инкремента и декремента</title>
|
||||
@ -92,7 +92,7 @@ int(4)
|
||||
|
||||
<warning>
|
||||
<para>
|
||||
Операторы инкремента и декремента влияет на логические значения (<type>bool</type>).
|
||||
Операторы инкремента и декремента не влияют на логические значения (<type>bool</type>).
|
||||
Начиная с PHP 8.3.0 вызывается ошибка уровня <constant>E_WARNING</constant> is emitted,
|
||||
потому что это в будущем будет неявно приведено к значению целого числа (<type>int</type>).
|
||||
</para>
|
||||
@ -132,7 +132,7 @@ int(4)
|
||||
Строка должна быть буквенно-цифровой последовательностью в кодировке ASCII.
|
||||
Буквы увеличиваются до следующей буквы, при достижении буквы
|
||||
<literal>Z</literal> инкремент переносится в следующий разряд слева.
|
||||
Например, <code>$a = 'Z'; $a++;</code> превратит значение переменной <varname>$a</varname>
|
||||
Например, выражение <code>$a = 'Z'; $a++;</code> превратит значение переменной <varname>$a</varname>
|
||||
в значение <literal>'AA'</literal>.
|
||||
</para>
|
||||
|
||||
@ -216,7 +216,7 @@ float(6)
|
||||
]]>
|
||||
</screen>
|
||||
<para>
|
||||
Так происходит потому, что значение <literal>"5e0"</literal> было интерпретировано
|
||||
Так происходит потому, что значение <literal>«5e0»</literal> было интерпретировано
|
||||
как число с плавающей точкой (<type>float</type>) и приведено к значению <literal>5.0</literal>
|
||||
перед началом увеличения.
|
||||
</para>
|
||||
|
||||
@ -48,9 +48,9 @@
|
||||
</tgroup>
|
||||
</table>
|
||||
<simpara>
|
||||
Смысл двух разных вариантов для операторов and и or в том, что
|
||||
они работают с разным приоритетом (смотрите таблицу
|
||||
<link linkend="language.operators.precedence">Приоритет выполнения операторов</link>).
|
||||
Причина существования двух разных операторов «И» и «ИЛИ» в том,
|
||||
что они работают с разным приоритетом (смотрите таблицы в разделе
|
||||
«<link linkend="language.operators.precedence">Приоритет оператора</link>»).
|
||||
</simpara>
|
||||
<example>
|
||||
<title>Объяснение логических операторов</title>
|
||||
@ -59,7 +59,7 @@
|
||||
<?php
|
||||
|
||||
// --------------------
|
||||
// foo() никогда не будет вызвана, т. к. эти операторы являются шунтирующими (short-circuit)
|
||||
// Функция foo() никогда не будет вызвана, т. к. эти операторы шунтирующие (short-circuit)
|
||||
|
||||
$a = (false && foo());
|
||||
$b = (true || foo());
|
||||
@ -67,32 +67,31 @@ $c = (false and foo());
|
||||
$d = (true or foo());
|
||||
|
||||
// --------------------
|
||||
// "||" имеет больший приоритет, чем "or"
|
||||
// У оператора «||» больший приоритет, чем у «or»
|
||||
|
||||
// Результат выражения (false || true) присваивается переменной $e
|
||||
// Действует как: ($e = (false || true))
|
||||
$e = false || true;
|
||||
|
||||
// Константа false присваивается $f, а затем значение true игнорируется
|
||||
// Константа false присваивается переменной $f, а затем значение true игнорируется
|
||||
// Действует как: (($f = false) or true)
|
||||
$f = false or true;
|
||||
|
||||
var_dump($e, $f);
|
||||
|
||||
// --------------------
|
||||
// "&&" имеет больший приоритет, чем "and"
|
||||
// У оператора «&&» больший приоритет, чем у «and»
|
||||
|
||||
// Результат выражения (true && false) присваивается переменной $g
|
||||
// Действует как: ($g = (true && false))
|
||||
$g = true && false;
|
||||
|
||||
// Константа true присваивается $h, а затем значение false игнорируется
|
||||
// Константа true присваивается переменной $h, а затем значение false игнорируется
|
||||
// Действует как: (($h = true) and false)
|
||||
$h = true and false;
|
||||
|
||||
var_dump($g, $h);
|
||||
|
||||
|
||||
]]>
|
||||
</programlisting>
|
||||
&example.outputs.similar;
|
||||
|
||||
@ -7,27 +7,27 @@
|
||||
Приоритет оператора определяет, насколько «тесно» он связывает между собой два
|
||||
выражения. Например, выражение <literal>1 + 5 * 3</literal> вычисляется как
|
||||
<literal>16</literal>, а не <literal>18</literal>, поскольку оператор умножения («*») имеет
|
||||
более высокий приоритет, чем оператор сложения («+»). Круглые скобки могут
|
||||
быть указаны для изменения порядка выполнения операторов. Например,
|
||||
более высокий приоритет, чем оператор сложения («+»). Круглые скобки
|
||||
можно указывать для изменения порядка выполнения операторов. Например,
|
||||
выражение <literal>(1 + 5) * 3</literal> вычисляется как <literal>18</literal>.
|
||||
</para>
|
||||
<para>
|
||||
Если операторы имеют равный приоритет, то будут ли они выполняться справа налево или
|
||||
слева направо — зависит от их ассоциативности. К примеру, «-» —
|
||||
лево-ассоциативный оператор. Следовательно, <literal>1 - 2 - 3</literal> сгруппируется
|
||||
как <literal>(1 - 2) - 3</literal> и пересчитается в <literal>-4</literal>. С другой стороны
|
||||
«=» — право-ассоциативный оператор, так что <literal>$a = $b = $c</literal> сгруппируется
|
||||
как <literal>$a = ($b = $c)</literal>.
|
||||
слева направо — зависит от их ассоциативности. Например, «-» —
|
||||
левоассоциативный оператор. Поэтому, выражение <literal>1 - 2 - 3</literal> сгруппируется
|
||||
как <literal>(1 - 2) - 3</literal> и пересчитается в <literal>-4</literal>.
|
||||
При этом оператор «=» — правоассоциативный, так что выражение <literal>$a = $b = $c</literal>
|
||||
сгруппируется как <literal>$a = ($b = $c)</literal>.
|
||||
</para>
|
||||
<para>
|
||||
Неассоциативные операторы с одинаковым приоритетом не могут быть указаны совместно.
|
||||
К примеру, <literal>1 < 2 > 1</literal> не будет работать в PHP. Выражение
|
||||
<literal>1 <= 1 == 1</literal>, с другой стороны, будет, поскольку у оператора <literal>==</literal>
|
||||
Неассоциативные операторы с одинаковым приоритетом нельзя указывать совместно.
|
||||
Например, выражение <literal>1 < 2 > 1</literal> не будет работать в PHP.
|
||||
При этом выражение <literal>1 <= 1 == 1</literal> будет, поскольку у оператора <literal>==</literal>
|
||||
более низкий приоритет, чем у оператора <literal><=</literal>.
|
||||
</para>
|
||||
<para>
|
||||
Ассоциативность имеет смысл только для двоичных (и тернарных) операторов.
|
||||
Унарные операторы являются префиксными или постфиксными, поэтому это понятие не применимо.
|
||||
Ассоциативность относится только для двоичных (и тернарных) операторов.
|
||||
Унарные операторы бывают префиксными или постфиксными, поэтому это понятие к ним не относится.
|
||||
Например, <literal>!!$a</literal> можно сгруппировать только как <literal>!(!$a)</literal>.
|
||||
</para>
|
||||
<para>
|
||||
@ -35,10 +35,9 @@
|
||||
читаемость кода за счёт явной группировки, а не опоры на приоритеты и ассоциативность.
|
||||
</para>
|
||||
<para>
|
||||
В следующей таблице приведён список операторов, отсортированный по
|
||||
убыванию их приоритетов. Операторы, размещённые в одной строке имеют
|
||||
одинаковый приоритет и порядок их выполнения определяется исходя из
|
||||
их ассоциативности.
|
||||
В следующей таблице приведён список операторов, отсортированный
|
||||
по убыванию их приоритетов. Операторы, перечисленные в одной строке, имеют
|
||||
одинаковый приоритет, тогда порядок их выполнения будет определён тем, как они сгруппированы.
|
||||
<table><title>Порядок выполнения операторов</title>
|
||||
<tgroup cols="2">
|
||||
<thead>
|
||||
@ -237,7 +236,7 @@
|
||||
</entry>
|
||||
<entry>
|
||||
<link linkend="language.operators.comparison.ternary">тернарный оператор</link>
|
||||
(лево-ассоциативный до PHP 8.0.0)
|
||||
(левоассоциативный до PHP 8.0.0)
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
@ -342,9 +341,9 @@ $a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5
|
||||
<para>
|
||||
Приоритет и ассоциативность оператора определяет только то, как группируется
|
||||
выражение, а не порядок его вычисления. Обычно PHP не указывает, в каком порядке
|
||||
вычисляются выражения и кода, который предполагает специфичный порядок вычисления
|
||||
следует избегать, потому, что поведение может меняться в разных версиях PHP или
|
||||
в зависимости от окружающего кода.
|
||||
вычисляются выражения, и нужно избегать кода, который предполагает спецефический порядок вычисления,
|
||||
потому что поведение может меняться в разных версиях PHP
|
||||
или в зависимости от окружающего кода.
|
||||
|
||||
<example>
|
||||
<title>Неопределённый порядок вычисления</title>
|
||||
@ -353,7 +352,7 @@ $a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5
|
||||
<?php
|
||||
|
||||
$a = 1;
|
||||
echo $a + $a++; // может вывести как 2 так и 3
|
||||
echo $a + $a++; // может вывести как 2, так и 3
|
||||
|
||||
$i = 1;
|
||||
$array[$i] = $i++; // может установить индекс как 1, так 2
|
||||
@ -392,8 +391,8 @@ x минус один равно 3, ну, я надеюсь
|
||||
<note>
|
||||
<para>
|
||||
Хотя оператор <literal>=</literal> и имеет более низкий приоритет, чем бо́льшая часть
|
||||
других операторов, PHP всё же позволяет делать так: <literal>if (!$a = foo())</literal>,
|
||||
в этом примере результат выполнения <literal>foo()</literal> будет присвоен
|
||||
других операторов, PHP всё же разрешает делать так: <literal>if (!$a = foo())</literal>,
|
||||
в этом примере результат выполнения функции <literal>foo()</literal> будет присвоен
|
||||
переменной <varname>$a</varname>.
|
||||
</para>
|
||||
</note>
|
||||
@ -422,23 +421,23 @@ x минус один равно 3, ну, я надеюсь
|
||||
<entry>8.0.0</entry>
|
||||
<entry>
|
||||
Тернарный оператор (<literal>? :</literal>) теперь неассоциативен;
|
||||
ранее он был лево-ассоциативным.
|
||||
ранее он был левоассоциативным.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>7.4.0</entry>
|
||||
<entry>
|
||||
Опираясь на приоритет конкатенации строк (<literal>.</literal>) относительно
|
||||
арифметического сложения/вычитания (<literal>+</literal> или <literal>-</literal>) или побитового
|
||||
сдвига влево/вправо (<literal><<</literal> или <literal>>></literal>),
|
||||
т. е. их совместное использование в выражении без скобок не рекомендуется.
|
||||
Практика, когда можно было опираться на приоритет конкатенации строк (<literal>.</literal>)
|
||||
при арифметических операциях сложения/вычитания (<literal>+</literal> или <literal>-</literal>)
|
||||
или побитовом сдвиге влево/вправо (<literal><<</literal> или <literal>>></literal>),
|
||||
т. е. когда в выражении без скобок они указаны вместе, не рекомендована.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>7.4.0</entry>
|
||||
<entry>
|
||||
Не рекомендуется полагаться на лево-ассоциативность тернарного оператора (<literal>? :</literal>),
|
||||
т. е. вложение нескольких тернарных операторов без скобок.
|
||||
Практика, когда можно было полагаться на левоассоциативность тернарного оператора (<literal>? :</literal>),
|
||||
т. е. вложение нескольких тернарных операторов без скобок, не рекомендована.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
|
||||
@ -5,11 +5,11 @@
|
||||
<title>Строковые операторы</title>
|
||||
<simpara>
|
||||
В PHP есть два оператора для работы со строками (<type>string</type>).
|
||||
Первый — оператор конкатенации ('.'), который возвращает строку, представляющую
|
||||
Первый — оператор конкатенации («.»), который возвращает строку, представляющую
|
||||
собой соединение левого и правого аргумента. Второй — оператор присваивания
|
||||
с конкатенацией ('<literal>.=</literal>'), который присоединяет правый аргумент к левому.
|
||||
Для получения более полной информации ознакомьтесь с разделом
|
||||
<link linkend="language.operators.assignment">Операторы присваивания</link>.
|
||||
Подробно об этом рассказано в разделе
|
||||
«<link linkend="language.operators.assignment">Операторы присваивания</link>».
|
||||
</simpara>
|
||||
<para>
|
||||
<informalexample>
|
||||
|
||||
@ -5,8 +5,8 @@
|
||||
<title>Оператор проверки типа</title>
|
||||
<para>
|
||||
Оператор <literal>instanceof</literal> определяет,
|
||||
переменная PHP — это экземпляр
|
||||
<link linkend="language.oop5.basic.class">класса</link>.
|
||||
относится ли сохранённый в PHP-переменной объект
|
||||
к конкретному <link linkend="language.oop5.basic.class">классу</link>.
|
||||
<example>
|
||||
<title>Пример использования оператора <literal>instanceof</literal> с классами</title>
|
||||
<programlisting role="php">
|
||||
@ -34,7 +34,8 @@ bool(false)
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
Оператор <literal>instanceof</literal> также определяет, наследует ли объект класс:
|
||||
Оператор <literal>instanceof</literal> также определяет,
|
||||
принадлежит ли сохранённый в переменной объект к классу-наследнику:
|
||||
<example>
|
||||
<title>Использование оператора <literal>instanceof</literal> с наследуемыми классами</title>
|
||||
<programlisting role="php">
|
||||
@ -118,8 +119,8 @@ bool(true)
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
Хотя оператор <literal>instanceof</literal> обычно используют с прямо указанным именем класса,
|
||||
его также можно указывать с другим объектом или строковой переменной:
|
||||
Хотя оператор <literal>instanceof</literal> обычно указывают с буквальным именем класса,
|
||||
его можно также указывать с переменной объекта или строковой переменной:
|
||||
<example>
|
||||
<title>Использование оператора <literal>instanceof</literal> с другими переменными</title>
|
||||
<programlisting role="php">
|
||||
@ -151,8 +152,8 @@ bool(false)
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
Оператор instanceof не генерирует никаких ошибок, если проверяемая переменная
|
||||
не объект. В этом случае он просто возвращает &false;. Константы, однако,
|
||||
Оператор instanceof не выбрасывает никаких ошибок, если проверяемая переменная —
|
||||
не объект, он просто возвращает &false;. Константы, однако,
|
||||
не были разрешены до PHP 7.3.0.
|
||||
<example>
|
||||
<title>Пример использования оператора <literal>instanceof</literal> для проверки других переменных</title>
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 37280533a76693adac626a37ffc8daa2276400ce Maintainer: aur Status: ready -->
|
||||
<!-- EN-Revision: 5380fa1f30a0beacd62aec0d331939015f395fd6 Maintainer: aur Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<appendix xml:id="openssl.constants" xmlns="http://docbook.org/ns/docbook">
|
||||
&reftitle.constants;
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Проверяет, считается ли переменная пустой. Переменная считается пустой, если она не существует или её значение равно &false;.
|
||||
<function>empty</function> не генерирует предупреждение, если переменная не существует.
|
||||
Языковая конструкция <function>empty</function> не генерирует предупреждение, если переменная не существует.
|
||||
</para>
|
||||
</refsect1>
|
||||
<refsect1 role="parameters">
|
||||
@ -25,10 +25,12 @@
|
||||
<term><parameter>var</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Проверяемая переменная
|
||||
Проверяемая переменная.
|
||||
</para>
|
||||
<para>
|
||||
Если переменная не существует, предупреждение не генерируется. Это значит, что <function>empty</function> фактически является точным эквивалентом конструкции <command>!isset($var) || $var == false</command>
|
||||
Если переменная не существует, предупреждение не генерируется.
|
||||
То есть конструкция <function>empty</function> —
|
||||
это краткий эквивалент конструкции <command>!isset($var) || $var == false</command>.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@ -38,9 +40,11 @@
|
||||
<refsect1 role="returnvalues">
|
||||
&reftitle.returnvalues;
|
||||
<para>
|
||||
Возвращает &true;, если параметр <parameter>var</parameter> не существует, если значение равно нулю, либо не задано,
|
||||
смотрите <link linkend="language.types.boolean.casting">Преобразование в булев тип</link>.
|
||||
В противном случае возвращает &false;.
|
||||
Возвращает &true;, если переданная в параметр <parameter>var</parameter> переменная не существует,
|
||||
содержит пустое или равно нулю значение, то есть ложно,
|
||||
подробнее о приведении значений к булевым типам рассказано
|
||||
в параграфе <link linkend="language.types.boolean.casting">преобразование в логический тип</link>.
|
||||
В остальных случаях возвращает &false;.
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@ -49,19 +53,19 @@
|
||||
<para>
|
||||
<example>
|
||||
<title>
|
||||
Простое сравнение <function>empty</function> и <function>isset</function>.
|
||||
Простое сравнение языковых конструкций <function>empty</function> и <function>isset</function>.
|
||||
</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$var = 0;
|
||||
|
||||
// Принимает значение true, потому что $var пусто
|
||||
// Принимает значение true, потому что переменная $var содержит пустое значение
|
||||
if (empty($var)) {
|
||||
echo '$var или 0, или пусто, или вообще не определена';
|
||||
}
|
||||
|
||||
// Принимает значение true, потому что $var определена
|
||||
// Принимает значение true, потому что переменная $var определена
|
||||
if (isset($var)) {
|
||||
echo '$var определена, даже если она пустая';
|
||||
}
|
||||
@ -71,7 +75,7 @@ if (isset($var)) {
|
||||
</example>
|
||||
</para>
|
||||
<example>
|
||||
<title><function>empty</function> и строковые индексы</title>
|
||||
<title>Конструкция <function>empty</function> и строковые индексы</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@ -103,9 +107,9 @@ bool(true)
|
||||
¬e.language-construct;
|
||||
<note>
|
||||
<para>
|
||||
При использовании функции <function>empty</function> на
|
||||
недоступных (необъявленных) свойствах объекта будет вызван
|
||||
встроенный метод объекта <link linkend="object.isset">__isset()</link>,
|
||||
При вызове языковой конструкции <function>empty</function>
|
||||
на недоступных (необъявленных, защищённых или закрытых) свойствах объекта
|
||||
вызывается метод перегрузки — <link linkend="object.isset">__isset()</link>,
|
||||
если он определён.
|
||||
</para>
|
||||
</note>
|
||||
|
||||
Reference in New Issue
Block a user