\n"; // выводим элемент
}
}
// отображаем строки "лесенкой"
myecho("Меркурий", "Венера", "Земля", "Марс");
Глава 11. Функции и области видимости 189
Обратите внимание на то, что при описании myecho() мы указали пустые скобки в
качестве списка параметров, словно функция не получает ни одного параметра. На
самом деле в PHP при вызове функции можно указывать параметров больше, чем
задано в списке аргументов — в этом случае никакие предупреждения не выводятся
(но если фактическое число параметров меньше, чем указано в описании, PHP
выдаст
сообщение об ошибке). "Лишние" параметры как бы игнорируются, в результате пус-
тые скобки в myecho() позволяют нам в действительности передать ей сколько
угод-
но параметров.
Для того чтобы все же иметь доступ к "проигнорированным" параметрам, существу-
ют три встроенные в PHP функции, которые я сейчас подробно опишу.
r int func_num_args()
Возвращает общее число аргументов, переданных функции при вызове.
r mixed func_get_arg(int $num)
Возвращает значение аргумента с номером $num, заданного при вызове функции.
Нумерация, как всегда, отсчитывается с нуля.
r list func_get_args()
Возвращает список всех аргументов, указанных при вызове функции. Думаю, что
применение этой функции оказывается практически всегда удобнее, чем первых
двух.
Перепишем наш пример с применением последней функции (листинг 11.7):
Листинг 11.7. Использование fuct_get_args()
function myecho()
{ foreach(func_get_args() as $v) {
for($j=0; $j<@$i; $j++) echo " ";
echo "$v".HtmlSpecialChars($k)." => ", TextDump($v,$Level);
}
}
else echo '"',HtmlSpecialChars($Var),'"'."\n";
}
// Основная функция
function Dump(&$Var)
{ // Подфункция, выводящая практически окончательный результат
if((is_array($Var)||is_object($Var)) && count($Var))
echo "\n",TextDump($Var)," \n";
else
echo "",TextDump($Var)," \n";
}
В реальной жизни следует использовать функцию Dump(). Функция TextDump()
(которая, по правде говоря, и делает всю работу) использует только одну
неизвестную
нам еще функцию — HtmlSpecialChars(), заменяющую в строке символы типа <,
> или " на их HTML-эквиваленты (соответственно, <, > и "). Мы при-
менили дополнительную функцию для того, чтобы вывести сам результат, а главная
функция занимается только форматированием этого результата (вставка его в тэги
или в зависимости от размера вывода).
Несколько советов
по использованию функций
Хочется напоследок сказать еще несколько слов о функциях.
Первое — не допускайте, чтобы ваши функции разрастались до гигантских размеров.
Дробите их на маленькие, по возможности независимые, части, желательно полезные
и сами по себе. Это повысит "читабельность", устойчивость и переносимость ваших
программ. В идеале каждая функция не должна занимать больше 20—30 строк, воз-
можно, за редким исключением. Этот совет применим вообще ко всем языкам про-
граммирования, а не только к PHP.
Второе: как известно, вызов функции тоже отнимает какое-то время, поэтому
распро-
странено мнение, что чем меньше функций, тем быстрее работает программа. Оно в
корне неверно: не стоит обращать внимания на цену вызова функции, пока она сама
об этом не заявит. В конце концов, объединить несколько функций в одну всегда
на
порядок проще, чем разбить одну функцию на несколько. Помните об этом.
Наконец, последнее: больше используйте встроенные, стандартные функции. Прежде
чем писать какую-то процедуру, сверьтесь с документацией — возможно, она уже
Часть III. Основы языка PHP 202
реализована в ядре PHP. Если это так, то не думайте, что сможете написать ее
эффек-
тивнее на PHP — ведь часто самый неэффективный Си-код работает быстрее, чем
самый изящный на PHP. Возможно, лучше пожертвовать объемом за счет быстродей-
ствия — например, при работе с базами данных и сложными файлами лучше приме-
нять стандартные функции сериализации, чем писать более эффективно упаковы-
вающие, но свои, потому что стандартные работают очень быстро. Правда, из этого
правила существуют и исключения: например, я бы не советовал вам использовать
Serialize() для формирования строки, сохраняющейся в Cookies браузера — здесь
лучше написать свои функции. Опять же, тут действует принцип: чем меньше в про-
грамме собственноручно реализованных функций, тем надежнее она будет работать и
тем меньше ее придется тестировать.
ЧАСТЬ IV.
СТАНДАРТНЫЕ
ФУНКЦИИ PHP
Глава 12
Строковые функции
Строки в PHP — одни из самых универсальных объектов. Как мы уже видели, любой,
сколь угодно сложный объект можно упаковать в строку при помощи функции
Serialize() (и обратно через Unserialize()). Строка может содержать абсолют-
но любые символы с кодами от 0 до 255 включительно. Нет никакого специального
маркера "конца строки", как это сделано в Си (там конец строки помечается
симво-
лом с нулевым кодом). А значит, длина строки во внутреннем представлении PHP
хранится где-то отдельно. Для формирования и вставки непечатаемого символа в
строку (например, с кодом 1 или 15) используется функция chr(), которую мы рас-
смотрим ниже.
Наконец, из-за слабого контроля типов в PHP строка может содержать
(и часто содержит) число, причем с ней можно работать, как с числом: прибавлять
другие числа, умножать и т. д. При этом все преобразования (в десятичной
системе)
производятся автоматически. Существуют также функции, преобразующие число,
записанное в различных системах счисления (например, в восьмеричной), в обычное
представление, и наоборот. Их мы обсудим позже, в следующей главе.
В этой главе я описываю только самые употребительные и удобные функции
(около 80%), пропуская все остальные. Какие-то из не вошедших в данную гла-
ву функций (например, quotemeta()) мы будем рассматривать в других гла-
вах — там, где это показалось мне наиболее логичным. Так что, не найдя опи-
сание интересующей вас функции здесь, подумайте: возможно, оно лучше
подходит для другой темы и его лучше поискать там? И, наконец, последней
инстанцией для вас, конечно же, должна являться документация PHP.
Конкатенация строк
Самая, пожалуй, распространенная операция со строками — это их конкатенация,
или присоединение к одной строке другой. В ранних версиях PHP для этого, как и
для
сложения чисел, использовался оператор +, что постоянно приводило к путанице:
ес-
ли к числу прибавляется строка, что должно получиться — число или строка? Если
число, то вдруг наша строка содержала на самом деле не число, а какой-то текст?
В
новой — третьей — версии интерпретатора разработчики отказались от этого меха-
низма и объявили, что + следует применять только для сложения чисел, и никак
ина-
Глава 12. Строковые функции 207
че. Что же касается конкатенации строк, то для нее ввели специальный оператор ".
"
(точка).
Оператор "." всегда воспринимает свои операнды как строки и возвращает строку.
В
случае, если один из операндов не может быть переведен в строковое
представление,
т. е. если это массив или объект, то он воспринимается как строки array и
object
соответственно. Вообще говоря, это правило применимо и не только при сцеплении
строк, но и при передаче такого операнда в какую-нибудь стандартную функцию,
ко-
торой требуется строка. Например, следующие команды выведут слово array:
$a=array(10,20,30);
echo $a // Внимание! Неожиданный результат!
Есть и другой, более специализированный, способ конкатенации строк. Он обычно
используется, когда значения строковых или числовых переменных перемежаются с
обычными словами. Если, к примеру, у нас в $day хранится текущее число, в
$month — название месяца и в $year — год, то вывести строку вида "Сегодня 8 мая
2000 года" можно так:
echo "Сегодня $day $month $year года";
При этом в строку, вырабатываемую инструкцией echo, автоматически в нужных
местах вставятся значения наших переменных. Это позволяет констатировать тот
факт, что в PHP все переменные начинаются с $.
О сравнении строк
и инструкции if-else
Теперь я хотел бы рассмотреть одно тонкое место в интерпретаторе PHP,
касающееся
немного неправильной работы со строками. Заключается оно вот в чем. Если мы ис-
пользуем операторы сравнения == и != (или любые другие, которые могут потребо-
вать перевода строки в число) с операндами-строками, то результат, вопреки
ожида-
ниям, не всегда оказывается верным. Чаще всего это проявляется как раз в
инструкции if. Вот примеры (листинг 12.1):
Листинг 12.1. Внимание! Опасное место!
$one=1 // число один
$zero=0 // присваиваем число ноль
if($one=="") echo 1 // очевидно, не равно — не выводит 1
if($zero=="") echo 3 // Внимание! Вопреки ожиданиям печатает 3!
if(""==$zero) echo 4 // И это тоже не поможет!..
if("$zero"=="") echo 5 // Не работает в некоторых версиях PHP 3
if(strval($zero)=="") echo 6; // Вот теперь правильно — не выводит 6
Часть IV. Стандартные функции PHP 208
if($zero==="") echo 7 // Самый лучший способ, но не действует в PHP 3
Получается, что в операциях сравнения пустая строка "" прежде всего трактуется
как
0 (ноль) и уж затем — как "пусто"? Это звучит довольно парадоксально, но это
дей-
ствительно так. Операнды сравниваются как строки только в том случае, если они
оба — строки, в противном случае идет числовое сравнение. При этом пустая
строка
воспринимается как 0, впрочем, как и любая другая, которую интерпретатору не
уда-
лось перевести в число.
В первых версиях PHP 3 при присоединении к числовому нулю пустой строки
этот ноль не менял типа, не становился строкой "0". Видимо, срабатывала ка-
кая-то оптимизация, и PHP просто пропускал этот бессмысленный, на его
взгляд, шаг. Проведенные мной тесты показывают, что в PHP версии 3.0.12 и
старше эта ошибка исправлена, но все же иногда нужно иметь ее в виду, осо-
бенно, если сценарии должны быть хорошо переносимыми.
Итак, если вы хотите сравнить две переменные-строки, нужно быть абсолютно уве-
ренными, что их типы именно строковые, а не числовые.
Впрочем, это не распространяется на новый оператор PHP версии 4 === (тройное
ра-
венство, или оператор эквивалентности). Его использование заставляет
интерпрета-
тор всегда сравнивать величины и по значению, и по их типу. Итак, с точки
зрения
PHP 0=="", но 0!==="". Если вы не собираетесь программировать на PHP версии,
ниже третьей, рекомендую всегда использовать === вместо strval(), как это было
сделано в листинге 12.1.
Существует одна стандартная ошибка, которую делают многие. Вот в чем она состо-
ит. Есть такая функция — strpos($str,$what), которая возвращает позицию под-
строки $what в строке $str или false, если подстрока не найдена. Пусть нам
нужно
проверить, встречается ли в некоторой строке $str подстрока
:
Часть IV. Стандартные функции PHP 210
?>
int ord(char $ch)
Эта функция, наоборот, возвращает код символа в $ch. Например, ord(chr($n))
всегда равно $n — конечно, если $n заключено между нулем и числом 255.
int strrpos(string $where, char $what)
Данная функция, хотя и похожа внешне на strpos() (см. ниже), несет несколько
иную нагрузку. Она ищет в строке $where последнюю позицию, в которой встречает-
ся символ $what (если $what — строка из нескольких символов, то выявляется
толь-
ко первый из них, остальные не играют никакой роли — обратите на это особое
вни-
мание!). В случае, если искомый символ не найден, возвращается false (см.
замечание по этому поводу для strpos()). Вообще, могу сказать, что функция
strrpos() применяется очень редко. Слишком уж она не универсальна.
Функции отрезания пробелов
По поводу философии написания программ, которые интенсивно обрабатывают дан-
ные, вводимые пользователем (а именно такими программами является большинство
сценариев) есть очень правильное изречение: ваша программа должна быть макси-
мально строга к формату выходных данных и максимально лояльна по отношению ко
входным данным. Это означает, что, прежде чем передавать полученные от
пользова-
теля строки куда-то дальше, — например, другим функциям, — нужно над ними не-
много поработать. Самое простое, что можно сделать — это отрезать начальные и
концевые пробелы.
Иногда трудно даже представить, какими могут быть странными пользователи, если
дать им в руки клавиатуру и попросить напечатать на ней какое-нибудь слово. Так
как клавиша пробела — самая большая, то пользователи имеют обыкновение нажи-
мать ее в самые невероятные моменты. Этому способствует также и тот факт, что
символ с кодом 32, обозначающий пробел, как вы знаете, на экране не виден. Если
программа не способна обработать описанную ситуацию, то она, в лучшем случае
после тягостного молчания отобразит в браузере что-нибудь типа "неверные
входные
данные", а в худшем — сделает при этом что-нибудь необратимое.
Глава 12. Строковые функции 211
Между тем, обезопасить себя от паразитных пробелов чрезвычайно просто, и разра-
ботчики PHP предоставляют нам для этого ряд специализированных функций. Не
волнуйтесь о том, что их применение замедляет программу. Эти функции работают с
молниеносной скоростью, а главное, одинаково быстро, независимо от объема пере-
данных им строк. Конечно, я не призываю к пароноидальному применению функций
"отрезания" на каждой строчке программы, но в то же время, если есть хоть
1%-ная
возможность того, что строка может содержать лишние пробелы, следует без
колеба-
ний от них избавляться. В конце концов, отсекать пробелы один раз или тысячу —
все равно, а вот не отрезать совсем и отрезать однажды — большая разница.
Кстати,
если отделять нечего, описанные ниже функции мгновенно заканчивают свою работу,
так что их вызов обходится совсем дешево.
string trim(string $st)
Возвращает копию $st, только с удаленными ведущими и концевыми пробельными
символами. Под пробельными символами я здесь и далее подразумеваю: пробел " ",
символ перевода строки \n, символ возврата каретки \r и символ табуляции \t.
На-
пример, вызов trim(" test\n ") вернет строку "test".
Эта функция используется очень широко. Старайтесь применять ее везде, где есть
хоть малейшее подозрение на наличие ошибочных пробелов. Поскольку работает она
очень быстро.
string ltrim(string $st)
То же, что и trim(), только удаляет исключительно ведущие пробелы, а концевые
не
трогает. Используется гораздо реже. Старайтесь всегда вместо нее применять
trim(), и не прогадаете.
string chop(string $st)
Удаляет только концевые пробелы, ведущие не трогает. Эта функция будет
наверняка
очень популярной у тех, кто раньше программировал на Perl. Однако следует заме-
тить, что в PHP она выполняет другую функцию.
Базовые функции
int strlen(string $st)
Одна из наиболее полезных функций. Возвращает просто длину строки, т. е.,
сколько
символов содержится в $st. Как уже упоминалось, строка может содержать любые
символы, в том числе и с нулевым кодом (что запрещено в Си). Функция strlen()
будет правильно работать и с такими строками.
int strpos(string $where, string $what, int $fromwhere=0)
Пытается найти в строке $where подстроку (то есть последовательность символов)
$what и в случае успеха возвращает позицию (индекс) этой подстроки в строке.
Пер-
Часть IV. Стандартные функции PHP 212
вый символ строки, как и в Си, имеет индекс 0. Необязательный параметр
$fromwhere можно задавать, если поиск нужно вести не с начала строки $from, а с
какой-то другой позиции. В этом случае следует эту позицию передать в
$fromwhere. Если подстроку найти не удалось, функция возвращает false. Однако
будьте внимательны, проверяя результат вызова strpos() на false — используйте
ля этого только оператор ===.
string substr(string $str, int $from [,int $length])
Данная функция тоже востребуется очень часто. Ее назначение — возвращать уча-
сток строки $str, начиная с позиции $start и длиной $length. Если $length не
задана, то подразумевается подстрока от $start до конца строки $str. Если
$start
больше, чем длина строки, или же значение $length равно нулю, то возвращается
пустая подстрока.
Однако эта функция может делать и еще довольно полезные вещи. К примеру, если
мы передадим в $start отрицательное число, то будет считаться, что это число
яв-
ляется индексом подстроки, но только отсчитываемым от конца $str (например, -1
означает "начиная с последнего символа строки"). Параметр $length, если он
задан,
тоже может быть отрицательным. В этом случае последним символом возвращенной
подстроки будет символ из $str с индексом $length, определяемым от конца стро-
ки.
int strcmp(string $str1, string $str2)
Сравнивает две строки посимвольно (точнее, побайтово) и возвращает: 0, если
строки
полностью совпадают; -1, если строка $str1 лексикографически меньше $str2; и 1,
если, наоборот, $str1 "больше" $str2. Так как сравнение идет побайтово, то ре-
гистр символов влияет на результаты сравнений.
int strcasecmp(string $str1, string $str2)
То же самое, что и strcmp(), только при работе не учитывается регистр букв. На-
пример, с точки зрения этой функции "ab" и "AB" равны.
Если ваша строка состоит только из "английских" букв, проблем не будет. Од-
нако в случае использования "русских" букв результат (точнее, правильность)
работы функции strcasecmp() сильно зависит от настроек текущей локали
(см. ниже).
Работа с блоками текста
Перечисленные ниже функции чаще всего оказываются полезны, если нужно прово-
дить однотипные операции с многострочными блоками текста, заданными в строко-
вой переменной.
Глава 12. Строковые функции 213
string str_replace(string $from, string $to, string $str)
Заменяет в строке $str все вхождения подстроки $from (с учетом регистра) на $to
и
возвращает результат. Исходная строка, переданная третьим параметром, при этом
не
меняется. Эта функция работает значительно быстрее, чем ereg_replace(), кото-
рую мы рассмотрим в главе о регулярных выражениях PHP, и ее часто используют,
если нет необходимости в каких-то экзотических правилах поиска подстроки.
Напри-
мер, вот так мы можем заместить все символы перевода строки на их HTML-
эквивалент — тэг Жирный текст
Моноширинный текст
Ссылка ";
echo "Исходный текст: $st";
echo "")." и не были удалены
(ровно как и их парные закрывающие), в то время как исчез.
string str_repeat(string $st, string $number)
Функция "повторяет" строку $st $number раз и возвращает объединенный результат.
Вот пример:
echo str_repeat("test!",3); // выводит test!test!test!
Функции для преобразований
символов
Web-программирование — одна из тех областей, в которых постоянно приходится
манипулировать строками: разрывать их, добавлять и удалять пробелы, перекодиро-
вать в разные кодировки, наконец, URL-кодировать и декодировать. В PHP реализо-
вать все эти действия вручную, используя только уже описанные примитивы, просто
невозможно из соображений быстродействия. Поэтому-то и существуют встроенные
функции, описанные в этом разделе.
string strtr(string $str, string $from, string $to)
Эта функция применяется не столь широко, но все-таки иногда она бывает довольно
полезной. Делает она вот что: в строке $str заменяет все символы, встречающиеся
в
$from, на их "парные" (то есть расположенные в тех же позициях, что и во $from)
из
$to. Функция работает существенно быстрее, чем ereg_replace(), которую мы
рассмотрим в главе, посвященной регулярным выражениям. Правде, она имеет вме-
сте с тем несколько меньшую функциональность...
Следующие несколько функций предназначены для быстрого URL-кодирования и
декодирования.
string UrlEncode(string $st)
Функция URL-кодирует строку $st и возвращает результат. Эту функцию удобно
применять, если вы, например, хотите динамически сформировать ссылку на какой-то сценарий, но не уверены, что его параметры содержат
только
алфавитно-цифровые символы. В этом случае воспользуйтесь функцией так:
echo " $v) {?>
Имя: .
string StripSlashes(string $st)
Заменяет в строке $st некоторые предваренные слэшем символы на их однокодовые
эквиваленты. Это относится к следующим символам: ", ', \ и никаким другим.
string AddSlashes(string $st)
Вставляет слэши только перед следующими символами: ', " и \. Функцию очень
удобно использовать при вызове eval() (эта функция выполняет строку, переданную
ей в параметрах, так, как будто имеет дело с небольшой PHP-программой; о ней
(функции) мы еще поговорим, и при том очень подробно).
Функции изменения регистра
Довольно часто нам приходится переводить какие-то строки, скажем, в верхний ре-
гистр, т. е. делать все прописные буквы в строке заглавными. В принципе, для
этой
цели можно было бы воспользоваться функцией strtr(), рассмотренной выше, но
она все же будет работать не так быстро, как нам иногда хотелось бы. В PHP есть
функции, которые предназначены специально для таких нужд. Вот они.
string strtolower(string $str)
Преобразует строку в нижний регистр. Возвращает результат перевода.
Надо заметить, что при неправильной настройке локали (про локаль будет
рассказано
чуть позже, а пока скажу только, что это набор правил по переводу символов из
одно-
го регистра в другой, переводу даты и времени, денежных единиц и т. д.) функция
будет выдавать, мягко говоря, странные результаты при работе с буквами
кириллицы.
Возможно, в несложных программах, а также если нет уверенности в поддержке со-
ответствующей локали операционной системой, проще будет воспользоваться "руч-
ным" преобразованием символов, задействуя функцию strtr():
$st=strtr($st,
"АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩљЫЬЭЮЯ", "абвгдеёжзийклмнопрстуфхцчшщъыьэ-
юя");
Главное достоинство данного способа — то, что в случае проблем с кодировкой для
восстановления работоспособности сценария вам придется всего лишь преобразовать
его в ту же кодировку, в которой у вас хранятся документы на сервере.
string strtoupper(string $str)
Глава 12. Строковые функции 217
Переводит строку в верхний регистр. Возвращает результат преобразования. Эта
функции также прекрасно работает со строками, составленными из "английских"
букв, но с "русскими" буквами может возникнуть все та же проблема.
Установка локали (локальных настроек)
string SetLocale(string $category, string $locale)
Функция устанавливает текущую локаль, с которой будут работать функции преобра-
зования регистра символов, вывода даты-времени и т. д. Вообще говоря, для
каждой
категории функций локаль определяется отдельно и выглядит по-разному. То, какую
именно категорию функций затронет вызов SetLocale(), задается в параметре
$category. Он может принимать следующие строковые значения:
r LC_CTYPE — активизирует указанную локаль для функций перевода в верх-
ний/нижний регистры;
r LC_NUMERIC — активизирует локаль для функций форматирования дробных чи-
сел — а именно, задает разделитель целой и дробной части в числах;
r LC_TIME — задает формат вывода даты и времени по умолчанию;
r LC_ALL — устанавливает все вышеперечисленные режимы.
Теперь поговорим о параметре $locale. Как известно, каждая локаль,
установленная
в системе, имеет свое уникальное имя, по которому к ней можно обратиться.
Именно
оно и фиксируется в этом параметре. Однако, есть два важных исключения из этого
правила. Во-первых, если величина $locale равна пустой строке "", то
устанавлива-
ется та локаль, которая указана в глобальной переменной окружения с именем,
сов-
падающим с именем категории $category (или LANG — она практически всегда
присутствует в Unix). Во-вторых, если в этом параметре передается 0, то новая
ло-
каль не устанавливается, а просто возвращается имя текущей локали для
указанного
режима.
К сожалению, имена локалей задаются при настройке операционной системы, и для
них, по-видимому, не существует стандартов. Выясните у своего
хостинг-провайдера,
как называются локали для разных кодировок русских символов. Но, если следую-
щий фрагмент работает у вашего хостинг-провайдера, это не означает, что он
зарабо-
тает, например, под Windows:
setlocale('LC_CTYPE','ru_SU.KOI8-R');
Здесь вызов устанавливает таблицу замены регистра букв в соответствии с
кодиров-
кой KOI8-R.
По правде говоря, локаль — вещь довольно непредсказуемая и, как я уже говорил,
довольно плохо переносимая между операционными системами. Так что, если ваш
сценарий не очень велик, задумайтесь: возможно, лучше будет искать обходной
путь
(например, использовать strtr()), а не рассчитывать на локаль.
Часть IV. Стандартные функции PHP 218
Преобразование кодировок
Часто встречается ситуация, когда нам требуется преобразовать строку из одной
ко-
дировки кириллицы в другую. Например, мы в программе сменили локаль: была ко-
дировка windows, а стала — KOI8-R. Но строки-то остались по-прежнему в
кодировке
WIN-1251, а значит, для правильной работы с ними нам нужно их перекодировать в
KOI8-R. Для этого и служит функция преобразования кодировок.
string convert_cyr_string(string $str, char $from, char $to);
Функция переводит строку $str из кодировки $from в кодировку $to. Конечно, это
имеет смысл только для строк, содержащих "русские" буквы, т. к. латиница во
всех
кодировках выглядит одинаково. Разумеется, кодировка $from должна совпадать с
истинной кодировкой строки, иначе результат получится неверным. Значения $from
и $to — один символ, определяющий кодировку:
r k — koi8-r
r w — windows-1251
r i — iso8859-5
r a — x-cp866
r d — x-cp866
r m — x-mac-cyrillic
Функция работает достаточно быстро, так что ее вполне можно применять, скажем,
для перекодировки писем в нужную форму перед их отправкой по электронной почте.
Функции форматных преобразований
Как мы знаем, переменные в строках PHP интерполируются, поэтому практически
всегда задача "смешивания" текста со значениями переменных не является пробле-
мой. Например, мы можем спокойно написать что-то вроде:
echo "Привет, $name! Вам $age лет.";
Вспомните, что в Си нам приходилось для аналогичных целей писать следующий
код:
printf("Привет, %s! Вам %s лет",name,age);
Язык PHP также поддерживает ряд функций, использующих такой же синтаксис, как
и их Си-эквиваленты. Бывают случаи, когда их применение дает наиболее красивое
и
лаконичное решение, хотя это и случается довольно нечасто.
string sprintf(string $format [, mixed args, ...])
Эта функция — аналог функции sprintf() в Си. Она возвращает строку, состав-
ленную на основе строки форматирования, содержащей некоторые специальные сим-
Глава 12. Строковые функции 219
волы, которые будут впоследствии заменены на значения соответствующих перемен-
ных из списка аргументов.
Строка форматирования $format может включать в себя команды форматирования,
предваренные символом %. Все остальные символы копируются в выходную строку
как есть. Каждый спецификатор формата (то есть, символ % и следующие за ним ко-
манды) соответствует одному, и только одному параметру, указанному после пара-
метра $format. Если же нужно поместить в текст % как обычный символ, необходи-
мо его удвоить:
echo sprintf("The percentage was %d%%",$percentage);
Каждый спецификатор формата включает максимум пять элементов (в порядке их
следования после символа %):
r Необязательный спецификатор размера поля, который указывает, сколько симво-
лов будет отведено под выводимую величину. В качестве символов-заполнителей
(если значение имеет меньший размер, чем размер поля для его вывода) может
использоваться пробел или 0, по умолчанию подставляется пробел. Можно задать
любой другой символ-наполнитель, если указать его в строке форматирования,
предварив апострофом '. (См. примеры, как это делается.)
r Опциональный спецификатор выравнивания, определяющий, будет результат вы-
ровнен по правому или по левому краю поля. По умолчанию производится вырав-
нивание по правому краю, однако можно указать и левое выравнивание, задав
символ - (минус).
r Необязательное число, определяющее размер поля для вывода величины. Если
результат не будет в поле помещаться, то он "вылезет" за края этого поля, но не
будет усечен.
r Необязательное число, предваренное точкой ".", предписывающее, сколько знаков
после запятой будет в результирующей строке. Этот спецификатор учитывается
только в том случае, если происходит вывод числа с плавающей точкой, в против-
ном случае он игнорируется.
r Наконец, обязательный (заметьте — единственный обязательный!) спецификатор
типа величины, которая будет помещена в выходную строку:
· b — очередной аргумент из списка выводится как двоичное целое число;
· c — выводится символ с указанным в аргументе кодом;
· d — целое число;
· f — число с плавающей точкой;
· o — восьмеричное целое число;
· s — строка символов;
· x — шестнадцатеричное целое число с маленькими буквами a—z;
Часть IV. Стандартные функции PHP 220
· X — шестнадцатеричное число с большими буквами A—Z.
Вот как можно указать точность представления чисел с плавающей точкой:
$money1 = 68.75;
$money2 = 54.35;
$money = $money1 + $money2;
// echo $money выведет "123.1"...
$formatted = sprintf ("%01.2f", $money);
// echo $formatted выведет "123.10"!
Вот пример вывода целого числа, предваренного нужным количеством нулей:
$isodate=sprintf("%04d-%02d-%02d",$year,$month,$day);
Последний пример может вам очень пригодиться и показывает, насколько удобной
может иногда быть функция sprintf().
void printf(string $format [, mixed args, ...])
Делает то же самое, что и sprintf(), только результирующая строка не
возвращает-
ся, а направляется в браузер пользователя.
string number_format(float $number, int $decimals,
string $dec_point=".", string $thousands_sep=",");
Эта функция форматирует число с плавающей точкой с разделением его на триады с
указанной точностью. Она может быть вызвана с двумя или четырьмя аргументами,
но не с тремя! Параметр $decimals задает, сколько цифр после запятой должно
быть у числа в выходной строке. Параметр $dec_point представляет собой раздели-
тель целой и дробной частей, а параметр $thousands_sep — разделитель триад в
числе (если указать на его месте пустую строку, то триады не отделяются друг от
дру-
га).
В PHP существует еще несколько функций для выполнения форматных преобразова-
ний, среди них — sscanf() и fscanf(), которые часто применяются в Си. Однако
в PHP их использование весьма ограничено: чаще всего для разбора строк
оказывает-
ся гораздо выгоднее привлечь регулярные выражения или функцию explode().
Именно по этой причине я здесь не уделяю повышенного внимания этим функциям.
Работа с бинарными данными
Как мы уже знаем, строки могут содержать любые, в том числе и бинарные, данные
(то есть, символы с кодами, меньшими 32). Для работы с такими строками иногда
удобно использовать функции pack() и unpack().
string pack(string $format [,mixed $args, ...])
Функция pack() упаковывает заданные аргументы в бинарную строку, которая затем
и возвращается. Формат параметров, а также их количество, задается при помощи
Глава 12. Строковые функции 221
строки $format, которая представляет собой набор однобуквенных спецификаторов
форматирования — наподобие тех, которые указываются в sprintf(), но только без
знака %. После каждого спецификатора может стоять число, которое отмечает,
сколь-
ко информации будет обработано данным спецификатором. А именно, для форматов
a, A, h и H число задает, какое количество символов будет помещено в бинарную
строку из тех, что находятся в очередном параметре-строке при вызове функции
(то
есть, определяется размер поля для вывода строки). В случае @ оно определяет
абсо-
лютную позицию, в которую будут помещены следующие данные. Для всех осталь-
ных спецификаторов следующие за ними числа задают количество аргументов, на
которые распространяется действие данного формата. Вместо числа можно указать *,
в этом случае подразумевается, что спецификатор действует на все оставшиеся
дан-
ные. Вот полный список спецификаторов формата:
r a — строка, свободные места в поле заполняются символом с кодом 0;
r A — строка, свободные места заполняются пробелами;
r h — шестнадцатеричная строка, младшие разряды в начале;
r H — шестнадцатеричная строка, старшие разряды в начале;
r c — знаковый байт (символ);
r C — беззнаковый байт;
r s — знаковое короткое целое (16 битов, порядок байтов определяется архитекту-
рой процессора);
r S — беззнаковое короткое целое;
r n — беззнаковое целое (16 битов, старшие разряды в конце);
r v — беззнаковое целое (16 битов, младшие разряды в конце);
r i — знаковое целое (размер и порядок байтов определяется архитектурой);
r I — беззнаковое целое;
r l — знаковое длинное целое (32 бита, порядок байтов определяется архитекту-
рой);
r L — беззнаковое длинное целое;
r N — беззнаковое длинное целое (32 бита, старшие разряды в конце);
r V — беззнаковое целое (32 бита, младшие разряды в конце);
r f — число с плавающей точкой (зависит от архитектуры);
r d — число с плавающей точкой двойной точности (зависит от архитектуры);
r x — символ с нулевым кодом;
r X — возврат назад на 1 байт;
r @ — заполнение нулевым кодом до заданной абсолютной позиции.
Немало, не правда ли? Вот пример использования этой функции:
Часть IV. Стандартные функции PHP 222
// Целое, целое, все остальное — символы
$bindata = pack("nvc*", 0x1234, 0x5678, 65, 66);
После выполнения приведенного кода в строке $bindata будет содержаться 6 байтов
в такой последовательности: 0x12, 0x34, 0x78, 0x56, 0x41, 0x42 (в
шестнадцатерич-
ной системе счисления).
array unpack(string $format, string $data)
Функция unpack() выполняет действия, обратные pack() — распаковывает строку
$data, пользуясь информацией о формате $format. Возвращает она ассоциативный
массив, содержащий элементы распакованных данных. Строка $format задается
немного в другом формате, чем в функции pack(), а именно, после каждого специ-
фикатора (или после завершающего его числа) должно "впритык" следовать имя
ключа в ассоциативном массиве. Разделяются параметры при помощи символа /.
Например:
$array=unpack("c2chars/nint", $bindata);
В результирующий массив будут записаны элементы с ключами: chars1, chars2 и
int. Как видим, если после спецификатора задано число, то к имени ключа будут
добавлены номера 1, 2 и т. д., т. е. в массиве появятся несколько ключей,
отличаю-
щихся суффиксами.
Когда бывают полезны функции pack() и unpack()? Например, вы считали участок
GIF-файла, содержащий его размер в пикселах, и хотите преобразовать бинарную
32-
битную ячейку памяти в формат, понятный PHP. Или, наоборот, стремитесь работать
с файлами с фиксированным размером записи. В этом случае вам и пригодятся рас-
сматриваемые функции. Вообще говоря, функции pack() и unpack() применяются
сравнительно редко. Это связано с тем, что в PHP практически все действия,
которые
могут потребовать работы с бинарными данными (например, анализ файла с рисун-
ком с целью определения его размера), уже реализованы в виде встроенных функций
(в нашем примере с GIF-картинкой это GetImageSize()).
Хэш-функции
string md5(string $st)
Возвращает хэш-код строки $st, основанный на алгоритме корпорации RSA Data
Security под названием "MD5 Message-Digest Algorithm". Хэш-код — это просто
строка, практически уникальная для каждой из строк $st. То есть вероятность
того,
что две разные строки, переданные в $st, дадут нам одинаковый хэш-код,
стремится
к нулю.
Глава 12. Строковые функции 223
Я где-то читал об одном опыте, в котором принимали участие более 1000 мощ-
ных компьютеров, на протяжении года генерировавшие хэш-коды для строк, и
за все время не было обнаружено ни одного совпадения MD5-кодов для раз-
личных строк. Более того, математически доказано, что они могли бы с тем же
результатом заниматься этим на протяжении еще нескольких тысяч лет.
В то же время, если длина строки $st может достигать нескольких тысяч символов,
то ее MD5-код занимает максимум 32 символа.
Для чего нужен хэш-код и, в частности, алгоритм MD5? Например, для проверки па-
ролей на истинность. Пусть, к примеру, у нас есть система со многими
пользователя-
ми, каждый из которых имеет свой пароль. Можно, конечно, хранить все эти пароли
в обычном виде, или зашифровать их каким-нибудь способом, но тогда велика веро-
ятность того, что в один прекрасный день этот файл с паролями у вас украдут.
Если
пароли были зашифрованы, то, зная метод шифрования, не составит особого труда
их
раскодировать. Однако можно поступить другим способом, при использовании кото-
рого даже если файл с паролями украдут, расшифровать его будет математически
невозможно. Сделаем так: в файле паролей будем хранить не сами пароли, а их
(MD5) хэш-коды. При попытке какого-либо пользователя войти в систему мы вычис-
лим хэш-код только что введенного им пароля и сравним его с тем, который
записан
у нас в базе данных. Если коды совпадут, значит, все в порядке, а если нет —
что ж,
извините...
Конечно, при вычислении хэш-кода какая-то часть информации о строке $st безвоз-
вратно теряется. И именно это позволяет нам не опасаться, что злоумышленник,
по-
лучивший файл паролей, сможет его когда-нибудь расшифровать. Ведь в нем нет са-
мих паролей, нет даже их каких-то связных частей!
Алгоритм MD5 специально был изобретен для того, чтобы как раз и обеспечить опи-
санную выше схему. Так как все же есть вероятность того, что у разных строк
MD5-
коды совпадут, то, чтобы не дать возможность злоумышленнику войти в систему,
перебирая пароли с бешеной скоростью, алгоритм MD5 работает довольно медленно.
И его нельзя никак убыстрить, потому что это будет уже не MD5. Так что даже на
самых мощных компьютерах вряд ли получится перебирать более нескольких тысяч
паролей в секунду, а это совсем маленькая скорость, капля в океане возможных
MD5-
кодов.
int crc32(string $str)
Функция crc32() вычисляет 32-битную контрольную сумму строки $str. То есть,
результат ее работы — 32-битное (4-байтовое) целое число. Эта функция работает
гораздо быстрее md5(), но в то же время выдает гораздо менее надежные
"хэш-коды"
для строки. Так что, теперь, чтобы получить методом случайного подбора для двух
разных строк одинаковые "хэш-коды", вам потребуется не триллион лет работы
само-
го мощного компьютера, а всего лишь… год-другой. Впрочем, если не использовать
генератор случайных чисел, а разобраться в алгоритме вычисления 32-битной кон-
Часть IV. Стандартные функции PHP 224
трольной суммы, эту же задачу легко можно решить буквально за секунду, потому
что алгоритм crc32 имеет неизмеримо большую предсказуемость, чем MD5.
string crypt(string $str [,string $salt])
Алгоритм шифрования DES до недавнего времени был стандартным для всех версий
Unix и использовался как раз для кодирования паролей пользователей (тем же
самым
способом, о котором мы говорили при рассмотрении функции md5()). Но в последнее
время MD5 постепенно начал его вытеснять. Это и понятно: MD5 гораздо более на-
дежен. Рекомендую и вам везде применять md5() вместо crypt(). Впрочем, функ-
ция crypt() все же может понадобиться вам в одном случае: если вы хотите сгене-
рировать хэш-код для другой программы, которая использует именно алгоритм DES
(например, для сервера Apache).
Хэш-код для одной и той же строки, но с различными значениями $salt (кстати,
это
должна быть обязательно двухсимвольная строка) дает разные результаты. Если па-
раметр $salt пропущен, PHP сгенерирует его случайным образом, так что не удив-
ляйтесь работе следующего примера:
$st="This is the test";
echo crypt($st)."значение не сохраняются, более того — ключи просто
пропадают, поэтому сортировать что-либо, отличное от списка, вряд ли целе-
сообразно.
Сортировка списка при помощи
функции usort()
Эта функция как бы является "гибридом" функций uasort() и sort(). От sort()
она отличается тем, что критерий сравнения обеспечивается пользовательской
функ-
цией. А от uasort() — тем, что она не сохраняет связей между ключами и значе-
ниями, а потому пригодна разве что для сортировки списков. Вот тривиальный при-
мер:
function FCmp($a,$b) { return strcmp($a,$b); }
$A=array("One","Two","Three","Four");
usort($A);
for($i=0; $i$b. В принципе, приведенный здесь пример
полностью эквивалентен простому вызову sort().
Перемешивание списка shuffle()
Функция shuffle() "перемешивает" список, переданный ей первым параметром,
так, чтобы его значения распределялись случайным образом. Обратите внимание,
что, во-первых, изменяется сам массив, а во-вторых, ассоциативные массивы
воспри-
нимаются как списки. Пример:
$A=array(10,20,30,40,50);
shuffle($A);
foreach($A as $v) echo "$v ";
Приведенный фрагмент выводит числа 10, 20, 30, 40 и 50 в случайном порядке.
Выполнив этот фрагмент несколько раз, вы можете обнаружить, что от запуска
к запуску очередность следования чисел не изменяется. Это свойство обу-
словлено тем, что функция shuffle() использует стандартный генератор
Часть IV. Стандартные функции PHP 230
случайных чисел, который перед работой необходимо инициализировать при
помощи вызова srand(). Подробности можно найти в следующей главе (см.
функцию mt_srand()). Она — не совсем то, что нам требуется (нам нужна
srand()), но формы записи обеих функций не различаются.
Ключи и значения
array array_flip(array $Arr)
Эта функция "пробегает" по массиву и меняет местами его ключи и значения.
Исход-
ный массив $Arr не изменяется, а результирующий массив просто возвращается.
Конечно, если в массиве присутствовали несколько элементов с одинаковыми значе-
ниями, учитываться будет только последний из них:
$A=array("a"=>"aaa", "b"=>"aaa", "c"=>"ccc");
$A=array_flip($A);
// теперь $A===array("aaa"=>"b", "ccc"=>"c");
list array_keys(array $Arr [,mixed $SearchVal])
Функция возвращает список, содержащий все ключи массива $Arr. Если задан не-
обязательный параметр $SearchVal, то она вернет только те ключи, которым соот-
ветствуют значения $SearchVal.
Фактически, эта функция с заданным вторым параметром является обратной
по отношению к оператору [] — извлечению значения по его ключу.
list array_values(array $Arr)
Функция array_values() возвращает список всех значений в ассоциативном мас-
сиве $Arr. Очевидно, такое действие бесполезно для списков, но иногда оправдано
для хэшей.
bool in_array(mixed $val, array $Arr)
Возвращает true, если элемент со значением $val присутствует в массиве $Arr.
Впрочем, если вам часто приходится проделывать эту операцию, подумайте: не луч-
ше ли будет воспользоваться ассоциативным массивом и хранить данные в его клю-
чах, а не в значениях? На этом вы можете сильно выиграть в быстродействии.
array array_count_values(list $List)
Эта функция подсчитывает, сколько раз каждое значение встречается в списке
$List,
и возвращает ассоциативный массив с ключами — элементами списка и значения-
ми — количеством повторов этих элементов. Иными словами, функция
Глава 13. Работа с массивами 231
array_count_values() подсчитывает частоту появления значений в списке $List.
Вот пример:
$List=array(1, "hello", 1, "world", "hello");
array_count_values($array);
// возвращает array(1=>2, "hello"=>2, "world"=>1)
Комплексная замена в строке
В предыдущей главе мы рассматривали функцию strtr(), которая заменяла в стро-
ке одни буквы на другие, и функцию str_replace(), осуществляющую контекст-
ный поиск и замену. В свете ассоциативных массивов эти две функции объединяются
в одну, также называющуюся strtr(), но несущую в себе возможности
str_replace().
string strtr(string $st, array $Substitutes)
Эта функция (заметьте — с двумя параметрами, а не с тремя, как обычная
strtr()!)
берет строку $st и проводит в ней контекстный поиск и замену: ищутся подстроки
—
ключи в массиве $Substitutes — и замещаются на соответствующие им значения.
Таким образом, теперь мы можем выполнить несколько замен сразу, не используя
str_replace() в цикле:
$Subs=array(
"" => "Larry",
"" => date("d.m.Y")
);
$st="Привет, ! Сейчас ";
echo strtr($st,$Subs);
А вот как можно "отменить" действие функции HtmlSpecialChars():
$Trans=array_flip(get_html_translation_table());
$st=strtr($st, $Trans);
В результате мы из строки, в которой все спецсимволы заменены на их HTML-
эквиваленты, получим исходную строку во всей ее первозданной красе. Функции
get_html_translation_table() не уделено много внимания в этой книге. Она
возвращает таблицу преобразований, которая применяется при вызове
HtmlSpecialChars().
Функция strtr() начинает поиск с самой длинной подстроки и не проходит по
одному и тому же ключу дважды.
Часть IV. Стандартные функции PHP 232
Слияние массивов
array array_merge(array $A1, array $A2, ...)
Функция array_merge() призвана устранить все недостатки, присущие оператору +
для слияния массивов. А именно, она сливает массивы, перечисленные в ее
аргумен-
тах, в один большой массив и возвращает результат. Если в массивах встречаются
одинаковые ключи, в результат помещается пара ключ=>значение из того массива,
который расположен правее в списке аргументов. Однако это не затрагивает число-
вые ключи: элементы с такими ключами помещаются в конец результирующего мас-
сива в любом случае.
Таким образом, с помощью array_merge() мы можем избавиться от всех недостатков
оператора + для массивов. Вот пример, сливающий два списка в один:
$L1=array(10,20,30);
$L2=array(100,200,300);
$L=array_merge($L1,$L2);
// теперь $L===array(10,20,30,100,200,300);
Всегда используйте эту функцию, если вам нужно работать именно со списками, а
не
с обычными ассоциативными массивами.
Получение части массива
array array_slice(array $Arr, int $offset [, int $len])
Эта функция возвращает часть массива ассоциативного массива, начиная с пары
ключ=>значения со смещением (номером) $offset от начала и длиной $len (если
последний параметр не задан, до конца массива).
Параметры $offset и $len задаются по точно таким же правилам, как и аналогич-
ные параметры в функции substr(). А именно, они могут быть отрицательными (в
этом случае отсчет осуществляется от конца массива),
и т. д. Вот несколько примеров из документации PHP:
$input = array ("a", "b", "c", "d", "e");
$output = array_slice ($input, 2); // "c", "d", "e"
$output = array_slice ($input, 2, -1); // "c", "d"
$output = array_slice ($input, -2, 1); // "d"
$output = array_slice ($input, 0, 3); // "a", "b", "c"
Вставка/удаление элементов
Мы уже знаем несколько операторов, которые отвечают за вставку и удаление эле-
ментов. Например, оператор [] (пустые квадратные скобки) добавляет элемент в
ко-
Глава 13. Работа с массивами 233
нец массива, присваивая ему числовой ключ, а оператор Unset() вместе с извлече-
нием по ключу удаляет нужный элемент. Язык PHP версии 4 поддерживает и многие
другие функции, которые иногда бывает удобно использовать.
int array_push(alist &$Arr, mixed $var1 [, mixed $var2, …])
Эта функция добавляет к списку $Arr элементы $var1, $var2 и т. д. Она
присваива-
ет им числовые индексы — точно так же, как это происходит для стандарных [].
Ес-
ли вам нужно добавить всего один элемент, наверное, проще и будет
воспользоваться
этим оператором:
array_push($Arr,1000); // вызываем функцию…
$Arr[]=100; // то же самое, но короче
Обратите внимание, что функция array_push() воспринимает массив, как стек, и
добавляет элементы всегда в его конец. Она возвращает новое число элементов в
массиве.
mixed array_pop(list &$Arr)
Функция array_pop(), а противоположность array_push(), снимает элемент с
"вершины" стека (то есть берет последний элемент списка) и возвращает его,
удалив
после этого его из $Arr. С помощью этой функции мы можем строить конструкции,
напоминающие стек. Если список $Arr был пуст, функция возвращает пустую стро-
ку.
int array_unshift(list &$Arr, mixed $var1 [, mixed $var2, …])
Функция очень похожа на array_push(), но добавляет перечисленные элементы не
в конец, а в начало массива. При этом порядок следования $var1, $var2 и т. д.
оста-
ется тем же, т. е. элементы как бы "вдвигаются" в список слева. Новым элементам
списка, как обычно, назначаются числовые индексы, начиная с 0; при этом все
ключи
старых элементов массива, которые также были числовыми, изменяются (чаще всего
они увеличиваются на число вставляемых значений). Функция возвращает новый
размер массива. Вот пример ее применения:
$A=array(10,"a"=>20,30);
array_unshift($A,"!","?");
// теперь $A===array(0=>"!", 1=>"?", 2=>10, a=>20, 3=>30)
mixed array_shift(list &$Arr)
Эта функция извлекает первый элемент массива $Arr и возвращает его. Она сильно
напоминает array_pop(), но только получает начальный, а не конечный элемент, а
также производит довольно сильную "встряску" всего массива: ведь при извлечении
первого элемента приходится корректировать все числовые индексы у всех
оставших-
ся элементов…
array array_unique(array $Arr)
Часть IV. Стандартные функции PHP 234
Функция array_unique() возвращает массив, составленный из всех уникальных
значений массива $Arr вместе с их ключами. В результирующий массив помещают-
ся первые встретившиеся пары ключ=>значение:
$input=array("a" => "green", "red", "b" => "green", "blue", "red");
$result=array_unique($input);
// теперь $result===array("a"=>"green", "red", "blue");
array array_splice(array &$Arr, int $offset [, int $len] [, int $Repl])
Эта функция, также как и array_slice(), возвращает подмассив $Arr, начиная с
индекса $offset максимальной длины $len, но, вместе с тем, она делает и другое
полезное действие. А именно, она заменяет только что указанные элементы на то,
что
находится в массиве $Repl (или просто удаляет, если $Repl не указан). Параметры
$offset и $len задаются так же, как и в функции substr() — а именно, они могут
быть и отрицательными, в этом случае отсчет начинается от конца массива. За де-
тальными разъяснениями обращайтесь к описанию функции substr(), рассмотрен-
ной в предыдущей главе.
Приведу несколько примеров:
$input=array("red", "green", "blue", "yellow");
array_splice($input,2);
// Теперь $input===array("red", "green")
array_splice($input,1,-1);
// Теперь $input===array("red", "yellow")
array_splice($input, -1, 1, array("black", "maroon"));
// Теперь $input===array("red", "green", "blue", "black", "maroon")
array_splice($input, 1, count($input), "orange");
// Теперь $input===array("red", "orange")
Последний пример показывает, что в качестве параметра $Repl мы можем указать и
обычное, строковое значение, а не массив из одного элемента.
Переменные и массивы
array compact(mixed $vn1 [, mixed $vn2, …])
Функция compact(), впервые появившаяся в PHP версии 4, упаковывает в массив
переменные из текущего контекста (глобального или контекста функции), заданные
своими именами в $vn1, $vn2 и т. д. При этом в массиве образуются пары с ключа-
ми, равными содержимому $vnN, и значениями соответствующих переменных. Вот
пример использования этой функции:
$a="Test string";
Глава 13. Работа с массивами 235
$b="Some text";
$A=compact("a","b");
// теперь $A===array("a"=>"Test string", "b"=>"Some text")
Почему же тогда параметры функции обозначены как mixed? Дело в том, что они
могут быть не только строками, но и списками строк. В этом случае функция
после-
довательно перебирает все элементы этого списка, и упаковывает те переменные из
текущего контекста, имена которых она встретила. Более того — эти списки могут,
в
свою очередь, также содержать списки строк, и т. д. Правда, последнее
используется
сравнительно редко, но все же вот пример:
$a="Test";
$b="Text";
$c="CCC";
$d="DDD";
$Lst=array("b",array("c","d"));
$A=compact("a",$Lst);
// теперь $A===array("a"=>"Test", "b"=>"Text", "c"=>"CCC", "d"=>"DDD")
void extract(array $Arr [, int $type] [, string $prefix])
Эта функция производит действия, прямо противоположные compact().
А именно, она получает в параметрах массив $Arr и превращает каждую его пару
ключ=>значение в переменную текущего контекста.
Параметр $type предписывает, что делать, если в текущем контексте уже
существует
переменная с таким же именем, как очередной ключ в $Arr. Он может быть равен
одной из констант, перечисленных в табл. 13.1
Таблица 13.1. Поведение функции extract в случае совпадения переменных
Константа Действие
EXTR_OVERWRITE Переписывать существующую переменную (по умолчанию)
EXTR_SKIP Не перезаписывать переменную, если она уже существует
EXTR_PREFIX_SAME В случае совпадения имен создавать переменную с име-
нем, предваренным префиксом из $prefix. Надо сказать,
что на практике этот режим должен быть совершенно бес-
полезен
EXTR_PREFIX_ALL Всегда предварять имена создаваемых переменных пре-
фиксом $prefix
По умолчанию подразумевается EXTR_OVERWRITE, т. е. переменные перезаписыва-
ются. Вот пара примеров применения этой функции:
// Сделать все переменные окружения глобальными
Часть IV. Стандартные функции PHP 236
extract($HTTP_ENV_VARS);
// То же самое, но с префиксом E_
extract($HTTP_ENV_VARS, EXTR_PREFIX_ALL, "E_");
echo $E_COMSPEC; // выводит переменную окружения COMSPEC
Параметр $prefix имеет смысл указывать только тогда, когда вы применяете
режимы EXTR_PREFIX_SAME или EXTR_PREFIX_ALL.
Вообще говоря, использование extract() и compact() может быть оправдано
лишь для небольших массивов, да и то только в шаблонах, а в остальных случаях
считается признаком дурного тона. Впрочем, если ваш дизайнер никак не может по-
нять, зачем же ему в шаблонах страниц гостевой книги указывать все эти ужасные
квадратные скобки и апострофы, можете пойти ему навстречу так:
Здесь вы должны загодя позаботиться, чтобы ключи $Entry ненароком не затерли
нужные переменные. Этого можно добиться, например, назвав все важные перемен-
ные с прописной буквы (например, $Book и $Entry), а все ключи — с маленькой,
как и было сделано немного выше.
Создание списка – диапазона чисел
list range(int $low, int $high)
Эта функция очень простая. Она создает список, заполненный целыми числами от
$low до $high включительно. Ее удобно применять, если мы хотим быстро сгенери-
ровать массив для последующего прохождения по нему циклом foreach:
Это строка номер
С точки зрения дизайнеров (не знакомых с PHP, но которым придется модифициро-
вать внешний вид вашего сценария) представленный подход выглядит явно лучше,
чем следующий фрагмент:
Глава 14
Математические
функции
В PHP представлен полный набор математических функций, которые присутствуют в
большинстве других языков программирования. Правда, здесь они используются не-
сколько реже, потому что в сценаиях вообще редко приходится иметь дело со слож-
ными вычислениями.
Встроенные константы
PHP версии 4 предлагает нам несколько предопределенных констант, которые обо-
значают различные математические постоянные с максимальной машинной точно-
стью. Соответствующие этим константам ключевые слова и значения приводятся в
табл. 14.1.
Таблица 14.1. Математические константы.
Константа Aaee.eia Пояснение
M_PI 3,14159265358979323846 Число p
M_E 2,7182818284590452354 e
M_LOG2E 1,4426950408889634074 Log2(e)
M_LOG10E 0,43429448190325182765 Lg(e)
M_LN2 0,69314718055994530942 Ln(2)
M_LN10 2,30258509299404568402 Ln(10)
M_PI_2 1,57079632679489661923 p /2
M_PI_4 0,78539816339744830962 p /4
M_1_PI 0,31830988618379067154 1/ p
M_2_PI 0,63661977236758134308 2/ p
M_SQRTPI 1,77245385090551602729 sqrt(p)
M_2_SQRTPI 1,12837916709551257390 2/sqrt(p)
Глава 14. Математические функции 239
M_SQRT2 1,41421356237309504880 sqrt(2)
Таблица 14.1 (окончание)
Константа Aaee.eia Пояснение
M_SQRT3 1,73205080756887729352 sqrt(3)
M_SQRT1_2 0,70710678118654752440 1/sqrt(2)
M_LNPI 1,14472988584940017414 Ln(p)
M_EULER 0,57721566490153286061 Постоянная Эйлера
Надо заметить, разработчики PHP что-то слишком разошлись, когда вводили стан-
дартные константы. Например, я не могу даже и представить, зачем в Web-
программировании может потребоваться, например, константа Эйлера. Что же, это
их право….
Функции округления
mixed abs(mixed $number)
Возвращает модуль числа. Тип параметра $number может быть float или int, а тип
возвращаемого значения всегда совпадает с типом этого параметра.
double round(double $val)
Округляет $val до ближайшего целого и возвращает результат, например:
$foo = round(3.4); // $foo == 3.0
$foo = round(3.5); // $foo == 4.0
$foo = round(3.6); // $foo == 4.0
int ceil(float $number)
Возвращает наименьшее целое число, не меньшее $number. Разумеется, передавать в
$number целое число бессмысленно.
int floor(float $number)
Возвращает максимальное целое число, не превосходящее $number.
Случайные числа
Следующие три функции предназначены для генерации случайных чисел. Пожалуй, в
Web-программировании самое распространенное применение они находят в сценари-
ях показа баннеров.
Часть IV. Стандартные функции PHP 240
Я намеренно не рассматриваю функции rand() и srand(), потому что каче-
ство случайных чисел, которые они выдают, никуда не годится. Настоятельно
рекомендую вместо них использовать описанные ниже функции, а про rand()
вообще забыть.
int mt_rand(int $min=0, int $max=RAND_MAX)
Функция возвращает случайное число, достаточно равномерно даже для того, чтобы
использовать ее в криптографии. Подробнее о том алгоритме, который она
использу-
ет, можно прочитать в Интернете по адресу
http://www.math.keio.ac.jp/~matumoto/emt.html, а исходные тексты найти по
адресу
http://www.scp.syr.edu/~marc/hawk/twister.html. Если вы хотите генерировать
числа
не от 0 до RAND_MAX (эта константа задает максимально допустимое случайное
число,
и ее можно получить при помощи вызова mt_getrandmax()), задайте соответст-
вующий интервал в параметрах $min и $max.
Не забудьте только перед первым вызовом этой функции запустить mt_srand().
Давайте теперь рассмотрим один из случаев применения функции mt_rand(). Речь
пойдет об извлечении строки со случайным номером из текстового файла (работу с
файлами мы рассмотрим чуть позже, а пока скажу лишь, что функция fget() читает
очередную строку из файла, дескриптор которого указан ей в первом параметре, а
второй параметр задает максимально возможную длину этой строки, для нас это —
очень большое число). Поступим так:
for($i=0; mt_rand(0,$i)<1; $i++)
$s=fgets($OurFile,10000);
echo "Случайная строка: $s";
Этот способ работает в строгом соответствии с теорией вероятностей: для первой
строки вероятность ее извлечения будет 100%, для второй — 50% (она перепишется
поверх первой), для третьей — 33%, и т. д. Например, если файл состоит всего из
трех строк, то вероятность извлечения третьей строки, как мы уже заметили,
будет
равна 33%, а значит, первой или второй — соответственно, 66%. Но вероятность
из-
влечения второй строки после первой равна 50%, а 50% от 66% будет также 33%, т.
е.
вероятность извлечения каждой строки одинакова. Мы видим, что для файла из трех
строк алгоритм работает правильно. Не вдаваясь в математические подробности,
скажу, что он работает верно и для любого количества строк.
Безусловно, мы могли бы загрузить весь файл в память и выбрать из него нужную
строку и при помощи одного-единственного вызова mt_rand(), но если файл содер-
жит очень много данных, это может быть довольно не экономично с точки зрения
расхода памяти. Наоборот, для случая коротких файлов способ единовременной за-
грузки предпочтительнее. Насколько коротких? Думаю, это легче всего определить
опытным путем. Рассмотренный нами способ решает проблему с большими файлами.
Глава 14. Математические функции 241
Отмечу, что использование обычной функции rand() в этом примере просто
невозможно — сказывается слишком плохое качество генерируемых ей слу-
чайных чисел, и строки вряд ли будут равновероятны.
void mt_srand(int $seed)
Настраивает генератор случайных чисел на новую последовательность. Дело в том,
что хотя числа, генерируемые mt_rand(), достаточно равновероятны, но у них есть
один недостаток (который, как это обычно бывает, иногда перерастает в
достоинст-
во): последовательность сгенерированных чисел будет одинакова если сценарий вы-
звать несколько раз подряд. Функция mt_srand() как раз решает данную проблему:
она выбирает новую последовательность на основе параметра $seed, причем практи-
чески непредсказуемым образом. Чаще всего ее инициализируют так:
mt_srand(time()+(double)microtime()*1000000);
$randval = mt_rand();
В этом случае последовательность устанавливается на основе времени запуска
сцена-
рия (в секундах), поэтому она достаточно непредсказуема. Для еще более
надежного
результата рекомендуется приплюсовать сюда также микросекунды (что и было сде-
лано), а также идентификатор процесса, вызвавшего сценарий.
int mt_getrandmax()
Возвращает максимальное число, которое может быть сгенерировано функцией
mt_rand() — иными словами, константу RAND_MAX.
Перевод в различные
системы счисления
string base_convert(string $number, int $frombase, int $tobase)
Переводит число $number (заданное как строка в системе счисления по основанию
$frombase) в систему по основанию $tobase. Параметры $frombase и $tobase
могут принимать значения только от 2 до 36 включительно. В строке $number цифры
обозначают сами себя, буква a соответствует 11, b — 12, и т. д. до z, которая
обозна-
чает 36. Например, следующие команды выведут 11111111 (8 единичек), потому что
это — не что иное, как представление шестнадцатеричного числа FF в двоичной
сис-
теме счисления:
echo base_convert("FF",16,2);
int bindec(string $binary_string)
Часть IV. Стандартные функции PHP 242
Преобразует двоичное число, заданное в строке $binary_string, в десятичное чис-
ло.
string decbin(int $number)
Возвращает строку, представляющую собой двоичное представление целого числа
$number. Максимальное число, которое еще может быть преобразовано, равно
2 147 483 647, которое выглядит как 31 единичка в двоичной системе.
Существуют аналогичные функции для восьмеричной и шестнадцатеричной систем.
Называются они так же, только вместо "bin" подставляется соответственно "oct" и
"hex".
Минимум и максимум
mixed min(mixed $arg1 [int $arg2, ..., int $argn])
Эта функция возвращает наименьшее из чисел, заданных в ее аргументах. Различают
два способа вызова этой функции: с одним параметром или с несколькими. Если
ука-
зан лишь один параметр (первый), то он обязательно должен быть массивом и воз-
вращается минимальный элемент этого массива. В противном случае первый (и ос-
тальные) аргументы трактуются как числа с плавающей точкой, они сравниваются, и
возвращается наименьшее. Тип возвращаемого значения выбирается так: если хотя
бы одно из чисел, переданных на вход, задано в формате с плавающей точкой, то и
результат будет с плавающей точкой, в противном случае результат будет целым
чис-
лом. Обратите внимание на то, что с помощью этой функции нельзя лексикографиче-
ски сравнивать строки — только числа.
mixed max(mixed $arg1 [int $arg2, ..., int $argn])
Функция работает аналогично min(), только ищет максимальное значение.
Степенные функции
float sqrt(float $arg)
Возвращает квадратный корень из аргумента. Если аргумент отрицателен, то
генери-
руется предупреждение, но работа программы не прекращается! Это выглядит до-
вольно странно: интересно, что в этом случае возвращается функцией?..
float log(float $arg)
Возвращает натуральный логарифм аргумента. В случае недопустимого числа печа-
тает предупреждение, но, как и sqrt(), не завершает программу.
float exp(float $arg)
Возвращает e (2,718281828…) в степени $arg.
float pow(float $base, float $exp)
Возвращает $base в степени $exp.
Глава 14. Математические функции 243
Тригонометрия
Далее рассмотрим тригонометрические функции. Правда, они редко применяются
при программировании сценариев, но все же...
float acos(float $arg)
Возвращает арккосинус аргумента.
float asin(float $arg)
Возвращает арксинус.
float atan(float $arg)
Возвращает арктангенс аргумента.
float atan2(float $y, float $x)
Возвращает арктангенс величины $y/$x, но с учетом той четверти, в которой лежит
точка ($x, $y). Эта функция возвращает результат в радианах, принадлежащий от-
резку от -? до ?. Вот пара примеров:
$alpha=atan2(1,1); // $alpha==pi/4
$alpha=atan2(-1,-1); // $alpha==-3*pi/4
float sin(float arg)
Возвращает синус аргумента. Аргумент задается в радианах.
float cos(float $arg)
Возвращает косинус аргумента.
float tan(float arg)
Возвращает тангенс аргумента, заданного в радианах.
double pi()
Возвращает число ?. Эту функцию в PHP версии 4 обязательно нужно вызывать с
парой пустых скобок (в отличие от PHP 3):
echo pi()*10;
Впрочем, наверное, лучше будет воспользоваться константой M_PI?..
Глава 15
Работа с файлами
Хорошие новости. Во-первых, вы можете наконец с облегчением вздохнуть и забыть
о том, что в Windows (в отличие от Unix) для разделения полного пути файла
исполь-
зуются не прямые, а обратные слэши. Интерпретатору PHP совершенно все равно,
какие слэши вы будете использовать: прямые или обратные. Он в любом случае пе-
реведет их в ту форму, которая требуется вашей ОС, а функции по работе с
полными
именами файлов также не будут против "чужих" слэшей.
Во-вторых, вы теперь можете работать с файлами на удаленных серверах Web в точ-
ности так же, как и со своими собственными (ну, разве что записывать в них
можно
не всегда). Если вы предваряете имя файла строкой http:// или ftp://, то PHP
понимает, что нужно на самом деле установить сетевое соединение и работать
именно
с ним, а не с файлом. При этом в программе такой файл ничем не отличается от
обычного (если у вас есть соответствующие права, что вы можете и записывать в
по-
добный HTTP- или FTP-файл).
О текстовых и бинарных файлах
Во многих (да что там — практически во всех) языках программирования для работы
с текстовыми файлами применяется некоторый трюк. Вот в чем он заключается. Не
секрет, что в Unix-системах для отделения одной строки файла от другой
использует-
ся один специальный символ — его принято обозначать \n.
Обращаю ваше внимание на то, что \n здесь обозначает именно один символ,
т. е., один байт. Когда PHP встречает комбинацию \n в строке (например,
"это \n тест"), он воспринимает ее как один байт. В то же время, в строке,
заключенной в апострофы, комбинация \n не имеет никакого специального
назначения и обозначает буквально "символ \, за которым идет символ n".
В Windows по историческим причинам для разделения строк применяется не один, а
сразу два символа, следующих подряд, — \r\n. Для того чтобы языки программиро-
вания были лучше переносимы с одной операционной системы на другую, при чтении
текстовых файлов эта комбинация \r\n преобразуется "на лету" в один символ \n,
так что программа и не замечает, что формат файла не такой, как в Unix. В
результа-
те этой деятельности, если мы, например, прочитаем содержимое всего текстового
Глава 15. Работа с файлами 245
файла в строку, то длина такой строки наверняка окажется меньше физического
раз-
мера файла — ведь из нее "съелись" некоторые символы \r. Это относится к
системе
Windows и MacOS (кстати, в последней применяется комбинация не \r\n, а наобо-
рот — \n\r, что довольно-таки забавно). При записи строки в текстовый файл про-
исходит в точности наоборот: один \n становится на диске парой \r\n.
Впрочем, практически во всех языках программирования вы можете и отключить
режим автоматической трансляции \r\n в один \n. Обычно для этого используется
вызов специальной функции, который говорит, что для указанного файла нужно при-
менять бинарный режим ввода/вывода, когда все байты читаются, как есть. Правда,
программисты, всю жизнь писавшие под Unix, склонны игнорировать этот факт, в
результате чего программы перестают работать под Windows и вообще начинают
вытворять забавные вещи.
Так как PHP был написан целиком на Си, а Си использует трансляцию символов пе-
ревода строк, то описанная техника работает и в PHP. Однако тут есть один очень
опасный момент. Дело в том, что разработчики PHP в официальной документации к
функции fopen() старательно умалчивают о том, что интерпретатор может работать
с файлами в режиме трансляции символа перевода строки. Так вот, я возьму на
себя
смелость заявить, что такая возможность в действительности существует, а тесты
подтвердили, что ее можно корректно использовать как в Windows и MacOS, так и в
Unix. Подробнее об этом мы поговорим при рассмотрении функции fopen().
Если файл открыт в режиме бинарного чтения/записи, то PHP совершенно все равно,
что вы читаете или пишете. Вы можете совершенно спокойно считать содержимое
какого-нибудь бинарного файла (например, GIF-рисунка) в обычную строковую пе-
ременную, а потом записать эту строку в другой файл, и при этом информация нис-
колько не исказится. Правда, при чтении текстового файла в Windows вы получите
символы \r\n в конце строки вместо одного \n, если не предпримете некоторых
дей-
ствий, а откроете файл, как об этом написано в документации. Об этом речь ниже.
Открытие файла
Как и в Си, работа с файлами в PHP разделяется на три этапа. Сначала файл
откры-
вается в нужном режиме, при этом возвращается некое целое число, служащее иден-
тификатором открытого файла (дескриптор файла). Затем настает очередь команд
работы с файлом (чтение или запись, или и то и другое), причем они "привязаны"
уже
к дескриптору файла, а не к его имени. После этого файл лучше всего закрыть
(хотя
это можно и не делать, поскольку PHP автоматически закрывает все файлы по
завер-
шении сценария).
int fopen(string $filename, string $mode, bool $use_include_path=false)
Открывает файл с именем $filename в режиме $mode и возвращает дескриптор от-
крытого файла. Если операция "провалилась", то, как это принято, fopen()
возвра-
щает false. Впрочем, мы можем не особо беспокоиться, проверяя выходное значе-
Часть IV. Стандартные функции PHP 246
ние на ложность — вполне подойдет и проверка на ноль, потому что дескриптор 0 в
системе соответствует стандартному потоку ввода, а он, очевидно, никогда не
будет
открыт функцией fopen() (во всяком случае, пока не будет закрыт нулевой
дескрип-
тор, а это делается крайне редко). Необязательный параметр $use_include_path
говорит PHP о том, что, если задано относительное имя файла, его следует искать
также и в списке путей, используемом инструкциями include и require. Обычно
этот параметр не используют.
Параметр $mode может принимать следующие значения:
r r — файл открывается только для чтения. Если файла не существует, вызов реги-
стрирует ошибку. После удачного открытия указатель файла устанавливается на
его первый байт, т. е. на начало;
r r+ — файл открывается одновременно на чтение и запись. Указатель текущей
позиции устанавливается на его первый байт. Как и для режима r, если файла не
существует, возвращается false. Следует отметить, что если в момент записи
указатель файла установлен где-то в середине файла, то данные запишутся прямо
поверх уже имеющихся, а не "раздвинут" их, при необходимости увеличив размер
файла. Будьте внимательны;
r w — создает новый пустой файл. Если на момент вызова уже был файл с таким
именем, то он предварительно уничтожается. В случае неверно заданного имени
файла вызов, как нетрудно догадаться, "проваливается";
r w+ — аналогичен r+, но если файла изначально не существовало, создает его.
По-
сле этого с файлом можно работать как в режиме чтения, так и записи. Если файл
существовал до момента вызова, его содержимое удаляется;
r a — открывает существующий файл в режиме записи, и при этом сдвигает указа-
тель текущей позиции за последний байт файла. Этот режим полезен, если требу-
ется что-то дописать в конец уже имеющегося файла. Как водится, вызов неуспе-
шен в случае отсутствия файла;
r a+ — открывает файл в режиме чтения и записи, указатель файла устанавливается
на конец файла, при этом содержимое файла не уничтожается. Отличается от a
тем, что если файла изначально не существовало, то он создается. Этот режим по-
лезен, если вам нужно что-то дописать в файл (например, в журнал), но вы не
знаете, создан ли уже такой файл;
Но это еще не полное описание параметра $mode. Дело в том, что в конце любой из
строк r, w, a, r+, w+ и a+ может находиться еще один необязательный символ — b
или t. Если указан b (или не указан вообще никакой), то файл открывается в
режиме
бинарного чтения/записи. Если же это t, то для файла устанавливается режим
транс-
ляции символа перевода строки, т. е. он воспринимается как текстовый.
Глава 15. Работа с файлами 247
О режиме t нет ни слова в документации PHP (во всяком случае, на момент
написания этих строк), однако, как показывают мои тесты, он работает на всех
системах.
Чтобы проиллюстрировать это, давайте рассмотрим пример сценария. Он будет рабо-
тать по-разному в зависимости от того, в каком режиме мы откроем файл: в бинар-
ном или текстовом. Забегая вперед, замечу, что функция fgets() читает из файла
очередную строку.
Листинг 15.1. Сценарий test.php: работа с текстовыми файлами
\n";
$f=fopen("test.php","rt"); // текстовый режим
echo MakeHex(fgets($f,100)),"[email protected] /", "w") or die("Ошибка!");
Конструкция or die()
Давайте еще раз посмотрим на предыдущие примеры. Обратите внимание на доселе
не встречавшуюся нам конструкцию or die(). Ее особенно удобно применять как
раз при работе с файлами. Как мы знаем, оператор or имеет очень низкий
приоритет
(даже ниже, чем у =), поэтому в нашем примере всегда выполняется уже после при-
сваивания. Иными словами, первая строчка примера с точки зрения PHP выглядит
так:
($f=fopen("/home/user/file.txt", "r")) or die("Ошибка!");
Глава 15. Работа с файлами 249
Конечно, то, что or обозначает "логическое ИЛИ" в нашем случае не так интересно
(ибо возвращаемое значение просто игнорируется). Нас же сейчас интересует
другое
свойство оператора: выполнять второй свой операнд только в случае ложности
перво-
го. Смотрите: если файл открыть не удалось, fopen() возвращает false, а значит,
осуществляется вызов die() "на другом конце" оператора or.
Заметьте, что нельзя просто так заменить or на, казалось бы равнозначный ему
опе-
ратор ||, потому что последний имеет гораздо более высокий приоритет — выше,
чем у =. Таким образом, в результате вызова функции
$f=fopen("/home/user/file.txt", "r") || die("Ошибка!");
в действительности будет выполнено
$f = (fopen("/home/user/file.txt", "r") || die("Ошибка!"));
Как видите, это не совсем то, что нам нужно.
Безымянные временные файлы
Иногда всем нам приходится работать с временными файлами, которые при завер-
шении программы хотелось бы удалить. При этом нас интересует лишь файловый
дескриптор, а не имя временного файла. Для создания таких объектов в PHP
предусмотрена специальная функция.
int tmpfile()
Создает новый файл с уникальным именем (чтобы другой процесс случайно не по-
считал этот файл "своим") и открывает его на чтение и запись. В дальнейшем вся
работа должна вестись с возвращенным файловым дескриптором, потому что имя
файла недоступно.
Фраза "имя файла недоступно" может породить некоторые сомнения, но это
действительно так по одной-единственной причине: его просто нет. Вот как
такое может произойти? В большинстве систем после открытия файла его имя
можно спокойно удалить из дерева файловой системы, продолжая при этом
работать с "безымянным" файлом через дескриптор, как обычно. При закрытии
этого дескриптора блоки, которые занимает файл на диске, будут автоматиче-
ски помечены как свободные.
Пространство, занимаемое временным файлом, автоматически освобождается при его
закрытии и при завершении работы программы.
Часть IV. Стандартные функции PHP 250
Закрытие файла
После работы файл лучше всего закрыть. На самом деле это делается и автоматиче-
ски при завершении сценария, но лучше все же не искушать судьбу и законы Мэрфи.
Особенно, если вы одновременно открыли десятки (или сотни) файлов.
int fclose(int $fp)
Закрывает файл, открытый предварительно функцией fopen() (или popen() или
fsockopen(), но об этом позже). Возвращает false, если файл закрыть не удалось
(например, что-то с ним случилось или же разорвалась связь с удаленным хостом).
В
противном случае возвращает значение "истина".
Заметьте, что вы должны всегда закрывать FTP- и HTTP-соединения, потому что в
про-
тивном случае "беспризорный" файл приведет к неоправданному простою канала и
из-
лишней загрузке сервера. Кроме того, успешно закрыв соединение, вы будете
уверены в
том, что все данные были доставлены без ошибок.
Особенно своевременное закрытие критично при использовании FTP-файла в
режиме записи, когда вывод программы для ускорения буферизуется. Не за-
крыв файл, вы вообще не сможете быть уверены, что буфер вывода очистил-
ся, а значит, файл записался на удаленную машину верно.
Чтение и запись
Для каждого открытого файла (точнее, для каждого файлового дескриптора, ведь
один и тот же файл может быть открыт несколько раз, т. е. с ним может быть
связано
сразу несколько дескрипторов) система хранит определенную величину, которая на-
зывается текущей позицией ввода-вывода, или указатель файла. Функции чтения и
записи файлов работают именно с этой позицией. А именно, функции чтения читают
блок данных, начиная с этой позиции, а функции записи — записывают, также от-
считывая от нее. Если указатель файла установлен за последним байтом и
осуществляется запись, то файл автоматически увеличивается в размере. Есть
также
функции для установки этой самой позиции в любое место файла.
После того как файл успешно открыт, из него (при помощи дескриптора файла) мож-
но читать, а также, при соответствующем режиме открытия, писать. Обмен данными
осуществляется через обыкновенные строки и, что важнее всего, начиная с позиции
указателя файла. В следующих разделах рассматриваются несколько функций для
чтения/записи.
Блочные чтение/запись
string fread(int $f, int $numbytes)
Глава 15. Работа с файлами 251
Читает из файла $f $numbytes символов и возвращает строку этих символов. После
чтения указатель файла продвигается к следующим после прочитанного блока пози-
циям (это происходит и для всех остальных функций, так что дальше я буду
пропус-
кать такие подробности). Разумеется, если $numbytes больше, чем можно прочитать
из файла (например, раньше достигается конец файла), возвращается то, что
удалось
считать. Этот прием можно использовать, если вам нужно считать в строку файл
це-
ликом. Для этого просто задайте в $numbytes очень большое число (например, сто
тысяч). Но если вы заботитесь об экономии памяти в системе, так поступать не
реко-
мендуется. Дело в том, что в некоторых версиях PHP передача большой длины
строки
во втором параметре fread() вызывает первоначальное выделение этой памяти в
соответствии с запросом (даже если строка гораздо короче). Конечно, потом
лишняя
память освобождается, но все же ее может и не хватить для начального выделения.
int fwrite(int $f, string $st)
Записывает в файл $f все содержимое строки $st. Эта функция составляет пару для
fread(), действуя "в обратном направлении".
Например, с помощью описанных двух функций можно копировать файлы
(правда, в PHP есть для этого отдельная функция — copy()), считав файл
целиком посредством fread() и затем записав в новое место при помощи
fwrite().
При работе с текстовыми файлами (то есть когда указан символ t в режиме
открытия
файла) все \n автоматически преобразуются в тот разделитель строк, который
принят
в вашей операционной системе.
Построчные чтение/запись
string fgets(int $f, int $length)
Читает из файла одну строку, заканчивающуюся символом новой строки \n. Этот
символ также считывается и включается в результат. Если строка в файле занимает
больше $length-1 байтов, то возвращаются только ее $length-1 символов. Функ-
ция полезна, если вы открыли файл и хотите "пройтись" по всем его строкам.
Однако
даже в этом случае лучше (и быстрее) будет воспользоваться функцией File(), ко-
торая рассматривается ниже. Стоит также заметить, что эта функция (ровно как и
функция fread()) в случае текстового режима) в Windows заботится о преобразо-
вании пар \r\n в один символ \n, так что будьте внимательны при работе с
тексто-
выми файлами в этой операционной системе.
int fputs(int $f, string $st)
Эта функция — полный аналог fwrite(). В официальной документации по PHP
описания обеих функций просто совпадают, но там ничего не сказано про то, что
Часть IV. Стандартные функции PHP 252
функции являются синонимами. Что ж... Несмотря на это, я все-таки рискну выдви-
нуть такое предположение.
Чтение CSV-файла
Программа Excel из Microsoft Office стала настолько популярна, что в PHP даже
встроили функцию для работы с одним из форматов файлов, в которых может сохра-
нять данные Excel. Часто она бывает довольно удобна и экономит пару строк
допол-
нительного кода.
list fgetcsv(int $f, int $length, char $delim=’,’)
Функция читает одну строку из файла, заданного дескриптором $f, и разбивает ее
по
символу $delim. Параметр $delim должен обязательно быть строкой из одного сим-
вола, в противном случае принимается во внимание только первый символ этой
стро-
ки. Функция возвращает получившийся список или false, если строки кончились.
Параметр $length задает максимальную длину строки точно так же, как это делает-
ся в fgets(). Пустые строки в файле не игнорируются, а возвращаются как список
из одного элемента — пустой строки.
Функция fgetcsv() работает чуть быстрее пары fgets()/explode(), но зато она,
как мы можем видеть, гораздо менее универсальна. Применяйте ее в таком
контексте:
$f=fopen("file.csv","r") or die("Ошибка!");
for($i=0; $data=fgetcsv($f, 1000, ";"); $i++) {
$num = count($data);
if($num==1 && $data[0]==="") continue;
echo "Строка номер $i ($num полей): ";
for($c=0; $c<$num; $c++)
print "[$c]: $data[$c] ";
?>
Часть IV. Стандартные функции PHP 272
Сразу хочу предупредить, что результат работы этого сценария представляет собой
довольно длинную распечатку. Кроме того, программа работает медленно, т. к. ей
нужно будет обойти тысячи каталогов вашей системы.
Последний факт делает метод рекурсивного обхода каталогов совершенно не-
пригодным для автоматического построения карты сервера. В случае приме-
нения технологии кэширования информации между запусками сценариев для
больших сайтов построение карты даже, скажем, раз в час, выглядит довольно
плачевно. Как обойти эту трудность (фактически, используя кэш и разделен-
ные вычисления) рассказано в части V этой книги.
Глава 17
Каналы
и символические ссылки
Вообще-то, каналы и символические ссылки — совершенно разные вещи. Однако у
меня есть по крайней мере два веских основания для того, чтобы сгруппировать их
описания в одном месте.
r И то и другое сколько-нибудь результативно можно использовать лишь в системах
на основе Unix, в других же операционных системах функции либо не реализова-
ны, либо просто не работают.
r Примерно лишь один сценарий на PHP из тысячи может нуждаться в создании и
использовании каналов и символических ссылок.
Каналы
Давайте начнем с каналов. Мы уже привыкли, что можем открыть какой-то файл для
чтения при помощи fopen(), а затем читать или писать в него данные. Теперь
пред-
ставьте себе немного отвлеченную ситуацию: вы хотите из сценария запустить
какую-
то внешнюю программу (скажем, утилиту mail для отправки или приема почты).
Вам нужен будет механизм, посредством которого вы могли бы передать этой утили-
те данные (например, E-mail и текст письма), а затем получить результат работы
про-
граммы.
Можно, конечно, заранее сохранить данные для запроса в отдельном временном фай-
ле, затем запустить программу, передав ей этот файл в параметрах и направив ре-
зультат в другой файл, а затем считать его и таким образом решить задачу. Этот
спо-
соб вполне приемлем (хотя и несколько медлителен), если вы используете утилиту,
которая работает не в режиме диалога (а только читает запрос и возвращает
ответ).
Однако, если после ответа программы-утилиты ей нужно будет послать какой-то
дру-
гой запрос, не перезапускаясь, то задача становится на этом уровне неразрешимой.
Как раз в такой ситуации и удобно использовать межпроцессные каналы. И вот как
это работает.
// Запускаем процесс /bin/ls (параллельно работе сценария) в режиме
// чтения. Эта утилита Unix просто распечатывает содержимое текущего
// каталога, а ключ -l заставляет ее детализировать распечатку.
Часть IV. Стандартные функции PHP 274
$fp=popen("/bin/ls -l","r");
// Теперь мы можем работать с $fp как с обычным файловым
// идентификатором. То есть выполнять функции чтения.
for($Lines=array(); !eof($fp);)
$Lines[]=fgets($fp,1000);
// Не забудем также закрыть канал.
pclose($fp);
Теперь более подробно. По команде popen() запускается указанная в первом пара-
метре программа, причем выполняется она параллельно сценарию. Соответственно,
управление сразу возвращается на следующую строку, и сценарий не ждет, пока за-
вершится наша утилита (в отличие от функции system(), которая будет вскоре рас-
смотрена). Второй параметр задает режим работы: чтение или запись, точно так же,
как это делается в функции fopen().
Хочу обратить ваше внимание на то, что канал нельзя открыть в режиме одно-
временного чтения и записи. Что послужило этому причиной? Ответ на по-
ставленный вопрос в деталях занял бы слишком много места, чтобы помес-
титься в этой книге, но в двух словах можно сказать так: из-за буферизации
ввода-вывода реально возникновение ситуации, когда процесс-родитель будет
находиться в режиме ожидания данных от запущенного сына, а сын — будет
ждать данные от родителя. Таким образом, возникает состояние взаимной
блокировки: оба процесса оказываются приостановлены. В общем случае эта
проблема неразрешима, если у нас нет полного контроля над кодом процесса-
сына.
Далее в нашем примере происходит вот что. Стандартный вывод утилиты (тот, кото-
рый по умолчанию всегда является просто выводом на экран — да простят меня по-
клонники Unix, но все-таки так будет проще объяснить, не разъясняя, что такое
пере-
направление ввода-вывода и какую роль оно играет в этой ОС) прикрепляется к
идентификатору $fp. Теперь все, что печатает утилита (а в нашем случае она
печата-
ет содержимое каталога), может быть прочитано при помощи обычных вызовов фай-
ловых функций чтения — fgets(), fread() и т. д.
Программа ls не ждет никакого ввода (однако в общем случае это далеко не всегда
так),
вот почему мы пользуемся только серией вызовов fgets(). После того, как "дело
сдела-
но", канал $fp, вообще говоря, нужно закрыть. Если он ранее был открыт в режиме
запи-
си, утилите "на том конце" передается, что ввод данных "с клавиатуры" завершен,
и она
может закончить свою работу.
В PHP не существует функций, которые могли бы открывать канал к дочернему
процессу в режиме чтения и записи.
Глава 17. Каналы и символические ссылки 275
Теперь, когда мы разобрались с каналами, давайте посмотрим, что предлагает нам
PHP для работы с символическими ссылками.
Символические ссылки
Для начала (для тех, кто не знает) — что это такое? В системе Unix (да и в
других ОС
в общем-то тоже) довольно часто возникает необходимость иметь для одного и того
же файла или каталога разные имена. При этом логично одно из имен назвать
основ-
ным, а все другие — его псевдонимами. В терминологии Unix такие псевдонимы на-
зываются символическими ссылками.
Символическая ссылка — это просто бинарный файл специального вида, который
содержит ссылку на основной файл. При обращении к такому файлу (например, от-
крытию его на чтение) система "соображает", к какому объекту на самом деле
запра-
шивается доступ, и "прозрачно его обеспечивает. Это означает, что мы можем ис-
пользовать символические ссылки точно так же, как и обычные файлы (в частности,
работают fopen(), fread()
и т. д.) Однако иногда нужно бывает работать со ссылкой именно как со ссылкой
(простите за тавтологию), а не как с файлом. Для этого и существуют
перечисленные
ниже функции PHP.
string readlink(string $linkname)
Возвращает имя основного файла, с которым связан его синоним $linkname. Это
бывает полезно, если вы хотите узнать основное имя файла, чтобы, например, уда-
лить сам файл, а не ссылку на него. В случае ошибки функция возвращает значение
"ложь".
bool symlink(string $target, string $link)
Эта функция создает символическую ссылку с именем $link на объект (файл или
каталог), заданную в $target. В случае "провала" функция возвращает false.
array lstat(string $filename)
Функция полностью аналогична вызову stat(), за исключением того, что если
$filename задает не файл, а символическую ссылку, будет возвращена информация
именно об этой ссылке (а не о файле, на который она указывает, как это делает
stat()).
int linkinfo(string $linkname)
Функция возвращает значение поля "устройство" из результата, выдаваемого
функци-
ей lstat(), которую мы рассматривали выше. Ее обычно задействуют, если хотят
определить, существует ли еще объект, на который указывает символическая ссылка
в $linkname. Я предпочитаю пользоваться для этого вызовом stat(), т. к., по-
моему, ее название несколько более "читабельно".
Часть IV. Стандартные функции PHP 276
Нужно добавить, что можно совершенно спокойно удалять символические ссылки, не
опасаясь за содержимое основного файла. Это делается обычным способом — на-
пример, вызовом unlink() или rmdir().
Жесткие ссылки
И в конце этой главы я хочу рассмотреть еще один вид ссылок — жесткие ссылки.
Оказывается, создание символической ссылки — не единственный способ задать для
одного файла несколько имен. Главный недостаток символических ссылок, как вы,
наверное, уже догадались, — существование основного имени файла, на которое все
и ссылаются. Попробуйте удалить этот файл — и вся "паутина" ссылок, если
таковая
имелась, развалится на куски. Есть и другой недостаток: открытие файла, на
который
указывает ссылка, происходит несколько медленнее, т. к. системе нужно
проанализи-
ровать содержимое ссылки и установить связь с "настоящим" файлом. Особенно это
чувствуется, если одна ссылка указывает на другую, та — на третью и т. д.
уровней
на 10.
Жесткие ссылки позволяют вам иметь для одного файла несколько совершенно рав-
ноправных имен, причем доступ по ним осуществляется одинаково быстро. При этом,
если одно из таких имен будет удалено (например, при помощи unlink()), то сам
файл удалится только в том случае, если данное имя было последним, и других
имен
у файла нет. Сравните с символическими ссылками, удаляя которые файл испортить
нельзя.
Зарегистрировать новое имя у файла (то есть создать для него жесткую ссылку)
мож-
но с помощью функции link(). Ее синтаксис полностью идентичен функции
symlink(), да и работает она по тем же правилам, за исключением того, что
создает
не символическую, а жесткую ссылку. Фактически, вызов link() — это почти то же,
что и rename(), только старое имя файла не удаляется, а остается.
Напоминаю, работает это все только в Unix, но не в Windows. И почему только
до таких вещей не додумались парни из Microsoft?..
Глава 18
Запуск внешних
программ
Функции запуска внешних программ в PHP востребуются достаточно редко. Их "не-
популярность" объясняется прежде всего тем, что при использовании PHP програм-
мист получает в свое распоряжение почти все возможности, которые могут когда-
либо понадобиться, в частности, почтовые функции, на которые приходится львиная
доля вызовов внешних программ в других языках — например, в Perl. Тем не менее,
в числе стандартных функций языка присутствует полный набор средств, предназна-
ченных для запуска программ и утилит операционной системы.
string system(string $command [,int& return_var])
Эта функция, как и ее аналог в Си, запускает внешнюю программу, имя которой пе-
редано первым параметром, и выводит результат работы программы в выходной по-
ток, т. е. в браузер. Последнее обстоятельство сильно ограничивает область
примене-
ния функции.
Впрочем, задействуя функции перенаправления вывода, мы все-таки можем
получить и обработать то, что выдала нам запущенная программа, но стоит ли
игра свеч? Может быть, лучше воспользоваться более подходящими средст-
вами?
Если функции передан также второй параметр — переменная (именно переменная, а
не константа!), то в нее помещается код возврата вызванного процесса. Ясно, что
это
требует от PHP ожидания завершения запущенной программы — так он и поступает в
любом случае, даже если последний параметр не задан.
Не нужно и говорить, что при помощи этой функции можно запускать только те
команды, в которых вы абсолютно уверены. В частности, никогда не переда-
вайте функции system() данные, пришедшие из браузера пользователя
(предварительно не обработав их) — это может нанести серьезный урон ва-
шему серверу, если злоумышленник запустит какую-нибудь разрушительную
утилиту — например, rm -R ~/, которая быстро и "без лишних слов" очистит
весь ваш каталог.
Часть IV. Стандартные функции PHP 278
Как уже упоминалось, выходной поток данных программы направляется в браузер.
Если вы хотите этого избежать, воспользуйтесь функциями popen() или exec().
Если же вы, наоборот, желаете, чтобы выходные данные запущенной программы по-
пали прямиком в браузер и никак при этом не исказились (например, вы вызываете
программу, выводящую в стандартный выходной поток какой-нибудь GIF-рисунок), в
этом случае в самый раз будет функция PassThru().
string exec(string $command [,list& $array] [,int& $return_var])
Функция exec(), как и system(), запускает указанную программу или команду,
однако, в отличие от последней, она ничего не выводит в браузер. Вместо этого
функ-
ция возвращает последнюю строку из выходного потока запущенной программы и,
если задан параметр $array (который обязательно должен быть переменной), то он
заполняется списком строк в выходном потоке — по одной строке на элемент.
Если массив уже содержал какие-то данные перед вызовом exec(), новые
строки просто добавляются в его конец, а не заменяют старое содержимое
массива. Учитывайте это в своих программах, иначе нетрудно получить очень
нетривиальную ошибку.
Как и в функции system(), при задании параметра-переменной $return_var код
возврата запущенного процесса будет помещен в эту переменную. Так что функция
exec() тоже дожидается окончания работы нового процесса и только потом возвра-
щает управление в PHP-программу.
string EscapeShellCmd(string $command)
Помните, мы говорили о том, что нельзя допускать возможности передачи данных из
браузера пользователя (например, из формы) в функции system() и exec()? Если
это все же нужно сделать, то данные должны быть соответствующим способом обра-
ботаны: например, можно защитить все специальные символы обратными слэшами, и
т. д. Это и делает функция EscapeShellCmd(). Чаще всего ее применяют примерно
в таком контексте:
system("cd ".EscapeShellCmd($to_directory));
Здесь переменная $to_directory пришла от пользователя — например, из формы
или Cookies. Давайте посмотрим, как злоумышленник может стереть все данные на
вашем сервере, если вы по каким-то причинам забудете про EscapeShellCmd(),
написав следующий код:
system("cd $to_directory"); // Никогда так не делайте!
Задав такое значение для $to_directory:
~; rm -R *; sendmail [email protected] \n";
$gregorian = JDToGregorian($jd);
echo "$gregorian[email protected] [email protected] ,
"My Subject",
"Line 1\nLine 2\nLine 3"
);
В случае, если указан четвертый параметр, переданная в нем строка вставляется
ме-
жду концом стандартных почтовых заголовков (таких как To, Content-type и т. д.)
и началом текста письма. Обычно этот параметр используется для задания дополни-
тельных заголовков письма. Пример:
mail("[email protected] [email protected] ",
"the subject",
"Line 1\nLine 2\nLine 3",
"From: webmaster@$SERVER_NAME\n".
"Reply-To: webmaster@$SERVER_NAME\n".
"X-Mailer: PHP/" . phpversion()
);
Необходимо добавить, что этот пример довольно-таки неказист. Гораздо лучше было
бы включить указанные заголовки прямо в тело письма $msg (в начало тела),
отделив
их от самого письма пустой строкой (прямо как в стандарте HTTP). То же самое
при-
менимо и к параметру $subject: лучше задавать в нем всегда пустую строку и ука-
Часть IV. Стандартные функции PHP 286
зывать заголовок Subject в самом письме. Всегда старайтесь поступать таким
обра-
зом. Далее будет ясно, зачем.
Проблема с кодировками
Думаю, не надо напоминать, что русских кодировок существует великое множество.
Поэтому от того, насколько умело вы перекодируете письмо перед его отсылкой,
за-
висит, прочтет ли его получатель или, махнув рукой, отправит в корзину, даже не
попытавшись установить в своем почтовом клиенте нужную кодировку. Эта глава как
раз и призвана раз и навсегда решить проблему кодировок. Если вы воспользуетесь
советами, изложенными в ней, ваши письма всегда будут читаемыми.
Посылка в указанной кодировке
Сначала давайте договоримся об одном соглашении: функции mail() передавать
только адрес получателя и текст письма. Ни заголовков, ни темы — и то и другое
должно присутствовать в самом письме. Например:
$message=
"From: Лист рассылки
To: Иванов Иван Иванович
Subject: Пробная рассылка
Content-type: text/plain; charset=windows-1825
Уважаемый товарищ! Это письмо послано почтовым роботом.
Всего хорошего!";
Mail("[email protected] ","",$message);
Обратите внимание на заголовок Content-type (в некоторых системах он обяза-
тельно должен стоять последним — проверьте это экспериментально). Он задает,
что,
во-первых, письмо доставляется как простой текст (text/plain), а во-вторых, что
его кодировка — Windows. Теперь письмо всегда можно будет прочитать, даже если
почтовая программа клиента по умолчанию настроена на китайскую кодировку.
И почему некоторые программы так не делают, а посылают письма без указа-
ния их кодировки? Неужели им жалко лишнего десятка байтов для названия
кодировки?
Обратите внимание на то, что тело письма отделяется от заголовков пустой
строкой, с
тем, чтобы почтовая программа могла понять, где кончаются заголовки и
начинается
тело.
Глава 20. Посылка писем через PHP 287
Динамическая смена кодировки
Приведенное в предыдущем примере письмо можно будет прочитать в 90% сущест-
вующих почтовых программ. Для "удовлетворения" остальных желательно посылать
письма не в Windows-кодировке, а в KOI-8R. Для перекодирования можно восполь-
зоваться уже известной нам функцией convert_cyr_string(). И, конечно, нужно в
Content-type заменить charset на koi8-r. Вот что у нас получится:
$message=
"From: Лист рассылки
To: Иванов Иван Иванович
Subject: Пробная рассылка
Content-type: text/plain; charset=koi8-r
Уважаемый товарищ! Это письмо послано почтовым роботом.
Всего хорошего!";
$message=convert_cyr_string($message,"w","k");
Mail("[email protected] ","",$message);
Теперь вы понимаете, почему я говорил о том, чтобы все заголовки и Subject
нахо-
дились внутри тела письма? Этим мы достигаем того, что одной командой
convert_cyr_string() перекодируется сразу все письмо, включая поля From, To,
Subject и др. Иначе пришлось бы применять эту функцию дополнительно для пере-
кодировки параметров $subject и $headers...
Проблема с заголовками
Есть одна проблема, возникающая при подобном использовании заголовка
Contenttype.
Дело в том, что существуют почтовые программы, которые понимают заголо-
вок Content-type, но не понимают русский текст в поле Subject, если это поле
стоит до Content-type. В то же время, другие почтовые клиенты обязывают нас
задавать Content-type последним заголовком в списке. Чтобы обойти этот закол-
дованный круг, проще всего разместить поле Content-type сразу в двух местах —
перед первым и после последнего заголовка:
$message=
"Content-type: text/plain; charset=koi8-r
From: Лист рассылки
To: Иванов Иван Иванович
Subject: Пробная рассылка
Content-type: text/plain; charset=koi8-r
Уважаемый товарищ! Это письмо послано почтовым роботом.
Всего хорошего!";
$message=convert_cyr_string($message,"w","k");
Mail("[email protected] ","",$message);
Часть IV. Стандартные функции PHP 288
Да, это может показаться весьма искусственным приемом, но зато работает "на
ура".
Теперь вы можете быть уверены, что ваше письмо прочитает любой пользователь
(особенно если оно послано в кодировке KOI8), даже если его почтовая программа
вообще не настроена ни на какую кодировку. Можете похвастать этим достижением
перед начальством, предложив ему поставить у себя в Outlook Express по
умолчанию
японскую кодировку, а затем попросив принять письмо, сгенерированное роботом по
указанной схеме.
Перспективы: создание "умной"
функции для отправки писем
Возможно, вам уже пришла в голову идея сделать универсальную функцию для рас-
сылки писем — чтобы она сама добавляла к полю To в письме E-mail в угловых
скобках (как в примере выше), проставляла нужную кодировку у письма (которая
задается в параметрах при вызове функции), ну и т. д. Это вполне осуществимо.
Функция может выглядеть, например, так:
bool PostMail(string $ToAddress, string $Encode, string $Message)
Посылает письмо $Message по адресу $ToAddress, перекодировав его предвари-
тельно в кодировку, заданную в $Encode. Параметр $Encode может принимать сле-
дующие значения:
r w — Windows
r k — KOI8-R
r m — Mac
r i — Iso Latin
r t — Translit
В письме автоматически проставляется Content-type...charset (если заголовок
Content-type уже присутствует в письме, то он не портится, а просто у него
меняет-
ся поле charset на нужное значение). Также корректируется поле To в письме. Од-
новременно правильно обрабатываются вставки PHP-кода в тело письма (можно ис-
пользовать глобальные переменные и оператор echo). Для этого, как обычно,
применяются "скобки" .
Реализацию поставленной задачи мы отложим до части V, где описаны и другие
приемы, облегчающие работу на PHP. Для этого нам понадобится техника регуляр-
ных выражений, которыми мы вскоре займемся, а также еще некоторые навыки. Если
вы уже сейчас хотите использовать функцию PostMail(), можете сразу открыть
часть V книги и скопировать оттуда ее исходный код на PHP.
Глава 21
Работа с WWW
Мы уже рассматривали основы протокола HTTP в части I книги. Оператор echo,
предназначенный для вывода данных в браузер, нам также хорошо знаком. Теперь
осталось лишь разобрать, какие средства предусмотрены в PHP для работы с
заголов-
ками HTTP.
Установка заголовков ответа
Первая функция, которую мы сейчас рассмотрим, — Header() — предназначена для
посылки заголовка браузеру (точнее, для добавления заголовка к документу,
пересы-
лаемому браузеру). Она может быть вызвана только до первой команды вывода сце-
нария (конечно, если вы до этого не воспользовались функцией буферизации
ob_start()).
Вывод заголовка
int Header(string $string)
Обычно функция Header() является одной из первых команд сценария. Она предна-
значена для установки заголовков ответа, которые будут переданы браузеру — по
одному заголовку на вызов. Не забывайте, что вызов Header() обязательно должен
осуществляться до любого оператора вывода в сценарии — в противном случае вы
получите предупреждение. Заметьте, что текст вне также рассматривается
как оператор вывода, а потому старайтесь не делать лишних пробелов до первой
"скобки" во включаемом файле. Впрочем,
вы сможете легко обнаружить подобную ошибку, если выставите уровень контроля
ошибок, равный 15 (1+2+4+8) — в этом случае при недопустимом вызове Header()
вы получите предупреждение. Пример:
// перенаправляет браузер на сайт PHP
Header("Location: http://www.php.net");
// теперь принудительно завершаем сценарий, ввиду того, что после
// перенаправления больше делать нечего
exit;
Часть IV. Стандартные функции PHP 290
Запрет кэширования
Еще одно полезное приложение функции Header() — запрет кэширования докумен-
та браузером и Proxy-серверами. Большинство сценариев формируют документы,
которые при каждом запуске программы изменяются. Очевидно, если браузер поль-
зователя начнет кэшировать такие документы, ничего хорошего не получится. Вы-
ход — использовать в начале сценария следующие команды:
Header("Expires: Mon, 26 Jul 1997 05:00:00 GMT"); // Дата в прошлом
Header("Cache-Control: no-cache, must-revalidate"); // HTTP/1.1
Header("Pragma: no-cache"); // HTTP/1.0
Header("Last-Modified: ".gmdate("D, d M Y H:i:s")."GMT");
Самое неприятное то, что для полного запрета кэширования приходится всегда
посы-
лать 4 указанных заголовка, и ни один пропустить нельзя — в противном случае не
сработает либо браузер, либо Proxy-сервер. Так что рекомендую оформить их все в
виде функции (например, с именем NoCache()) и затем вызывать эту функцию в
нужный момент.
Получение заголовков запроса
Для получения всех заголовков запроса (того самого запроса, что вынудил
запустить-
ся сценарий) следует воспользоваться функцией GetAllHeaders():
array GetAllHeaders()
Функция GetAllHeaders() возвращает ассоциативный массив, содержащий данные
о HTTP-заголовках запроса клиента, породившего запуск сценария. Ключи массива
содержат названия заголовков, а значения — их величины.
Вот пример использования этой функции:
$headers = GetAllHeaders();
foreach($headers as $header=>$value)
echo "$header: $value и , — для последующего вывода в браузер.
Это может понадобиться, если мы хотим текст некоторой программы на PHP вывести
так, чтобы в нем выделялись имена переменных. Очевидно, выражение для обнару-
жения имени переменной в строке будет таким: \$[a-zA-Z_][[:alnum:]]*.
Но как нам использовать его в функции ereg_Replace()? Вот фрагмент програм-
мы, которая делает это:
$str=" // к примеру
$str=ereg_Replace("(\\$[a-zA-Z_][[:alnum:]]*)","\\1 ",$str);
Пожалуйста, обратите опять внимание на то, что слэши должны удваиваться.
Нетрудно догадаться, как "оно" работает: просто во время замены везде вместо
соче-
тания \1 подставляется содержимое кармана номер 1.
Глава 22. Основы регулярных выражений в формате RegEx 307
Использование карманов
в функции сопоставления
И даже на том, что было описано выше, возможности карманов не исчерпываются.
Мы можем задействовать содержимое карманов и в функции ereg() — раньше, чем
закончится сопоставление. А именно, управлять ходом поиска на основе данных в
карманах.
В качестве примера рассмотрим такую далеко не праздную задачу. Известно, что в
строке есть подстрока, обрамленная какими-то HTML-тэгами (например, или
), но неизвестно, какими. Требуется поместить эту подстроку в карман,
чтобы в
дальнейшем с ней работать. Разумеется, закрывающий тэг должен соответствовать
открывающему — например, к тэгу парный — , а к — .
Задача решается с помощью такого регулярного выражения:
<([[:alnum:]]+)>([^<]*)
При этом результат окажется во втором кармане, а имя тэга — в первом. Вот как
это
работает: PHP пытается найти открывающий тэг, и, как только находит, записывает
его имя в первый карман (так как это имя обрамлено в выражении первой парой
ско-
бок). Дальше он смотрит вперед и, как только наталкивается на word is bold!";
if(ereg("<([[:alnum:]]+)>([^<]*)",$str,$Pockets))
echo "Слово '$Pockets[2]' обрамлено тэгом '<$Pockets[1]>'";
Дополнительные функции
bool eregi(string $expr, string $str [,list &$Matches])
То же, что и ereg(), только без учета регистра символов.
Хотя регистр и не учитывается при поиске, в карманах $Matches все найден-
ные подстроки все же запишутся с точным сохранением регистра букв.
string eregi_replace(string $expr, strint $str, string $strToChange)
То же, что и ereg_replace(), но без учета регистра буквенных символов.
Часть IV. Стандартные функции PHP 308
int quotemeta(string $str)
Часто бывает нужно гарантировать, чтобы в какой-то переменной-строке ни один
символ не мог трактоваться как метасимвол. Этого можно добиться, предварив каж-
дый из них наклонной чертой, что и делает функция quotemeta(). А именно, она
"заслэшивает" следующие символы: . , \\, +, *, ? , [ ^ ] , ( $ ).
Перед | слэш почему-то не ставится. Будьте особо внимательны!
list split(string $pattern, string $string [,int $limit])
Эта функция очень похожа на explode(). Она тоже разбивает строку $string на
части, но делает это, руководствуясь регулярным выражением $pattern. А именно,
те участки строки, которые совпадают с этим выражением, и будут служить
раздели-
телями. Параметр $limit, если он задан, имеет то же самое значение, что и в
функ-
ции explode() — а именно, возвращается список из не более чем $limit элемен-
тов, последний из которых содержит участок строки от ($limit-1)-го совпадения
до
конца строки.
Наверное, вы уже догадались, что функция split() работает гораздо медленнее,
чем
explode(). Однако она, вместе с тем, имеет впечатляющие возможности, в чем мы
очень скоро убедимся. Тем не менее, не стоит применять split() там, где
прекрасно
подойдет explode(). Чаще всего этим грешат программисты, имеющие некоторый
опыт работы с Perl, потому что в Perl для разбиения строки на составляющие есть
только функция split().
list spliti(string $pattern, string $string [,int $limit])
Аналог функции split(), который делает то же самое, только при сопоставлении с
регулярным выражением не учитывается регистр символов.
Примеры использования
регулярных выражений
Какая же книга, описывающая (даже вкратце) регулярные выражения, обходится без
примеров…. Я не буду отступать от установленных канонов, хотя, конечно, понимаю,
что истинная свобода при работе с выражениями достигается только практикой. Не-
которые из следующих ниже примеров выглядят довольно сложно, но, если разо-
браться, смысл чаще всего оказывается на поверхности.
Имя и расширение файла
Задача: для имени файла в $fname установить расширение out независимо от его
предыдущего расширения.
Глава 22. Основы регулярных выражений в формате RegEx 309
Решение:
$fname=ereg_Replace(
'([[:alnum:]])(\\.[[:alnum:].]*)?$',
'\\1.out',
$fname
);
Обратите внимание на довольно интересную структуру этого выражения: мы не мо-
жем просто "привязать" его к концу строки при помощи $, что обусловлено
специфи-
кой работы RegEx. Мы также привязываем начало выражения к любой букве или
цифре, которой оканчивается имя файла.
Имя каталога и файла
Цель: разбить полное имя файла $path на имя каталога $dir и и имя файла $fname.
Средства:
$fname = ereg_Replace(".*[\\/]","",$path);
$dir = ereg_Replace("[\\/]?[^\\/]*$","",$path);
Проверка на идентификатор
Задача: проверить, является ли строка $id идентификатором, т. е. состоит ли она
ис-
ключительно из алфавитно-цифровых символов (чтобы сделать задачу более инте-
ресной, договоримся также, что первым символом строки не может быть цифра).
Решение:
if(eregi("[a-z_][[:alnum:]]*",$id)) echo "Это идентификатор!";
Модификация тэгов
Задача: в тексте, заданном в $text, у всех тэгов ]*src="?[[:alnum:]/\\]*)(\\.[[:alnum:]]*)?',
'\\1.jpg',
$text
);
Часть IV. Стандартные функции PHP 310
Преобразование гиперссылок
Задача: имеется текст, в котором иногда встречаются подстроки вида
протокол://URL, где протокол — один из протоколов http, ftp или gopher, а URL —
какой-нибудь адрес в Интернете. Нужно заместить их на HTML-эквиваленты … .
Решение:
$w="[:alnum:]";
$p="[:punct:]";
$text=eregi_Replace(
"((https?|ftp|gopher)://". // протокол
"[$w-]+(\\.[$w-]+)*". // имя хоста
"(/[$w+&.%]*(\\?[$w?+&%]*)?)?". // имя файла и параметры
")",
'\\1 ',
$text
);
Преобразование адресов E-mail
Задача: имеется текст, в котором иногда встречаются строки вида
пользователь@хост, т. е. E-mail-адреса в обычном формате (или хотя бы большин-
ство таких E-mail). Необходимо преобразовать их в HTML-ссылки.
Решение:
$text=eregi_Replace(
'([[:alnum:]-.]+@'. // пользователь
'[[:alnum:]-]+(\\.[[:alnum:]-]+)*'. // домен
'(\\?([[:alnum:]?+&%]*)?)?'. // необязательные параметры
')',
'\\1 ',
$text
);
Этот пример, хоть и не безупречен, но все же преобразует правильно львиную долю
адресов электронной почты.
Глава 22. Основы регулярных выражений в формате RegEx 311
Выделение всех уникальных
слов из текста
Задача: перед нами некоторый довольно длинный текст в переменной $text. Необ-
ходимо выделить из него все слова и оставить из них только уникальные.
Результат
должен быть представлен в виде списка, отсортированного в алфавитном порядке.
Решение этой задачи может потребоваться, например, при написании индексирующей
поисковой системы на PHP.
Решение: воспользуемся функцией split() и ассоциативным массивом.
Листинг 22.1. Отбор уникальных слов
// Эта функция выделяет из текста в $text все уникальные слова и
// возвращает их список, отсортированный в алфавитном порядке.
function GetUniques($text)
{ // Сначала получаем все слова в тексте
$Words=split("[[:punct:][:blank:]]+",$text);
$Uniq=array(); // список уникальных слов
$Test=array(); // хэш уже обработанных слов
// Проходимся по всем словам в $Words и заносим в $Uniq уникальные
foreach($Words as $v) {
$v=strtolower($v); // в нижний регистр
// Слово уже нам встречалось? Если нет, то занести в $Uniq
if(!@$Test[$v]) $Uniq[]=$v;
// Указать, что это слово уже обрабатывалось
$Test[$v]=1;
}
// Наконец, сортируем список
sort($Uniq);
return $Uniq;
}
Данный пример довольно интересен, т. к. он имеет довольно большую функциональ-
ность при небольшом объеме. Его "сердце" — функция split() и цикл перебора
слов с отбором уникальных. Мы используем алгоритм, основанный на применении
ассоциативного массива для отбора уникальных элементов. Как он работает — наде-
юсь, ясно из комментариев.
Теперь мы можем воспользоваться функцией из листинга 22.1, например, в таком
контексте:
$fname="sometext.txt";
Часть IV. Стандартные функции PHP 312
$f=fopen($fname,"r");
$text=fread($f,filesize($fname));
fclose($f);
$Uniq=GetUniques($text);
foreach($Uniq as $v) echo "$v ";
Интересно будет отметить, что функция preg_split(), которая работает с
регулярными выражениями в формате PCRE, и которую мы не рассматриваем
в этой книге, показывает гораздо лучшую производительность в этом примере,
чем split() — чуть ли не в 3 раза быстрее! Если вам нужна максимальная
производительность, пожалуй, будет лучше воспользоваться именно ей, но
прежде почитайте что-нибудь о Perl и его регулярных выражениях — напри-
мер, в замечательной книге Perl Cookbook Тома Кристиансена и Ната Торкинг-
тона (русское издание: "Библиотека программиста. Perl", издательство Питер,
2000).
Заключение
Конечно, можно придумать и еще множество примеров применения регулярных вы-
ражений. Вы наверняка сможете это сделать самостоятельно — особенно после неко-
торой практики, которая так важна для понимания этого материала.
Однако я хочу обратить ваше внимание на то, что во многих задачах как раз не
обя-
зательно применять регулярные выражения. Так, например, задачи "поставить слэш
перед всеми кавычками в строке" и "заменить в строке все кавычки на ""
мож-
но и нужно решать при помощи str_replace(), а не ereg_Replace() (это сущест-
венно — раз в 20 — повысит быстродействие). Не забывайте, что регулярное выра-
жение — некоторого рода "насилие" над компьютером, принуждение делать нечто
такое, для чего он мало приспособлен. Этим объясняется медлительность
механизмов
обработки регулярных выражений, экспоненциально возрастающая с ростом сложно-
сти шаблона.
Глава 23
Работа с изображениями
Как мы знаем, одним из самых важных достижений WWW по сравнению со всеми
остальными службами Интернета стала возможность представления в браузерах
пользователей мультимедиа-информации, а не только "сухого" текста. Основной
объ-
ем этой информации приходится, конечно же, на изображения.
Разумеется, было бы довольно расточительно хранить и передавать все рисунки в
обыкновенном растровом формате (наподобие BMP), тем более, что современные
алгоритмы сжатия позволяют упаковывать такого рода данные в сотни и более раз
эффективней. Чаще всего для хранения изображений используются три формата сжа-
тия с перечисленными ниже свойствами.
r JPEG. Идеален для фотографий, но сжатие изображения происходит с потерями
качества, так что этот формат совершенно не подходит для хранения различных
диаграмм и графиков.
r GIF. Позволяет достичь довольно хорошего соотношения размер/качество, в то же
время не искажая изображение; применяется в основном для хранения небольших
точечных рисунков и диаграмм.
r PNG. Сочетает в себе хорошие стороны как JPEG, так и GIF, но в настоящий мо-
мент ему почему-то не выражают особого доверия — скорее, по историческим
причинам, из-за нежелания отказываться от GIF и т. д.
В последнее время GIF все более вытесняется форматом PNG, что связано в первую
очередь с окончанием действия бесплатной лицензии изобретателя на его использо-
вание. К сожалению, для небольших изображений GIF все еще остается самым опти-
мальным форматом, оставляя позади (иногда далеко позади) PNG.
Зачем может понадобиться в Web-программировании работа с изображениями? Разве
это не работа дизайнера?
В большинстве случаев это действительно так. Однако есть и исключения, например,
графические счетчики (автоматически создаваемые картинки с отображаемым поверх
числом, которое увеличивается при каждом "заходе" пользователя на страницу),
или
же графики, которые пользователь может строить в реальном времени — скажем,
диаграммы сбыта продукции или снижения цен на комплектующие. Все эти прило-
жения требуют как минимум умения генерировать изображения "на лету", причем с
довольно большой скоростью. Чтобы этого добиться на PHP, можно применить два
способа: задействовать какую-нибудь внешнюю утилиту для формирования изобра-
Глава 23. Работа с изображениями 315
жения (например, известную программу fly), или же воспользоваться встроенными
функциями PHP для работы с графикой. Оба способа имеют как достоинства, так и
недостатки, но, пожалуй, недостатков меньше у второго метода, так что им-то мы
и
займемся в этой главе.
С недавнего времени все программные продукты, которые умели формировать изо-
бражения в формате GIF, переориентируются на PNG. В частности, не так давно
ком-
пания, поддерживающая библиотеку GD для работы с GIF-изображениями, перепи-
сала ее код с учетом формата PNG. Так как PHP использует эту библиотеку, то
поддержка GIF автоматически исключилась и из него. К счастью, в Интернете все
еще можно найти старые версии GD с поддержкой GIF и, таким образом, настроить
PHP для работы с этим форматом, но задумайтесь: стоит ли теперь применять GIF,
если весь мир вполне успешно переходит на PNG, тем более, что его поддерживают
практически все современные браузеры (четвертой версии) — а это 98% от исполь-
зуемого их числа...
Универсальная функция
GetImageSize()
Что же, работать с картинками приходится часто — гораздо чаще, чем может пока-
заться на первый взгляд. Среди наиболее распространенных операций можно особо
выделить одну — определение размера рисунка. Чтобы сделать программистам
"жизнь раем", разработчики PHP встроили в него функцию, которая работает
практи-
чески со всеми распространенными форматами изображений, в том числе с GIF,
JPEG и PNG.
list GetIimageSize(string $filename [,array& $imageinfo])
Эта функция предназначена для быстрого определения в сценарии размеров (в
пиксе-
лах) и формата рисунка, имя файла которого передано ей в первом параметре. Она
возвращает список из четырех элементов. Первый элемент (с ключом 0) хранит ши-
рину картинки в пикселах, второй (с ключом 1) — его высоту. Ячейка массива с
клю-
чом 2 определяется форматом изображения: 0, если это GIF, 1 в случае JPG и 2
для
PNG. Следующий элемент, имеющий ключ 3, будет содержать после вызова функции
строку примерно следующего вида: height=sx width=sy, где sx и sy — соответст-
венно ширина и высота изображения. Это применение задумывалось для того, чтобы
облегчить вставку данных о размере изображения в тэг
Но, согласитесь, следующий код куда элегантнее:
Старайтесь чаще пользоваться оператором @ и реже — установкой слабого контроля
ошибок.
Принудительное завершение
программы
void exit()
Эта функция немедленно завершает работу сценария. Из нее никогда не происходит
возврата. Перед окончанием программы вызываются функции-финализаторы, кото-
рые скоро будут нами рассмотрены.
void die(string $message)
Функция делает почти то же самое, что и exit(), только перед завершением работы
выводит строку, заданную в параметре $message. Чаще всего ее применяют, если
нужно напечатать сообщение об ошибке и аварийно завершить программу.
Полезным примером применения die() может служить такой код:
$filename='/path/to/data-file';
$file=fopen($filename, 'r') or die("не могу открыть файл $filename!");
Здесь мы ориентируемся на специфику оператора or — "выполнять" второй операнд
только тогда, когда первый "ложен". Мы уже встречались с этим приемом в главе,
посвященной работе с файлами. Заметьте, что оператор || здесь применять нельзя
—
он имеет более высокий приоритет, чем =. С использованием || последний пример
нужно было бы переписать следующим образом:
Часть IV. Стандартные функции PHP 338
$filename='/path/to/data-file';
($file=fopen($filename, 'r')) || die("не могу открыть файл $filename!");
Согласитесь, последнее практически полностью исключает возможность применения
|| в подобных конструкциях.
Финализаторы
Слава богу, разработчики PHP предусмотрели возможность указать в программе
функцию-финализатор, которая будет автоматически вызвана, как только работа
сце-
нария завершится — неважно, из-за ошибки или легально. В такой функции мы мо-
жем, например, записать информацию в кэш или обновить какой-нибудь файл жур-
нала работы программы. Что же нужно для этого сделать?
Во-первых, написать саму функцию и дать ей любое имя. Желательно также, чтобы
она была небольшой, и чтобы в ней не было ошибок, потому что сама функция,
впол-
не возможно, будет вызываться перед завершением сценария из-за ошибки. Во-
вторых зарегистрировать ее как финализатор, передав ее имя стандартной функции
Register_shutdown_function().
int Register_shutdown_function(string $func)
Регистрирует функцию с указанным именем с той целью, чтобы она автоматически
вызывалась перед возвратом из сценария. Функция будет вызвана как при окончании
программы, так и при вызовах exit() или die(), а также при фатальных ошибках,
приводящих к завершению сценария — например, при синтаксической ошибке.
Конечно, можно зарегистрировать несколько финальных функций, которые будут
вызываться в том же порядке, в котором они регистрировались.
Правда, есть одно "но". Финальная функция вызывается уже после закрытия
соедине-
ния с браузером клиента. Поэтому все данные, выведенные в ней через echo,
теряют-
ся (во всяком случае, так происходит в Unix-версии PHP, а под Windows
CGI-версия
PHP и echo работают прекрасно). Так что лучше не выводить никаких данных в та-
кой функции, а ограничиться работой с файлами и другими вызовами, которые ниче-
го не направляют в браузер.
Последнее обстоятельство, к сожалению, ограничивает функциональность финализа-
торов: им нельзя поручить, например, вывод окончания страницы, если сценарий по
каким-то причинам прервался из-за ошибки. Вообще говоря, надо заметить, что в
PHP никак нельзя в случае ошибки в некотором запущенном коде проделать какие-
либо разумные действия (кроме, разумеется, мгновенного выхода). Это несколько
может ограничивать область применимости PHP для написания шаблонизатора (о
шаблонах будет подробно рассказано в части V этой книги).
Глава 24. Управление интерпретатором 339
Генерация кода
во время выполнения
Так как PHP в действительности является транслирующим интерпретатором, в нем
заложены возможности по созданию и выполнению кода программы прямо во время
ее выполнения. То есть мы можем писать сценарии, которые в буквальном смысле
создают сами себя, точнее, свой код! Это незаменимо при написании
шаблонизаторов
и функций, занимающихся динамическим формированием писем. Мы поговорим о
таких функциях в части V книги.
Выполнение кода
int eval(string $code)
Эта функция делает довольно интересную вещь: она берет параметр $st и, рассмат-
ривая его как код программы на PHP, запускает. Если этот код возвратил какое-то
значение оператором return (как, например, это обычно делают функции), eval()
также вернет эту величину.
Параметр $st представляет собой обычную строку, содержащую участок PHP-
программы. То есть в ней может быть все, что допустимо в сценариях:
r ввод-вывод, в том числе закрытие и открытие тэгов ;
r управляющие инструкции: циклы, условные операторы и т. д.;
r объявления и вызовы функций;
r вложенные вызовы функции eval().
Тем не менее, нужно помнить несколько важных правил.
r Код в $st будет использовать те же самые глобальные переменные, что и вы-
звавшая программа. Таким образом, переменные не локализуются внутри
eval().
r Любая критическая ошибка (например, вызов неопределенной функции) в коде
строки $st приведет к завершению работы всего сценария (разумеется, сообще-
ние об ошибке также напечатается в браузер). Это значит, что мы не можем пере-
хватить все ошибки в коде, вставив его в eval().
Последний факт вызывает довольно удручающие мысли. К сожалению, разра-
ботчики PHP опять не задумались о том, как было бы удобно, если бы eval()
при ошибке в вызванном ей коде просто возвращала значение false, поме-
щая сообщение об ошибке в какую-нибудь переменную (как это сделано, на-
пример, в Perl).
Часть IV. Стандартные функции PHP 340
r Тем не менее, синтаксические ошибки и предупреждения, возникающие при
трансля-
ции кода в $st, не приводят к завершению работы сценария, а всего лишь вызывают
возврат из eval()значения ложь. Что ж, хоть кое-что.
Не забывайте, что переменные в строках, заключенных в двойные кавычки, в PHP
интерполируются (то есть заменяются на соответствующие значения). Это значит,
что, если мы хотим реже использовать обратные слэши для защиты символов-
кавычек, нужно стараться применять строки в апострофах для параметра,
передавае-
мого eval(). Например:
eval("$a=$b;"); // Неверно!
// Вы, видимо, хотели написать следующее:
eval("\$a=\$b");
// но короче будет так:
eval('$a=$b');
Возможно, вы спросите: зачем нам использовать eval(), если она занимается лишь
выполнением кода, который мы и так можем написать прямо в нужном месте про-
граммы? Например, следующий фрагмент
eval('for($i=0; $i<10; $i++) echo $i; ');
эквивалентен такому коду:
for($i=0; $i<10; $i++) echo $i;
Почему бы всегда не пользоваться последним фрагментом? Да, конечно, в нашем
примере лучше было бы так и поступить. Однако сила eval() заключается прежде
всего в том, что параметр $st может являться (и чаще всего является) не
статической
строковой константой, а сгенерированной переменной. Вот, например, как мы можем
создать 100 функций с именами Func1()...Func100(), которые будут печатать
квадраты первых 100 чисел:
Листинг 24.1. Генерация семейства функций
for($i=1; $i<=100; $i++)
eval("function Func$i() { return $i*$i; }");
Попробуйте-ка сделать это, не прибегая к услугам eval()!
Я уже говорил, что в случае ошибки (например, синтаксической) в коде, обрабаты-
ваемом eval(), сценарий завершает свою работу и выводит сообщение об ошибке в
браузер. Как обычно, сообщение сопровождается указанием того, в какой строке
про-
изошла ошибка, однако вместе с именем файла выдается уведомление, что програм-
ма оборвалась в функции eval(). Вот как, например, может выглядеть такое сооб-
щение:
Parse error: parse error in eval.php(4) : eval()'d code on line 1
Глава 24. Управление интерпретатором 341
Как видим, в круглых скобках после имени файла PHP печатает номер строки, в ко-
торой была вызвана сама функция eval(), а после "on line" — номер строки в
параметре eval() $st. Впрочем, мы никак не можем перехватить эту ошибку, по-
этому последнее нам не особенно-то интересно.
Давайте теперь в качестве тренировки напишем код, являющийся аналогом инструк-
ции include. Пусть нам нужно включить файл, имя которого хранится в $fname.
Вот как это будет выглядеть:
$code=join("",File($fname));
eval("?>$code c creri.carlnn. — переводим текущий контекст в режим восприятия
документа, чтобы eval() "осознала" статический текст верно. Мы еще неоднократно
столкнемся с этим приемом в будущем.
Генерация функций
В последнем примере мы рассмотрели, как можно создать 100 функций с разными
именами, написав программу длиной в 2 строчки. Это, конечно, впечатляет, но мы
должны жестко задавать имена функций. Почему бы не поручить эту работу PHP,
если нас не особо интересуют получающиеся имена?
Листинг 24.2. Генерация "анонимных" функций
$Funcs=array();
for($i=0; $i<=100; $i++) {
$id=uniqid("F");
eval("function $id() { return $i*$i; }");
$Funcs[]=$id;
}
Часть IV. Стандартные функции PHP 342
Теперь мы имеем список $Funcs, который содержит имена наших сгенерированных
функций. Как нам вызвать какую-либо из них? Это очень просто:
echo $Funcs[12](); // выводит 144
Однако мы могли бы написать с тем же результатом и
echo Func12();
при том условии, если бы воспользовались кодом генерации функций из листинга
24.1. Кажется, что так короче? Тогда не торопитесь. Все хорошо, если мы точно
зна-
ем, что надо вызвать 12-ю функцию, но как же быть, если номер хранится в
перемен-
ной — например, в $n? Вот решение:
echo $Funcs[$n](); // выводит результат работы $n-й функции
Не правда ли, просто? Выглядит явно лучше, чем такой код:
$F="Func$n";
$F();
Тут нам не удастся обойтись без временной переменной $F (вариант с допол-
нительной eval() тоже не подойдет, т. к. у функции могут быть строковые па-
раметры, и придется перед всеми кавычками ставить слэши, чтобы поместить
их в параметр функции eval().
Оказывается, в PHP версии 4 существует функция, которая поможет нам упростить
генерацию "анонимных" функций, подобных полученным в примере из листинга
24.2. Называется она create_function().
string create_function(string $args, string $code)
Создает функцию с уникальным именем, выполняющую действия, заданные в коде
$code (это строка, содержащая программу на PHP). Созданная функция будет при-
нимать параметры, перечисленные в $args. Перечисляются они в соответствии со
стандартным синтаксисом передачи параметров любой функции. Возвращаемое зна-
чение представляет собой уникальное имя функции, которая была сгенерирована.
Вот
несколько примеров:
$Mul=create_function('$a,$b', 'return $a*$b;');
$Neg=create_function('$a', 'return -$a;');
echo $Mul(10,20); // выводит 200
echo $Neg(2); // выводит -2
Не пропустите последнюю точку с запятой в конце строки, переданной вторым
параметром create_function()!
Глава 24. Управление интерпретатором 343
Давайте теперь перепишем наш пример из листинга 24.2 с учетом
create_function(). Это довольно несложно. Обратите внимание, насколько сокра-
тился код.
$Funcs=array();
for($i=0; $i<=100; $i++)
$Funcs[]=create_function("","return $i*$i;");
echo $Funcs[12](); // выводит 144
И последний пример применения анонимных функций — в программах сортировки с
использованием пользовательских функций:
$a=array("orange", "apple", "apricot", "lemon");
usort($a,create_function('$a,$b', 'return strcmp($a,$b);'));
foreach($a as $key=>$value) echo "$key: $valueСчетчик
В текущей сессии работы с браузером Вы открыли эту страницу
раз(а). Закройте браузер, чтобы обнулить счетчик.
Как видим, все предельно просто.
Идентификатор сессии
и имя группы
Что же, теперь мы уже можем начать писать кое-какие сценарии. Но вскоре возник-
нет небольшая проблема. Дело в том, что на одном и том же сайте могут
сосущество-
Глава 25. Управление сессиями 349
вать сразу несколько сценариев, которые нуждаются в услугах поддержки сессий
PHP. Они "ничего не знают" друг о друге, поэтому временные хранилища для сессий
должны выбираться не только на основе идентификатора пользователя, но и на
осно-
ве того, какой из сценариев запросил обслуживание сессии.
Имя группы сессий
Что, не совсем понятно? Хорошо, тогда рассмотрим пример. Пусть разработчик A
написал сценарий счетчика, приведенный в листинге 25.1. Он использует перемен-
ную $count, и не имеет никаких проблем. До тех пор, пока разработчик B, ничего
не
знающий о сценарии A, не создал систему статистики, которая тоже использует
сес-
сии. Самое ужасное, что он также регистрирует переменную $count, не зная о том,
что она уже "занята". В результате, как всегда, страдает пользователь: запустив
сна-
чала сценарий разработчика B, а потом — A, он видит, что данные счетчиков пере-
мешались. Непорядок!
Нам нужно как-то разграничить сессии, принадлежащие одному сценарию, от сессий,
принадлежащих другому. К счастью, разработчики PHP предусмотрели такое поло-
жение вещей. Мы можем давать группам сессий непересекающиеся имена, и сцена-
рий, знающий имя своей группы сессии, сможет получить к ней доступ. Вот
теперь-то
разработчики A и B могут оградить свои сценарии от проблем с пересечениями имен
переменных. Достаточно в первой программе указать PHP, что мы хотим использо-
вать группу с именем, скажем, sesA, а во второй — sesB.
string session_name([string $newname])
Эта функция устанавливает или возвращает имя группы сессии, которая будет ис-
пользоваться PHP для хранения зарегистрированных переменных. Если $newname не
задан, то возвращается текущее имя. Если же этот параметр указан, то имя группы
будет изменено на $newname, при этом функция вернет предыдущее имя.
Session_name() лишь сменяет имя текущей группы и сессии, но не создает
новую сессию и временное хранилище! Это значит, что мы должны в большин-
стве случаев вызывать session_name(имя_группы) еще до ее инициализа-
ции — вызова session_start(), в противном случае мы получим совсем не
то, что ожидали.
Если функция session_name() не была вызвана до инициализации, PHP будет ис-
пользовать имя по умолчанию — PHPSESID.
Кстати говоря, имя группы сессий, устанавливаемое рассматриваемой функ-
цией, — это как раз имя того самого Cookie, который посылается в браузер
клиента для его идентификации. Таким образом, пользователь может одно-
временно активизировать две и более сессий — с точки зрения PHP он будет
Часть IV. Стандартные функции PHP 350
менно активизировать две и более сессий — с точки зрения PHP он будет вы-
глядеть как два ли более различных пользователя. Однако не забывайте, что,
случайно установив в сценарии Cookie, имя которого совпадает с одним из
имен группы сессий, вы "затрете" Cookie.
Вот простой пример применения этой функции.
В текущей сессии Вы открыли эту страницу раз(а).
Рекомендую всегда указывать имя группы сессии вручную, не полагаясь на значение
по умолчанию. За это вам скажут спасибо разработчики других сценариев, когда
они
захотят использовать вашу программу вместе со своими.
Идентификатор сессии
Мы уже говорили с вами, зачем нужен идентификатор сессии (SID). Фактически, он
является именем временного хранилища, которое будет использовано для хранения
данных сессии между запусками сценария. Итак, один SID — одно хранилище. Нет
SID, нет и хранилища, и наоборот.
В этом месте очень легко запутаться. В самом деле, как же соотносится
идентифика-
тор сессии и имя группы? А вот как: имя — это всего лишь собирательное название
для нескольких сессий (то есть, для многих SID), запущенных разными пользовате-
лями. Один и тот же клиент никогда не будет иметь два различных SID в пределах
одного имени группы. Но его браузер вполне может работать (и часто работает) с
не-
сколькими SID, расположенными логически в разных "пространствах имен".
Итак, все SID уникальны и однозначно определяют сессию на компьютере, выпол-
няющем сценарий — независимо от имени сессии. Имя же задает "пространство
имен", в которое будут сгруппированы сессии, запущенные разными пользователями.
Один клиент может иметь сразу несколько активных пространств имен (то есть не-
сколько имен групп сессий).
string session_id([string $sid])
Функция возвращает текущий идентификатор сессии SID. Если задан параметр $sid,
то у активной сессии изменяется идентификатор на $sid. Делать это, вообще
говоря,
не рекомендуется.
Фактически, вызвав session_id() до session_start(), мы можем подключиться
к любой (в том числе и к "чужой") сессии на сервере, если знаем ее
идентификатор.
Глава 25. Управление сессиями 351
Мы можем также создать сессию с угодным нам идентификатором, при этом автома-
тически установив его в Cookies пользователя. Но это — не лучшее решение, —
предпочтительнее переложить всю "грязную работу" на PHP.
Другие функции
Здесь мы для полноты картины рассмотрим функции для работы с сессиями, которые
применяются гораздо реже, чем уже описанные.
bool session_is_registered(string $name)
Функция session_is_registered() возвращает значение true, если переменная с
именем $name была зарегистрирована в сессии, иначе возвращается false.
bool session_unregister(struing $name)
Эта функция отменяет регистрацию для переменной с именем $name для текущей
сессии. Иными словами, при завершении сценария все будет выглядеть так, словно
переменная с именем $name и не была никогда зарегистрирована. Возвращает true,
если все прошло успешно, и false — в противном случае.
После вызова функции session_unregister() глобальная переменная, ко-
торая была "аннулирована", не уничтожается, а сохраняет свое значение.
void session_unset()
Функция session_unset(), в отличие от session_unregister(), не только отме-
няет регистрацию переменных (кстати говоря, всех переменных сессии, а не
какой-то
одной), но и уничтожает глобальные переменные, которые были зарегистрированы в
сессии.
string session_save_path([string $path])
Эта функция возвращает имя каталога, в котором будут помещаться файлы — вре-
менные хранилища данных сессии. В случае, если указан параметр, как обычно, ак-
тивное имя каталога будет переустановлено на $path. При этом функция вернет
пре-
дыдущий каталог.
К сожалению, функции, которая бы возвращала список всех зарегистрированных в
сессии переменных, почему-то нет. Во всяком случае, в PHP версии 4.0.3.
Установка обработчиков сессии
До сих пор мы с вами пользовались стандартными обработчиками сессии, которые
PHP использовал каждый раз, когда нужно было сохранить или загрузить данные из
временного хранилища. Возможно, они вас не устроят — например, вы захотите хра-
Часть IV. Стандартные функции PHP 352
нить переменные сессии в базе данных или еще где-то. В этом случае достаточно
бу-
дет переопределить обработчики своими собственными функциями, и вот как оно
делается.
Обзор обработчиков
Всего существует 6 функций, связанных с сессиями, которые PHP вызывает в тот
или
иной момент работы механизма обработки сессий. Им передаются различные пара-
метры, необходимые для работы. Сейчас я перечислю все эти функции вместе с их
описаниями.
bool handler_open(string $save_path, string $session_name)
Функция вызывается, когда вызывается session_start(). Обработчик должен
взять на себя всю работу, связанную с открытием базы данных для группы сессий с
именем $session_name. В параметре $save_path передается то, что было указано
при вызове session_save_path() или же путь к файлам-хранилищам данных сес-
сий по умолчанию. Возможно, если вы используете базу данных, этот параметр
будет
бесполезным.
bool handler_close()
Этот обработчик вызывается, когда данные сессии уже записаны во временное хра-
нилище и его нужно закрыть.
string handler_read(string $sid)
Вызов обработчика происходит, когда нужно прочитать данные сессии с идентифика-
тором $sid из временного хранилища. Функция должна возвращать данные сессии в
специальном формате, который выглядит так:
имя1=значение1;имя2=значение2;имя3=значение3;...;
Здесь имяN задает имя очередной переменной, зарегистрированной в сессии, а
значениеN — результат вызова функции Serialize() для значения этой перемен-
ной. Например, запись может иметь следующий вид:
foo|i:1;count|i:10;
Она говорит о том, что из временного хранилища были прочитаны две целые пере-
менные, первая из которых равна 1, а вторая — 10.
string handler_write(string $sid, string $data)
Этот обработчик предназначен для записи данных сессии с идентификатором $sid во
временное хранилище — например, открытое ранее обработчиком handler_open().
Параметр $data задается в точно таком же формате, который был описан выше.
Фактически, чаще всего действия этой функции сводятся к записи в базу данных
строки $data без каких-либо ее изменений.
bool handler_destroy(string $sid)
Глава 25. Управление сессиями 353
Обработчик вызывается, когда сессия с идентификатором $sid должна быть уничто-
жена.
bool handler_gc(int $maxlifetime)
Данный обработчик — особенный. Он вызывается каждый раз при завершении рабо-
ты сценария. Если пользователь окончательно "покинул" сервер, значит, данные
сес-
сии во временном хранилище можно уничтожить. Этим и должна заниматься функ-
ция handler_gc(). Ей передается в параметрах то время (в секундах), по
прошествии которого PHP принимает решение о необходимости "почистить перыш-
ки", или "собрать мусор" (garbage collection) — т. е., это максимальное время
сущест-
вования сессии.
Как же должна работать рассматриваемая функция? Очень просто. Например, если
мы храним данные сессии в базе данных, мы просто должны удалить из нее все
запи-
си, доступ к которым не осуществлялся более, чем $maxlifetime секунд. Таким об-
разом, "застарелые" временные хранилища будут иногда очищаться.
На самом деле обработчик handler_gc() вызывается не при каждом запуске
сценария, а только изредка. Когда именно — определяется конфигурационным
параметром session.gc_probability. А именно, им задается (в процен-
тах), какова вероятность того, что при очередном запуске сценария будет вы-
бран обработчик "чистки мусора". Сделано это для улучшения производитель-
ности сервера, потому что обычно сборка мусора — довольно ресурсоемкая
задача, особенно если сессий много.
Регистрация обработчиков
Вы, наверное, обратили внимание, что при описании обработчиков я указывал их
имена с префиксом handler. На самом деле, это совсем не является обязательным.
Даже наоборот — вы можете давать такие имена своим обработчикам, какие только
захотите.
Но возникает вопрос: как же тогда PHP их найдет? Вот для этого и существует
функ-
ция регистрации обработчиков, которая говорит интерпретатору, какую функцию он
должен вызывать при наступлении того или иного события.
void session_set_save_handler($open,$close,$read,$write,$destroy,$gc)
Эта функция регистрирует подпрограммы, имена которых переданы в ее параметрах,
как обработчики текущей сессии. Параметр $open содержит имя функции, которая
будет вызвана при инициализации сессии, а $close — функции, вызываемой при ее
закрытии. В $read и $write нужно указать имена обработчиков, соответственно,
для чтения и записи во временное хранилище. Функция с именем, заданным в
Часть IV. Стандартные функции PHP 354
$destroy, будет вызвана при уничтожении сессии. Наконец, обработчик, определяе-
мый параметром $gc, используется как сборщик мусора.
Эту функцию можно вызывать только до инициализации сессии, в противном случае
она просто игнорируется.
Пример: переопределение обработчиков
Давайте напишем пример, который бы иллюстрировал механизм переопределения
обработчиков. Мы будем держать временные хранилища сессий в подкаталоге
sessiondata текущего каталога, и для каждого имени группы сессий создавать от-
дельный каталог.
Код листинга 25.2 довольно велик, но не сложен. Тут уж ничего не поделаешь —
нам
в любом случае приходится задавать все 6 обработчиков, а это выливается в
"объе-
мистые" описания.
Листинг 25.2. Переопределение обработчиков сессии
=$maxlifetime) {
@unlink($fname);
continue;
}
// Нашли не очень старый файл — значит, каталог точно
Часть IV. Стандартные функции PHP 356
// не будет в результате работы пуст.
$DelDir=0;
}
closedir($d);
// Если все файлы оказались слишком старые и удалены,
// удалить и каталог
if($DelDir) @rmdir($dir);
return true;
}
// Регистрируем наши новые обработчики
session_set_save_handler(
"ses_open", "ses_close",
"ses_read", "ses_write",
"ses_destroy", "ses_gc"
);
// Для примера подключаемся к группе сессий test
session_name("test");
session_start();
session_register("count");
// Дальше как обычно...
$count=@$count+1;
?>
Счетчик
В текущей сессии работы с браузером Вы открыли эту страницу
раз(а). Закройте браузер, чтобы обнулить этот счетчик.
Сессии и Cookies
До сих пор я подразумевал, что использование сессий немыслимо без Cookies.
Дейст-
вительно, Cookies представляют собой наиболее элегантное и простое решение
задачи
идентификации каждого подключившегося пользователя, что необходимо для связи
временного хранилища и данных сессии. Но как быть, если пользователи отключили
Cookies в своих браузерах?
Глава 25. Управление сессиями 357
К сожалению, пользователи отключают Cookies гораздо чаще, чем это может
показаться на первый взгляд. Например, всего год назад Всероссийский Клуб
Вебмастеров проводил опрос, в результате которого выяснилось, что количе-
ство пользователей Интернета, отключивших у себя по каким-то соображениям
поддержку Cookies, достигает 20—30%. Что это за соображения? Многие ду-
мают, что Cookies потенциально являются "дырой" в безопасности их компью-
тера. Это совершенно не соответствует действительности, потому что браузе-
ры всегда имеют ограничения на количество и суммарный объем Cookies,
которые могут быть в них установлены. Другие же просто не хотят, чтобы неиз-
вестно кто писал что угодно на их жесткий диск. Правда, это не мешает таким
"перестраховщикам" открывать пришедший по почте исполняемый файл — та-
кой же, как из письма типа "Love letter"…
В общем, вы видите, что для абсолютной уверенности в работоспособности ваших
сценариев на любом браузере нужен механизм, позволяющий отказаться от исполь-
зования Cookies при управлении сессиями. Такой механизм действительно
существует в PHP, и основная его идея состоит в том, чтобы передавать
идентификатор сессии не в Cookies, а каким-нибудь аналогичным путем — например,
в данных запроса GET. Последнее мы сейчас и рассмотрим.
Явное использование
константы SID
В PHP существует одна специальная константа с именем SID. Она всегда содержит
имя группы текущей сессии и ее идентификатор в формате имя=идентификатор.
Вспомните: именно в таком формате данные принимаются, когда они приходят из
Cookies браузера. Таким образом, нам достаточно просто-напросто передать
значение
константы SID в сценарий, чтобы он "подумал", будто бы данные пришли из Cookies.
Вот пример:
Листинг 25.3. Sesget.php: простой пример использования сессий без Cookies
Счетчик
В текущей сессии работы с браузером Вы открыли эту страницу
Часть IV. Стандартные функции PHP 358
раз(а). Закройте браузер, чтобы обнулить этот счетчик.>Click here!
Если набрать в браузере адрес вроде такого:
http://www.somehost.ru/sesget.php
то создастся новая сессия с уникальным идентификатором. Разумеется, если сразу
же
нажать кнопку Обновить, счетчик не увеличится, потому что при каждом запуске
будет создаваться новое временное хранилище — у PHP просто нет информации об
идентификаторе пользователя. Теперь обратите внимание на предпоследнюю строчку
листинга 25.3. Видите, как хитро мы передаем в сценарий, запускаемый через
гипер-
ссылку, данные об идентификаторе текущей сессии? Теперь с его точки зрения они
якобы пришли из Cookies…
Все будет работать так, как описано, только в том случае, если в браузере
действительно отключены Cookies. Если же они включены, PHP просто не бу-
дет генерировать константу SID (она будет пустой) и задействует Cookies. Все
вполне логично.
Неявное изменение гиперссылок
Похоже, что вы уже начали думать о том, как же это все-таки неудобно — везде
вставлять участки кода , и, пропусти вы их в одном месте, придется
долго
искать ошибку? Что же, законный повод для беспокойства, но, к счастью,
разработ-
чики PHP уберегли нас и от этой напасти.
Вы не поверите, но, если в какой-нибудь гипессылке вы по ошибке пропустите
, PHP вставит его за вас автоматически. Причем так, чтобы это никак не
повредило другим параметрам, возможно, уже присутствующим в URL. Если вы в
шоке, то запустите следующий сценарий в браузере, а затем наведите мышь на
гипер-
ссылку и посмотрите в строке состояния, какой адрес имеет ссылка:
Click here! Click here! Click here! 
