Двойные кавычки в переменных php. В чем разница между одинарными и двойными кавычками в PHP? Как экранировать двойные кавычки в php
Я сторонник красивого и оптимизированного кода, хоть и не всегда у меня получается следовать всем правилам «хорошего тона» в программировании.
Сейчас же речь пойдет о правильном использовании двойных и одинарных кавычек в php. Перед тем, как начать писать пост, я бегло просмотрел имеющиеся у меня книги по php, и, что странно, ни в одной не увидел правильного использования кавычек. Почему – для меня загадка. Обвинять авторов в дилетантстве нет ни малейшей возможности, книги далеко не для «чайников». Может быть просто не хотели акцентировать на этом внимание, дескать кому надо, тот сам разберется.
Кавычки, что логично, бывают одинарными и двойными. Различие их использования в php заключается в следующем. Строку, заключенную в одинарные кавычки, интерпретатор php выводит как есть, заключенную же в двойные кавычки парсит на наличие в ней переменных и, найдя таковые, подставляет их значения.
Следовательно, если нам надо вывести текст «как есть», то используем одинарные кавычки. Если необходимо подставить вместо переменной ее значение – двойные (если переменная только одна, то кавычки можно и вовсе опустить). Часто можно встретить такой код:
Выводится просто текст. Но в коде он по какой-то неведомой причине заключен в двойные кавычки, что заставляет интерпретатор парсить его на наличие переменных. Правильным будет заключить текст в одинарные кавычки.
Рассмотрим тривиальную задачу вывода переменной в составе текста, в том числе и с использованием html кода.
$date"; ?>Все выводится хорошо, текст и выделенная жирным дата, которая подставляется вместо переменной. Но необходимо помнить две вещи. Первое, это особенность интерпретатора: конкатенация строк происходим намного быстрее и требует меньше ресурсов, нежели синтаксический анализ строк. И второе — не стоит забывать про парадигму программирования «разделяй и властвуй». Не надо мешать все в одно, гораздо правильнее будет разделить текст на две части – требующую и не требующую парсинга интерпретатором. Таким образом, пример выше стоит записать так:
".$date.""; ?>Естественно, следовать этому правилу (заключать все, что не требует парсинга, в одинарные кавычки) надо не только при выводе текста, но и при присвоении значений строковым переменным:
Или, например, при использовании строк при передаче аргументов функции:
И хотя на современных компьютерах выигрыш во времени интерпретирования кода в зависимости от использования одинарных или двойных кавычек будет фактически незаметен, особенно в небольших скриптах, стоит все-таки изначально приучать себя писать грамотный код, это намного легче, чем потом переучиваться.
Не секрет, что кавычки в php бывают одинарные и двойные. Давайте выясним, когда уместнее те или иные варианты использования кавычек.
Одинарные кавычки
Простейшим способом определить строку является — выделение текста в одинарные кавычки.
Если нам нужно использовать одинарную кавычку в тексте, то необходимо проэкранировать ее косой чертой (\).
Управляющие последовательности в одинарных кавычках не работают.
Примеры использования одинарных кавычек :
Двойные кавычки
Если выделить текст двойными кавычками, то строка будет определена также, как и одинарными. Но отличия у кавычек конечно же есть.
Ситуация с экранированием кавычек такая же, как и с одинарными кавычками.
Строка, которая заключена двойными кавычками — распознает большинство управляющих последовательностей для специальных символов.
Важнейшим отличием является тот факт, что двойные кавычки обрабатывают переменные.
Примеры использования двойных кавычек :
Заострим внимание на том, что строки с двойными кавычками обрабатывают переменные.
Что происходит при обработке строки? Интерпретатор проверяют каждую строку с двойными кавычками на переменные , т.е. происходит принудительный парсинг, на что уходит дополнительное время. Да, часто это доли секунды, но сам факт надо понимать. То есть если сравнить обработку разными кавычками одной строки (без переменных само собой), то строка с одинарными кавычками однозначно будет обработана быстрее.
Расчеты
На сайте ProfiPHP нашел интересные расчеты на данную тему. Автор написал простой скрипт, с помощью которого вычислял время на обработку строк.
Я не эксперт в PHP-программировании, но я немного смущен, почему я вижу некоторый код в PHP со строкой, помещенной в одинарные кавычки, а иногда и в двойные кавычки.
Я просто знаю в.NET или языке C, если он находится в одной кавычке, это означает, что это символ, а не строка.
11 ответов
что вы должны знать
$a = "name"; $b = "my $a"; == "my name" $c = "my $a"; != "my name"
в PHP люди используют одинарную кавычку для определения постоянной строки, например "a" , "my name" , "abc xyz" , при использовании двойной кавычки для определения строки содержит идентификатор, например "a $b $c $d" .
Echo "my name";
быстрее чем
Echo "my name";
Echo "my " . $a;
медленнее, чем
Echo "my $a";
это верно для других используемых строк.
пример одиночных, двойных, heredoc и nowdoc кавычек
оба вида вложенных символов являются строками. Один тип цитаты удобно использован для того чтобы заключить другой тип цитаты. """ и """ . Самая большая разница между типами кавычек заключается в том, что ссылки на вложенные идентификаторы заменяются внутри двойных кавычек, но не внутри одинарных кавычек.
в PHP текст одинарной кавычки рассматривается как строковое значение, а текст двойной кавычки будет анализировать переменные, заменяя и обрабатывая их значение.
$test = "variable"; echo "Hello Mr $test"; // the output would be: Hello Mr variable echo "Hello Mr $test"; // the output would be: Hello Mr $test
здесь двойная кавычка анализирует значение, а одинарная кавычка рассматривается как строковое значение (без разбора переменной $test.)
возможно, я немного опоздал, и немного не по теме, но все же...
вам не нужно выбирать из-за содержимого вашей строки между:
alert("It"s \"game\" time."); или alert("It\"s "game" time.");
вместо этого вы можете ввести вот так, а затем использовать двойные или одинарные кавычки, потому что это не имеет значения:
alert("It’s “game” time."); и alert("It’s “game” time.");
$name = "test"; $singleQuote = "This is example for single quote $name"; // here $name variable not evaluating echo $singleQuote; // Output: This is example for single quote $name $singleQuote = "This is example for single quote $name"; // here $name variable will evaluate and replace variable value echo $singleQuote; // Output: This is example for single quote test Also inside single quote expression evaluate faster campare to double quotes
одно:
очень важно отметить, что строка с закрывающим идентификатором помощи heredoc должен содержать никаких других символов, кроме точка с запятой (;) . Это означает, что идентификатор не может быть отступом , и не может быть помещения или вкладки до или после запятой.
пример:
$str = << Простейший способ определить строку - это заключить ее в
одинарные кавычки (символ "
). Чтобы использовать одинарную кавычку внутри строки,
проэкранируйте ее обратной косой чертой (\
).
Если необходимо написать саму обратную косую черту, продублируйте ее
(\\
).
Все остальные случаи применения обратной косой черты будут интерпретированы как
обычные символы: это означает, что если вы попытаетесь использовать другие управляющие
последовательности, такие как \r
или \n
,
они будут выведены как есть вместо какого-либо особого поведения. echo
"это простая строка"
; echo
"Также вы можете вставлять в строки // Выводит: Однажды Арнольд сказал: "I"ll be back" Echo
"Вы удалили C:\\*.*?"
; // Выводит: Вы удалили C:\*.*? // Выводит: Это не будет развернуто: \n новая строка // Выводит: Переменные $expand также $either не разворачиваются Если строка заключена в двойные кавычки ("), PHP распознает
большее количество управляющих последовательностей для
специальных символов: Как и в строке, заключенной в одинарные кавычки, экранирование любого символа
выведет также и саму обратную косую черту. До версии PHP 5.1.1, обратная косая
черта в \{$var}
не печаталась. Третий способ определения строк - это использование
heredoc-синтаксиса: <<<
. После
этого оператора необходимо указать идентификатор,
затем перевод строки. После этого идет сама строка,
а потом этот же идентификатор, закрывающий вставку. Строка должна
начинаться с закрывающего идентификатора,
т.е. он должен стоять в первом столбце строки. Кроме того, идентификатор должен
соответствовать тем же правилам именования, что и все остальные
метки в PHP: содержать только буквенно-цифровые символы и знак
подчеркивания, и не должен начинаться с цифры (знак подчеркивания разрешается). Внимание
Очень важно отметить, что строка с закрывающим идентификатором
не должна содержать других символов, за исключением точки с запятой
(;
). Это означает, что идентификатор
не должен вводиться с отступом
и что не
может быть никаких пробелов или знаков табуляции до или после
точки с запятой. Важно также понимать, что первым символом перед
закрывающим идентификатором должен быть символ новой строки,
определенный в вашей операционной системе. Например, в UNIX системах, включая Mac OS X,
это \n
. После закрывающего идентификатора также
сразу должна начинаться новая строка. Если это правило нарушено и закрывающий идентификатор не является
"чистым", считается, что закрывающий идентификатор отсутствует и
PHP продолжит его поиск дальше. Если в этом случае верный
закрывающий идентификатор так и не будет найден, то это вызовет
ошибку парсинга с номером строки в конце скрипта. Heredoc не может быть использован для инициализации полей класса.
Начиная с версии PHP 5.3, это ограничение распространяется только на heredoc,
содержащие внутри себя переменные. Пример #1 Неверный пример
class
foo
{ Heredoc-текст ведет себя так же, как и строка в двойных кавычках,
при этом их не имея. Это означает, что вам нет необходимости
экранировать кавычки в heredoc, но вы по-прежнему можете
использовать вышеперечисленные управляющие последовательности.
Переменные обрабатываются, но с применением сложных переменных
внутри heredoc нужно быть также внимательным, как и при работе
со строками. Пример #2 Пример определения heredoc-строки
$str
= << Class
foo Function
foo
()
$foo
= new
foo
(); echo << Меня зовут "МоеИмя". Я печатаю Foo.
Теперь, я вывожу Bar2.
Это должно вывести заглавную букву "A": A Также возможно использовать heredoc-синтаксис для передачи данных
через аргументы функции: Начиная с версии 5.3.0, стала возможной инциализация статических переменных
и свойств/констант класса с помощью синтаксиса heredoc: Пример #4 Использование heredoc для инциализации статических переменных
// Статические переменные // Class properties/constants Public
$baz
= << Начиная с версии PHP 5.3.0 можно также окружать идентификатор Heredoc
двойными кавычками: Nowdoc - это то же самое для строк в одинарных кавычках, что и
heredoc для строк в двойных кавычках.
Nowdoc похож на heredoc, но внутри него не осуществляется
никаких подстановок
. Эта конструкция идеальна для внедрения
PHP-кода или других больших блоков текста без необходимости
его экранирования. В этом он немного похож на SGML-конструкцию
тем, что объявляет блок текста,
не предназначенный для обработки. Nowdoc указывается той же последовательностью <<<
,
что используется в heredoc, но последующий за ней идентификатор заключается
в одинарные кавычки, например, <<<"EOT"
.
Все условия, действующие для heredoc идентификаторов также действительны
и для nowdoc, особенно те, что относятся к закрывающему идентификатору. Пример #6 Пример использования nowdoc
$str
= <<<"EOD" /* Более сложный пример с переменными. */ Function
foo
()
$foo
= new
foo
(); echo <<<"EOT" Результат выполнения данного примера: Меня зовут "$name". Я печатаю $foo->foo.
Теперь я печатаю {$foo->bar}.
Это не должно вывести заглавную "A": \x41 Замечание
: В отличие от heredoc, nowdoc может быть использован в любом контексте
со статическими данными. Типичный пример инициализации полей класса
или констант: Пример #7 Пример использования статичных данных
class
foo
{ Замечание
: Поддержка nowdoc была добавлена в PHP 5.3.0. Если строка указывается в двойных кавычках, либо при помощи
heredoc, переменные внутри
нее обрабатываются. Существует два типа синтаксиса:
простой и
сложный .
Простой синтаксис более легок и удобен. Он дает возможность
обработки переменной, значения массива (array
) или
свойства объекта (object
) с минимумом усилий. Сложный синтаксис может быть определен
по фигурным скобкам, окружающим выражение. Если интерпретатор встречает знак доллара ($
), он
захватывает так много символов, сколько возможно, чтобы сформировать
правильное имя переменной. Если вы хотите точно определить конец имени,
заключайте имя переменной в фигурные скобки. $juice
=
"apple"
; echo
"He drank some
$juice
juice."
.
PHP_EOL
; Результат выполнения данного примера: He drank some apple juice.
He drank some juice made of . Аналогично могут быть обработаны элемент массива
(array
) или свойство объекта (object
).
В индексах массива закрывающая квадратная скобка
(]
) обозначает конец определения индекса.
Для свойств объекта применяются те же правила, что и для простых
переменных. Пример #8 Пример простого синтаксиса
$juices
= array("apple"
,
"orange"
,
"koolaid1"
=>
"purple"
); echo
"He drank some
$juices
[
0
]
juice."
.
PHP_EOL
; class
people
{ Public
$smith
=
"Smith"
;
$people
= new
people
(); echo
"
$people
->
john
drank some
$juices
[
0
]
juice."
.
PHP_EOL
; Результат выполнения данного примера: He drank some apple juice.
He drank some orange juice.
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 . Для чего-либо более сложного, используйте сложный синтаксис. Он называется сложным не потому, что труден в понимании,
а потому что позволяет использовать сложные выражения. Любая скалярная переменная, элемент массива или свойство объекта,
отображаемое в строку, может быть представлена в строке этим синтаксисом.
Просто запишите выражение так же, как и вне строки, а
затем заключите его в {
и }
.
Поскольку {
не может быть
экранирован, этот синтаксис будет распознаваться только когда $
следует непосредственно за {
. Используйте
{\$
, чтобы напечатать {$
.
Несколько поясняющих примеров: // Показываем все ошибки
$great
=
"здорово"
; // Не работает, выводит: Это { здорово} // Работает, выводит: Это здорово
// Работает // Работает, ключи, заключенные в кавычки, работают только с синтаксисом фигурных скобок
// Работает // Это неверно по той же причине, что и $foo вне // Работает. При использовании многомерных массивов внутри
// Работает. echo
"Это тоже работает:
{
$obj
->
values
[
3
]->
name
}
"
; echo
"Это значение переменной по имени
$name
:
{${
$name
}}
"
; echo
"Это значение переменной по имени, которое возвращает функция getName():
{${
getName
()}}
"
; echo
"Это значение переменной по имени, которое возвращает \$object->getName():
{${
$object
->
getName
()}}
"
; // Не работает, выводит: Это то, что возвращает getName(): {getName()} С помощью этого синтаксиса также возможен доступ к свойствам объекта
внутри строк. class
foo
{
$foo
= new
foo
(); Результат выполнения данного примера: I am bar.
I am bar. Замечание
: Функции, вызовы методов, статические переменные классов, а также
константы классов работает внутри {$}
, начиная
с версии PHP 5.
Однако, указываемое значение будет обработано как имя переменной
в том же контексте, что и строка, в которой она определяется.
Использование одинарных фигурных скобок ({}
)
не будет работать для доступа к значениям функций, методов,
констант классов или статических переменных класса. // Показываем все ошибки class
beers
{
$rootbeer
=
"A & W"
; // Это работает, выводит: Я бы хотел A & W // Это тоже работает, выводит: Я бы хотел Alexander Keith"s Символы в строках можно использовать и модифицировать,
определив их смещение относительно начала строки, начиная с
нуля, в квадратных скобках после строки, например, $str .
Думайте о строке для этой цели, как о массиве символов.
Если нужно получить или заменить более 1 символа, можно использовать
функции substr()
и substr_replace()
. Замечание
:
К символу в строке также можно обращаться с помощью фигурных скобок,
например, $str{42} .
Внимание
Попытка записи в смещение за границами строки дополнит строку
пробелами до этого смещения. Нецелые типы будет преобразованы в целые.
Неверный тип смещения вызовет ошибку уровня E_NOTICE
.
Запись по отрицательному смещению вызовет ошибку уровня E_NOTICE
,
а при чтении вернет пустую строку.
Используется только первый символ присваемой строки.
Присвоение пустой строки присваивает нулевой байт (NULL). Внимание
Строки в PHP внутренне представляют из себя массивы байт. Как результат,
доступ или изменение строки по смещению небезопасно с точки зрения многобайтной
кодировки, и должно выполняться только со строками в однобайтных кодировках,
таких как, например, ISO-8859-1. Пример #9 Несколько примеров строк
// Получение первого символа строки // Получение третьего символа строки // Получение последнего символа строки // Изменение последнего символа строки
?>
Начиная с PHP 5.4 смещение в строке должно задаваться либо целым числом либо строкой, содержащей цифры, иначе будет
выдаваться предупреждение. Ранее смещение, заданное строкой вида "foo"
, без предупреждений преобразовывалось в 0
. Пример #10 Различия между PHP 5.3 и PHP 5.4
$str
=
"abc"
; Var_dump
($str
[
"1"
]); Var_dump
($str
[
"1.0"
]); Var_dump
($str
[
"x"
]); Var_dump
($str
[
"1x"
]); Результат выполнения данного примера в PHP 5.3: string(1) "b"
bool(true)
string(1) "b"
bool(true)
string(1) "a"
bool(true)
string(1) "b"
bool(true) Результат выполнения данного примера в PHP 5.4: string(1) "b"
bool(true)
Warning: Illegal string offset "1.0" in /tmp/t.php on line 7
string(1) "b"
bool(false)
Warning: Illegal string offset "x" in /tmp/t.php on line 9
string(1) "a"
bool(false)
string(1) "b"
bool(false) Замечание
: Попытка доступа к переменным других типов (исключая массивы или
объекты, реализующие определенные интерфейсы) с помощью
или {}
молча вернет NULL
. Замечание
: В PHP 5.5 была добавлена поддержка доступа к символам в строковых литералах
с помощью синтаксиса
или {}
. Для модификации строк существует множество полезных функций. Основные функции описаны в разделе
строковых функций , а
для расширенного поиска и замены - функции
регулярных выражений
или Perl-совместимых регулярных выражений . Значение может быть преобразовано в строку, с помощью приведения
(string)
, либо функции strval()
.
В выражениях, где необходима строка, преобразование происходит автоматически.
Это происходит, когда вы используете функции echo
или print
, либо когда значение переменной сравнивается
со строкой. Прочтение разделов руководства Типы и Манипуляции с типами сделает
следующее более понятным. Смотрите также settype()
. Массивы всегда преобразуются в строку "Array"
,
так что вы не можете отобразить содержимое массива (array
),
используя echo
или print
,
чтобы узнать, что он содержит. Чтобы просмотреть отдельный элемент, используйте
что-нибудь вроде echo $arr["foo"]
. Смотрите
ниже советы о том, как отобразить/просмотреть все содержимое. Объекты в PHP 4 всегда преобразовывались в строку "Object"
.
Если вы хотите вывести значения полей объекта
(object
) с целью отладки, читайте дальше. Если
вы хотите получить имя класса требуемого объекта, используйте
get_class()
. Начиная с PHP 5, также стал доступен метод
__toString . NULL
всегда преобразуется в пустую строку. Как вы могли видеть выше, прямое преобразование в строку массивов, объектов
или ресурсов не дает никакой полезной информации о самих значениях, кроме их типов.
Более подходящий способ вывода значений для отладки - использовать функции
print_r()
и var_dump()
. Большинство значений в PHP может быть преобразовано в строку для постоянного
хранения. Этот метод называется сериализацией и может быть выполнен
при помощи функции serialize()
. Кроме того, если в
вашей установке PHP есть поддержка WDDX ,
возможна также сериализация в XML-структуру. Если строка распознается как числовое значение, результирующее значение
и тип определяется так, как показано далее. Если строка не содержит какой-либо из символов ".", "e", или "E", и
значение числа помещается в пределы целых чисел (определенных
PHP_INT_MAX
), строка будет распознана как целое число (integer
).
Во всех остальных случаях она считается числом с плавающей точкой (float
). Значение определяется по начальной части строки. Если строка
начинается с верного числового значения, будет использовано это
значение. Иначе значением будет 0 (ноль). Верное числовое значение
- это одна или более цифр (могущих содержать десятичную точку),
по желанию предваренных знаком, с последующим необязательным
показателем степени. Показатель степени - это "e" или "E" с
последующими одной или более цифрами. $foo
=
1
+
"10.5"
;
// $foo это float (11.5) Более подробную информацию об этом преобразовании смотрите в разделе
о strtod(3) документации Unix. Если вы хотите протестировать любой из примеров этого раздела,
скопируйте и вставьте его и следующую строку, чтобы
увидеть, что происходит: echo
"\$foo==
$foo
; тип: "
.
gettype
($foo
) .
" Не ожидайте получить код символа, преобразовав его в целое (как
это делается, например, в C). Для преобразования символов в
их ASCII коды и обратно используйте функции ord()
и chr()
. Строковый тип (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. Учтите также, что кодировки, зависящие
от состояния, где одни и те же значения байт могут быть использованы
в начальном и не начальном состоянии сдвига (initial and non-inital
shift state), могут вызвать проблемы. Разумеется, чтобы приносить пользу, строковые функции должны сделать
некоторые предположения о кодировке строки. К несчастью, среди
PHP-функций довольно большое разнообразие подходов к этому вопросу: В конечном счете, написание корректных программ, работающих с Unicode,
означает осторожное избегание функций, которые не работают с Unicode
и, скорее всего, испортят данные, и использование вместо них корректных
функций, обычно из расширений intl
и mbstring .
Однако, использование функций, способных работать с Unicode, является
самым началом. Вне зависимости от тех функций, которые предоставляет
язык, необходимо знать спецификацию самого Unicode. Например, если
программа предполагает существование в языке только строчных и
заглавных букв, то она делает большую ошибку. Замечание
:
В PHP 7.0.0 на 64-битных платформах нет каких-либо достижимых ограничений для длины
строки, в 32-битных системах и в более ранних версиях PHP, строки не могут быть
более 2 ГБ (2147483647 байт).
Строка может быть определена четырьмя различными способами: Простейший способ определить строку - это заключить ее в одинарные кавычки
(символ "
). Чтобы использовать одинарную кавычку внутри строки, проэкранируйте ее обратным слешем
(\
). Если необходимо написать сам обратный слеш, продублируйте его
(\\
). Все остальные случаи применения обратного слеша будут
интерпретированы как обычные символы: это означает, что если вы попытаетесь
использовать другие управляющие последовательности, такие как \r
или
\n
, они будут выведены как есть вместо какого-либо особого поведения. echo
"это простая строка"
; echo
"Также вы можете вставлять в строки // Выводит: Однажды Арнольд сказал: "I"ll be back" Echo
"Вы удалили C:\\*.*?"
; // Выводит: Вы удалили C:\*.*? // Выводит: Это не будет развернуто: \n новая строка // Выводит: Переменные $expand также $either не разворачиваются Если строка заключена в двойные кавычки ("), PHP распознает
следующие управляющие последовательности специальных символов: Как и в строке, заключенной в одинарные кавычки, экранирование любого символа
выведет также и сам символ экранирования. До версии PHP 5.1.1, обратный слеш в
\{$var}
не печатался. Третий способ определения строк - это использование heredoc-синтаксиса:
<<<
. После этого оператора необходимо указать идентификатор,
затем перевод строки. После этого идет сама строка, а потом этот же идентификатор,
закрывающий вставку. Строка должна
начинаться с закрывающего идентификатора,
т.е. он должен стоять в первом столбце строки. Кроме того, идентификатор должен
соответствовать тем же правилам именования, что и все остальные
метки в PHP: содержать только буквенно-цифровые символы и знак
подчеркивания, и не должен начинаться с цифры (знак подчеркивания разрешается). Внимание
Очень важно отметить, что строка с закрывающим идентификатором не должна содержать
других символов, за исключением точки с запятой (;
). Это означает,
что идентификатор не должен вводиться с отступом
и что не
может быть никаких пробелов или знаков табуляции до или после точки с запятой. Важно
также понимать, что первым символом перед закрывающим идентификатором должен быть
символ новой строки, определенный в вашей операционной системе. Например, в UNIX
системах, включая macOS, это \n
. После закрывающего
идентификатора также сразу должна начинаться новая строка. Если это правило нарушено и закрывающий идентификатор не является "чистым",
считается, что закрывающий идентификатор отсутствует и PHP продолжит его поиск
дальше. Если в этом случае верный закрывающий идентификатор так и не будет найден,
то это вызовет ошибку парсинга с номером строки в конце скрипта. Пример #1 Пример неправильного синтаксиса
class
foo
{ Пример #2 Пример правильного синтаксиса
class
foo
{ Heredoc не может быть использован для инициализации полей класса.
Начиная с версии PHP 5.3, это ограничение распространяется только на heredoc,
содержащие внутри себя переменные. Heredoc-текст ведет себя так же, как и строка в двойных кавычках, при этом их не имея.
Это означает, что вам нет необходимости экранировать кавычки в heredoc, но вы
по-прежнему можете использовать вышеперечисленные управляющие последовательности.
Переменные обрабатываются, но с применением сложных переменных внутри heredoc
нужно быть также внимательным, как и при работе со строками. Пример #3 Пример определения heredoc-строки
$str
= << Class
foo Function
__construct
()
$foo
= new
foo
(); echo << Меня зовут "Имярек". Я печатаю Foo.
Теперь, я вывожу Bar2.
Это должно вывести заглавную букву "A": A Также возможно использовать heredoc-синтаксис для передачи данных
через аргументы функции: Начиная с версии 5.3.0, стала возможной инциализация статических переменных
и свойств/констант класса с помощью синтаксиса heredoc: Пример #5 Использование heredoc для инциализации статических переменных
// Статические переменные // Константы/свойства класса Public
$baz
= << Начиная с PHP 5.3.0, можно также окружать идентификатор Heredoc
двойными кавычками: Nowdoc - это то же самое для строк в одинарных кавычках, что и heredoc для строк в
двойных кавычках. Nowdoc похож на heredoc, но внутри него
не осуществляется никаких подстановок
. Эта конструкция
идеальна для внедрения PHP-кода или других больших блоков текста без необходимости
его экранирования. В этом он немного похож на SGML-конструкцию
тем, что объявляет блок текста,
не предназначенный для обработки. Nowdoc указывается той же последовательностью <<<
,
что используется в heredoc, но последующий за ней идентификатор заключается
в одинарные кавычки, например, <<<"EOT"
.
Все условия, действующие для идентификаторов heredoc также действительны
и для nowdoc, особенно те, что относятся к закрывающему идентификатору. Пример #7 Пример использования nowdoc
echo <<<"EOD" Результат выполнения данного примера: Пример текста,
занимающего несколько строк,
с помощью синтаксиса nowdoc. Обратные слеши всегда обрабатываются буквально,
например, \\ и \". Пример #8 Nowdoc string quoting example with variables
/* Более сложный пример с переменными. */ Function
__construct
()
$foo
= new
foo
(); echo <<<"EOT" Результат выполнения данного примера: Меня зовут "$name". Я печатаю $foo->foo.
Теперь я печатаю {$foo->bar}.
Это не должно вывести заглавную "A": \x41 Пример #9 Пример использования статичных данных
class
foo
{ Замечание
: Поддержка nowdoc была добавлена в PHP 5.3.0. Если строка указывается в двойных кавычках, либо при помощи heredoc,
переменные внутри нее обрабатываются. Существует два типа синтаксиса:
простой и
сложный .
Простой синтаксис более легок и удобен. Он дает возможность
обработки переменной, значения массива (array
) или
свойства объекта (object
) с минимумом усилий. Сложный синтаксис может быть определен
по фигурным скобкам, окружающим выражение. Если интерпретатор встречает знак доллара ($
), он захватывает так
много символов, сколько возможно, чтобы сформировать правильное имя переменной. Если
вы хотите точно определить конец имени, заключайте имя переменной в фигурные скобки. $juice
=
"apple"
; echo
"He drank some
$juice
juice."
.
PHP_EOL
; // Некорректно. "s" - верный символ для имени переменной, но переменная имеет имя $juice. // Корректно. Строго указан конец имени переменной с помощью скобок: Результат выполнения данного примера: He drank some apple juice.
He drank some juice made of .
He drank some juice made of apples. Аналогично могут быть обработаны элемент массива (array
) или свойство
объекта (object
). В индексах массива закрывающая квадратная скобка
(]
) обозначает конец определения индекса. Для свойств объекта
применяются те же правила, что и для простых переменных. Пример #10 Пример простого синтаксиса
define
("KOOLAID"
,
"koolaid1"
); echo
"He drank some
$juices
[
0
]
juice."
.
PHP_EOL
; class
people
{ Public
$smith
=
"Smith"
;
$people
= new
people
(); echo
"
$people
->
john
drank some
$juices
[
0
]
juice."
.
PHP_EOL
; Результат выполнения данного примера: He drank some apple juice.
He drank some orange juice.
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 7.1.0 добавлена поддержка отрицательных
числовых
индексов. Пример #11 Отрицательные числовые индексы
$string
=
"string"
; Результат выполнения данного примера: Символ с индексом -2 равен n.
Изменение символа на позиции -3 на "o" дает следующую строку: strong Для чего-либо более сложного, используйте сложный синтаксис. Он называется сложным не потому, что труден в понимании,
а потому что позволяет использовать сложные выражения. Любая скалярная переменная, элемент массива или свойство объекта, отображаемое в
строку, может быть представлена в строке этим синтаксисом. Просто запишите выражение
так же, как и вне строки, а затем заключите его в {
и }
. Поскольку {
не может быть экранирован, этот синтаксис будет
распознаваться только когда $
следует непосредственно за
{
. Используйте {\$
, чтобы напечатать {$
.
Несколько поясняющих примеров: // Показываем все ошибки
$great
=
"здорово"
; // Не работает, выводит: Это { здорово} // Работает, выводит: Это здорово
// Работает // Работает, ключи, заключенные в кавычки, работают только с синтаксисом фигурных скобок
// Работает // Это неверно по той же причине, что и $foo вне // Работает. При использовании многомерных массивов внутри
// Работает. echo
"Это тоже работает:
{
$obj
->
values
[
3
]->
name
}
"
; echo
"Это значение переменной по имени
$name
:
{${
$name
}}
"
; echo
"Это значение переменной по имени, которое возвращает функция getName():
{${
getName
()}}
"
; echo
"Это значение переменной по имени, которое возвращает \$object->getName():
{${
$object
->
getName
()}}
"
; // Не работает, выводит: Это то, что возвращает getName(): {getName()} С помощью этого синтаксиса также возможен доступ к свойствам объекта внутри строк. class
foo
{
$foo
= new
foo
(); Результат выполнения данного примера: I am bar.
I am bar. Замечание
: Функции, вызовы методов, статические переменные классов, а также константы классов
работает внутри {$}
, начиная с версии PHP 5. Однако, указываемое
значение будет обработано как имя переменной в том же контексте, что и строка, в
которой она определяется. Использование одинарных фигурных скобок
({}
) не будет работать для доступа к значениям функций, методов,
констант классов или статических переменных класса. // Показываем все ошибки class
beers
{
$rootbeer
=
"A & W"
; // Это работает, выводит: Я бы хотел A & W // Это тоже работает, выводит: Я бы хотел Alexander Keith"s Символы в строках можно использовать и модифицировать,
определив их смещение относительно начала строки, начиная с
нуля, в квадратных скобках после строки, например, $str .
Думайте о строке для этой цели, как о массиве символов.
Если нужно получить или заменить более 1 символа, можно использовать
функции substr()
и substr_replace()
. Замечание
:
начиная с PHP 7.1.0, поддерживаются отрицательные значения смещения.
Они задают смещение с конца строки. Ранее отрицательные смещение вызывали
ошибку уровня E_NOTICE
при чтении (возвращая пустую строку)
либо E_WARNING
при записи (оставляя строку без изменений).
Замечание
:
К символу в строке также можно обращаться с помощью фигурных скобок,
например, $str{42} .
Внимание
Попытка записи в смещение за границами строки дополнит строку
пробелами до этого смещения. Нецелые типы будет преобразованы в целые.
Неверный тип смещения вызовет ошибку уровня E_WARNING
.
Используется только первый символ присваемой строки.
Начиная с PHP 7.1.0, присвоение пустой строки вызовет фатальную ошибку. Ранее
в таком случае присваивался нулевой байт (NULL). Внимание
Строки в PHP внутренне представляют из себя массивы байт. Как результат,
доступ или изменение строки по смещению небезопасно с точки зрения многобайтной
кодировки, и должно выполняться только со строками в однобайтных кодировках,
таких как, например, ISO-8859-1. Замечание
:
Начиная с PHP 7.1.0, использование пустого индекса вызывает фатальную ошибку,
ранее в подобном случае строка преобразовывалась в массив без предупреждения.
Пример #12 Несколько примеров строк
// Получение первого символа строки // Получение третьего символа строки // Получение последнего символа строки // Изменение последнего символа строки
?>
Начиная с PHP 5.4 смещение в строке должно задаваться либо целым числом, либо строкой,
содержащей цифры, иначе будет выдаваться предупреждение. Ранее смещение, заданное
строкой вида "foo"
, без предупреждений преобразовывалось в
0
. Пример #13 Различия между PHP 5.3 и PHP 5.4
$str
=
"abc"
; Var_dump
($str
[
"1"
]); Var_dump
($str
[
"1.0"
]); Var_dump
($str
[
"x"
]); Var_dump
($str
[
"1x"
]); Результат выполнения данного примера в PHP 5.3: string(1) "b"
bool(true)
string(1) "b"
bool(true)
string(1) "a"
bool(true)
string(1) "b"
bool(true) Результат выполнения данного примера в PHP 5.4: string(1) "b"
bool(true)
Warning: Illegal string offset "1.0" in /tmp/t.php on line 7
string(1) "b"
bool(false)
Warning: Illegal string offset "x" in /tmp/t.php on line 9
string(1) "a"
bool(false)
string(1) "b"
bool(false) Замечание
: Попытка доступа к переменным других типов (исключая массивы или
объекты, реализующие определенные интерфейсы) с помощью
или {}
молча вернет NULL
. Замечание
: В PHP 5.5 была добавлена поддержка доступа к символам в строковых литералах
с помощью синтаксиса
или {}
. Для модификации строк существует множество полезных функций. Основные функции описаны в разделе
строковых функций , а для расширенного поиска и
замены - функции Perl-совместимых регулярных выражений . Значение может быть преобразовано в строку с помощью приведения
(string)
, либо функции strval()
.
В выражениях, где необходима строка, преобразование происходит автоматически.
Это происходит, когда вы используете функции echo
или print
, либо когда значение переменной сравнивается
со строкой. Прочтение разделов руководства Типы и Манипуляции с типами сделает
следующее более понятным. Смотрите также settype()
. Массивы всегда преобразуются в строку "Array"
,
так что вы не можете отобразить содержимое массива (array
),
используя echo
или print
,
чтобы узнать, что он содержит. Чтобы просмотреть отдельный элемент, используйте
что-нибудь вроде echo $arr["foo"]
. Смотрите
ниже советы о том, как отобразить/просмотреть все содержимое. Для преобразования переменной типа "Object"
в тип string
используется магический метод
__toString . Значение NULL
всегда преобразуется в пустую строку. Как вы могли видеть выше, прямое преобразование в строку массивов, объектов
или ресурсов не дает никакой полезной информации о самих значениях, кроме их типов.
Более подходящий способ вывода значений для отладки - использовать функции
print_r()
и var_dump()
. Большинство значений в PHP может быть преобразовано в строку для постоянного
хранения. Этот метод называется сериализацией и может быть выполнен
при помощи функции
serialize()
. Если строка распознается как числовое значение, результирующее значение
и тип определяется так, как показано далее. Если строка не содержит какой-либо из символов ".", "e", или "E", и
значение числа помещается в пределы целых чисел (определенных
PHP_INT_MAX
), строка будет распознана как целое число (integer
).
Во всех остальных случаях она считается числом с плавающей точкой (float
). Значение определяется по начальной части строки. Если строка
начинается с верного числового значения, будет использовано это
значение. Иначе значением будет 0 (ноль). Верное числовое значение
- это одна или более цифр (могущих содержать десятичную точку),
по желанию предваренных знаком с последующим необязательным
показателем степени. Показатель степени - это "e" или "E" с
последующими одной или более цифрами. $foo
=
1
+
"10.5"
;
// $foo это float (11.5) Более подробную информацию об этом преобразовании смотрите в разделе
о strtod(3) документации Unix. Если вы хотите протестировать любой из примеров этого раздела,
скопируйте и вставьте его и следующую строку, чтобы
увидеть, что происходит: echo
"\$foo==
$foo
; тип: "
.
gettype
($foo
) .
" Не ожидайте получить код символа, преобразовав его в целое (как
это делается, например, в C). Для преобразования символов в
их ASCII-коды и обратно используйте функции ord()
и chr()
. 7 years ago
The documentation does not mention, but a closing semicolon at the end of the heredoc is actually interpreted as a real semicolon, and as such, sometimes leads to syntax errors. $foo
= << foo
(<< foo
(<< 3 years ago
You can use string like array of char (like C) $a = "String array test"; var_dump($a); var_dump($a); // -- With array cast -- var_dump((array) $a); Norihiori
15 years ago
You can use the complex syntax to put the value of both object properties AND object methods inside a string. For example... However, you cannot do this for all values in your namespace. Class constants and static properties/methods will not work because the complex syntax looks for the "$". 3 years ago
Beware that consistent with "String conversion to numbers": If ("123abc"
==
123
) echo
"(intstr == int) incorrectly tests as true."
; // Because one side is a number, the string is incorrectly converted from intstr to int, which then matches the test number. // True for all conditionals such as if and switch statements (probably also while loops)! // This could be a huge security risk when testing/using/saving user input, while expecting and testing for only an integer. // It seems the only fix is for 123 to be a string as "123" so no conversion happens.
?>
6 years ago
Leading zeroes in strings are (least-surprise) not treated as octal. 10 years ago
Here is an easy hack to allow double-quoted strings and heredocs to contain arbitrary expressions in curly braces syntax, including constants and other function calls:
// Hack declaration
// Our playground
$a
=
3
; function
c
($a
,
$b
) { return
$a
+
$b
; }
// Usage // General syntax is {$_expr(...)} 2 years ago
I though that it would be helpful to add this comment so that the information at least appears on the right page on the PHP site. Note that if you intend to use a double-quoted string with an associative key, you may run into the T_ENCAPSED_AND_WHITESPACE error. Some regard this as one of the less obvious error messages. An expression such as: $fruit
=array( Print
"This is a
$fruit
[
"a"]"
;
// T_ENCAPSED_AND_WHITESPACE You can resolve it as follows: print
"This is a
$fruit
[
a
]
"
;
// unquote the key It’s not clear (to me, at least) why PHP misinterprets the single quote inside the expression but I imagine that it has something to do with the fact quotes are not part of the value string - once the string is already being parsed the quotes just get in the way … ?
2 years ago
Both should work:(
class
Testing
{ Public function
sayHelloStatic
() { Public function
sayHelloConst
() {
$obj
= new
Testing
(); 3 years ago
Something I experienced which no doubt will help someone . . . $html = <<<"EOD" Using this shows all the same colour: $html = << making it a lot easier to work with
11 years ago
To save Your mind don"t read previous comments about dates ;) When both strings can be converted to the numerics (in ("$a" > "$b") test) then resulted numerics are used, else FULL strings are compared char-by-char: var_dump
("1.22"
>
"01.23"
);
// bool(false)
символ новой строки вот так,
это нормально"
;
echo
"Однажды Арнольд сказал: "I\"ll be back""
;
echo
"Вы удалили C:\*.*?"
;
echo
"Это не будет развернуто: \n новая строка"
;
echo
"Переменные $expand также $either не разворачиваются"
;
?>
Двойные кавычки
Управляющие последовательности
Последовательность
Значение
\n
новая строка (LF или 0x0A (10) в ASCII)
\r
возврат каретки (CR или 0x0D (13) в ASCII)
\t
горизонтальная табуляция (HT или 0x09 (9) в ASCII)
\v
вертикальная табуляция (VT или 0x0B (11) в ASCII) (с версии PHP 5.2.5)
\e
escape-знак (ESC или 0x1B (27) в ASCII) (с версии PHP 5.4.4)
\f
подача страницы (FF или 0x0C (12) в ASCII) (с версии PHP 5.2.5)
\\
обратная косая черта
\$
знак доллара
\"
двойная кавычка
\{1,3}
последовательность символов, соответствующая
регулярному выражению символа в восьмеричной
системе счисления
\x{1,2}
последовательность символов, соответствующая
регулярному выражению символа в шестнадцатеричной
системе счисления
Heredoc
public
$bar
= <<
EOT;
}
?>
охватывающей несколько строчек,
с использованием heredoc-синтаксиса.
EOD;
{
var
$foo
;
var
$bar
;
{
$this
->
foo
=
"Foo"
;
$this
->
}
}
$name
=
"МоеИмя"
;
Теперь я вывожу
{
$foo
->
bar
[
1
]}
.
Это должно вывести заглавную букву "A": \x41
EOT;
?>
function
foo
()
{
static
$bar
= <<
class
foo
{
const
BAR
= <<
FOOBAR;
FOOBAR;
}
?>
Nowdoc
Пример текста,
занимающего несколько строк,
с помощью синтаксиса nowdoc.
EOD;
class
foo
{
public
$foo
;
public
$bar
;
{
$this
->
foo
=
"Foo"
;
$this
->
bar
= array("Bar1"
,
"Bar2"
,
"Bar3"
);
}
}
$name
=
"МоеИмя"
;
Меня зовут "$name". Я печатаю $foo->foo.
Теперь я печатаю {$foo->bar}.
Это не должно вывести заглавную "A": \x41
EOT;
?>
public
$bar
= <<<"EOT"
bar
EOT;
}
?>
Обработка переменных
Простой синтаксис
// не работает, "s" - это верный символ для имени переменной,
// но наша переменная имеет имя $juice.
echo
"He drank some juice made of
$juices
."
;
?>
echo
"He drank some
$juices
[
1
]
juice."
.
PHP_EOL
;
echo
"He drank some
$juices
[
koolaid1
]
juice."
.
PHP_EOL
;
public
$john
=
"John Smith"
;
public
$jane
=
"Jane Smith"
;
public
$robert
=
"Robert Paulsen"
;
}
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
."
;
// Won"t work
?>
Сложный (фигурный) синтаксис
error_reporting
(E_ALL
);
echo
"Это {
$great
}"
;
echo
"Это
{
$great
}
"
;
echo
"Это
${
great
}
"
;
echo
"Этот квадрат шириной
{
$square
->
width
}
00 сантиметров."
;
echo
"Это работает:
{
$arr
[
"key"
]}
"
;
echo
"Это работает:
{
$arr
[
4
][
3
]}
"
;
// строки. Другими словами, это по-прежнему будет работать,
// но поскольку PHP сначала ищет константу foo, это вызовет
// ошибку уровня E_NOTICE (неопределенная константа).
echo
"Это неправильно:
{
$arr
[
foo
][
3
]}
"
;
// строк всегда используйте фигурные скобки
echo
"Это работает:
{
$arr
[
"foo"
][
3
]}
"
;
echo
"Это работает: "
.
$arr
[
"foo"
][
3
];
echo
"Это то, что возвращает getName(): {getName()}"
;
?>
var
$bar
=
"I am bar."
;
}
$bar
=
"bar"
;
$baz
= array("foo"
,
"bar"
,
"baz"
,
"quux"
);
echo
"
{
$foo
->
$bar
}
\n"
;
echo
"
{
$foo
->
$baz
[
1
]}
\n"
;
?>
error_reporting
(E_ALL
);
const
softdrink
=
"rootbeer"
;
public static
$ale
=
"ipa"
;
}
$ipa
=
"Alexander Keith\"s"
;
echo
"Я бы хотел
{${
beers
::
softdrink
}}
\n"
;
echo
"Я бы хотел
{${
beers
::
$ale
}}
\n"
;
?>
Доступ к символу в строке и его изменение
$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"
;
var_dump
(isset($str
[
"1"
]));
var_dump
(isset($str
[
"1.0"
]));
var_dump
(isset($str
[
"x"
]));
var_dump
(isset($str
[
"1x"
]));
?>
Преобразование в строку
Преобразование строк в числа
$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)
?>
\n"
;
?>
Подробности реализации строкового типа
Синтаксис
Одинарные кавычки
символ новой строки вот так,
это нормально"
;
echo
"Однажды Арнольд сказал: "I\"ll be back""
;
echo
"Вы удалили C:\*.*?"
;
echo
"Это не будет развернуто: \n новая строка"
;
echo
"Переменные $expand также $either не разворачиваются"
;
?>
Двойные кавычки
Управляющие последовательности
Последовательность
Значение
\n
новая строка (LF или 0x0A (10) в ASCII)
\r
возврат каретки (CR или 0x0D (13) в ASCII)
\t
горизонтальная табуляция (HT или 0x09 (9) в ASCII)
\v
вертикальная табуляция (VT или 0x0B (11) в ASCII) (с PHP 5.2.5)
\e
escape-знак (ESC или 0x1B (27) в ASCII) (с PHP 5.4.4)
\f
подача страницы (FF или 0x0C (12) в ASCII) (с PHP 5.2.5)
\\
обратная косая черта
\$
знак доллара
\"
двойная кавычка
\{1,3}
последовательность символов, соответствующая регулярному выражению символа в
восьмеричной системе счисления, который молча переполняется, чтобы поместиться
в байт (т.е. "\400" === "\000")
\x{1,2}
последовательность символов, соответствующая регулярному выражению символа
в шестнадцатеричной системе счисления
\u{+}
последовательность символов, соответствующая регулярному выражению символа
Unicode, которая отображается в строка в представлении UTF-8 (добавлено в PHP 7.0.0)
Heredoc
public
$bar
= <<
EOT;
// отступ перед закрывающим идентификатором недопустим
}
?>
public
$bar
= <<
EOT;
}
?>
охватывающей несколько строк,
с использованием heredoc-синтаксиса.
EOD;
{
var
$foo
;
var
$bar
;
{
$this
->
foo
=
"Foo"
;
$this
->
}
}
$name
=
"Имярек"
;
Теперь я вывожу
{
$foo
->
bar
[
1
]}
.
Это должно вывести заглавную букву "A": \x41
EOT;
?>
function
foo
()
{
static
$bar
= <<
class
foo
{
const
BAR
= <<
FOOBAR;
FOOBAR;
}
?>
Nowdoc
Пример текста,
занимающего несколько строк,
с помощью синтаксиса nowdoc. Обратные слеши всегда обрабатываются буквально,
например, \\ и \".
EOD;
class
foo
{
public
$foo
;
public
$bar
;
{
$this
->
foo
=
"Foo"
;
$this
->
bar
= array("Bar1"
,
"Bar2"
,
"Bar3"
);
}
}
$name
=
"Имярек"
;
Меня зовут "$name". Я печатаю $foo->foo.
Теперь я печатаю {$foo->bar}.
Это не должно вывести заглавную "A": \x41
EOT;
?>
public
$bar
= <<<"EOT"
bar
EOT;
}
?>
Обработка переменных
Простой синтаксис
echo
"He drank some juice made of
$juices
."
;
echo
"He drank some juice made of
${
juice
}
s."
;
?>
$juices
= array("apple"
,
"orange"
,
"koolaid1"
=>
"purple"
);
echo
"He drank some
$juices
[
1
]
juice."
.
PHP_EOL
;
echo
"He drank some
$juices
[
koolaid1
]
juice."
.
PHP_EOL
;
public
$john
=
"John Smith"
;
public
$jane
=
"Jane Smith"
;
public
$robert
=
"Robert Paulsen"
;
}
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
."
;
// Не сработает
?>
echo
"Символ с индексом -2 равен
$string
[-
2
]
."
,
PHP_EOL
;
$string
[-
3
] =
"o"
;
echo
"Изменение символа на позиции -3 на "o" дает следующую строку:
$string
."
,
PHP_EOL
;
?>
Сложный (фигурный) синтаксис
error_reporting
(E_ALL
);
echo
"Это {
$great
}"
;
echo
"Это
{
$great
}
"
;
echo
"Этот квадрат шириной
{
$square
->
width
}
00 сантиметров."
;
echo
"Это работает:
{
$arr
[
"key"
]}
"
;
echo
"Это работает:
{
$arr
[
4
][
3
]}
"
;
// строки. Другими словами, это по-прежнему будет работать,
// но поскольку PHP сначала ищет константу foo, это вызовет
// ошибку уровня E_NOTICE (неопределенная константа).
echo
"Это неправильно:
{
$arr
[
foo
][
3
]}
"
;
// строк всегда используйте фигурные скобки
echo
"Это работает:
{
$arr
[
"foo"
][
3
]}
"
;
echo
"Это работает: "
.
$arr
[
"foo"
][
3
];
echo
"Это то, что возвращает getName(): {getName()}"
;
?>
var
$bar
=
"I am bar."
;
}
$bar
=
"bar"
;
$baz
= array("foo"
,
"bar"
,
"baz"
,
"quux"
);
echo
"
{
$foo
->
$bar
}
\n"
;
echo
"
{
$foo
->{
$baz
[
1
]}}
\n"
;
?>
error_reporting
(E_ALL
);
const
softdrink
=
"rootbeer"
;
public static
$ale
=
"ipa"
;
}
$ipa
=
"Alexander Keith\"s"
;
echo
"Я бы хотел
{${
beers
::
softdrink
}}
\n"
;
echo
"Я бы хотел
{${
beers
::
$ale
}}
\n"
;
?>
Доступ к символу в строке и его изменение
$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"
;
var_dump
(isset($str
[
"1"
]));
var_dump
(isset($str
[
"1.0"
]));
var_dump
(isset($str
[
"x"
]));
var_dump
(isset($str
[
"1x"
]));
?>
Преобразование в строку
Преобразование строк в числа
$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)
?>
\n"
;
?>
Подробности реализации строкового типа
END;
?>
This does not:
END;
);
// syntax error, unexpected ";"
?>
Without semicolon, it works fine:
END
);
?>
// Return string(17) "String array test"
// Return string(1) "S"
var_dump((array) $a);
// Return array(1) { => string(17) "String array test"}
// Return string(17) "S"
class
Test
{
public
$one
=
1
;
public function
two
() {
return
2
;
}
}
$test
= new
Test
();
echo
"foo
{
$test
->
one
}
bar
{
$test
->
two
()}
"
;
?>
Will output "foo 1 bar 2".
class
Test
{
const
ONE
=
1
;
}
echo
"foo {Test::ONE} bar"
;
?>
This will output "foo {Test::one} bar". Constants and static properties require you to break up the string.
Consider:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x is $x, y is $y"; //prints "x is 123, y is 83"
in other words:
* leading zeros in numeric literals in the source-code are interpreted as "octal", c.f. strtol().
* leading zeros in strings (eg user-submitted data), when cast (implicitly or explicitly) to integer are ignored, and considered as decimal, c.f. strtod().
function
_expr
($v
) { return
$v
; }
$_expr
=
"_expr"
;
define
("qwe"
,
"asd"
);
define
("zxc"
,
5
);
$b
=
4
;
echo
"pre
{
$_expr
(1
+
2
)}
post\n"
;
// outputs "pre 3 post"
echo
"pre
{
$_expr
(qwe
)}
post\n"
;
// outputs "pre asd post"
echo
"pre
{
$_expr
(c
($a
,
$b
)+
zxc
*
2
)}
post\n"
;
// outputs "pre 17 post"
?>
"a"
=>
"apple"
,
"b"
=>
"banana"
,
// etc
);
?>
will definitely fall to pieces.
print
"This is a
${
fruit
[
"a"
]}
"
;
// Complex Syntax
print
"This is a
{
$fruit
[
"a"
]}
"
;
// Complex Syntax variation
?>
I have a personal preference for the last variation as it is more natural and closer to what the expression would be like outside the string.
public static
$VAR
=
"static"
;
public const VAR =
"const"
;
echo
"hello:
{
$this
::
$VAR
}
"
;
}
echo
"hello:
{
$this
::VAR}
"
;
//Parse error: syntax error, unexpected "}", expecting "["
}
}
$obj
->
sayHelloStatic
();
$obj
->
sayHelloConst
();
In my editor, this will syntax highlight HTML and the $comment:
$comment
EOD;
EOD;
var_dump
("1.22.00"
>
"01.23.00"
);
// bool(true)
var_dump
("1-22-00"
>
"01-23-00"
);
// bool(true)
var_dump
((float)
"1.22.00"
> (float)
"01.23.00"
);
// bool(false)
?>