Строка - это набор символов, поэтому символ - это то же самое, что и байт. Это значит, что возможно ровно 256 различных символов. Это также означает, что PHP не имеет встроенной поддержки Unicode. Некоторую базовую поддержку Unicode обеспечивают функции utf8_encode() и utf8_decode().
Замечание: Нет никаких проблем, если строка очень велика. Практически не существует ограничений на размер строк, налагаемых PHP; единственный лимит - это доступная память на компьютере, на котором запущен PHP.
Строка может быть определена четырьмя различными способами:
Простейший способ определить строку - это заключить ее в одинарные кавычки (символ ').
Чтобы использовать одинарную кавычку внутри строки, проэкранируйте ее обратной косой чертой (\). Если необходимо написать саму обратную косую черту, продублируйте ее (\\). Все остальные случаи применения обратной косой черты будут интерпретированы как обычные символы: это означает, что если вы попытаетесь использовать другие управляющие последовательности, такие как \r или \n, они будут выведены как есть вместо какого-либо особого поведения.
Замечание: В отличие от синтаксиса двойных кавычек и heredoc, переменные и управляющие последовательности для специальных символов, заключенных в одинарные кавычки, не обрабатываются.
<?php
echo 'это простая строка';
echo 'Также вы можете вставлять в строки
символ новой строки вот так,
это нормально';
// Выводит: Однажды Арнольд сказал: "I'll be back"
echo 'Однажды Арнольд сказал: "I\'ll be back"';
// Выводит: Вы удалили C:\*.*?
echo 'Вы удалили C:\\*.*?';
// Выводит: Вы удалили C:\*.*?
echo 'Вы удалили C:\*.*?';
// Выводит: Это не будет развернуто: \n новая строка
echo 'Это не будет развернуто: \n новая строка';
// Выводит: Переменные $expand также $either не разворачиваются
echo 'Переменные $expand также $either не разворачиваются';
?>
Если строка заключена в двойные кавычки ("), PHP распознает большее количество управляющих последовательностей для специальных символов:
| Последовательность | Значение |
|---|---|
| \n | новая строка (LF или 0x0A (10) в ASCII) |
| \r | возврат каретки (CR или 0x0D (13) в ASCII) |
| \t | горизонтальная табуляция (HT или 0x09 (9) в ASCII) |
| \v | вертикальная табуляция (VT или 0x0B (11) в ASCII) (с версии PHP 5.2.5) |
| \f | подача страницы (FF или 0x0C (12) в ASCII) (с версии PHP 5.2.5) |
| \\ | обратная косая черта |
| \$ | знак доллара |
| \" | двойная кавычка |
| \[0-7]{1,3} | последовательность символов, соответствующая регулярному выражению символа в восьмеричной системе счисления |
| \x[0-9A-Fa-f]{1,2} | последовательность символов, соответствующая регулярному выражению символа в шестнадцатеричной системе счисления |
Как и в строке, заключенной в одинарные кавычки, экранирование любого символа выведет также и саму обратную косую черту. До версии PHP 5.1.1, обратная косая черта в \{$var} не печаталась.
Но самым важным свойством строк в двойных кавычках является обработка переменных. Смотрите более подробно: обработка строк
Третий способ определения строк - это использование heredoc-синтаксиса: <<<. После этого оператора необходимо указать идентификатор, затем перевод строки. После этого идет сама строка, а потом этот же идентификатор, закрывающий вставку.
Строка должна начинаться с закрывающего идентификатора, т.е. он должен стоять в первом столбце строки. Кроме того, идентификатор должен соответствовать тем же правилам именования, что и все остальные метки в PHP: содержать только буквенно-цифровые символы и знак подчеркивания, и не должен начинаться с цифры (знак подчеркивания разрешается).
Очень важно отметить, что строка с закрывающим идентификатором не содержит других символов, за исключением, возможно, точки с запятой (;). Это означает, что идентификатор не должен вводиться с отступом и что не может быть никаких пробелов или знаков табуляции до или после точки с запятой. Важно также понимать, что первым символом перед закрывающим идентификатором должен быть символ новой строки, определенный в вашей операционной системе. Например, на Macintosh это \r. После закрывающего идентификатора (необязательно дополненного точкой с запятой) также сразу должна начинаться новая строка.
Если это правило нарушено и закрывающий идентификатор не является "чистым", считается, что закрывающий идентификатор отсутствует и PHP продолжит его поиск дальше. Если в этом случае верный закрывающий идентификатор так и не будет найден, то это вызовет ошибку парсинга с номером строки в конце скрипта.
Heredoc не может быть использован для инициализации полей класса. Начиная с версии PHP 5.3, это ограничение распространяется только на heredoc, содержащие внутри себя переменные.
Пример #1 Неверный пример
<?php
class foo {
public $bar = <<<EOT
bar
EOT;
}
?>
Heredoc-текст ведет себя так же, как и строка в двойных кавычках, при этом их не имея. Это означает, что вам нет необходимости экранировать кавычки в heredoc, но вы по-прежнему можете использовать вышеперечисленные управляющие последовательности. Переменные обрабатываются, но с применением сложных переменных внутри heredoc нужно быть также внимательным, как и при работе со строками.
Пример #2 Пример определения heredoc-строки
<?php
$str = <<<EOD
Пример строки,
охватывающей несколько строчек,
с использованием heredoc-синтаксиса.
EOD;
/* Более сложный пример с переменными. */
class foo
{
var $foo;
var $bar;
function foo()
{
$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-синтаксис для передачи данных через аргументы функции:
Пример #3 Пример применения heredoc в аргументах
<?php
var_dump(array(<<<EOD
foobar!
EOD
));
?>
Начиная с версии 5.3.0, стала возможной инциализация статических переменных и свойств/констант класса с помощью синтаксиса heredoc:
Пример #4 Использование heredoc для инциализации статических переменных
<?php
// Статические переменные
function foo()
{
static $bar = <<<LABEL
Здесь ничего нет...
LABEL;
}
// Class properties/constants
class foo
{
const BAR = <<<FOOBAR
Пример использования константы
FOOBAR;
public $baz = <<<FOOBAR
Пример использования поля
FOOBAR;
}
?>
В PHP 5.3.0 также была введена возможность использования двойных кавычек при объявлении идентификатора:
Пример #5 Использование двойных кавычек в heredoc
<?php
echo <<<"FOOBAR"
Привет, мир!
FOOBAR;
?>
Замечание:
Поддержка heredoc была добавлена в PHP 4.
Nowdoc - это то же самое для строк в одинарных кавычках, что и heredoc для строк в двойных кавычках. Nowdoc похож на heredoc, но внутри него не осуществляется никаких подстановок. Эта конструкция идеальна для внедрения PHP-кода или других больших блоков текста без необходимости его экранирования. В этом он немного похож на SGML-конструкцию <![CDATA[ ]]> тем, что объявляет блок текста, не предназначенный для обработки.
Nowdoc указывается той же последовательностью <<<, что используется в heredoc, но последующий за ней идентификатор заключается в одинарные кавычки, например, <<<'EOT'. Все условия, действующие для heredoc идентификаторов также действительны и для nowdoc, особенно те, что относятся к закрывающему идентификатору.
Пример #6 Пример использования nowdoc
<?php
$str = <<<'EOD'
Пример текста,
занимающего несколько строк,
с помощью синтаксиса nowdoc.
EOD;
/* Более сложный пример с переменными. */
class foo
{
public $foo;
public $bar;
function foo()
{
$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Замечание:
В отличие от heredoc, nowdoc может быть использован в любом контексте со статическими данными. Типичный пример инициализации полей класса или констант:
Пример #7 Пример использования статичных данных
<?php
class foo {
public $bar = <<<'EOT'
bar
EOT;
}
?>
Замечание:
Поддержка nowdoc была добавлена в PHP 5.3.0.
Если строка указывается в двойных кавычках, либо при помощи heredoc, переменные внутри нее обрабатываются.
Существует два типа синтаксиса: простой и сложный. Простой синтаксис более легок и удобен. Он дает возможность обработки переменной, значения массива (array) или свойства объекта (object) с минимумом усилий.
Сложный синтаксис был введен в PHP 4 и может быть определен по фигурным скобкам, окружающих выражение.
Если интерпретатор встречает знак доллара ($), он захватывает так много символов, сколько возможно, чтобы сформировать правильное имя переменной. Если вы хотите точно определить конец имени, заключайте имя переменной в фигурные скобки.
<?php
$juice = "apple";
echo "He drank some $juice juice.".PHP_EOL;
echo "He drank some juice made of $juices."; // не работает, 's' - это верный символ для имени переменной,
// но наша переменная имеет имя $juice.
?>
Результат выполнения данного примера:
He drank some apple juice. He drank some juice made of .
Аналогично могут быть обработаны элемент массива (array) или свойство объекта (object). В индексах массива закрывающая квадратная скобка (]) обозначает конец определения индекса. Для свойств объекта применяются те же правила, что и для простых переменных.
Пример #8 Пример простого синтаксиса
<?php
$juices = array("apple", "orange", "koolaid1" => "purple");
echo "He drank some $juices[0] juice.".PHP_EOL;
echo "He drank some $juices[1] juice.".PHP_EOL;
echo "He drank some juice made of $juice[0]s.".PHP_EOL; // Не будет работать
echo "He drank some $juices[koolaid1] juice.".PHP_EOL;
class people {
public $john = "John Smith";
public $jane = "Jane Smith";
public $robert = "Robert Paulsen";
public $smith = "Smith";
}
$people = new people();
echo "$people->john drank some $juices[0] juice.".PHP_EOL;
echo "$people->john then said hello to $people->jane.".PHP_EOL;
echo "$people->john's wife greeted $people->robert.".PHP_EOL;
echo "$people->robert greeted the two $people->smiths."; // Не будет работать
?>
Результат выполнения данного примера:
He drank some apple juice. He drank some orange juice. He drank some juice made of s. He drank some purple juice. John Smith drank some apple juice. John Smith then said hello to Jane Smith. John Smith's wife greeted Robert Paulsen. Robert Paulsen greeted the two .
Для чего-либо более сложного, используйте сложный синтаксис.
Он называется сложным не потому, что труден в понимании, а потому что позволяет использовать сложные выражения.
Любая скалярная переменная, элемент массива или свойство объекта, отображаемое в строку, может быть представлена в строке этим синтаксисом. Просто запишите выражение так же, как и вне строки, а затем заключите его в { и }. Поскольку { не может быть экранирован, этот синтаксис будет распознаваться только когда $ следует непосредственно за {. Используйте {\$, чтобы напечатать {$. Несколько поясняющих примеров:
<?php
// Показываем все ошибки
error_reporting(E_ALL);
$great = 'здорово';
// Не работает, выводит: Это { здорово}
echo "Это { $great}";
// Работает, выводит: Это здорово
echo "Это {$great}";
echo "Это ${great}";
// Работает
echo "Этот квадрат шириной {$square->width}00 сантиметров.";
// Работает, ключи, заключенные в кавычки, работают только с синтаксисом фигурных скобок
echo "Это работает: {$arr['key']}";
// Работает
echo "Это работает: {$arr[4][3]}";
// Это неверно по той же причине, что и $foo[bar] вне
// строки. Другими словами, это по-прежнему будет работать,
// но поскольку PHP сначала ищет константу foo, это вызовет
// ошибку уровня E_NOTICE (неопределенная константа).
echo "Это неправильно: {$arr[foo][3]}";
// Работает. При использовании многомерных массивов внутри
// строк всегда используйте фигурные скобки
echo "Это работает: {$arr['foo'][3]}";
// Работает.
echo "Это работает: " . $arr['foo'][3];
echo "Это тоже работает: {$obj->values[3]->name}";
echo "Это значение переменной по имени $name: {${$name}}";
echo "Это значение переменной по имени, которое возвращает функция getName(): {${getName()}}";
echo "Это значение переменной по имени, которое возвращает \$object->getName(): {${$object->getName()}}";
// Не работает, выводит: Это то, что возвращает getName(): {getName()}
echo "Это то, что возвращает getName(): {getName()}";
?>
С помощью этого синтаксиса также возможен доступ к свойствам объекта внутри строк.
<?php
class foo {
var $bar = 'I am bar.';
}
$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo "{$foo->$bar}\n";
echo "{$foo->$baz[1]}\n";
?>
Результат выполнения данного примера:
Замечание:
Функции, вызовы методов, статические переменные классов, а также константы классов работает внутри {$}, начиная с версии PHP 5. Однако, указываемое значение будет обработано как имя переменной в том же контексте, что и строка, в которой она определяется. Использование одинарных фигурных скобок ({}) не будет работать для доступа к значениям функций, методов, констант классов или статических переменных класса.
<?php
// Показываем все ошибки
error_reporting(E_ALL);
class beers {
const softdrink = 'rootbeer';
public static $ale = 'ipa';
}
$rootbeer = 'A & W';
$ipa = 'Alexander Keith\'s';
// Это работает, выводит: Я бы хотел A & W
echo "Я бы хотел {${beers::softdrink}}\n";
// Это тоже работает, выводит: Я бы хотел Alexander Keith's
echo "Я бы хотел {${beers::$ale}}\n";
?>
Символы в строках можно использовать и модифицировать, определив их смещение относительно начала строки, начиная с нуля, в квадратных скобках после строки, например, $str[42]. Думайте о строке для этой цели, как о массиве символов. Если нужно получить или заменить более 1 символа, можно использовать функции substr() и substr_replace().
Замечание: К символу в строке также можно обращаться с помощью фигурных скобок, например, $str{42}.
Попытка записи в смещение за границами строки дополнит строку пробелами до этого смещения. Нецелые типы будет преобразованы в целые. Неверный тип смещения вызовет ошибку уровня E_NOTICE. Запись по отрицательному смещению вызовет ошибку уровня E_NOTICE, а при чтении вернет пустую строку. Используется только первый символ присваемой строки. Присвоение пустой строки присваивает нулевой байт (NUL).
Пример #9 Несколько примеров строк
<?php
// Получение первого символа строки
$str = 'This is a test.';
$first = $str[0];
// Получение третьего символа строки
$third = $str[2];
// Получение последнего символа строки
$str = 'This is still a test.';
$last = $str[strlen($str)-1];
// Изменение последнего символа строки
$str = 'Look at the sea';
$str[strlen($str)-1] = 'e';
?>
Замечание:
Попытка доступа к переменным других типов (исключая массивы или объекты, реализующие определенные интерфейсы) с помощью [] или {} молча вернет NULL.
Строки могут быть объединены при помощи оператора '.' (точка). Обратите внимание, оператор сложения '+' здесь не работает. Дополнительную информацию смотрите в разделе Строковые операторы.
Для модификации строк существует множество полезных функций.
Основные функции описаны в разделе строковых функций, а для расширенного поиска и замены - функции регулярных выражений или Perl-совместимых регулярных выражений.
Также существуют функции для работы с URL, и функции шифрования/дешифрования строк (mcrypt и mhash).
Наконец, смотрите также функции символьных типов.
Значение может быть преобразовано в строку, с помощью приведения (string), либо функции strval(). В выражениях, где необходима строка, преобразование происходит автоматически. Это происходит, когда вы используете функции echo() или print(), либо когда значение переменной сравнивается со строкой. Прочтение разделов руководства Типы и Манипуляции с типами сделает следующее более понятным. Смотрите также settype().
Значение boolean TRUE преобразуется в строку "1", а значение FALSE преобразуется в "" (пустую строку). Это позволяет преобразовывать значения в обе стороны - из булева типа в строковый и наоборот.
Целое (integer) или число с плавающей точкой (float) преобразуется в строку, представленную числом, состоящим из его цифр (включая показатель степени для чисел с плавающей точкой). Числа с плавающей точкой могут быть преобразованы с помощью экспоненциального представления (4.1E+6).
Замечание:
Символ десятичной точки определяется из настроек локали текущего скрипта (категория LC_NUMERIC). Смотрите также setlocale().
Массивы всегда преобразуются в строку "Array", так что вы не можете отобразить содержимое массива (array), используя echo() или print(), чтобы узнать, что он содержит. Чтобы просмотреть отдельный элемент, используйте что-нибудь вроде echo $arr['foo']. Смотрите ниже советы о том, как отобразить/просмотреть все содержимое.
Объекты в PHP 4 всегда преобразовывались в строку "Object". Если вы хотите вывести значения полей объекта (object) с целью отладки, читайте дальше. Если вы хотите получить имя класса требуемого объекта, используйте get_class(). Начиная с PHP 5, также стал доступен метод __toString.
Ресурсы всегда преобразуются в строки со структурой "Resource id #1", где 1 - это уникальный номер ресурса (resource), присвоенный ему PHP во время выполнения. Не полагайтесь на эту структуру, она может измениться в любое время. Если вы хотите получить тип ресурса, используйте get_resource_type().
NULL всегда преобразуется в пустую строку.
Как вы могли видеть выше, прямое преобразование в строку массивов, объектов или ресурсов не дает никакой полезной информации о самих значениях, кроме их типов. Более подходящий способ вывода значений для отладки - использовать функции print_r() и var_dump().
Большинство значений в PHP может быть преобразовано в строку для постоянного хранения. Этот метод называется сериализацией и может быть выполнен при помощи функции serialize(). Кроме того, если в вашей установке PHP есть поддержка WDDX, возможна также сериализация в XML-структуру.
Если строка распознается как числовое значение, результирующее значение и тип определяется так, как показано далее.
Если строка не содержит какой-либо из символов '.', 'e', или 'E', и значение числа помещается в пределы целых чисел (определенных PHP_INT_MAX), строка будет распознана как целое число (integer). Во всех остальных случаях она считается числом с плавающей точкой (float).
Значение определяется по начальной части строки. Если строка начинается с верного числового значения, будет использовано это значение. Иначе значением будет 0 (ноль). Верное числовое значение - это одна или более цифр (могущих содержать десятичную точку), по желанию предваренных знаком, с последующим необязательным показателем степени. Показатель степени - это 'e' или 'E' с последующими одной или более цифрами.
<?php
$foo = 1 + "10.5"; // $foo это float (11.5)
$foo = 1 + "-1.3e3"; // $foo это float (-1299)
$foo = 1 + "bob-1.3e3"; // $foo это integer (1)
$foo = 1 + "bob3"; // $foo это integer (1)
$foo = 1 + "10 Small Pigs"; // $foo это integer (11)
$foo = 4 + "10.2 Little Piggies"; // $foo это float (14.2)
$foo = "10.0 pigs " + 1; // $foo это float (11)
$foo = "10.0 pigs " + 1.0; // $foo это float (11)
?>
Более подробную информацию об этом преобразовании смотрите в разделе о strtod(3) документации Unix.
Если вы хотите протестировать любой из примеров этого раздела, скопируйте и вставьте его и следующую строку, чтобы увидеть, что происходит:
<?php
echo "\$foo==$foo; тип: " . gettype ($foo) . "<br />\n";
?>
Не ожидайте получить код символа, преобразовав его в целое (как это делается, например, в C). Для преобразования символов в их ASCII коды и обратно используйте функции ord() и chr().