Php подстановка переменных в строку. Str_replace - Заменяет все вхождения строки поиска на строку замены. Строка в двойных кавычках

Замечание : В PHP 7.0.0 на 64-битных платформах нет каких-либо достижимых ограничений для длины строки, в 32-битных системах и в более ранних версиях PHP, строки не могут быть более 2 ГБ (2147483647 байт).

Синтаксис

Строка может быть определена четырьмя различными способами:

  • одинарными кавычками
  • двойными кавычками
  • nowdoc-синтаксисом (начиная с PHP 5.3.0)

Одинарные кавычки

Простейший способ определить строку - это заключить ее в одинарные кавычки (символ " ).

Чтобы использовать одинарную кавычку внутри строки, проэкранируйте ее обратным слешем (\ ). Если необходимо написать сам обратный слеш, продублируйте его (\\ ). Все остальные случаи применения обратного слеша будут интерпретированы как обычные символы: это означает, что если вы попытаетесь использовать другие управляющие последовательности, такие как \r или \n , они будут выведены как есть вместо какого-либо особого поведения.

echo "это простая строка" ;

echo "Также вы можете вставлять в строки
символ новой строки вот так,
это нормально" ;

// Выводит: Однажды Арнольд сказал: "I"ll be back"
echo "Однажды Арнольд сказал: "I\"ll be back"" ;

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)
\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)

Как и в строке, заключенной в одинарные кавычки, экранирование любого символа выведет также и сам символ экранирования. До версии PHP 5.1.1, обратный слеш в \{$var} не печатался.

Heredoc

Третий способ определения строк - это использование heredoc-синтаксиса: <<< . После этого оператора необходимо указать идентификатор, затем перевод строки. После этого идет сама строка, а потом этот же идентификатор, закрывающий вставку.

Строка должна начинаться с закрывающего идентификатора, т.е. он должен стоять в первом столбце строки. Кроме того, идентификатор должен соответствовать тем же правилам именования, что и все остальные метки в PHP: содержать только буквенно-цифровые символы и знак подчеркивания, и не должен начинаться с цифры (знак подчеркивания разрешается).

Внимание

Очень важно отметить, что строка с закрывающим идентификатором не должна содержать других символов, за исключением точки с запятой (; ). Это означает, что идентификатор не должен вводиться с отступом и что не может быть никаких пробелов или знаков табуляции до или после точки с запятой. Важно также понимать, что первым символом перед закрывающим идентификатором должен быть символ новой строки, определенный в вашей операционной системе. Например, в UNIX системах, включая macOS, это \n . После закрывающего идентификатора также сразу должна начинаться новая строка.

Если это правило нарушено и закрывающий идентификатор не является "чистым", считается, что закрывающий идентификатор отсутствует и PHP продолжит его поиск дальше. Если в этом случае верный закрывающий идентификатор так и не будет найден, то это вызовет ошибку парсинга с номером строки в конце скрипта.

Пример #1 Пример неправильного синтаксиса

class foo {
public $bar = <<bar
EOT;
// отступ перед закрывающим идентификатором недопустим
}
?>

Пример #2 Пример правильного синтаксиса

class foo {
public $bar = <<bar
EOT;
}
?>

Heredoc не может быть использован для инициализации полей класса. Начиная с версии PHP 5.3, это ограничение распространяется только на heredoc, содержащие внутри себя переменные.

Heredoc-текст ведет себя так же, как и строка в двойных кавычках, при этом их не имея. Это означает, что вам нет необходимости экранировать кавычки в heredoc, но вы по-прежнему можете использовать вышеперечисленные управляющие последовательности. Переменные обрабатываются, но с применением сложных переменных внутри heredoc нужно быть также внимательным, как и при работе со строками.

Пример #3 Пример определения heredoc-строки

$str = <<Пример строки,
охватывающей несколько строк,
с использованием heredoc-синтаксиса.
EOD;

Class foo
{
var $foo ;
var $bar ;

Function __construct ()
{
$this -> foo = "Foo" ;
$this ->
}
}

$foo = new foo ();
$name = "Имярек" ;

echo <<Меня зовут " $name ". Я печатаю $foo -> foo .
Теперь я вывожу { $foo -> bar [ 1 ]} .
Это должно вывести заглавную букву "A": \x41
EOT;
?>

Меня зовут "Имярек". Я печатаю Foo. Теперь, я вывожу Bar2. Это должно вывести заглавную букву "A": A

Также возможно использовать heredoc-синтаксис для передачи данных через аргументы функции:

Начиная с версии 5.3.0, стала возможной инциализация статических переменных и свойств/констант класса с помощью синтаксиса heredoc:

Пример #5 Использование heredoc для инциализации статических переменных

// Статические переменные
function foo ()
{
static $bar = <<Здесь ничего нет...
LABEL;
}

// Константы/свойства класса
class foo
{
const BAR = <<Пример использования константы
FOOBAR;

Public $baz = <<Пример использования поля
FOOBAR;
}
?>

Начиная с PHP 5.3.0, можно также окружать идентификатор Heredoc двойными кавычками:

Nowdoc

Nowdoc - это то же самое для строк в одинарных кавычках, что и heredoc для строк в двойных кавычках. Nowdoc похож на heredoc, но внутри него не осуществляется никаких подстановок . Эта конструкция идеальна для внедрения PHP-кода или других больших блоков текста без необходимости его экранирования. В этом он немного похож на SGML-конструкцию тем, что объявляет блок текста, не предназначенный для обработки.

Nowdoc указывается той же последовательностью <<< , что используется в heredoc, но последующий за ней идентификатор заключается в одинарные кавычки, например, <<<"EOT" . Все условия, действующие для идентификаторов heredoc также действительны и для nowdoc, особенно те, что относятся к закрывающему идентификатору.

Пример #7 Пример использования nowdoc

echo <<<"EOD"
Пример текста,
занимающего несколько строк,
с помощью синтаксиса nowdoc. Обратные слеши всегда обрабатываются буквально,
например, \\ и \".
EOD;

Результат выполнения данного примера:

Пример текста, занимающего несколько строк, с помощью синтаксиса nowdoc. Обратные слеши всегда обрабатываются буквально, например, \\ и \".

Пример #8 Nowdoc string quoting example with variables

/* Более сложный пример с переменными. */
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}.
Это не должно вывести заглавную "A": \x41
EOT;
?>

Результат выполнения данного примера:

Меня зовут "$name". Я печатаю $foo->foo. Теперь я печатаю {$foo->bar}. Это не должно вывести заглавную "A": \x41

Пример #9 Пример использования статичных данных

class foo {
public $bar = <<<"EOT"
bar
EOT;
}
?>

Замечание :

Поддержка nowdoc была добавлена в PHP 5.3.0.

Обработка переменных

Если строка указывается в двойных кавычках, либо при помощи heredoc, переменные внутри нее обрабатываются.

Существует два типа синтаксиса: простой и сложный . Простой синтаксис более легок и удобен. Он дает возможность обработки переменной, значения массива (array ) или свойства объекта (object ) с минимумом усилий.

Сложный синтаксис может быть определен по фигурным скобкам, окружающим выражение.

Простой синтаксис

Если интерпретатор встречает знак доллара ($ ), он захватывает так много символов, сколько возможно, чтобы сформировать правильное имя переменной. Если вы хотите точно определить конец имени, заключайте имя переменной в фигурные скобки.

$juice = "apple" ;

echo "He drank some $juice juice." . PHP_EOL ;

// Некорректно. "s" - верный символ для имени переменной, но переменная имеет имя $juice.
echo "He drank some juice made of $juices ." ;

// Корректно. Строго указан конец имени переменной с помощью скобок:
echo "He drank some juice made of ${ juice } s." ;
?>

Результат выполнения данного примера:

He drank some apple juice. He drank some juice made of . He drank some juice made of apples.

Аналогично могут быть обработаны элемент массива (array ) или свойство объекта (object ). В индексах массива закрывающая квадратная скобка (] ) обозначает конец определения индекса. Для свойств объекта применяются те же правила, что и для простых переменных.

Пример #10 Пример простого синтаксиса

define ("KOOLAID" , "koolaid1" );
$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 $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 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" ;
echo "Символ с индексом -2 равен $string [- 2 ] ." , PHP_EOL ;
$string [- 3 ] = "o" ;
echo "Изменение символа на позиции -3 на "o" дает следующую строку: $string ." , PHP_EOL ;
?>

Результат выполнения данного примера:

Символ с индексом -2 равен n. Изменение символа на позиции -3 на "o" дает следующую строку: strong

Для чего-либо более сложного, используйте сложный синтаксис.

Сложный (фигурный) синтаксис

Он называется сложным не потому, что труден в понимании, а потому что позволяет использовать сложные выражения.

Любая скалярная переменная, элемент массива или свойство объекта, отображаемое в строку, может быть представлена в строке этим синтаксисом. Просто запишите выражение так же, как и вне строки, а затем заключите его в { и } . Поскольку { не может быть экранирован, этот синтаксис будет распознаваться только когда $ следует непосредственно за { . Используйте {\$ , чтобы напечатать {$ . Несколько поясняющих примеров:

// Показываем все ошибки
error_reporting (E_ALL );

$great = "здорово" ;

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

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

// Работает
echo "Этот квадрат шириной { $square -> width } 00 сантиметров." ;

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

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

// Это неверно по той же причине, что и $foo вне
// строки. Другими словами, это по-прежнему будет работать,
// но поскольку 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()}" ;
?>

С помощью этого синтаксиса также возможен доступ к свойствам объекта внутри строк.

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" ;
?>

Результат выполнения данного примера:

I am bar. I am bar.

Замечание :

Функции, вызовы методов, статические переменные классов, а также константы классов работает внутри {$} , начиная с версии PHP 5. Однако, указываемое значение будет обработано как имя переменной в том же контексте, что и строка, в которой она определяется. Использование одинарных фигурных скобок ({} ) не будет работать для доступа к значениям функций, методов, констант классов или статических переменных класса.

// Показываем все ошибки
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 . Думайте о строке для этой цели, как о массиве символов. Если нужно получить или заменить более 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 Несколько примеров строк

// Получение первого символа строки
$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" ;

?>

Начиная с PHP 5.4 смещение в строке должно задаваться либо целым числом, либо строкой, содержащей цифры, иначе будет выдаваться предупреждение. Ранее смещение, заданное строкой вида "foo" , без предупреждений преобразовывалось в 0 .

Пример #13 Различия между PHP 5.3 и PHP 5.4

$str = "abc" ;

Var_dump ($str [ "1" ]);
var_dump (isset($str [ "1" ]));

Var_dump ($str [ "1.0" ]);
var_dump (isset($str [ "1.0" ]));

Var_dump ($str [ "x" ]);
var_dump (isset($str [ "x" ]));

Var_dump ($str [ "1x" ]);
var_dump (isset($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)
$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.

Если вы хотите протестировать любой из примеров этого раздела, скопируйте и вставьте его и следующую строку, чтобы увидеть, что происходит:

echo "\$foo== $foo ; тип: " . gettype ($foo ) . "
\n" ;
?>

Не ожидайте получить код символа, преобразовав его в целое (как это делается, например, в 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 = <<abcd
END;
?>

This does not:

foo (<<abcd
END;
);
// syntax error, unexpected ";"
?>

Without semicolon, it works fine:

foo (<<abcd
END
);
?>

3 years ago

You can use string like array of char (like C)

$a = "String array test";

var_dump($a);
// Return string(17) "String array test"

var_dump($a);
// Return string(1) "S"

// -- With array cast --
var_dump((array) $a);
// Return array(1) { => string(17) "String array test"}

var_dump((array) $a);
// Return string(17) "S"

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...
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".

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 "$".
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.

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.
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().

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
function _expr ($v ) { return $v ; }
$_expr = "_expr" ;

// Our playground
define ("qwe" , "asd" );
define ("zxc" , 5 );

$a = 3 ;
$b = 4 ;

function c ($a , $b ) { return $a + $b ; }

// Usage
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"

// 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(
"a" => "apple" ,
"b" => "banana" ,
// etc
);

Print "This is a $fruit [ "a"]" ; // T_ENCAPSED_AND_WHITESPACE
?>

will definitely fall to pieces.

You can resolve it as follows:

print "This is a $fruit [ a ] " ; // unquote the key
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.

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 static $VAR = "static" ;
public const VAR = "const" ;

Public function sayHelloStatic () {
echo "hello: { $this :: $VAR } " ;
}

Public function sayHelloConst () {
echo "hello: { $this ::VAR} " ; //Parse error: syntax error, unexpected "}", expecting "["
}
}

$obj = new Testing ();
$obj -> sayHelloStatic ();
$obj -> sayHelloConst ();

3 years ago

Something I experienced which no doubt will help someone . . .
In my editor, this will syntax highlight HTML and the $comment:

$html = <<<"EOD"
$comment
EOD;

Using this shows all the same colour:

$html = <<$comment
EOD;

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)
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)
?>

(PHP 4, PHP 5, PHP 7)

str_replace — Заменяет все вхождения строки поиска на строку замены

Описание

Эта функция возвращает строку или массив, в котором все вхождения search в subject заменены на replace .

Если не нужны сложные правила поиска/замены (например, регулярные выражения), использование этой функции предпочтительнее preg_replace() .

Список параметров

Если search и replace - массивы, то str_replace() использует каждое значение из соответствующего массива для поиска и замены в subject . Если в массиве replace меньше элементов, чем в search , в качестве строки замены для оставшихся значений будет использована пустая строка. Если search - массив, а replace - строка, то эта строка замены будет использована для каждого элемента массива search . Обратный случай смысла не имеет.

Если search или replace являются массивами, их элементы будут обработаны от первого к последнему.

Искомое значение, также известное как needle (иголка). Для множества искомых значений можно использовать массив.

Replace

Значение замены, будет использовано для замены искомых значений search . Для множества значений можно использовать массив.

Subject

Строка или массив, в котором производится поиск и замена, также известный как haystack (стог сена).

Если subject является массивом, то поиск с заменой будет осуществляться над каждым элементом subject , а результатом функции также будет являться массив.

Если передан, то будет установлен в количество произведенных замен.

Возвращаемые значения

Эта функция возвращает строку или массив с замененными значениями.

Примеры

Пример #1 Примеры использования str_replace()

// присваивает
$bodytag = str_replace ("%body%" , "black" , "" );

// присваивает: Hll Wrld f PHP
$vowels = array("a" , "e" , "i" , "o" , "u" , "A" , "E" , "I" , "O" , "U" );
$onlyconsonants = str_replace ($vowels , "" , "Hello World of PHP" );

// присваивает: You should eat pizza, beer, and ice cream every day
$phrase = "You should eat fruits, vegetables, and fiber every day." ;
$healthy = array("fruits" , "vegetables" , "fiber" );
$yummy = array("pizza" , "beer" , "ice cream" );

$newphrase = str_replace ($healthy , $yummy , $phrase );

// присваивает: 2
$str = str_replace ("ll" , "" , "good golly miss molly!" , $count );
echo $count ;
?>

Пример #2 Примеры потенциальных трюков с str_replace()

// Порядок замены
$str = "Строка 1\nСтрока 2\rСтрока 3\r\nСтрока 4\n" ;
$order = array("\r\n" , "\n" , "\r" );
$replace = "
" ;

// Обрабатывает сначала \r\n для избежания их повторной замены.
echo $newstr = str_replace ($order , $replace , $str );

// Выводит F, т.к. A заменяется на B, затем B на C, и так далее...
// В итоге E будет заменено F, так как замена происходит слева направо.
$search = array("A" , "B" , "C" , "D" , "E" );
$replace = array("B" , "C" , "D" , "E" , "F" );
$subject = "A" ;
echo str_replace ($search , $replace , $subject );

// Выводит: яблорехкорех орех (по вышеуказанной причине)
$letters = array("я" , "о" );
$fruit = array("яблоко" , "орех" );
$text = "я о" ;
$output = str_replace ($letters , $fruit , $text );
echo $output ;
?>

Примечания

Замечание : Эта функция безопасна для обработки данных в двоичной форме.

Предостережение

Замечание о порядке замены

Так как str_replace() осуществляет замену слева направо, то при использовании множественных замен она может заменить ранее вставленное значение на другое. Смотрите также примеры на этой странице.

Замечание :

Эта функция чувствительна к регистру. Используйте str_ireplace() для замены, нечувствительной к регистру.

В последнее время обсуждения языка PHP на хабре сводятся больше к возможностям проектировать сложные системы, что не может не радовать. Однако, просмотрев с десяток самых признаваемых веб-фреймворков (Zend Framework, Adept, CakePHP, CodeIgniter, LIMB, Symfony, MZZ и другие) я с искренним удивлением обнаружил в некоторых существенные недочеты с точки зрения элементарной оптимизации.

Для того, чтобы данный топик был более технически-ориентированным, результаты оформлены в более строгой форме, что может несколько усложнить восприятие.

Итак, поехали… Задача предельно проста: провести эксперименты по скорости формирования строк из подстрок в одинарных и двойных кавычках. В принципе, этот вопрос будет актуален еще долгое время в связи с особенностями обработки строк в PHP.

Существует немало статей по базовой оптимизации скриптов как на русском, так и на других языках. Про строки там говорится мало, но отмечается факт «парсинга» строк в двойных кавычках на предмет переменных и управляющих символов (врочем, как и в официальной документации). На основе этого логично предположить, что использование строк в двойных кавычках в работе будет несколько медленнее, чем те же операции с подстроками в одинарных кавычках.

Кроме подстановки переменных в строки и конкатенации переменных с подстроками, в PHP реализован еще как минимум один способ формирования строк: работа с функцией sprintf. Логично предположить, что данный метод будет существенно уступать «стандартным» из-за лишнего вызова функции и парсинга строки внутри.

Единственное дополнение, перед тем, как я представлю вам код тестового скрипта: необходимо учитывать 2 возможных варианта работы со строками в двойных кавычках: с учетом простого и «продвинутого» стиля кодирования. На то, что переменные стоят в самом начале строк обращать внимания не стоит, наверное - они являются только примерами:
$string = "$_SERVER["HTTP_HOST"] - не администрация Ульяновской области. Мы любим русский язык и не любим тех, кто его..."
и
$string = "{$_SERVER["HTTP_HOST"]} - не администрация Ульяновской области. Мы любим русский язык и не любим тех, кто его..."

Тест номер один.
Ну, вроде бы, все оговорки сделаны - пора показывать результаты работы. Исходный код тестировщика можно найти .

По скриншотам видно, что моя гипотеза не подтвердилась. Единственно-верным оказалось предположение о работе со строками через sprintf. Наиболее быстрыми оказались функции, работающие именно с двойными кавычками.

После непродолжительного обдумывания ситуации объяснение пришло само собой: все дело в том, что эталонная строка, в которую производились подстановки является слишком короткой: проход парсера по такой строке - дело плевое. Однако, даже тут видно, что нативная подстановка переменной в строку дает преимущество перед «продвинутым стилем».
В этом же и слабость подхода конкатенации: объемы вставляемых данных превышают объемы подстрок. Откуда берутся накладные расходы можно прочесть в уже упомянутом хабратопике .

Однако, даже эти мысли нужно было подтвердить. Для этого понадобился второй тест с изменениями на возможные упомянутые причины столь непредсказуемого (для меня) поведения. Видимо уж очень многое подкрутили в пятой версии (признаюсь, в пятой версии php я проводил только 1 тест: на обход элементов массивов).

Тест номер два.
Вторая гипотеза: удлинение эталонной строки даст, в конечном счете, увеличение процентного отношения времени работы функций-тестировщиков, связанных с формированием строк в двойных кавычках, относительно результатов теста номер 1. Такая же ситуация, теоретически, должна наблюдаться и в отношении работы функции sprintf. Связано это, в первую очередь, с необходимостью парсинга строк и увеличением времени, затраченных на это. В ситуации с конкатенацией подстрок в одинарных кавычках, думаю, будет наблюдаться примерно тот же результат, что и в первом тесте, что даст небольшое уменьшение доли времени выполнения функции quotes_3() ко времени работы всего скрипта (но никак не прирост производительности).

Выводы, собственно только положительные и подтверждающие гипотезу. При незначительном увеличении эталонной строки появляется большая нагрузка, что приводит к падению быстродействия функций работы с двойными кавычками и sprintf.

Предположение относительно строк в одинарных кавычках так же оказалось верным: вместо 36,75% времени в первом тесте, во втором функция quotes_3() заняла 33,76% времени исполнения скрипта

Практическая ценность.
Говоря простым языком, абстрагируясь от данных, можно сделать вывод: чем длиннее строка, в которой необходимо произвести подстановку, тем больше вероятность, что операция-конкатенация выполнится быстрее, чем поиск переменной в двойных кавычках. Добровольцы могут попробовать подобрать необходимые параметры вставки (количество переменных, длина эталонной строки, длины строк в переменных) такими, чтобы они удовлетворяли равенству времен выполнения.

Вот, собственно, и все. Остается только добавить, что в программировании мелочей не бывает (это я любителям сказать «экономия на спичках» (с) Adelf). Зная такие тонкости и принимая их во внимание, можно писать код, который будет оптимизирован на всех своих уровнях;)

PS:
Тесты проведены с помощью Zend Studio For Eclipse 6.0.0 (Debugger + Profiler included).
Версия PHP 5.2.5
ОС Debian Linux

PPS:
Буду рад, если кто-то выложит свои результаты данных тестов. Думаю, это позволит более объективно составить оценку необходимости использования того либо иного метода подстановки в строки. Так же буду признателен здоровой критике стиля изложения и оформления.

PHP, в настоящее время, – один из наиболее популярных языков для реализации веб-приложений. Данный курс посвящен изучению его основ. Акцент делается на практическое применение полученных навыков.

Язык PHP был создан для решения конкретной практической задачи в среде интернет (какой именно можно узнать, прочитав первую лекцию курса). Мы тоже постараемся не отвлекаться слишком сильно на теоретические рассуждения, и будем стремиться к решению какой-нибудь конкретной задачи в каждой из лекций. Большинство примеров взяты из реально существующей системы: виртуального музея истории информатики. Первая часть курса посвящена изучению основ синтаксиса и управляющим конструкциям. После этого рассматривается технология клиент-сервер, как основная сфера приложения языка PHP. Затем переходим к изучению наиболее полезных на наш взгляд встроенных функций и решению с их помощью практических задач. Хотя объектная модель в языке PHP не самая богатая, ее принципиальное наличие позволяет естественным образом описывать объектные модели данных. В качестве базовой модели будет рассмотрена модель документа виртуального музея информатики. После этого будет рассмотрен ряд прикладных аспектов: работа с файловой системой, с БД, строками, сессиями, DOM XML - все это позволит рассмотреть ключевые задачи практического использования языка.

Книга:

Использование шаблонов в PHP

Использование шаблонов в PHP

Что такое шаблоны и зачем они нужны

Что такое шаблон в языке программирования? Можно сказать, что шаблон - это текст с переменными внутри него. При обработке шаблона происходит замена переменных на их значения.

В одной из лекций мы уже рассматривали пример шаблона. Это был шаблон для отображения документов. Пользователь создавал строку текста, размеченного с помощью html-тегов, и вставлял в нее специальные метасимволы (вида ), которые наша программа впоследствии заменяла на значения соответствующих элементов. Для чего нам был нужен такой шаблон? Чтобы, например, можно было изменить стиль отображения документа, не меняя кода программы.

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

Приведенный пример шаблона - один из самых простых. Для его обработки используется только функция подстановки str_replace(). Чаще всего для того, чтобы работать с шаблонами, создают библиотеки классов. В принципе создавать свою библиотеку не обязательно, поскольку существует множество свободно распространяемых библиотек шаблонов, над функциональностью которых трудятся большие коллективы разработчиков, стараясь сделать их универсальными, мощными и быстрыми. Некоторые из таких библиотек мы и рассмотрим. Но для начала сформулируем задачу, на примере решения которой будем демонстрировать использование различных шаблонов.

Итак, задача:

Требуется сгенерировать web-страницу со списком статей, имеющихся в базе данных. Для простоты считаем, что статья имеет название title, автора author, краткое содержание abstract и полное содержание fulltext, которое представлено либо в виде текста в базе данных, либо в виде ссылки на файл. Список должен быть организован так, чтобы при щелчке мышью на названии статьи ее полное содержание появлялось в новом окне.

Шаблоны подстановки

Как можно решить такую задачу способом простой подстановки, т.е. тем методом, которым мы решили задачу отображения документов?

Нужно придумать шаблон для этой страницы и где-то его хранить (в файле или в базе данных). Очевидно, что мы не можем придумать шаблон для всей страницы, потому что не знаем, сколько статей в базе данных. В шаблоне же мы договорились использовать только html и метасимволы . Поэтому мы можем написать только шаблон для одной строки списка, который уже программно надо преобразовать в нужное количество строк.

  • "
    target=new>
    ()

    Кроме того, здесь есть еще одна загвоздка - с отображением ссылки на полный текст статьи. Если мы будем действовать по правилу подстановки (менять все метасимволы на их значения из базы данных), то может получиться, что вместо вставим не ссылку на текст, а сам текст. То есть для этого элемента нужна дополнительная проверка перед заменой и какие-то дополнительные действия в случае, если в поле fulltext содержится текст статьи, а не ссылка на файл. Не будем усложнять себе жизнь и договоримся, что в поле fulltext всегда содержится только ссылка на файл. Тогда задачу можно решить следующим образом:

    $li_tmpl = file_get_contents("tmpl.html");
    // считываем шаблон строки из файла
    // устанавливаем соединение и выбираем
    // базу данных
    $conn = mysql_connect("localhost",
    "nina","123")
    or die("Cant connect");
    mysql_select_db("book");
    $sql = "SELECT * FROM Articles";
    $q = mysql_query($sql,$conn);
    // отправляем запрос
    $num = mysql_num_rows($q);
    for($i=0; $i<$num; $i++){
    $tmpl .= $li_tmpl;
    $tmpl = str_replace("",
    mysql_result($q,$i,"title"),$tmpl);
    $tmpl = str_replace("",
    mysql_result($q,$i,"author"),$tmpl);
    $tmpl = str_replace("",
    mysql_result($q,$i,"abstract"),$tmpl);
    $tmpl = str_replace("",
    mysql_result($q,$i,"fulltext"),$tmpl);
    }
    echo $tmpl;
    ?>

    Если шаблон был такой, как приведен выше, то получим примерно следующее.

    Введение в PHP (Савельева Н.В.)

    Лекция дает представление о том, что такое язык PHP, для чего он создавался изначально и как используется теперь, какими возможностями обладает.

    Установка и настройка ПО (Иванов Иван)

    В принципе метод достаточно прост и удобен, но требует дополнительных усилий программиста при возникновении задач более сложных, чем простая подстановка значений. Для решения задач, где требуется делать подстановку целых блоков или даже проверять условия, создают классы шаблонов, такие как FastTemplate и Smarty. Обсудим их подробнее.

    Шаблоны FastTemplate

    FastTemplate - это набор классов, позволяющих реализовать работу с шаблонами. Логику добавить в шаблон FastTemplate нельзя, вся она должна находиться в коде программы. Идея работы шаблонов FastTemplate заключается в том, что любая большая страница состоит из множества кусочков, самые маленькие из которых - обычные строки текста, и они получают имя и значение.

    Что представляет собой файл шаблона FastTemplate? Это обычный html-файл, в котором могут встречаться переменные особого вида, впоследствии обрабатываемые методами класса FastTemplate.

    Синтаксис переменных в шаблонах FastTemplate описывается следующим выражением: {(+)}

    Это значит, что переменная должна начинаться с фигурной скобки "{". Второй и последующие символы должны быть буквами верхнего регистра от A до Z, цифрами или символами подчеркивания. Переменная вычисляется с помощью закрывающей фигурной скобки "}".

    {TITLE}
    {AUTH20}
    {TOP_OF_PAGE}

    Как уже было сказано, основная идея FastTemplate - создание страницы с помощью вложенных шаблонов. Например, для решения нашей задачи можно создать три файла шаблона:


    {TITLE_}


    {MAIN}



      {LIST_ELEMENT}

  • {TITLE}
    ({AUTHOR})

    {ABSTRACT}

    Шаблоны мы создали - работу дизайнера выполнили. Теперь нужно научиться их обрабатывать, т.е. выполнить работу программиста. Сейчас создадим программу для обработки приведенных выше шаблонов.

    Перед началом работы с шаблонами FastTemplate нужно подключить этот набор классов к нашей программе. В реальной жизни набор классов FastTemplate записан в один файл, как правило, с названием class.FastTemplate.php3, поэтому подключить его можно, например, с помощью команды:

    include("class.FastTemplate.php3");

    Следующий важный шаг - это создание объекта класса FastTemplate, с которым впоследствии мы будем работать:

    $tpl = new FastTemplate(
    "/path/to/templates");

    В качестве параметра передается путь к месту, где находятся наши шаблоны.

    Для работы с FastTemplate нужно знать четыре основных метода: define, assign, parse и FastPrint.

    Метод define

    Синтаксис:

    define(array (ключ => значение,
    ключ1 => значение1, ...))

    Метод define() связывает имя файла шаблона с более коротким именем, которое можно будет использовать в программе. То есть "ключ" - это имя, которое мы будем использовать в программе для ссылки на файл шаблона, имя которого записано в строке "значение". Реальные имена файлов шаблонов не рекомендуется использовать нигде, кроме метода define. При вызове метода define() происходит загрузка всех определенных в нем шаблонов.

    $tpl->define(array (main => "main.tpl",
    list_f => "list.tpl",
    list_el=> "list_element.tpl"));

    Здесь мы задаем псевдонимы именам файлов шаблонов. Эти псевдонимы, т.е. переменные main, list_f и list_el, будут использоваться в программе вместо соответствующих имен файлов main.tpl, list.tpl и list_element.tpl.

    Метод assign

    Синтаксис:

    assign((пары ключ/значение) или
    (array(пары ключ/значение))

    Метод assign() присваивает переменным значения, "ключ" - это имя переменной, а "значение" - значение, которое ей нужно присвоить. Чтобы переменная в шаблоне была заменена значением, это значение нужно задать ей с помощью метода assign(). Согласно синтаксису этот метод можно использовать в двух различных формах. В FastTemplate есть только один массив, поэтому, если вы повторно задаете значение одному и тому же ключу, оно будет перезаписано.

    $tpl->assign(array(
    TITLE => "Установка и настройка ПО",
    TITLE => "Введение в PHP"));

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

    Метод parse

    Синтаксис:

    parse (возвращаемая переменная,
    источники шаблонов)

    Метод parse() - самый основной в FastTemplate. Он устанавливает значение возвращаемой переменной равным обработанным шаблонам из указанных источников. Метод может использоваться в трех формах: простой, составной и присоединяющей.

    $tpl->parse(MAIN, "main");
    // простая форма
    $tpl->parse(MAIN, array ("list_f", "main"));
    // составная форма
    $tpl->parse(MAIN, ".list_el");
    // присоединяющая форма

    В простой форме шаблон с псевдонимом "main" загружается (если еще не был загружен), все его переменные подставляются, и результат сохраняется как значение переменной MAIN. Если переменная {MAIN} появится в более поздних шаблонах, то вместо нее будет подставлено значение, полученное в результате обработки шаблона "main". Это позволяет создавать вложенные шаблоны.

    Составная форма метода parse() создана для того, чтобы упростить вложение шаблонов друг в друга. Следующие записи эквивалентны:

    $tpl->parse(MAIN, "list_f");
    $tpl->parse(MAIN, ".main");

    это то же самое что и

    $tpl->parse(MAIN, array("list_f", "main"));

    Когда используется составная форма, важно, чтобы каждый шаблон, идущий в списке после первого, содержал ту переменную, в которую передаются результаты обработки шаблона. В примере выше main должен содержать переменную {MAIN}, поскольку именно в нее передаются результаты обработки шаблона list_f. Если main не содержит переменной {MAIN}, то результаты обработки шаблона list_f будут потеряны.

    Присоединяющий стиль позволяет добавлять результаты обработки шаблона к переменной результата. Точка перед псевдонимом файла шаблона говорит FastTemplate о том, что нужно присоединить результат обработки этого шаблона к возвращенным результатам, а не перезаписывать его. Такой стиль наиболее часто используется при построении таблиц с переменным числом рядов, получаемых, например, в результате запроса к базе данных.

    Метод FastPrint

    Синтаксис:

    FastPrint(обработанная переменная)

    Метод FastPrint() печатает содержимое переданной в него обработанной переменной. Если он вызван без параметров, то печатается последняя использованная методом parse() переменная.

    $tpl->FastPrint();
    /* если продолжать предыдущий пример,
    то эта функция напечатает значение
    переменной MAIN */
    $tpl->FastPrint("MAIN");
    // эта функция сделает тоже самое

    Если нужно печатать не на экран, а, например, в файл, то получить ссылку на данные можно с помощью метода fetch().

    $data = $tpl->fetch("MAIN");
    fwrite($fd, $data); // запись данных в файл

    Решение задачи с помощью шаблонов FastTemplate

    Теперь попробуем собрать воедино все изученные методы, чтобы решить нашу задачу.

    Заметим, что решение задачи получилось несколько более сложным, чем в первом случае, когда использовалась только функция регулярной замены. Зато здесь мы можем изменять три различных шаблона (документа в целом, списка и элемента списка).

    Этот класс шаблонов появился еще до выхода PHP4 для работы с PHP3. Чтобы протестировать приведенные примеры, нужно скачать библиотеку классов FastTemplate и скопировать этот файл в свою рабочую директорию. Если вы работаете с PHP4, то в файл class.FastTemplate.php3 нужно внести пару изменений, о которых написано в документации, поставляющейся вместе с этой библиотекой.

    Шаблоны Smarty

    Smarty - один из действующих проектов PHP, его официальный сайт - http://smarty.php.net. Там можно скачать как сам набор классов Smarty, так и документацию к нему. Этот набор классов для обработки шаблонов - гораздо более мощный и функциональный, чем FastTemplate.Чем отличается Smarty от классов шаблонов типа FastTemplate? Прежде всего, он не отделяет полностью логику от содержания. Логика, касающаяся отображения данных, может присутствовать в шаблоне, считают разработчики Smarty. Поэтому в шаблоне Smarty могут быть условные операторы, операторы вставки файлов, операторы изменения переменных, циклы и т.п. Другая особенность Smarty - это компиляция шаблонов. Шаблоны переводятся в php-код, и интерпретатор PHP производит все необходимые действия по подстановке значений. Для ускорения работы скомпилированные шаблоны кэшируются.

    Рассмотрим некоторые основные конструкции механизма шаблонов Smarty.

    Установка

    Первое, с чего мы начнем, - это установка Smarty. Здесь все не так просто, как с FastTemplate. Smarty состоит не из одного php-файла с описанием класса, а из целого набора различных файлов-библиотек. Для того чтобы работать с шаблонами Smarty, нужно сделать эти библиотеки доступными для всех ваших программ. Находятся они в каталоге /libs/ дистрибутива Smarty. Файл, в котором содержится определение самого класса Smarty, называется Smarty.class.php. Чтобы проверить, доступны ли библиотеки класса Smarty, нужно написать такой скрипт:

    require("Smarty.class.php");
    // подключаем файл с
    // описанием класса Smarty
    $smarty = new Smarty;
    // создаем экземпляр класса Smarty
    ?>

    Если при его исполнении появилась ошибка, то нужно попробовать один из перечисленных ниже вариантов.

    // подключаем файл с описанием класса
    require("c:/users/my/Smarty/libs/
    Smarty.class.php");
    $smarty = new Smarty;
    // создаем экземпляр класса Smarty
    ?>

    Добавить директорию, где содержатся библиотеки, в include_path (в этом случае код менять не нужно).

    define("SMARTY_DIR",
    "c:/users/my/Smarty/libs/index.html");
    require(SMARTY_DIR."Smarty.class.php");
    $smarty = new Smarty;
    ?>

    Теперь, после того как мы убедились, что библиотеки будут найдены, нужно создать директории, необходимые для работы Smarty, по умолчанию имеющие такие имена:

    Templates - директория, где мы будем хранить созданные шаблоны;

    Templates_c - директория, где Smarty будет хранить скомпилированные шаблоны;

    Configs - директория для хранения конфигурационных файлов;

    Cache - директория для кэша.

    Эти имена задаются свойствами $template_dir, $compile_dir, $config_dir, $cache_dir класса Smarty, поэтому их можно переопределить. Рекомендуется использовать различные наборы директорий для каждого приложения, работающего с шаблонами Smarty. Доступ к перечисленным директориям осуществляется библиотекой Smarty и никогда не выполняется напрямую через web-браузер. Поэтому, чтобы избежать проблем с безопасностью, лучше всего разместить эти директории там, куда нет доступа через www.

    Создадим перечисленные Smarty директории по адресу c:/smarty_dirs/book/. Заметим, что прочитать отсюда данные через браузер нельзя. Пусть наша программа (или приложение) находится по адресу /~my/tasks/book/. Для директорий $compile_dir и $cache_dir Smarty потребуется доступ на запись, так что нужно установить соответствующие им права для сетевого пользователя, с которым ваш сервер работает по умолчанию (обычно это www или nobody).

    Чтобы протестировать сделанные настройки, создадим простой шаблон и программу, обрабатывающую его с использованием механизма Smarty.

    index.tpl (является Smarty шаблоном и находится в директории шаблонов c:/smarty_dirs/book/templates/)

    {* Шаблон Smarty *}
    Привет, {$name}!

    index.php (является кодом нашей программы и находится в директории /~my/tasks/book/ или, что то же самое, в директории c:/users/my/tasks/book/)

    В результате должны получить:

    Привет, Вася!

    Все настройки, необходимые для работы нашего приложения, можно вынести в отдельный файл и организовать их в качестве расширения класса Smarty.

    Основной синтаксис

    Smarty - не просто класс для обработки шаблонов, он определяет целый язык построения шаблонов. Мы коснемся только основных его элементов. Итак, что представляет собой шаблон Smarty? Это набор специальных конструкций (переменных, вызовов функций и методов и т.п) и html-тегов. Все элементы (теги) языка шаблонов Smarty заключаются между символами-ограничителями. По умолчанию это символы фигурных скобок "{" и "}", но их можно изменить. Все, что не заключено в такие ограничители, Smarty рассматривает как константы, не требующие обработки. В шаблоне index.tpl, приведенном выше, {$name} - это переменная, а строки "Привет," и "!" - не изменяющиеся в процессе обработки шаблона константы.

    Комментарии в Smarty записываются между двумя звездочками:

    {* Это комментарий. После обработки шаблона
    он на экране не отображается *}

    Каждый Smarty тег либо выводит значение переменной, либо вызывает какую-либо функцию. Функция записывается следующим образом:

    {имя_функции атрибут1="значение1"
    атрибут2="значение2"}

    Переменные в шаблоне могут быть нескольких типов:

    Переменные, значение которым присваивается в php-скрипте пользователя, должны иметь перед именем знак доллара.

    Например: {$first_name}

    Элементы массива, значения которых были присвоены в php-скрипте пользователя, доступны в шаблоне с помощью синтаксиса {$имя_массива.ассоциативный_ключ}.

    Например: {$person.last_name}

    Элементы не ассоциативного массива доступны с помощью синтаксиса квадратных скобок: {имя_массива[числовой_индекс]}

    Например: {$person}

    Свойства объектов, заданные в php-скрипте, доступны в шаблоне с помощью такого синтаксиса: {имя_объекта->имя_свойства}

    Например: {$person->email}

    Переменные, загруженные из конфигурационных файлов (что это такое, мы расскажем чуть позже), заключаются между символами #. Также они доступны как элементы ассоциативного массива $smarty.config.

    Например: {#bodyBgColor#} или {$smarty.config.bodyBgColor}

    Кроме того, существует переменная {$smarty}, зарезервированная для некоторых специальных переменных шаблона, таких как переменные HTTP запроса, даты и времени, и т.п.

    В шаблонах Smarty определен ряд модификаторов, которые можно применять к переменным, пользовательским функциям или строкам с тем, чтобы модифицировать их значения. Чтобы применить модификатор, нужно указать его название после вертикальной черты, следующей за именем переменной, функции или строкой, к которой он применяется.

    Например, чтобы перевести значение переменной {$title} в верхний регистр, нужно применить к ней модификатор upper, т.е. написать следующее: {$title|upper}

    Можно использовать сразу несколько модификаторов, отделяя их друг от друга прямой вертикальной чертой. Например, {$title|upper|truncate} переведет значение переменной в верхний регистр и урежет до 80 символов.

    Перечислять все имеющиеся модификаторы мы не будем. Их список можно найти в документации Smarty. Скажем только, что с их помощью можно посчитать число символов, слов и параграфов, дописать строку, задать формат вывода даты и времени, сделать регулярную замену и многое другое.

    Конфигурационные файлы

    Конфигурационные файлы используются для того, чтобы управлять глобальными переменными, используемыми в шаблоне, с помощью одного файла. Их идея очень похожа на таблицы стилей css. Конфигурационный файл содержит набор переменных и их значения. Перед именем переменной не ставится никаких дополнительных символов типа знака доллара. Значение переменной по желанию заключают в кавычки (двойные или одинарные), если оно состоит из нескольких строк, то его заключают в тройные кавычки.

    # глобальные переменные
    pageTitle = "List of documents"
    bodyBgColor = #000000
    tableBgColor = #000000
    rowBgColor = #00ff00
    pageTitle = "Список статей"
    Intro = """Это значение состоит из
    нескольких строк. Поэтому его нужно
    заключить в тройные кавычки."""
    # скрытая секция
    [.Database]
    host=localhost
    db=book
    user=nina
    pass=123

    Конфигурационный файл может состоять из нескольких разделов (секций), каждая из которых имеет имя и может загружаться отдельно от остальных секций. Имя секции заключается в квадратные скобки. Кроме секций в конфигурационном файле могут содержаться глобальные переменные - они не входят ни в одну секцию и всегда загружаются при загрузке конфигурационного файла. Если загружается какая-то одна секция, то загружаются ее переменные и глобальные переменные. Если переменная существует и как глобальная переменная, и как переменная секции, то используется переменная секции. Если вы одинаково назовете две переменные внутри одной секции, то будет использоваться последняя из них. В приведенном выше примере две секции - Customer и Database, а кроме них заданы глобальные переменные pageTitle, bodyBgColor, tableBgColor и rowBgColor.

    Чтобы спрятать значение переменной или секцию целиком, нужно перед ее именем поставить точку. В таком случае при загрузке конфигурационного файла эти данные нельзя будет прочесть. В примере мы сделали скрытой секцию Database, чтобы нельзя было узнать пароль и имя пользователя, применяемые для установки соединения.

    Значениями типа string являются текстовые строки (кратко строки). Строка — это последовательность из нуля или более символов. Символы включают в себя буквы, цифры, знаки пунктуации, специальные символы и пробелы.

    Строка может быть определена четырьмя различными способами:

    • двойными кавычками
    • одинарными кавычками
    • heredoc-синтаксисом
    • nowdoc-синтаксисом

    Строка в двойных кавычках

    Строка в двойных кавычках:

    В строках с двойными кавычками можно использовать управляющие последовательности. Управляющая последовательность — это специальные символы предназначенные для форматирования текстового вывода. В PHP доступны следующие управляющие последовательности:

    Основным свойством строк в двойных кавычках является возможность обработки переменных внутри строк.


    Знак доллара: \$";

    Строки, заключённые в двойные кавычки, могут содержать символы одинарных кавычек:

    Echo "Одинарная кавычка: "";

    Строка в одинарных кавычках (апострофах)

    Строка в одинарных кавычках:

    $str = "Строка"; echo "Одну большую строку можно разбить на несколько маленьких строк, чтобы её было удобнее читать.";

    В отличие от строк в двойных кавычках и heredoc-синтаксиса, переменные и управляющие последовательности (за одним исключением), заключённые в одинарные кавычки, не обрабатываются. Это означает, что они будут интерпретированы как обычные символы строки:

    $num = 10; echo "Число: $num
    Знак доллара: \$";

    Чтобы в строке, заключённой в одинарные кавычки, можно было использовать одинарные кавычки, нужно их экранировать с помощью обратного слэша (\"). Если необходимо написать саму обратную косую черту, нужно продублировать её (\\):

    Echo "Внутри используются \"одинарные\" кавычки"; echo "Обратный слэш: \\";

    Строки, заключённые в одинарные кавычки, могут содержать символы двойных кавычек:

    Echo "Двойная кавычка: "";

    Heredoc-синтаксис

    Heredoc-синтаксис — это альтернативный способ записи строк.

    Строка, определяемая с помощью Heredoc-синтаксиса, работает также, как и строка, расположенная в двойных кавычках. Разница между Heredoc и строкой в двойных кавычках заключается в том, что используя Heredoc нет необходимости экранировать двойные кавычки.

    Heredoc-синтаксис начинается с трёх символов <<< , после которых должен быть указан произвольный идентификатор (назовём его открывающим). Идентификатор может быть указан как в двойных кавычках, так и без них. Сразу после идентификатора должен следовать перевод на новую строку, никаких других символов кроме перевода на новую строку после идентификатора не должно быть, иначе возникнет ошибка. Далее идёт непосредственно строковое содержимое. После строкового содержимого, на отдельной строке, должен быть указан закрывающий идентификатор (тот же, что и после <<<). Перед ним и после него не должно быть никаких пробелов или других символов, за исключением точки с запятой. Если это правило нарушено, то считается, что закрывающий идентификатор отсутствует и будет вызвана ошибка:

    <<

    Nowdoc-синтаксис

    Nowdoc-синтаксис также как и Heredoc является альтернативным способом записи строк.

    Строка, определяемая с помощью Nowdoc-синтаксиса, работает также, как и строка, расположенная в одинарных кавычках. Разница между Nowdoc и строкой в одинарных кавычках заключается в том, что используя Nowdoc нет необходимости экранировать одинарные кавычки.

    Синтаксис Nowdoc похож на Heredoc с той лишь разницей, что открывающий идентификатор обязательно должен быть заключён в одинарные кавычки:

    $num = 10; echo <<<"some_id" Число: $num some_id;

    Обработка переменных в строках

    Существует два типа синтаксиса обработки переменных в строках: простой и сложный .

    Простой синтаксис — это когда имя переменной указывается в строке как есть.

    Когда интерпретатор встречает знак доллара, он начинает последовательно проверять являются ли все последующие символы допустимыми символами в имени переменной. Таким образом, чтобы сформировать правильное имя переменной, он захватывает так много символов, на сколько это возможно:

    $str = "World!"; echo "Hello $str";

    Сложный синтаксис — это когда имя переменной заключается в фигурные скобки.

    Так как, для обработки переменной в строке, интерпретатор захватывает так много символов, на сколько это возможно бывают ситуации когда интерпретатор не способен самостоятельно определить, где оканчивается имя переменной:

    $sport1 = "волей"; $sport2 = "фут"; echo "Мне нравится $sport1бол и $sport2бол";

    В данном случае не будет достигнут желаемый результат, поскольку интерпретатор будет считать $sport1 как часть имени переменной $sport1бол, которой не существует.

    Чтобы явно указать интерпретатору, где оканчивается имя переменной требуется заключить имя переменной в фигурные скобки:

    $sport1 = "волей"; $sport2 = "фут"; echo "Мне нравится {$sport1}бол и {$sport2}бол.";

    Знак доллара может быть расположен как перед фигурной скобкой, так и после неё:

    $sport1 = "волей"; $sport2 = "фут"; echo "Мне нравится ${sport1}бол и {$sport2}бол.";

    Конкатенация

    Конкатенация — это объединение двух или более строк в одну большую. Объединение происходит с помощью оператора конкатенации — . (точка). При конкатенации каждая последующая строка добавляется в конец предыдущей:

    Значение любого типа, которое объединяется со строкой, будет неявно преобразовано в строку и далее будет произведена конкатенация:

    "; echo "Число: " . 1; ?>

    Рекомендуем почитать