Строка (string) — набор символов. Каждый байт строки интерпретируется как один символ. PHP поддерживает набор только из 256 символов и поэтому внутренне не поддерживает кодировку Unicode. Подробнее об этом рассказывает раздел «Подробные сведения о строковом типе».
Замечание: В 32-битных сборках размер строки (string) ограничивается 2 ГБ — максимум 2 147 483 647 байтов.
Строковый литерал определяют четырьмя способами:
Простейший способ определить строку — заключить строку в одинарные кавычки —
символ '.
Буквальную одинарную кавычку при записи в строке экранируют обратным
слешем — \. Сам обратный слеш дублируют —
\\. В остальных случаях обратный слеш в одинарных кавычках
обрабатывется как буквальный обратный слеш: PHP не рассматривает последовательности
вроде \r или \n в одинарных кавычках как управляющие,
а выводит как записали.
Замечание: Переменные и управляющие последовательности служебных символов в одинарных кавычках не обрабатываются, в отличие от синтаксиса двойных кавычек и heredoc.
Пример #1 Виды синтаксиса
<?php
echo 'Это — простая строка', PHP_EOL;
echo 'Переводы строки внутри кавычек
становятся частью строкового значения
и корректно обрабатываются', PHP_EOL;
// Выводит: Однажды Арнольд сказал: "I'll be back"
echo 'Однажды Арнольд сказал: "I\'ll be back"', PHP_EOL;
// Выводит: Вы удалили C:\*.*?
// (Обратите внимание на экранирование обратным слешем спецсимвола \ — прим. перев.)
echo 'Вы удалили C:\\*.*?', PHP_EOL;
// Выводит: Вы удалили C:\*.*?
// (Символ * не относится к спецсимволам и не образует в паре с обратным слешем управляющую последовательность,
// поэтому обратный слеш не экранирует символ * и выводится как есть — прим. перев.)
echo 'Вы удалили C:\*.*?', PHP_EOL;
// Выводит: В одинарных кавычках управляющая последовательность \n не разворачивается в символ первода строки
echo 'В одинарных кавычках управляющая последовательность \n не разворачивается в символ первода строки', PHP_EOL;
// Выводит: Переменные $expand и $either также не разворачиваются
echo 'Переменные $expand и $either также не разворачиваются', PHP_EOL;
?>
В строке в двойных кавычках — " —
PHP распознает следующие управляющие последовательности служебных символов:
| Последовательность | Значение |
|---|---|
\n |
Перевод строки. В кодировке ASCII управляющий символ обозначается аббревиатурой LF и соответствует коду 0x0A в шестнадцатеричной или 10 в десятичной нотации |
\r |
Возврат каретки. В кодировке ASCII управляющий символ обозначается аббревиатурой CR и соответствует коду 0x0D в шестнадцатеричной или 13 в десятичной нотации |
\t |
Горизонтальная табуляция. В кодировке ASCII этот управляющий символ обозначается аббревиатурой HT и соответствует коду 0x09 в шестнадцатеричной или 9 в десятичной нотации |
\v |
Вертикальная табуляция. В кодировке ASCII этот управляющий символ обозначается аббревиатурой VT и соответствует коду 0x0B в шестнадцатеричной или 11 в десятичной нотации |
\e |
Escape-символ. В кодировке ASCII этот управляющий символ обозначается аббревиатурой HT и соответствует коду 0x1B в шестнадцатеричной или 27 в десятичной нотации |
\f |
Подача страницы. В кодировке ASCII этот управляющий символ обозначается аббревиатурой HT и соответствует коду 0x0C в шестнадцатеричной или 12 в десятичной нотации |
\\ |
Обратный слеш |
\$ |
Знак доллара |
\" |
Двойная кавычка |
\[0-7]{1,3} |
Восьмеричная запись: последовательность символов, которая соответствует
регулярному выражению [0-7]{1,3}, — "\101" === "A".
При целочисленном переполнении, когда символ не помещается в один байт,
старшие биты без предупреждения отбрасываются: "\400" === "\000"
|
\x[0-9A-Fa-f]{1,2} |
Шестнадцатеричная запись: последовательность символов, которая соответствует
регулярному выражению [0-9A-Fa-f]{1,2}, — "\x41" === "A"
|
\u{[0-9A-Fa-f]+} |
Символы Юникода: последовательность символов, которая соответствует
регулярному выражению [0-9A-Fa-f]+, — кодовая точка Юникода,
которая выводится как строка в кодировке UTF-8.
Последовательность указывается в фигурных скобках:
"\u{41}" === "A"
|
Как и в строках в одинарных кавычках, при попытке заэкранировать другие символы, которые не относятся к управляющим, обратный слеш не интерпретируется как символ экранирования и выводится буквально.
Наиболее важное свойство строк в двойных кавычках состоит в том, что названия переменных в них развернутся и обработаются. Подробнее об этом рассказывает раздел «Интерполяция строк».
Третий способ определения строк — heredoc-синтаксис:
<<<. Следом за этим оператором указывают идентификатор,
а затем перевод строки. Затем идёт сама строка, за которой снова идёт тот же идентификатор,
чтобы закрыть вставку.
Закрывающий идентификатор разрешается отбивать пробелами или символами табуляции, и тогда отступ удалится из каждой строки в блоке документа. До PHP 7.3.0 закрывающий идентификатор указывали в самом начале новой строки.
Кроме того, закрывающий идентификатор подчиняется тем же правилам именования, что и другие метки в PHP: содержит только буквенно-цифровые символы и подчёркивания, и не начинается с цифрового символа или символа подчёркивания.
Пример #2 Базовый пример heredoc-синтаксиса в PHP 7.3.0
<?php
// Без отступа перед маркером закрытия
echo <<<END
a
b
c
\n
END;
// Отступ в 4 пробела перед маркером закрытия
echo <<<END
a
b
c
END;
?>Результат выполнения приведённого примера в PHP 7.3:
a
b
c
a
b
c
PHP выбросит исключение ParseError, если закрывающий идентификатор сместили дальше хотя бы одной строки тела:
Пример #3 Идентификатору закрытия нельзя отступать дальше строк тела
<?php
echo <<<END
a
b
c
END;
?>Результат выполнения приведённого примера в PHP 7.3:
Parse error: Invalid body indentation level (expecting an indentation level of at least 3) in example.php on line 4
В теле и перед идентификатором окончания heredoc-блока разрешается делать отступы символами пробелов и табуляции, но нельзя смешивать символы табуляции и пробелы относительно отступа идентификатора закрытия и отступа тела до начала закрывающего идентификатора; heredoc-синтаксис будет работать с отступом перед маркером закрытия, только если каждая строка тела начинается, но не ограничивается, с того же отступа, что и отступ перед маркером закрытия. При несовпадении отступов в начале строк тела с отступом перед идентификатором закрытия PHP выбросит исключение ParseError. Ограничения на пробельные отступы добавили, потому что смешивание табуляций и пробелов для отступов вредно для разбора.
Пример #4 Пример несовпадения отступов в теле и перед идентификатором закрытия тела
<?php
/**
* Каждый следующий пример кода не работает
*/
// Отступ тела отличается от отступа маркера окончания:
// тело — 5 пробелов, маркер окончания — 2 символа табуляции
{
echo <<<END
a
END;
}
// Смешивание пробелов и табуляций в теле:
// тело — 4 пробела + 1 символ табуляции, маркер окончания — 5 пробелов
{
echo <<<END
a
END;
}
// Смешивание пробелов и табуляций в маркере окончания:
// тело — 10 пробелов, маркер окончания — 2 символа табуляции + 1 пробел
{
echo <<<END
a
END;
}
?>Результат выполнения приведённого примера в PHP 7.3:
Parse error: Invalid indentation - tabs and spaces cannot be mixed in example.php line 8
За идентификатором закрытия строки тела не обязательно ставить точку с запятой или новую строку. Приведём пример кода, который разрешается с PHP 7.3.0:
Пример #5 Продолжение выражения после идентификатора закрытия
<?php
$values = [<<<END
a
b
c
END, 'd e f'];
var_dump($values);
?>Результат выполнения приведённого примера в PHP 7.3:
array(2) {
[0] =>
string(11) "a
b
c"
[1] =>
string(5) "d e f"
}
Парсер примет идентификатор за закрывающий и выбросит исключение ParseError, если найдёт закрывающий идентификатор в начале строки, даже если это часть слова.
Пример #6 Закрывающий идентификатор в теле текста провоцирует исключение ParseError
<?php
$values = [<<<END
a
b
END ING
END, 'd e f'];
?>Результат выполнения приведённого примера в PHP 7.3:
Parse error: syntax error, unexpected identifier "ING", expecting "]" in example.php on line 5
Таких проблем помогает избегать несложное, но надёжное правило: не указывать как идентификатор закрытия слово, которое встречается в теле текста.
До PHP 7.3.0 строке с закрывающим идентификатором нельзя было содержать
других символов, кроме точки с запятой — ;. То есть
идентификатор нельзя вводить с отступом,
а пробелы или знаки табуляции нельзя вводить до или после точки с запятой.
Учитывают также, что первым символом перед закрывающим идентификатором идёт
символ новой строки, который определяет операционная система. Например,
в Unix-системах, включая macOS, это символ \n. После идентификатора
закрытия должна сразу начинаться новая строка.
PHP не будет считать идентификатор закрывающим и продолжит поиск идентификатора, если это правило нарушили и идентификатор закрытия не «чистый». На последней строке возникнет ошибка синтаксического анализа, если PHP так и не найдёт правильный идентификатор закрытия до конца текущего файла.
Пример #7 Пример неправильного до PHP 7.3.0 синтаксиса
<?php
class Foo {
public $bar = <<<EOT
bar
EOT;
// Отступ перед закрывающим идентификатором недопустим
}
?>Пример #8 Пример правильного даже до PHP 7.3.0 синтаксиса
<?php
class Foo
{
public $bar = <<<EOT
bar
EOT;
}
?>В Heredoc-синтаксисе, который содержит переменные, нельзя инициализировать свойства класса.
Heredoc-текст ведёт себя как строка в двойных кавычках, хотя и не заключается в двойные кавычки. То есть в heredoc кавычки не экранируют, но перечисленные управляющие коды по-прежнему разрешено указывать. Переменные разворачиваются, но в выражениях со сложными переменными внутри heredoc работают так же внимательно, как и при работе со строками.
Пример #9 Пример определения heredoc-строки
<?php
$str = <<<EOD
Пример строки,
которую записали heredoc-синтаксисом
в несколько строк.
EOD;
/* Более сложный пример с переменными. */
class Foo
{
var $foo;
var $bar;
function __construct()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}
$foo = new Foo();
$name = 'Расмус';
echo <<<EOT
Меня зовут "$name". Я печатаю $foo->foo.
Теперь я вывожу {$foo->bar[1]}.
Это выведет заглавную букву 'A': \x41
EOT;
?>Результат выполнения приведённого примера:
Меня зовут "Расмус". Я печатаю Foo. Теперь, я вывожу Bar2. Это выведет заглавную букву 'A': A
Heredoc-синтаксис работает также и при передаче данных через аргументы функции:
Пример #10 Пример heredoc-синтаксиса с аргументами
<?php
var_dump(array(<<<EOD
foobar!
EOD
));
?>В heredoc-синтаксисе разрешено инициализировать статические переменные и свойства или константы класса:
Пример #11 Инициализация статических переменных heredoc-синтаксисом
<?php
// Статические переменные
function foo()
{
static $bar = <<<LABEL
Здесь ничего нет...
LABEL;
}
// Константы/свойства класса
class Foo
{
const BAR = <<<FOOBAR
Пример использования константы
FOOBAR;
public $baz = <<<FOOBAR
Пример использования поля
FOOBAR;
}
?>Допустимо также окружать heredoc-идентификатор двойными кавычками:
Пример #12 Двойные кавычки в heredoc
<?php
echo <<<"FOOBAR"
Привет, мир!
FOOBAR;
?>
Nowdoc — то же для строк в одинарных кавычках, что и heredoc для строк
в двойных кавычках. Синтаксис Nowdoc похож на heredoc-синтаксис, но внутри него
не выполняются интерполяция строк. Конструкция
легко встраивает PHP-код или другие большие блоки текста без
предварительного экранирования. В этом он отчасти похож на SGML-конструкцию
<![CDATA[ ]]>, в том, что он объявляет блок текста,
который не требует обработки.
Nowdoc задают той же последовательностью символов <<<,
что и в heredoc, но следующий за ней идентификатор берут
в одинарные кавычки, например, <<<'EOT'.
Условия, которые распространяются на идентификаторы heredoc-синтаксиса, действительны также
и для синтаксиса nowdoc, а больше остальных те, что относятся к закрывающему идентификатору.
Пример #13 Пример nowdoc-синтаксиса
<?php
echo <<<'EOD'
Пример текста,
занимающего несколько строк,
написанного синтаксисом nowdoc. Обратные слеши выводятся без обработки,
например, \\ и \'.
EOD;
?>Результат выполнения приведённого примера:
Пример текста, занимающего несколько строк, написанного синтаксисом nowdoc. Обратные слеши выводятся без обработки, например, \\ и \'.
Пример #14 Nowdoc-синтаксис с переменными в строках с двойными кавычками
<?php
/* Усложнённый пример с переменными. */
class Foo
{
public $foo;
public $bar;
function __construct()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}
$foo = new Foo();
$name = 'Расмус';
echo <<<'EOT'
Меня зовут "$name". Я печатаю $foo->foo.
Теперь я печатаю {$foo->bar[1]}.
Это не выведет заглавную 'A': \x41
EOT;
?>Результат выполнения приведённого примера:
Меня зовут "$name". Я печатаю $foo->foo.
Теперь я печатаю {$foo->bar[1]}.
Это не выведет заглавную 'A': \x41Пример #15 Пример со статичными данными
<?php
class Foo
{
public $bar = <<<'EOT'
bar
EOT;
}
?>PHP умеет подставлять внутри строк значения вместо переменных, если строку (string) указали в двойных кавычках или heredoc-синтаксисом.
В PHP предусмотрели два вида синтаксиса для указания переменных в строках: базовый и продвинутый. Базовым синтаксисом пользуются чаще, им легко встраивать переменную, значение массива (array) или свойство объекта (object) с минимумом усилий.
PHP интерпретирует как переменную и подставит вместо переменной значение этой переменной,
если встретит в строке знак доллара $,
за которым идут символы, допустимые для составления названий переменных.
Пример #16 Интерполяция строк
<?php
$juice = "яблочного";
echo "Он выпил немного $juice сока." . PHP_EOL;
?>Результат выполнения приведённого примера:
Он выпил немного яблочного сока.
Формально структура базового синтаксиса подстановки переменных выглядит вот так:
строковая переменная::
имя-переменной (смещение-или-свойство)?
| ${ выражение }
смещение-или-свойство::
смещение в строке
| свойство-в-строке
смещение-в-строке::
[ имя ]
| [ имя-переменной ]
| [ целочисленный-литерал ]
свойство-в-строке::
-> имя
имя-переменной::
$ имя
имя::
[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*
Синтаксис ${ выражение } устарел
с PHP 8.2.0, поскольку интерпретируется
как переменные переменных:
<?php
const foo = 'bar';
$foo = 'foo';
$bar = 'bar';
var_dump("${foo}");
var_dump("${(foo)}");
?>Результат выполнения приведённого примера в PHP 8.2:
Deprecated: Using ${var} in strings is deprecated, use {$var} instead in file on line 6
Deprecated: Using ${expr} (variable variables) in strings is deprecated, use {${expr}} instead in file on line 9
string(3) "foo"
string(3) "bar"
Результат выполнения приведённого примера:
string(3) "foo" string(3) "bar"
Замечание: Знак доллара остается в строке как сам знак доллара, если невозможно сформировать допустимое имя:
<?php
echo "Строка не содержит переменных $ для интерполяции\n";
echo "Строка не содержит переменных $\n для интерполяции\n";
echo "Строка не содержит переменных $2 для интерполяции\n";
?>Результат выполнения приведённого примера:
Строка не содержит переменных $ для интерполяции Строка не содержит переменных $ для интерполяции Строка не содержит переменных $2 для интерполяции
Пример #17 Пример интерполяции значений первого уровня массива или свойства объекта
<?php
$juices = array("яблочного", "апельсинового", "string_key" => "фиолетового");
echo "Он выпил немного $juices[0] сока.";
echo PHP_EOL;
echo "Он выпил немного $juices[1] сока.";
echo PHP_EOL;
echo "Он выпил немного $juices[string_key] сока.";
echo PHP_EOL;
class A
{
public $s = "string";
}
$o = new A();
echo "Значение свойства объекта: $o->s.";
?>Результат выполнения приведённого примера:
Он выпил немного яблочного сока. Он выпил немного апельсинового сока. Он выпил немного фиолетового сока. Значение свойства объекта: string.
Замечание: Ключ массива указывают без кавычек, поэтому невозможно ссылаться на константу как на ключ в базовом синтаксисе. Вместо этого пользуются продвинутым синтаксисом.
В PHP 7.1.0 добавили поддержку отрицательных числовых индексов.
Пример #18 Отрицательные числовые индексы
<?php
$string = 'string';
echo "Символ с индексом -2 равен $string[-2].", PHP_EOL;
$string[-3] = 'o';
echo "Изменение символа на позиции -3 на 'o' даёт следующую строку: $string.", PHP_EOL;
?>Результат выполнения приведённого примера:
Символ с индексом -2 равен n. Изменение символа на позиции -3 на «o» даёт следующую строку: strong
Для выражений, которые сложнее этих, лучше пользоваться продвинутым синтаксисом.
Продвинутый синтаксис разрешает интерполировать переменные с произвольными методами доступа.
В строках продвинутым синтаксисом указывают скалярные переменные, элементы массива,
статические и динамические свойства объекта со строковым представлением.
Выражение записывается как и вне строки, а затем оборачивается
в фигурные скобки { и }.
Поскольку знак { невозможно экранировать, продвинутый синтаксис
распознаётся только тогда, когда знак $ идёт непосредственно за знаком {.
Знак доллара экранируют синтаксисом {\$, чтобы получить литерал {$.
Поясняющие примеры:
Пример #19 Синтаксис фигурных скобок
<?php
const DATA_KEY = 'const-key';
$great = 'здорово';
$arr = [
'1',
'2',
'3',
[41, 42, 43],
'key' => 'Индексное значение',
'const-key' => 'Ключ со знаком минуса',
'foo' => ['foo1', 'foo2', 'foo3']
];
// Не работает, выводит: Это { здорово}
echo "Это { $great}";
// Работает, выводит: Это здорово
echo "Это {$great}";
class Square
{
public $width;
public function __construct(int $width)
{
$this->width = $width;
}
}
$square = new Square(5);
// Работает
echo "Ширина квадрата составляет {$square->width}00 сантиметров.";
// Работает, ключи, взятые в кавычки, работают только с синтаксисом фигурных скобок
echo "Это работает: {$arr['key']}";
// Работает
echo "Это работает: {$arr[3][2]}";
echo "Работает: {$arr[DATA_KEY]}";
// При работе с многомерными массивами массивы внутри строк оборачивают в фигурные скобки
echo "Это работает: {$arr['foo'][2]}";
echo "Работает: {$obj->values[3]->name}";
echo "Работает: {$obj->$staticProp}";
// Не работает, выводит: C:\directory\{fantastic}.txt
echo "C:\directory\{$great}.txt";
// Работает, выводит: C:\directory\fantastic.txt
echo "C:\\directory\\{$great}.txt";
?>Замечание: В строках с продвинутым синтаксисом возможно записывать переменные переменных, поскольку продвинутый синтаксис разрешает произвольные выражения.
Символы внутри строк индексируются с начала строки, индексы начинаются с 0. Смещение символа, который требуется прочитать или изменить внутри строки, указывают после строки в квадратных скобках массива (array), например $str[42]. Для этого о строке думают как о массиве символов. Больше одного символа получают и заменяют функциями substr() и substr_replace().
Замечание: Начиная с PHP 7.1.0 поддерживаются отрицательные значения смещения. Они задают смещение с конца строки. Раньше отрицательные смещение вызывали ошибку уровня
E_NOTICEпри чтении (возвращая пустую строку) илиE_WARNINGпри записи (оставляя строку без изменений).
Замечание: До PHP 8.0.0 доступ к символам в строках (string) получали, указывая фигурные скобки, например $str{42}. Синтаксис фигурных скобок устарел с PHP 7.4.0 и не поддерживается с PHP 8.0.0.
Попытка записи в смещение за границами строки дополнит строку
пробелами до этого смещения. Нецелочисленные типы преобразуются в целочисленные.
Неверный тип смещения выдаст ошибку уровня E_WARNING.
При добавлении в смещение строки новых символов присвоится только первый символ (байт).
Начиная с PHP 7.1.0 присваивание пустой строки вызовет фатальную ошибку. Раньше
присваивался нулевой байт (NULL).
Внутренне PHP представляет строки массивами байтов. Поэтому доступ или изменение строки по смещению небезопасны для многобайтовых данных и выполняются только со строками в однобайтовых кодировках, например ISO-8859-1.
Замечание: Начиная с PHP 7.1.0 попытка указать оператор пустого индекса на пустой строке выдаст фатальную ошибку. Раньше пустая строка преобразовывалась в массив без предупреждения.
Пример #20 Примеры строк
<?php
// Получим первый символ строки
$str = 'This is a test.';
$first = $str[0];
var_dump($first);
// Получим третий символ строки
$third = $str[2];
var_dump($third);
// Получим последний символ строки
$str = 'This is still a test.';
$last = $str[strlen($str) - 1];
var_dump($last);
// Изменим последний символ строки
$str = 'Look at the sea';
$str[strlen($str)-1] = 'e';
var_dump($str);
?>Смещение в строке задают либо целым числом, либо целочисленной строкой, иначе PHP выдаст предупреждение.
Пример #21 Пример недопустимого смещения строки
<?php
$str = 'abc';
$keys = [ '1', '1.0', 'x', '1x' ];
foreach ($keys as $keyToTry) {
var_dump(isset($str[$keyToTry]));
try {
var_dump($str[$keyToTry]);
} catch (TypeError $e) {
echo $e->getMessage(), PHP_EOL;
}
echo PHP_EOL;
}
?>Результат выполнения приведённого примера:
bool(true) string(1) "b" bool(false) Cannot access offset of type string on string bool(false) Cannot access offset of type string on string bool(false) Warning: Illegal string offset "1x" in Standard input code on line 10 string(1) "b"
Замечание:
Доступ к переменным других типов, кроме массивов и объектов, которые реализуют соответствующие интерфейсы, через операторы
[]или{}без предупреждения возвращаетnull.
Замечание:
Доступ к символам в строковых литералах получают через операторы
[]или{}.
Замечание:
Доступ к символам в строковых литералах через оператор
{}объявили устаревшим в PHP 7.4 и удалили в PHP 8.0.
Строки объединяют оператором «.» — точки. Обратите внимание, оператор сложения «+» здесь не работает. Подробнее об этом рассказано в разделе «Строковые операторы».
В языке предусмотрели ряд полезных функций для манипулирования строками.
Общие функции описывает раздел «Функции для работы со строками», а для расширенного поиска и замены — «Функции Perl-совместимых регулярных выражений».
В PHP также предусмотрели функции для работы с URL-адресами и функции шифрования и дешифрования строк (Sodium и Hash).
Наконец, смотрите также функции символьных типов.
Значение преобразовывают в строку приведением
через оператор (string) или функцией strval().
В выражениях, в которых требуется строка, преобразование выполняется автоматически.
Это выполняется во время вывода через языковые конструкции echo
или print, либо когда значение переменной сравнивается
со строкой. Разделы руководства
«Типы»
и «Жонглирование типами»,
прояснят сказанное ниже. Смотрите также описание функции settype().
Значение bool true преобразовывается в строку
«1», а логическое значение false преобразовывается
в «» (пустую строку). Такое поведение допускает преобразование значения
в обе стороны — из логического типа в строковый и наоборот.
Целое число (int) или число с плавающей точкой
(float) преобразовывается в строку, которая будет представлять число в текстовом виде
(включая экспоненциальную часть для чисел с плавающей точкой).
Большие числа с плавающей точкой преобразовываются в экспоненциальную запись (4.1E+6).
Замечание:
Начиная с PHP 8.0.0 в качестве разделителя дробной части в числах с плавающей точкой разрешено использовать только точку («
.»). До PHP 8.0.0 символ десятичной точки определялся в настройках языкового стандарта скрипта (категория LC_NUMERIC). Смотрите функцию setlocale().
Массивы преобразовываются в строку «Array».
Поэтому конструкции echo или print
не умеют без помощи функций отображать содержимое массива (array).
Чтобы просмотреть отдельный элемент, пользуются
синтаксисом echo $arr['foo']. Ниже рассказывается
об отображении или просмотре всего содержимого.
Для преобразования объекта (object) в строку (string)
определяют магический метод
__toString.
Ресурс (resource) преобразовывается в строку (string) вида
«Resource id #1», где 1 —
это номер ресурса, который PHP назначает ресурсу (resource) во время исполнения кода.
И хотя она уникальна для текущего запуска скрипта (т. е. веб-запроса или
CLI-процесса) и не будет использована повторно для этого ресурса,
не стоит полагаться на эту строку, потому что её могут изменить в будущем.
Тип ресурса можно получить вызовом функции get_resource_type().
Значение null всегда преобразовывается в пустую строку.
Как указано выше, прямое преобразование в строку массивов, объектов или ресурсов не даёт полезной информации о значении, кроме типа. Более эффективные инструменты вывода значений для отладки этих типов — это функции print_r() и var_dump().
Бо́льшая часть значений в PHP преобразуема в строку для постоянного хранения. Этот метод преобразования называется сериализацией. Сериализуют значения функцией serialize().
Строковый тип (string) в PHP реализовали в виде массива
байтов и целочисленного значения, которое содержит длину буфера. В этой структуре
нет информации о том, как преобразовывать байты в символы,
эту задачу решает программист. Нет ограничений на значения, из которых состоит строка,
например, байт со значением 0 (NUL-байт) разрешается
где угодно в строке (однако рекомендуют учитывать, что ряд функций,
которые в этом руководстве назвали «бинарно небезопасными»,
передают строки библиотекам, которые игнорируют данные после NUL-байта).
Такая природа строкового типа объясняет, почему в PHP нет отдельного типа «byte» — строки выполняют эту роль. Функции, которые не возвращают текстовых данных, — например, произвольный поток данных, считываемый из сетевого сокета, — по-прежнему возвращают строки.
С учётом того, что PHP не диктует конкретную кодировку
для строк, возникает вопрос: Как тогда кодируются строковые
литералы? Например, эквивалентна ли строка "á"
символу "\xE1" в кодировке ISO-8859-1, последовательности символов "\xC3\xA1"
в кодировке UTF-8 с формой нормализации C, последовательности "\x61\xCC\x81"
в кодировке UTF-8 с формой нормализации D или другому возможному
представлению? Ответ такой: строка закодируется
способом, которым её закодировали в файле скрипта. Поэтому, если
скрипт записан в кодировке ISO-8859-1, то и строка кодируется
в кодировке ISO-8859-1 и т. д. Однако это правило не выполняется при включённом
режиме Zend Multibyte: скрипт записывают в произвольной
кодировке, объявляя её или полагаясь на автоопределение,
а затем конвертируют в конкретную внутреннюю кодировку, в которой
и кодируются строковые литералы.
Учтите, что на кодировку скрипта (или на внутреннюю кодировку, если
включён режим Zend Multibyte) накладывается ряд ограничений:
почти в каждом случае эта кодировка должна быть надмножеством кодировки ASCII,
например, UTF-8 или ISO-8859-1. Учтите также, что кодировки, зависящие
от состояния, где одни и те же значения байтов допустимы
в начальном и не начальном состоянии сдвига, создают риск проблем.
Строковые функции, чтобы быть полезными, пробуют предположить кодировку строки. Единство в этом вопросе не помешало бы, но PHP-функции работают с текстом по-разному:
u).
В конечном счёте, программа будет работать с кодировкой Unicode правильно, если старательно избегать функций, которые не будут работать с Unicode-строками или повредят данные, и вызывать вместо них те, которые ведут себя корректно, обычно это функции из модулей intl и mbstring. Однако работа с функциями, которые умеют обрабатывать Unicode, — это только начало. Независимо от того, какие функции предлагает язык, рекомендовано знать спецификацию Unicode. Например, программа, которая предполагает существование только прописных и строчных букв, делает неверное предположение.