Строки

Строка (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

Третий способ определения строк — 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:

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

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}" . PHP_EOL;

// Работает, выводит: Это здорово
echo "Это {$great}" . PHP_EOL;

// Для вывода самих фигурных скобок:
echo "Это {{$great}}" . PHP_EOL;

class Square
{
    public $width;

    public function __construct(int $width)
    {
        $this->width = $width;
    }
}

$square = new Square(5);

// Работает
echo "Ширина квадрата составляет {$square->width}00 сантиметров." . PHP_EOL;

// Работает, ключи в кавычках работают только при записи синтаксисом фигурных скобок
echo "Это работает: {$arr['key']}" . PHP_EOL;

// Работает
echo "Это работает: {$arr[3][2]}" . PHP_EOL;

echo "Работает: {$arr[DATA_KEY]}" . PHP_EOL;

// При работе с многомерными массивами массивы внутри строк оборачивают в фигурные скобки
echo "Это работает: {$arr['foo'][2]}" . PHP_EOL;

echo "Работает: {$obj->values[3]->name}" . PHP_EOL;

echo "Работает: {$obj->$staticProp}" . PHP_EOL;

// Не работает, выводит: C:\directory\{fantastic}.txt
echo "C:\directory\{$great}.txt" . PHP_EOL;

// Работает, выводит: C:\directory\fantastic.txt
echo "C:\\directory\\{$great}.txt" . PHP_EOL;

Замечание: В строках с продвинутым синтаксисом возможно записывать переменные переменных, поскольку продвинутый синтаксис разрешает произвольные выражения.

Доступ к символам и изменение символов в строке

Символы внутри строк индексируются с начала строки, индексы начинаются с 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 символ десятичной точки определялся функцией setlocale() при установке региональных настроек скрипта для категории LC_NUMERIC.

Массивы преобразовываются в строку "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-функции работают с текстом по-разному:

Одни — предполагают, что строка закодирована в какой-то однобайтовой кодировке, но для корректной работы им не нужно интерпретировать байты как конкретные символы. Сюда попадают функции вроде substr(), strpos(), strlen() и strcmp(). Другой способ мышления об этих функциях — представлять, что они оперируют буферами памяти, т. е. работают непосредственно с байтами и их смещениями.
Другим — передаётся кодировка строки или они принимают значение по умолчанию, если кодировку не передали. Это относится к функции htmlentities() и большей части функций модуля mbstring.
Третьи — работают с текущими настройками локали (смотрите setlocale()), но оперируют побайтово.
Наконец четвёртые — предполагают, что строка использует конкретную кодировку, обычно UTF-8. Сюда попадает бо́льшая часть функций из модулей intl и PCRE (для последнего — только при указании модификатора u).

Программа правильно обработает строки в кодировке Unicode, только если вместо функций, которые не гарантируют правильную обработку или повреждают строки в Юникоде, вызывать функции модулей intl и mbstring, которые корректно обрабатывают строки с многобайтовыми символами. Работа с правильными PHP-функциями обработки строк в Юникоде — только начало, дополнительно потребуется изучить спецификацию стандарта Unicode. Строки состоят не только из прописных и строчных букв и часто не только из символов латинского алфавита, поэтому лучше готовить программу к обработке строк из многобайтовых символов.