Update e587d06 to En (#1088)

* Update types.xml to en

* Update array.xml to en + infostyle

* Update boolean.xml to en

* Update callable.xml to en

* Update float.xml to en

* Update integer.xml to en

* Update iterable.xml to en

* Update numeric-strings.xml to en

* Update object.xml to en

* Update type-juggling.xml to en

language/types.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: f908fff129bcd8ec1605658e06457cb04e5b2b51 Maintainer: shein Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: shein Status: ready -->
 <!-- Reviewed: no -->
-<chapter xml:id="language.types" xmlns="http://docbook.org/ns/docbook">
+<chapter xml:id="language.types" xmlns="http://docbook.org/ns/docbook" annotations="interactive">
  <title>Типы</title>
 
  <sect1 xml:id="language.types.intro">
@@ -63,7 +63,8 @@
    Принадлежность выражения конкретному типу проверяют функциями семейства
    <literal>is_<replaceable>type</replaceable></literal>.
 
-   <informalexample>
+   <example>
+    <title>Типы</title>
     <programlisting role="php">
 <![CDATA[
 <?php
@@ -82,7 +83,7 @@ if (is_int($an_int)) {
 }
 var_dump($an_int);
 
-// Проверить, содержит ли переменная $a_bool строку, и вывести её
+// Проверить, содержит ли переменная $a_bool строку, и вывести строковое значение
 if (is_string($a_bool)) {
     echo "Строка: $a_bool";
 }
@@ -98,7 +99,7 @@ string
 int(16)
 ]]>
     </screen>
-   </informalexample>
+   </example>
   </para>
   <note>
    <simpara>

language/types/array.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 22583751fbfdaa3eaa41aeb6470d1343f5cb2c78 Maintainer: shein Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: shein Status: ready -->
 <!-- Reviewed: no  -->
 <sect1 xml:id="language.types.array">
  <title>Массивы</title>
@@ -24,11 +24,11 @@
   <title>Синтаксис</title>
 
   <sect3 xml:id="language.types.array.syntax.array-func">
-   <title>Определение при помощи <function>array</function></title>
+   <title>Определение массива через языковую конструкцию <function>array</function></title>
 
    <para>
     Массив (<type>array</type>) создают языковой конструкцией <function>array</function>.
-    В качестве аргументов она принимает любое количество разделённых запятыми пар
+    Конструкция принимает как аргументы произвольное количество разделённых запятыми пар
     <literal><replaceable>ключ</replaceable> =&gt; <replaceable>значение</replaceable></literal>.
    </para>
 
@@ -42,10 +42,10 @@ array(
    <!-- Do not fix the whitespace for the synopsis end element. A limitation of PhD prevents proper trimming -->
 
    <para>
-    Запятая после последнего элемента массива необязательна и её можно опустить.
-    Обычно это делается для однострочных массивов, — лучше предпочесть <literal>array(1, 2)</literal>
+    Запятая после последнего элемента массива необязательна; пропуск конечной запятой не вызывает ошибок.
+    Конечную запятую часто опускают в определениях однострочных массивов, — лучше предпочесть <literal>array(1, 2)</literal>
     вместо <literal>array(1, 2, )</literal>. Для многострочных массивов, наоборот,
-    обычно указывают висящую запятую, так как упрощает добавление
+    часто указывают конечную запятую, поскольку это упрощает добавление
     новых элементов в конец массива.
    </para>
 
@@ -62,17 +62,19 @@ array(
 <![CDATA[
 <?php
 
-$array = array(
+$array1 = array(
     "foo" => "bar",
     "bar" => "foo",
 );
 
 // Работа с коротким синтаксисом массива
-$array = [
+$array2 = [
     "foo" => "bar",
     "bar" => "foo",
 ];
 
+var_dump($array1, $array2);
+
 ?>
 ]]>
     </programlisting>
@@ -89,12 +91,12 @@ $array = [
     <itemizedlist>
      <listitem>
       <simpara>
-       Строки (<type>string</type>), содержащие целое число (<type>int</type>)
-       (исключая случаи, когда перед числом указывают знак <literal>+</literal>),
-       будут преобразованы в целое число (<type>int</type>).
-       Например, ключ со значением <literal>«8»</literal> сохранится
-       со значением <literal>8</literal>. При этом, значение <literal>«08»</literal>
-       не преобразуется, так как оно — не корректное десятичное целое.
+       Строки (<type>string</type>), которые содержат целое число (<type>int</type>)
+       (исключая случаи, в которых перед числом указывают знак <literal>+</literal>),
+       преобразуются в целое число (<type>int</type>).
+       Например, ключ со значением <literal>"8"</literal> сохранится
+       со значением <literal>8</literal>. При этом, значение <literal>"08"</literal>
+       не преобразуется, поскольку значение не относится к корректным десятичным целым.
       </simpara>
      </listitem>
      <listitem>
@@ -123,16 +125,15 @@ $array = [
      <listitem>
       <simpara>
        Массивы (<type>array</type>) и объекты (<type>object</type>) <emphasis>нельзя</emphasis>
-       указывать как ключи. Это
-       сгенерирует предупреждение: <literal>Недопустимый тип смещения (Illegal offset type)</literal>.
+       указывать как ключи. Это сгенерирует предупреждение: <literal>Недопустимый тип смещения (Illegal offset type)</literal>.
       </simpara>
      </listitem>
     </itemizedlist>
    </para>
 
    <para>
-    Если нескольким элементам в объявлении массива указан одинаковый ключ, то только
-    последний будет сохранён, а другие будут перезаписаны.
+    PHP перезаписывает значение элемента, если встречает в объявлении массива
+    повтор одного и того же ключа, поэтому в массиве остается только последний такой элемент.
    </para>
 
    <example>
@@ -281,7 +282,7 @@ array(4) {
 ]]>
     </screen>
     <para>
-     Видно, что последнее значение <literal>«d»</literal> присвоилось ключу
+     Видно, что последнее значение <literal>"d"</literal> присвоилось ключу
      <literal>7</literal>. Это произошло потому, что перед этим
      самым большим значением целочисленного ключа было <literal>6</literal>.
     </para>
@@ -397,7 +398,7 @@ array(2) {
    <title>Доступ к элементам массива через синтаксис квадратных скобок</title>
 
    <para>
-    Доступ к элементам массива разрешено получать, используя синтакс <literal>array[key]</literal>.
+    Доступ к элементам массива получают синтаксисом <literal>array[key]</literal>.
    </para>
 
    <example>
@@ -448,12 +449,15 @@ string(3) "foo"
 <![CDATA[
 <?php
 
-function getArray() {
+function getArray()
+{
     return array(1, 2, 3);
 }
 
 $secondElement = getArray()[1];
 
+var_dump($secondElement);
+
 ?>
 ]]>
     </programlisting>
@@ -521,32 +525,36 @@ $secondElement = getArray()[1];
    </note>
 
    <para>
-    Для изменения конкретного значения элементу просто присваивают новое значение,
-    указывая его ключ. Если нужно удалить пару ключ/значение, необходимо
-    вызывать конструкцию <function>unset</function>.
+    Для изменения конкретного значения указывают ключ элемента и присваивают новое значение.
+    Пару «ключ — значение» удаляют языковой конструкцией <function>unset</function>.
    </para>
 
-   <informalexample>
+   <example>
+    <title>Работа с массивами через квадратные скобки</title>
     <programlisting role="php">
 <![CDATA[
 <?php
 
 $arr = array(5 => 1, 12 => 2);
 
-$arr[] = 56;    // В этом месте скрипта это
-                // то же самое, что и $arr[13] = 56;
+$arr[] = 56;    // В этом месте скрипта такое аналогично
+                // присваиванию $arr[13] = 56;
 
-$arr["x"] = 42; // Это добавляет в массив новый
-                // элемент с ключом «x»
+$arr["x"] = 42; // Добавление в массив нового
+                // элемента с ключом "x"
 
-unset($arr[5]); // Это удаляет элемент из массива
+unset($arr[5]); // Удаление элемента из массива
+
+var_dump($arr);
 
 unset($arr);    // Это удаляет весь массив
 
+var_dump($arr);
+
 ?>
 ]]>
     </programlisting>
-   </informalexample>
+   </example>
 
    <note>
     <para>
@@ -628,28 +636,30 @@ Array
     для деструктуризации массива на отдельные переменные.
    </para>
 
-   <informalexample>
+   <example>
+    <title>Деструктуризация массива</title>
     <programlisting role="php">
 <![CDATA[
 <?php
 
 $source_array = ['foo', 'bar', 'baz'];
 [$foo, $bar, $baz] = $source_array;
-echo $foo;    // выведет «foo»
-echo $bar;    // выведет «bar»
-echo $baz;    // выведет «baz»
+echo $foo, PHP_EOL;    // Выведет "foo"
+echo $bar, PHP_EOL;    // Выведет "bar"
+echo $baz, PHP_EOL;    // Выведет "baz"
 
 ?>
 ]]>
     </programlisting>
-   </informalexample>
+   </example>
 
    <para>
     Деструктуризацию массива также выполняют в конструкции &foreach;
     для деструктуризации многомерного массива во время итерации по массиву.
    </para>
 
-   <informalexample>
+   <example>
+    <title>Деструктуризация массива в конструкции foreach</title>
     <programlisting role="php">
 <![CDATA[
 <?php
@@ -658,21 +668,23 @@ $source_array = [
     [1, 'John'],
     [2, 'Jane'],
 ];
+
 foreach ($source_array as [$id, $name]) {
-    // логика работы с $id и $name
+    echo "{$id}: '{$name}'\n";
 }
 
 ?>
 ]]>
     </programlisting>
-   </informalexample>
+   </example>
 
    <para>
-    Элементы массива будут проигнорированы, если переменная не указана.
+    Деструктуризация проигнорирует элементы массива, для которых не указали переменную.
     Деструктуризация массива начинается с индекса <literal>0</literal>.
    </para>
 
-   <informalexample>
+   <example>
+    <title>Игнорирование элементов</title>
     <programlisting role="php">
 <![CDATA[
 <?php
@@ -682,48 +694,50 @@ $source_array = ['foo', 'bar', 'baz'];
 // Присваивание элемента с индексом 2 переменной $baz
 [, , $baz] = $source_array;
 
-echo $baz;    // выведет "baz"
+echo $baz;    // Выведет "baz"
 
 ?>
 ]]>
     </programlisting>
-   </informalexample>
+   </example>
 
    <para>
-    С PHP 7.1.0 ассоциативные массивы также разрешено деструктурировать.
-    Это упрощает выбор нужного элемента в массивах с числовым индексом,
-    так как индекс может быть указан явно.
+    Начиная с PHP 7.1.0 поддерживается деструктуризация ассоциативных массивов.
+    Это упрощает выбор элемента в массивах с числовым индексом,
+    поскольку разрешает явно указать индекс.
    </para>
 
-   <informalexample>
+   <example>
+    <title>Деструктуризация ассоциативных массивов</title>
     <programlisting role="php">
 <![CDATA[
 <?php
 
 $source_array = ['foo' => 1, 'bar' => 2, 'baz' => 3];
 
-// Присваивание элемента с индексом «baz» переменной $three
+// Присваивание элемента с индексом 'baz' переменной $three
 ['baz' => $three] = $source_array;
 
-echo $three;    // выведет 3
+echo $three, PHP_EOL;  // Выведет 3
 
 $source_array = ['foo', 'bar', 'baz'];
 
 // Присваивание элемента с индексом 2 переменной $baz
 [2 => $baz] = $source_array;
 
-echo $baz;    // выведет «baz»
+echo $baz, PHP_EOL;    // Выведет "baz"
 
 ?>
 ]]>
     </programlisting>
-   </informalexample>
+   </example>
 
    <para>
     Деструктуризацией массива пользуются, чтобы поменять две переменные местами.
    </para>
 
-   <informalexample>
+   <example>
+    <title>Перестановка двух переменных</title>
     <programlisting role="php">
 <![CDATA[
 <?php
@@ -731,13 +745,13 @@ echo $baz;    // выведет «baz»
 $a = 1;
 $b = 2;
 [$b, $a] = [$a, $b];
-echo $a;    // выведет 2
-echo $b;    // выведет 1
+echo $a, PHP_EOL;    // Выведет 2
+echo $b, PHP_EOL;    // Выведет 1
 
 ?>
 ]]>
     </programlisting>
-   </informalexample>
+   </example>
 
    <note>
     <para>
@@ -770,35 +784,39 @@ echo $b;    // выведет 1
    <para>
     Языковая конструкция <function>unset</function> умеет удалять ключи массива.
     Обратите внимание, что массив <emphasis>НЕ</emphasis>
-    будет переиндексирован. Если нужно поведение в стиле
-    «удалить и сдвинуть», можно переиндексировать массив
-    функцией <function>array_values</function>.
+    переиндексируется. Массив переиндексируют функцией <function>array_values</function>,
+    если требуется поведение в стиле «удалить и сдвинуть».
    </para>
 
-   <informalexample>
+   <example>
+    <title>Удаление промежуточных элементов</title>
     <programlisting role="php">
 <![CDATA[
 <?php
 
 $a = array(1 => 'один', 2 => 'два', 3 => 'три');
-unset($a[2]);
-/* даст массив, представленный так:
+
+/* Удаление элемента изменит массив так, как если бы его определили так:
    $a = array(1 => 'один', 3 => 'три');
-   а НЕ так:
+   но НЕ так:
    $a = array(1 => 'один', 2 => 'три');
 */
+unset($a[2]);
+var_dump($a);
 
 $b = array_values($a);
-// Теперь $b это array(0 => 'один', 1 => 'три')
+// Теперь переменная $b содержит array(0 => 'один', 1 => 'три')
+var_dump($b);
+
 ?>
 ]]>
     </programlisting>
-   </informalexample>
+   </example>
   </note>
 
   <para>
-   Управляющая конструкция &foreach; существует специально для массивов.
-   Она предлагает простой способ перебора массива.
+   Управляющая конструкция &foreach; появилась в языке для перебора массивов.
+   Конструкция предлагает простой способ обхода массива.
 
   </para>
  </sect2>
@@ -812,7 +830,7 @@ $b = array_values($a);
    <para>
     Рекомендовано заключать в кавычки строковый литерал в индексе ассоциативного массива.
     Например, нужно писать <literal>$foo['bar']</literal>, а не
-    <literal>$foo[bar]</literal>. Но почему? Часто в старых скриптах можно встретить
+    <literal>$foo[bar]</literal>. Но почему? Часто в старых скриптах встречается
     следующий синтаксис:
    </para>
 
@@ -831,14 +849,14 @@ echo $foo[bar];
    </informalexample>
 
    <para>
-    Это неверно, хотя и работает. Причина в том, что этот код содержит неопределённую
-    константу (<literal>bar</literal>), а не строку (<literal>'bar'</literal> — обратите внимание
-    на кавычки). Это работает, потому что PHP автоматически преобразовывает
-    <emphasis>«голую строку»</emphasis> (не заключённую в кавычки строку,
-    которая не соответствует ни одному из известных символов языка) в строку
-    со значением этой «голой строки». Например, если константа с именем <constant>bar</constant>
-    не определена, то PHP заменит bar на
-    строку <literal>«bar»</literal> и будет работать с ней.
+    Это неверно, хотя и работает. Причина состоит в том, что этот код содержит неопределённую
+    константу <literal>bar</literal>), а не строку (<literal>'bar'</literal> — обратите внимание
+    на кавычки. Это работает, потому что PHP автоматически преобразовывает
+    <emphasis>«голую строку»</emphasis> — строка без кавычек,
+    которая не соответствует ни одному известному символу языка — в строку
+    со значением этой «голой строки». PHP заменит строку bar
+    на строку <literal>'bar'</literal> и будет работать с ней,
+    если константу с названием <constant>bar</constant> не определили.
    </para>
 
    <warning>
@@ -851,17 +869,16 @@ echo $foo[bar];
     </simpara>
    </warning>
 
-   <note>
-    <simpara>
-     Это не значит, что нужно <emphasis>всегда</emphasis> заключать
-     ключ в кавычки. Не обязательно заключать в кавычки <link
-     linkend="language.constants">константы</link> или <link
-     linkend="language.variables">переменные</link>, поскольку это
-     помешает PHP обрабатывать их.
-    </simpara>
+   <simpara>
+    Это не значит, что в кавычки заключают <emphasis>каждый</emphasis> ключ.
+    В кавычки не берут <link linkend="language.constants">константы</link>
+    и <link linkend="language.variables">переменные</link>,
+    поскольку закавычивание помешает интерпретации.
+   </simpara>
 
-    <informalexample>
-     <programlisting role="php">
+   <example>
+    <title>Закавычивание ключей</title>
+    <programlisting role="php">
 <![CDATA[
 <?php
 
@@ -884,9 +901,9 @@ for ($i = 0; $i < $count; $i++) {
 ?>
 ]]>
      </programlisting>
-    </informalexample>
+    </example>
     &example.outputs;
-    <screen>
+   <screen>
 <![CDATA[
 Проверяем 0:
 Notice: Undefined index:  $i in /path/to/script.html on line 9
@@ -904,14 +921,14 @@ Notice: Undefined index:  $i in /path/to/script.html on line 11
 Плохо:
 Хорошо: 2
 ]]>
-    </screen>
-   </note>
+   </screen>
 
    <para>
     Дополнительные примеры, которые подтверждают этот факт:
    </para>
 
-   <informalexample>
+   <example>
+    <title>Дополнительные примеры</title>
     <programlisting role="php">
 <![CDATA[
 <?php
@@ -922,47 +939,52 @@ error_reporting(E_ALL);
 $arr = array('fruit' => 'apple', 'veggie' => 'carrot');
 
 // Верно
-print $arr['fruit'];  // apple
-print $arr['veggie']; // carrot
+echo $arr['fruit'], PHP_EOL;  // apple
+echo $arr['veggie'], PHP_EOL; // carrot
 
-// Неверно. Это работает, но из-за неопределённой константы с
-// именем fruit также выдаёт ошибку PHP уровня E_NOTICE
+// Неверно. Это работает, но также выбрасывает PHP-ошибку из-за неопределённой константы
+// с названием fruit
 //
-// Notice: Use of undefined constant fruit - assumed 'fruit' in...
-print $arr[fruit];    // apple
+// Error: Undefined constant "fruit"
+try {
+    echo $arr[fruit];    // apple
+} catch (Error $e) {
+    echo get_class($e), ': ', $e->getMessage(), PHP_EOL;
+}
 
-// Давайте определим константу, чтобы продемонстрировать, что
-// происходит. Присвоим константе с именем fruit значение «veggie».
+// Определим константу, чтобы посмотреть,
+// что произоёдет. Присвоим константе с названием fruit значение "veggie".
 define('fruit', 'veggie');
 
 // Теперь обратите внимание на разницу
-print $arr['fruit'];  // apple
-print $arr[fruit];    // carrot
+echo $arr['fruit'], PHP_EOL;  // apple
+echo $arr[fruit], PHP_EOL;    // carrot
 
-// Внутри строки это нормально. Внутри строк константы
-// не рассматриваются, поэтому ошибка E_NOTICE здесь не возникнет
-print "Hello $arr[fruit]";      // Hello apple
+// Доступ по ключу без кавычек сработает внутри строки. PHP не ищет константы внутри строк,
+// поэтому ошибка уровня E_NOTICE здесь не возникнет
+echo "Hello $arr[fruit]", PHP_EOL;      // Hello apple
 
-// С одним исключением: фигурные скобки вокруг массивов внутри
-// строк допускают константы
-print "Hello {$arr[fruit]}";    // Hello carrot
-print "Hello {$arr['fruit']}";  // Hello apple
+// За одним исключением: PHP интерпретирует константы,
+// если обращение к массиву внутри строки обернули фигурными скобками
+echo "Hello {$arr[fruit]}", PHP_EOL;    // Hello carrot
+echo "Hello {$arr['fruit']}", PHP_EOL;  // Hello apple
 
-// Ещё один способ — конкатенация
-print "Hello " . $arr['fruit']; // Hello apple
+// Ещё один способ вывести значение массива — конкатенация
+echo "Hello " . $arr['fruit'], PHP_EOL; // Hello apple
 
 ?>
 ]]>
     </programlisting>
-   </informalexample>
+   </example>
+
    <informalexample>
     <programlisting role="php">
 <![CDATA[
 <?php
 
-// Это не будет работать и вызовет ошибку обработки:
-// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
-// Это, конечно, также действует и с суперглобальными переменными в строках
+// Это не сработает и вызовет ошибку разбора наподобие:
+// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'.
+// Это относится и к суперглобальным переменным в строках
 print "Hello $arr['fruit']";
 print "Hello $_GET['foo']";
 
@@ -972,18 +994,16 @@ print "Hello $_GET['foo']";
    </informalexample>
 
    <para>
-    Если директива <link linkend="ini.error-reporting">error_reporting</link> настроена
-    на режим отображения ошибок уровня
-    <constant>E_NOTICE</constant> (например,
-    <constant>E_ALL</constant>), ошибки сразу будут видны.
-    По умолчанию директива <link linkend="ini.error-reporting">
-    error_reporting</link> настроена на то, чтобы не показывать предупреждения.
+    При установке для директивы <link linkend="ini.error-reporting">error_reporting</link> значения <constant>E_ALL</constant>,
+    которое включит также и режим отображения ошибок уровня <constant>E_NOTICE</constant>,
+    PHP сразу покажет ошибки, которые возникают при неправильном доступе к элементам массива.
+    Со значением по умолчанию директива <link linkend="ini.error-reporting">error_reporting</link>
+    не показывает уведомления.
    </para>
 
    <para>
-    Как указано в разделе <link linkend="language.types.array.syntax">о синтаксисе</link>,
-    внутри квадратных скобок («<literal>[</literal>»
-    и «<literal>]</literal>») должно быть выражение. То есть вот такой код работает:
+    Как указывает раздел <link linkend="language.types.array.syntax">о синтаксисе</link>,
+    внутри квадратных скобок '<literal>[</literal>' и '<literal>]</literal>' требуется указывать выражение. Поэтому следующий код работает:
    </para>
 
    <informalexample>
@@ -1058,7 +1078,7 @@ $error_descriptions[8] = "Это просто уведомление";
      <simpara>
       Повторим, внутри строки (<type>string</type>)
       в двойных кавычках допустимо не окружать индексы
-      массива кавычками, поэтому <literal>«$foo[bar]»</literal> —
+      массива кавычками, поэтому <literal>"$foo[bar]"</literal> —
       допустимая запись. В примерах выше объяснено, почему,
       дополнительная информация дана в разделе
       <link linkend="language.types.string.parsing">об обработке
@@ -1094,20 +1114,24 @@ $error_descriptions[8] = "Это просто уведомление";
    автоматически отбрасываются.
   </para>
 
-  <informalexample>
+  <example>
+   <title>Преобразование в массив</title>
    <programlisting role="php">
 <![CDATA[
 <?php
 
-class A {
+class A
+{
     private $B;
     protected $C;
     public $D;
+
     function __construct()
     {
         $this->{1} = null;
     }
 }
+
 var_export((array) new A());
 
 ?>
@@ -1124,24 +1148,29 @@ array (
 )
 ]]>
    </screen>
-  </informalexample>
+  </example>
 
   <para>
    Это может вызвать несколько неожиданное поведение:
   </para>
 
-  <informalexample>
+  <example>
+   <title>Приведение объекта к массиву</title>
    <programlisting role="php">
 <![CDATA[
 <?php
 
-class A {
-    private $A; // Это станет '\0A\0A'
+class A
+{
+    private $A; // Свойство станет ключом '\0A\0A'
 }
-class B extends A {
-    private $A; // Это станет '\0B\0A'
-    public $AA; // Это станет 'AA'
+
+class B extends A
+{
+    private $A; // Свойство станет ключом '\0B\0A'
+    public $AA; // Свойство станет ключом 'AA'
 }
+
 var_dump((array) new B());
 
 ?>
@@ -1160,16 +1189,16 @@ array(3) {
 }
 ]]>
    </screen>
-  </informalexample>
+  </example>
 
   <para>
-   Приведённый код покажет 2 ключа с именем «AA», хотя один из них на самом деле
-   имеет имя «\0A\0A».
+   Приведённый код покажет 2 ключа с названием 'AA', хотя один ключ на самом деле
+   называется '\0A\0A'.
   </para>
 
   <para>
-   Если преобразовать в массив значение &null;, получится
-   пустой массив.
+   Получится пустой массив,
+   если преобразовать в массив значение &null;.
   </para>
  </sect2>
 
@@ -1186,14 +1215,14 @@ array(3) {
   <title>Распаковка массива</title>
 
   <para>
-   Массив, перед которым указан оператор <code>...</code>, будет распакован во время определения массива.
-   Только массивы и объекты, которые реализуют интерфейс
-   <interfacename>Traversable</interfacename>, разрешено распаковывать.
+   Массив, перед которым указали оператор <code>...</code>, распакуется во время определения массива.
+   Распаковка доступна только массивам и объектам, которые реализуют интерфейс
+   <interfacename>Traversable</interfacename>.
    Распаковка массива оператором <code>...</code> доступна начиная с PHP 7.4.0.
   </para>
 
   <para>
-   Массив разрешено распаковывать несколько раз и добавлять обычные элементы до или после оператора <code>...</code>:
+   PHP поддерживает многократное чередование распаковки и стандартных элементов до или после оператора <code>...</code>:
    <example>
     <title>Простая распаковка массива</title>
     <programlisting role="php">
@@ -1212,7 +1241,9 @@ function getArr() {
   return ['a', 'b'];
 }
 
-$arr6 = [...getArr(), 'c' => 'd']; // ['a', 'b', 'c' => 'd']
+$arr6 = [...getArr(), 'c' => 'd']; // ['a', 'b', 'c' => 'd'];
+
+var_dump($arr1, $arr2, $arr3, $arr4, $arr5, $arr6);
 
 ?>
 ]]>
@@ -1221,27 +1252,27 @@ $arr6 = [...getArr(), 'c' => 'd']; // ['a', 'b', 'c' => 'd']
   </para>
 
   <para>
-   Распаковка массива оператором <code>...</code> соблюдает семантику функции <function>array_merge</function>.
-   То есть более поздние строковые ключи перезаписывают более ранние, а целочисленные ключи перенумеровываются:
+   Распаковка массива оператором <code>...</code> соблюдает семантику функции <function>array_merge</function>,
+   поэтому более поздние строковые ключи перезаписывают более ранние, а целочисленные ключи перенумеровываются:
    <example>
     <title>Распаковка массива с дублирующим ключом</title>
     <programlisting role="php">
      <![CDATA[
 <?php
 
-// строковый ключ
+// Строковый ключ
 $arr1 = ["a" => 1];
 $arr2 = ["a" => 2];
 $arr3 = ["a" => 0, ...$arr1, ...$arr2];
 var_dump($arr3); // ["a" => 2]
 
-// целочисленный ключ
+// Целочисленный ключ
 $arr4 = [1, 2, 3];
 $arr5 = [4, 5, 6];
 $arr6 = [...$arr4, ...$arr5];
 var_dump($arr6); // [1, 2, 3, 4, 5, 6]
-// Который [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
-// где исходные целочисленные ключи не были сохранены.
+// Распаковка массивов создаёт массив [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6],
+// в котором исходные целочисленные ключи не сохранились
 
 ?>
 ]]>
@@ -1288,43 +1319,48 @@ $arr6 = [...$arr4, ...$arr5]; // работает. [1, 2, 3, 4, 5]
    Массив в PHP — гибкий тип данных. Вот несколько примеров:
   </para>
 
-  <informalexample>
+  <example>
+   <title>Видимость массивов</title>
    <programlisting role="php">
 <![CDATA[
 <?php
 
-// Этот код:
+// Код:
 $a = array( 'color' => 'красный',
             'taste' => 'сладкий',
             'shape' => 'круг',
             'name'  => 'яблоко',
-            4        // ключом будет 0
+            4        // PHP назначит элементу ключ 0
           );
 
 $b = array('a', 'b', 'c');
 
-// ...эквивалентен этому:
+var_dump($a, $b);
+
+// ...эквивалентен следующему коду:
 $a = array();
 $a['color'] = 'красный';
 $a['taste'] = 'сладкий';
 $a['shape'] = 'круг';
 $a['name']  = 'яблоко';
-$a[]        = 4;        // ключом будет 0
+$a[]        = 4;        // ключом станет 0
 
 $b = array();
 $b[] = 'a';
 $b[] = 'b';
 $b[] = 'c';
 
-// после выполнения приведённого кода, переменная $a будет массивом
+// После выполнения приведённого кода переменная $a станет массивом
 // array('color' => 'красный', 'taste' => 'сладкий', 'shape' => 'круг',
-// 'name' => 'яблоко', 0 => 4), а переменная $b будет
-// array(0 => 'a', 1 => 'b', 2 => 'c'), или просто array('a', 'b', 'c').
+// 'name' => 'яблоко', 0 => 4), а переменная $b станет массивом
+// array(0 => 'a', 1 => 'b', 2 => 'c'), или просто array('a', 'b', 'c')
+
+var_dump($a, $b);
 
 ?>
 ]]>
    </programlisting>
-  </informalexample>
+  </example>
 
   <example>
    <title>Вызов языковой конструкции array()</title>
@@ -1340,7 +1376,10 @@ $map = array(
     'short_tags' => true
 );
 
-// строго числовые ключи
+var_dump($map);
+
+// Строго числовые ключи,
+// что эквивалентно массиву array(0 => 7, 1 => 8, ...)
 $array = array(
     7,
     8,
@@ -1348,7 +1387,7 @@ $array = array(
     156,
     -10
 );
-// это то же самое, что и array(0 => 7, 1 => 8, ...)
+var_dump($array);
 
 $switching = array(
     10,         // ключ = 0
@@ -1358,11 +1397,13 @@ $switching = array(
     11,         // ключ = 6 (максимальным числовым индексом было 5)
     '8'  =>  2, // ключ = 8 (число!)
     '02' => 77, // ключ = '02'
-    0    => 12  // значение 10 будет перезаписано на 12
+    0    => 12  // значение 10 перезапишется значением 12
 );
+var_dump($switching);
 
 // пустой массив
 $empty = array();
+var_dump($empty);
 
 ?>
 ]]>
@@ -1411,11 +1452,13 @@ foreach ($colors as $color) {
 <![CDATA[
 <?php
 
+$colors = array('red', 'blue', 'green', 'yellow');
+
 foreach ($colors as &$color) {
     $color = mb_strtoupper($color);
 }
-unset($color); /* это нужно, чтобы очередные записи в
-                  переменной $color не меняли последний элемент массива */
+unset($color); /* Переменную удаляют, чтобы очередные записи
+                  в переменной $color не меняли последний элемент массива */
 
 print_r($colors);
 
@@ -1441,12 +1484,12 @@ Array
   </para>
 
   <example>
-   <title>Индекс, начинающийся с единицы</title>
+   <title>Индексация с единицы</title>
    <programlisting role="php">
 <![CDATA[
 <?php
 
-$firstquarter  = array(1 => 'Январь', 'Февраль', 'Март');
+$firstquarter = array(1 => 'январь', 'февраль', 'март');
 print_r($firstquarter);
 
 ?>
@@ -1457,9 +1500,9 @@ print_r($firstquarter);
 <![CDATA[
 Array
 (
-    [1] => 'Январь'
-    [2] => 'Февраль'
-    [3] => 'Март'
+    [1] => 'январь'
+    [2] => 'февраль'
+    [3] => 'март'
 )
 ]]>
    </screen>
@@ -1471,13 +1514,15 @@ Array
 <![CDATA[
 <?php
 
-// заполняем массив всеми элементами из директории
+// Заполняем массив элементами из директории
 $handle = opendir('.');
 while (false !== ($file = readdir($handle))) {
     $files[] = $file;
 }
 closedir($handle);
 
+var_dump($files);
+
 ?>
 ]]>
    </programlisting>
@@ -1486,14 +1531,13 @@ closedir($handle);
   <para>
    Массивы упорядочены. Порядок изменяют
    разными функциями сортировки. Подробнее об этом рассказано
-   в разделе «<link linkend="ref.array">Функции
-   для работы с массивами</link>». Для подсчёта количества элементов
-   в массиве вызывают функцию <function>count</function>.
+   в разделе «<link linkend="ref.array">Функции для работы с массивами</link>».
+   Для подсчёта количества элементов в массиве вызывают функцию <function>count</function>.
   </para>
 
   <example>
    <title>Сортировка массива</title>
-   <programlisting role="php">
+   <programlisting role="php" annotations="non-interactive">
 <![CDATA[
 <?php
 
@@ -1506,9 +1550,8 @@ print_r($files);
   </example>
 
   <para>
-   Поскольку значению массива разрешено быть любым,
-   значение может быть также другим массивом. Поэтому разрешено создавать
-   рекурсивные и многомерные массивы.
+   Массивы поддерживают значения в виде других массивов, поскольку массивы принимают произвольные значения.
+   Поэтому PHP разрешает создавать рекурсивные и многомерные массивы.
   </para>
 
   <example>
@@ -1533,14 +1576,16 @@ $fruits = array ( "fruits"  => array ( "a" => "апельсин",
                                             "третья"
                                      )
                 );
+var_dump($fruits);
 
-// Несколько примеров доступа к значениям предыдущего массива
-echo $fruits["holes"][5];    // напечатает «вторая»
-echo $fruits["fruits"]["a"]; // напечатает «апельсин»
-unset($fruits["holes"][0]);  // удалит «первая»
+// Ряд примеров доступа к значениям предыдущего массива
+echo $fruits["holes"][5];    // Выведет "вторая"
+echo $fruits["fruits"]["a"]; // напечатает "апельсин"
+unset($fruits["holes"][0]);  // удалит "первая"
 
 // Создаст новый многомерный массив
 $juices["apple"]["green"] = "хороший";
+var_dump($juices);
 
 ?>
 ]]>
@@ -1552,7 +1597,8 @@ $juices["apple"]["green"] = "хороший";
    по ссылке, указывают <link linkend="language.operators">оператор присваивания по ссылке</link>.
   </para>
 
-  <informalexample>
+  <example>
+   <title>Копирование массивов</title>
    <programlisting role="php">
 <![CDATA[
 <?php
@@ -1565,10 +1611,12 @@ $arr2[] = 4; // Массив $arr2 изменился,
 $arr3 = &$arr1;
 $arr3[] = 4; // Теперь массивы $arr1 и $arr3 одинаковы
 
+var_dump($arr1, $arr2, $arr3);
+
 ?>
 ]]>
    </programlisting>
-  </informalexample>
+  </example>
 
  </sect2>
 </sect1>

language/types/boolean.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 161dde4fe721309398dd324edbf02aec409f127b Maintainer: shein Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: shein Status: ready -->
 <!-- Reviewed: no -->
 <sect1 xml:id="language.types.boolean">
  <title>Логические значения</title>
@@ -12,7 +12,7 @@
  <sect2 xml:id="language.types.boolean.syntax">
   <title>Синтаксис</title>
   <para>
-   Чтобы задать логический литерал <type>bool</type>, указывают константы &true;
+   Логические литералы — значения с типом <type>bool</type> — указывают константами &true;
    или &false;. Обе константы регистронезависимы.
   </para>
 
@@ -135,7 +135,8 @@ if ($show_separators) {
    </simpara>
   </warning>
 
-  <informalexample>
+  <example>
+   <title>Приведение к логическому типу</title>
    <programlisting role="php">
 <![CDATA[
 <?php
@@ -153,7 +154,7 @@ var_dump((bool) "false");   // bool(true)
 ?>
 ]]>
    </programlisting>
-  </informalexample>
+  </example>
 
  </sect2>
 </sect1>

language/types/callable.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: c897161ca5a62a887295c695adc161b8fde5d772 Maintainer: rjhdby Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: rjhdby Status: ready -->
 <!-- Reviewed: no -->
 <sect1 xml:id="language.types.callable">
  <title>Callable как выражение или псевдотип, и callback-функции</title>
@@ -70,7 +70,7 @@
 // Пример callback-функции
 function my_callback_function()
 {
-    echo 'Привет, мир!';
+    echo "Привет, мир!", PHP_EOL;
 }
 
 // Пример callback-метода
@@ -78,7 +78,7 @@ class MyClass
 {
     static function myCallbackMethod()
     {
-        echo 'Привет, мир!';
+        cho "Привет, мир!", PHP_EOL;
     }
 }
 
@@ -100,7 +100,7 @@ class A
 {
     public static function who()
     {
-        echo "A\n";
+        echo 'A', PHP_EOL;
     }
 }
 
@@ -108,11 +108,13 @@ class B extends A
 {
     public static function who()
     {
-        echo "B\n";
+        echo 'B', PHP_EOL;
     }
 }
 
-call_user_func(array('B', 'parent::who')); // A, устарело, начиная с PHP 8.2.0
+call_user_func(array('B', 'parent::who')); // Выводит: A.
+                                           // Начиная с PHP 8.2.0 callable-выражения
+                                           // с относительными названиями методов устарели
 
 // Тип 6: Объекты, классы которых реализуют магический метод __invoke(),
 // разрешается передавать как callable-объекты
@@ -120,7 +122,7 @@ class C
 {
     public function __invoke($name)
     {
-        echo 'Привет ', $name, "\n";
+        echo 'Привет, ', $name, PHP_EOL;
     }
 }
 

language/types/float.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: a1e3d629b4f01ee41bd38391cd5c6ae5ee894cb3 Maintainer: shein Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: shein Status: ready -->
 <!-- Reviewed: no -->
 <sect1 xml:id="language.types.float" xmlns:xlink="http://www.w3.org/1999/xlink">
  <title>Числа с плавающей точкой</title>
@@ -27,7 +27,7 @@ $d = 1_234.567; // Начиная с PHP 7.4.0
  </informalexample>
 
  <para>
-  Формально с PHP 7.4.0 (раньше подчёркивания не разрешались):
+  Поддержка подчёркиваний в числах появилась с PHP 7.4.0:
  </para>
 
  <informalexample>
@@ -79,9 +79,8 @@ EXPONENT_DNUM (({LNUM} | {DNUM}) [eE][+-]? {LNUM})
   </para>
 
   <para>
-   «Простое» объяснение даёт <link xlink:href="&url.floating.point.guide;">руководство
-   по числам с плавающей точкой</link>, которое также называется
-   «Why don’t my numbers add up?» («Почему мои числа не складываются?» — англ.)
+   «Простое» объяснение даёт <link xlink:href="&url.floating.point.guide;">руководство по числам с плавающей точкой</link>,
+   которое также называется «Why don’t my numbers add up?» («Почему мои числа не складываются?» — англ.)
   </para>
  </warning>
 
@@ -92,10 +91,9 @@ EXPONENT_DNUM (({LNUM} | {DNUM}) [eE][+-]? {LNUM})
    <title>Из строк</title>
 
    <simpara>
-    Если строка
-    <link linkend="language.types.numeric-strings">содержит число</link>
-    или ведущую числовую последовательность, тогда она будет преобразована в соответствующее значение с плавающей точкой,
-    в противном случае она преобразуется в ноль (<literal>0</literal>).
+    <link linkend="language.types.numeric-strings">Числовые строки</link>
+    или строки с начальной числовой последовательностью преобразовываются в значение с плавающей точкой,
+    иначе строка преобразуется в целочисленное значение <literal>0</literal>.
    </simpara>
   </sect3>
 
@@ -103,15 +101,14 @@ EXPONENT_DNUM (({LNUM} | {DNUM}) [eE][+-]? {LNUM})
    <title>Из других типов</title>
 
    <para>
-    Для значений других типов преобразование выполняется путём преобразования значения сначала в целое число (<type>int</type>), а затем в число с плавающей точкой (<type> float </type>).
-    Смотрите <link linkend="language.types.integer.casting">Преобразование в целое число</link> для получения
-    дополнительной информации.
+    При преобразовании значений других типов в число с плавающей точкой значение вначале преобразовывается в целое число (<type>int</type>),
+    а затем в число с плавающей точкой (<type>float</type>).
+    Дополнительную информацию о целочисленном преобразовании даёт раздел «<link linkend="language.types.integer.casting">Преобразование в целое число</link>».
    </para>
 
    <note>
     <para>
-     Поскольку определённые типы имеют неопределённое поведение при преобразовании в
-     целое число (<type>int</type>), то же самое происходит и при преобразовании в
+     Поскольку поведение отдельных типов при преобразовании в тип <type>int</type>, то же самое происходит и при преобразовании в
      число с плавающей точкой (<type>float</type>).
     </para>
    </note>
@@ -122,27 +119,30 @@ EXPONENT_DNUM (({LNUM} | {DNUM}) [eE][+-]? {LNUM})
   <title>Сравнение чисел с плавающей точкой</title>
 
   <para>
-   Как указано выше, проверять числа с плавающей точкой на равенство
-   проблематично из-за их внутреннего представления.
-   Тем не менее, существуют способы для их сравнения, которые работают
-   несмотря на все эти ограничения.
+   Как отмечалось в предыдущем предупреждении, проверка чисел с плавающей точкой на равенство
+   даёт сомнительные результаты из-за ограничений внутреннего представления таких чисел,
+   однако PHP поддерживает способы сравнения чисел с плавающей точкой,
+   которые обходят эти ограничения.
   </para>
 
   <para>
    Для сравнения чисел с плавающей точкой используется верхняя граница
    относительной ошибки при округлении. Эта величина называется
-   машинной эпсилон или единицей округления (unit roundoff) и
-   представляет собой самую маленькую допустимую разницу при расчётах.
+   машинной эпсилон или единицей округления (unit roundoff)
+   и представляет собой самую маленькую допустимую разницу при расчётах.
   </para>
 
-  <informalexample>
-   <simpara>
-    <varname>$a</varname> и <varname>$b</varname> равны до 5-ти
-    знаков после точки.
-   </simpara>
+  <para>
+   Числа <varname>$a</varname> и <varname>$b</varname> равны до 5-ти
+   знаков после точки.
+  </para>
+
+  <example>
+   <title>Сравнение чисел с плавающей точкой</title>
    <programlisting role="php">
 <![CDATA[
 <?php
+
 $a = 1.23456789;
 $b = 1.23456780;
 $epsilon = 0.00001;
@@ -150,10 +150,11 @@ $epsilon = 0.00001;
 if (abs($a - $b) < $epsilon) {
     echo "true";
 }
+
 ?>
 ]]>
    </programlisting>
-  </informalexample>
+  </example>
  </sect2>
 
  <sect2 xml:id="language.types.float.nan">

language/types/integer.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 8859c8b96cd9e80652813f7bcf561432a5e9f934 Maintainer: shein Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: shein Status: ready -->
 <!-- Reviewed: no -->
 <sect1 xml:id="language.types.integer">
  <title>Целые числа</title>
@@ -51,7 +51,7 @@
 
   <example>
    <title>Целые числа</title>
-   <programlisting role="php">
+   <programlisting role="php" annotations="non-interactive">
 <![CDATA[
 <?php
 
@@ -144,19 +144,20 @@ var_dump(PHP_INT_MAX + 1);       // В 32-разрядной системе syst
    но лучше предпочесть функцию <function>round</function>, которая точнее контролирует округление.
   </para>
 
-  <informalexample>
+  <example>
+   <title>Деление</title>
    <programlisting role="php">
 <![CDATA[
 <?php
 
-var_dump(25/7);         // float(3.5714285714286)
-var_dump((int) (25/7)); // int(3)
-var_dump(round(25/7));  // float(4)
+var_dump(25 / 7);         // float(3.5714285714286)
+var_dump((int) (25 / 7)); // int(3)
+var_dump(round(25 / 7));  // float(4)
 
 ?>
 ]]>
    </programlisting>
-  </informalexample>
+  </example>
  </sect2>
 
  <sect2 xml:id="language.types.integer.casting">
@@ -202,7 +203,9 @@ var_dump(round(25/7));  // float(4)
     в целое число (&integer;), которое теряет точность, PHP выдаёт уведомление об устаревании.
    </simpara>
 
-   <programlisting role="php">
+   <example>
+    <title>Приведение из числа с плавающей точкой</title>
+    <programlisting role="php">
 <![CDATA[
 <?php
 
@@ -220,10 +223,11 @@ var_dump(intval(8.1)); // 8 в обоих случаях
 
 ?>
 ]]>
-   </programlisting>
+    </programlisting>
+   </example>
 
    <para>
-    Результат будет неопределённым, если число с плавающей точкой превышает размеры
+    Приведение выдаст неопределённый реузльтат, если число с плавающей точкой превышает размеры
     типа <type>int</type> (обычно <literal>­± 2.15e+9 = 2^31</literal> на 32-битных системах
     и <literal>± 9.22e+18 = 2^63</literal> на 64-битных системах),
     поскольку у типа <type>float</type> нет достаточной точности,

language/types/iterable.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 161dde4fe721309398dd324edbf02aec409f127b Maintainer: rjhdby Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: rjhdby Status: ready -->
 <!-- Reviewed: no -->
 <sect1 xml:id="language.types.iterable">
  <title>Итерируемые значения</title>
@@ -14,8 +14,8 @@
 
  <note>
   <para>
-   Функциям, которые объявляют в качестве возвращаемого типа iterable,
-   также разрешено быть <link linkend="language.generators">генераторами</link>.
+   Функции, которые объявляют iterable как тип возврата,
+   поддерживают также и выдачу <link linkend="language.generators">генератора</link>.
    <example>
     <title>
      Пример возвращаемого типа итерируемого генератора
@@ -30,6 +30,10 @@ function gen(): iterable {
     yield 3;
 }
 
+foreach (gen() as $value) {
+    echo $value, "\n";
+}
+
 ?>
 ]]>
     </programlisting>

language/types/numeric-strings.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 7ba2406e555a240338d63f72d9ac54a46e0bee5d Maintainer: rjhdby Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: rjhdby Status: ready -->
 <!-- Reviewed: no -->
 <sect1 xml:id="language.types.numeric-strings" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
  <title>Числовые строки</title>
@@ -27,26 +27,30 @@ NUM_STRING       ({INT_NUM_STRING} | {FLOAT_NUM_STRING})
  </informalexample>
 
  <para>
-  В PHP также присутствует концепция <emphasis>префиксной</emphasis> числовой строки.
+  В PHP также поддерживается концепция <emphasis>префиксной</emphasis> числовой строки.
   Это строка, которая начинается как числовая и продолжается любыми другими символами.
  </para>
 
  <note>
   <para>
    Строка, которая содержит букву <literal>E</literal> (без учёта регистра),
-   ограниченную цифрами, будет восприниматься как число, которое выразили в научной нотации.
-   Это приводит к неожиданным результатам.
+   ограниченную цифрами, воспринимается как число, которое выразили в научной нотации.
+   Поведение при сравнении строк с числами в научной нотации иногда кажется неожиданным.
+  </para>
+  <example>
+   <title>Сравнение строк с числами в научной нотации</title>
    <programlisting role="php">
 <![CDATA[
 <?php
 
-var_dump("0D1" == "000"); // false, «0D1» — не научная нотация
-var_dump("0E1" == "000"); // true, «0E1» — это 0 * (10 ^ 1) или 0
-var_dump("2E1" == "020"); // true, «2E1» — это 2 * (10 ^ 1) или 20
+var_dump("0D1" == "000"); // false, "0D1" — не научная нотация
+var_dump("0E1" == "000"); // true, "0E1" интерпретируется как выражение 0 * (10 ^ 1), которое равно значению 0
+var_dump("2E1" == "020"); // true, "2E1" интерпретируется как выражение 2 * (10 ^ 1), которое равно значению 20
+
 ?>
 ]]>
    </programlisting>
-  </para>
+  </example>
  </note>
 
  <sect2 xml:id="language.types.numeric-string.conversion">
@@ -57,26 +61,25 @@ var_dump("2E1" == "020"); // true, «2E1» — это 2 * (10 ^ 1) или 20
    <orderedlist>
     <listitem>
      <simpara>
-      Если строка числовая, представляет целое число и не превышает максимально
-      допустимого значения для типа <type>int</type>, которое опеределяет
-      константа <constant>PHP_INT_MAX</constant>, то строка приводится к типу <type>int</type>.
-      Иначе строка приводится к типу <type>float</type>.
-     </simpara>
-    </listitem>
-    <listitem>
-     <simpara>
-      Если в заданном контексте разрешается использовать префиксную числовую строку,
-      то, если начало строки представляет целое число и не превышает максимально
+      Строка приводится к типу <type>int</type>, если строка числовая, представляет целое число и не превышает максимально
       допустимого значения для типа <type>int</type>, которое определяет
-      константа <constant>PHP_INT_MAX</constant>, строка приводится к типу <type>int</type>.
-      Иначе строка приводится к типу <type>float</type>.
-      В таких случаях также выдаётся ошибка уровня <constant>E_WARNING</constant>.
+      константа <constant>PHP_INT_MAX</constant>, иначе строка приводится к типу <type>float</type>.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
-      Если строка не числовая — выбрасывается исключение
-      <classname>TypeError</classname>.
+      Тип <type>string</type> приводится к типу <type>int</type>, если контекст разрешает строки,
+      которые начинаются с числа, и значение <type>string</type>
+      начинается с целочисленной числовой части, которая не превышает значение константы <constant>PHP_INT_MAX</constant>,
+      которая определяет в PHP наибольшее значение для типа <type>int</type>,
+      иначе строка разрешается
+      в тип <type>float</type> и дополнительно выдаёт ошибку
+      уровня <constant>E_WARNING</constant>.
+     </simpara>
+    </listitem>
+    <listitem>
+     <simpara>
+      Для нечисловых строк выбрасывается ошибка <classname>TypeError</classname>.
      </simpara>
     </listitem>
    </orderedlist>
@@ -87,13 +90,12 @@ var_dump("2E1" == "020"); // true, «2E1» — это 2 * (10 ^ 1) или 20
   <title>Поведение до PHP 8.0.0</title>
   <para>
    До PHP 8.0.0 строка считалась числовой, только если она
-   <emphasis>начиналась</emphasis> с пробельных символов. Если строка
-   <emphasis>завершалась</emphasis> пробельными символами —
-   PHP считал строку префиксной числовой.
+   <emphasis>начиналась</emphasis> с пробельных символов. PHP считал строку префиксной числовой,
+   если строка <emphasis>завершалась</emphasis> пробельными символами.
   </para>
 
   <para>
-   До PHP 8.0.0, когда строку требовалось использовать как число, применялся приведённый алгоритм,
+   До PHP 8.0.0 при работе со строкой как с числом применялся приведённый алгоритм,
    но с рядом отличий:
    <itemizedlist>
     <listitem>
@@ -104,7 +106,7 @@ var_dump("2E1" == "020"); // true, «2E1» — это 2 * (10 ^ 1) или 20
     </listitem>
     <listitem>
      <simpara>
-      Если строка не была числовой, вызывалась ошибка уровня <constant>E_WARNING</constant>,
+      Нечисловые строки вызывали ошибку уровня <constant>E_WARNING</constant>,
       а сама строка приводилась к числу <literal>0</literal>.
      </simpara>
     </listitem>

language/types/object.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 4c4b82965384d55f5c3efb1ffa80615acd98a737 Maintainer: shein Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: shein Status: ready -->
 <!-- Reviewed: no -->
 <sect1 xml:id="language.types.object">
  <title>Объекты</title>
@@ -12,7 +12,8 @@
    <literal>new</literal>, которое создаёт в переменной экземпляр класса:
   </para>
 
-  <informalexample>
+  <example>
+   <title>Создание объекта</title>
    <programlisting role="php">
 <![CDATA[
 <?php
@@ -25,13 +26,13 @@ class foo
     }
 }
 
-$bar = new foo;
+$bar = new foo();
 $bar->do_foo();
 
 ?>
 ]]>
    </programlisting>
-  </informalexample>
+  </example>
 
   <simpara>
    Полное рассмотрение производит раздел «<link linkend="language.oop5">Классы и объекты</link>».
@@ -54,37 +55,42 @@ $bar->do_foo();
    появляется только при итерации объекта.
   </para>
 
-  <informalexample>
+  <example>
+   <title>Приведение к объекту</title>
    <programlisting role="php">
 <![CDATA[
 <?php
 
 $obj = (object) array('1' => 'foo');
-var_dump(isset($obj->{'1'})); // С PHP 7.2.0 функция выводит 'bool(true)'; раньше выводила 'bool(false)'
-var_dump(key($obj)); // С PHP 7.2.0 функция выводит 'string(1) "1"'; раньше выводила 'int(1)'
+
+var_dump(isset($obj->{'1'})); // Выводит 'bool(true)'
+
+// Начиная с PHP 8.1 вызов функции key() на объектах устарел
+var_dump(key($obj)); // Выводит 'string(1) "1"'
 
 ?>
 ]]>
    </programlisting>
-  </informalexample>
+  </example>
 
   <para>
    Остальные значения при преобразовании PHP поместит
-   в переменную-член объекта с именем <literal>scalar</literal> с исходным типом значения.
+   в переменную-член объекта с названием <literal>scalar</literal> с исходным типом значения.
   </para>
 
-  <informalexample>
+  <example>
+   <title>Преобразование в объект через приведение типа <literal>(object)</literal></title>
    <programlisting role="php">
 <![CDATA[
 <?php
 
 $obj = (object) 'Привет';
-echo $obj->scalar;  // Выведет 'Привет'
+echo $obj->scalar;  // Выводит 'Привет'
 
 ?>
 ]]>
    </programlisting>
-  </informalexample>
+  </example>
 
  </sect2>
 </sect1>

language/types/type-juggling.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 22583751fbfdaa3eaa41aeb6470d1343f5cb2c78 Maintainer: shein Status: ready -->
+<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: shein Status: ready -->
 <!-- Reviewed: no -->
 <sect1 xml:id="language.types.type-juggling">
  <title>Жонглирование типами</title>
@@ -62,11 +62,11 @@
 
   <simpara>
    В этом контексте оба операнда интерпретируются как число с плавающей точкой (<type>float</type>)
-   и результатом будет число с плавающей точкой (<type>float</type>),
+   и результатом станет число с плавающей точкой (<type>float</type>),
    если один из операндов — число с плавающей точкой (<type>float</type>)
    (или не интерпретируется как целое число (<type>int</type>)).
    В противном случае операнды интерпретируются как целое число (<type>int</type>)
-   и результатом также будет целое число (<type>int</type>).
+   и результатом также станет целое число (<type>int</type>).
    С PHP 8.0.0 выбрасывается исключение <classname>TypeError</classname>,
    если не получается интерпретировать хотя бы один операнд.
   </simpara>
@@ -82,9 +82,9 @@
   </simpara>
 
   <simpara>
-   В этом контексте значение будет интерпретироваться как строка (<type>string</type>).
-   Выбрасывается исключение <classname>TypeError</classname>,
-   если значение не получается интерпретировать.
+   В этом контексте значение интерпретируется как значение <type>string</type>.
+   PHP выбросит ошибку <classname>TypeError</classname>,
+   если не получится интерпретировать значение.
    До версии PHP 7.4.0 выдавалась ошибка уровня <constant>E_RECOVERABLE_ERROR</constant>.
   </simpara>
  </sect2>
@@ -112,11 +112,11 @@
   </simpara>
 
   <simpara>
-   В этом контексте результатом будет строка (<type>string</type>),
-   если тип всех операндов — строка (<type>string</type>).
-   В противном случае операнды интерпретируются как целое число (<type>int</type>)
-   и результатом также будет целое число (<type>int</type>).
-   С PHP 8.0.0 выбрасывается исключение <classname>TypeError</classname>,
+   В этом контексте результатом станет значение <type>string</type>,
+   если каждый операнд принадлежит типу <type>string</type>,
+   иначе операнды интерпретируются как значения <type>int</type>
+   и результатом также становится тип <type>int</type>.
+   Начиная с версии 8.0.0 PHP выбрасывает ошибку <classname>TypeError</classname>,
    если не получается интерпретировать хотя бы один операнд.
   </simpara>
  </sect2>
@@ -264,7 +264,7 @@
     <para>
      Типы, которые не входят в список предпочтений, не станут целями
      для неявного приведения. Говоря конкретнее, никакого неявного приведения к типам
-     <type>null</type>, <type>false</type> и <type>true</type> не будет.
+     <type>null</type>, <type>false</type> и <type>true</type> не выполняется.
     </para>
    </note>
 
@@ -314,18 +314,21 @@ true  --> 1           // Тип bool совместим с типом int
    преобразовывается.
   </simpara>
 
-  <informalexample>
+  <example>
+   <title>Приведение типа</title>
    <programlisting role="php">
 <![CDATA[
 <?php
 
-$foo = 10;            // Переменная $foo — целое число
-$bar = (bool) $foo;   // Переменная $bar — логическое значение
+$foo = 10;            // Переменная $foo содержит целое число
+$bar = (bool) $foo;   // Переменная $bar содержит логическое значение
+
+var_dump($bar);
 
 ?>
 ]]>
    </programlisting>
-  </informalexample>
+  </example>
 
   <simpara>
    Разрешены следующие приведения типов:
@@ -413,31 +416,30 @@ $binary = b"binary string";
    </programlisting>
   </informalexample>
 
-  <note>
-   <simpara>
-    Вместо приведения переменной к строке (<type>string</type>)
-    переменную берут в двойные кавычки.
-   </simpara>
+  <simpara>
+   Вместо приведения переменной к типу <type>string</type>
+   переменную берут в двойные кавычки.
+  </simpara>
 
-   <informalexample>
-    <programlisting role="php">
+  <example>
+   <title>Механизмы приведения к строке</title>
+   <programlisting role="php">
 <![CDATA[
 <?php
 
-$foo = 10;            // Переменная $foo — целое число
-$str = "$foo";        // Переменная $str — строка
-$fst = (string) $foo; // Переменная $fst тоже строка
+$foo = 10;            // Переменная $foo содержит целое число
+$str = "$foo";        // Переменная $str содержит строку
+$fst = (string) $foo; // Переменная $fst тоже содержит строку
 
-// Выводит: «они одинаковые»
+// Выводит: "они одинаковые"
 if ($fst === $str) {
-    echo "они одинаковые";
+    echo "они одинаковые", PHP_EOL;
 }
 
 ?>
 ]]>
-    </programlisting>
-   </informalexample>
-  </note>
+   </programlisting>
+  </example>
 
   <para>
    Не всегда ясно, что произойдет при приведении между конкретными типами.
@@ -463,19 +465,20 @@ if ($fst === $str) {
     в массивах (<type>array</type>), следующий пример справедлив для всех версий PHP:
    </simpara>
 
-   <informalexample>
+   <example>
+    <title>Работа с символами строки по индексу</title>
     <programlisting role="php">
 <![CDATA[
 <?php
 
-$a    = 'car'; // Переменная $a — строка
-$a[0] = 'b';   // Переменная $a по-прежнему строка
+$a    = 'car'; // Переменная $a содержит строку
+$a[0] = 'b';   // Переменная $a по-прежнему содержит строку
 echo $a;       // Выводит: bar
 
 ?>
 ]]>
     </programlisting>
-   </informalexample>
+   </example>
 
    <simpara>
     Дополнительную информацию даёт раздел