<sect1 id="zend.cache.frontends">
    <title>Фронтэнды Zend_Cache</title>

    <sect2 id="zend.cache.frontends.core">
        <title><code>Zend_Cache_Core</code></title>
        <sect3 id="zend.cache.frontends.core.introduction">
            <title>Введение</title>
            <para>
                Фронтэнд <code>Zend_Cache_Core</code> является особым,
                так как это ядро всего модуля. Это фронтэнд общего назначения и
                он расширяется другими классами.
            </para>
            <note>
                <para>
                    Все фронтэнды наследуют от класса
                    <code>Zend_Cache_Core</code>, поэтому его методы и опции,
                    описанные ниже, должны быть доступны в других фронтэндах и
                    не будут описываться далее.
                </para>
            </note>
        </sect3>
        <sect3 id="zend.cache.frontends.core.options">
            <title>Доступные опции</title>
            <para>
                Эти опции передаются фабричному методу, как было показано в
                предыдущих примерах.
            </para>
            <table id="zend.cache.frontends.core.options.table">
                <title>Опции <code>Zend_Cache_Core</code></title>
                <tgroup cols="4">
                     <thead>
                          <row>
                            <entry>Опция</entry>
                            <entry>Тип данных</entry>
                            <entry>Значение по умолчанию</entry>
                            <entry>Описание</entry>
                        </row>
                     </thead>
                     <tbody>
                          <row>
                              <entry><code>caching</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>true</code></entry>
                              <entry>
                                  Включает/отключает кэширование (может быть
                                  очень полезным при отладке кэшируемых
                                  скриптов).
                              </entry>
                          </row>
                          <row>
                              <entry><code>cache_id_prefix</code></entry>
                              <entry><code>string</code></entry>
                              <entry><code>null</code></entry>
                              <entry>
                                  Префикс для всех идентификаторов кэша. Если
                                  установлен в <code>null</code>, то префикс не
                                  будет использоваться. Префикс идентификатора
                                  кэша в первую очередь создает пространство
                                  имен в кэше, что позволяет нескольким
                                  приложениям или веб-сайтам использовать общий
                                  кэш. Любое приложение или веб-сайт может
                                  использовать свой префикс идентификаторов
                                  кэша, благодаря чему отдельные идентификаторы
                                  кеша могут использоваться многократно.
                              </entry>
                          </row>
                          <row>
                              <entry><code>lifetime</code></entry>
                              <entry><code>int</code></entry>
                              <entry><code>3600</code></entry>
                              <entry>
                                Время жизни кэша (в секундах), если установлен в
                                <code>null</code>, то кэш имеет бесконечное
                                время жизни.
                              </entry>
                          </row>
                          <row>
                              <entry><code>logging</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>false</code></entry>
                              <entry>
                                 Если установлен в <code>true</code>, то
                                 включается логирование через
                                 <code>Zend_Log</code> (но система будет
                                 работать медленнее).
                              </entry>
                          </row>
                          <row>
                              <entry><code>write_сontrol</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>true</code></entry>
                              <entry>
                                Включает/отключает контроль записи (кэш
                                читается сразу после записи для выявления
                                поврежденных записей), включение write_control
                                немного замедлит запись кэша, но не чтение. Этот
                                контроль поможет выявить некоторые поврежденные
                                файлы кэша, но не является совершенным.
                              </entry>
                          </row>
                          <row>
                              <entry><code>automatic_serialization</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>false</code></entry>
                              <entry>
                                Включает/отключает автоматическую
                                сериализацию, она может использоваться для
                                сохранения напрямую данных, которые не являются
                                строками (но это будет медленнее).
                              </entry>
                          </row>
                          <row>
                              <entry><code>automatic_cleaning_factor</code></entry>
                              <entry><code>int</code></entry>
                              <entry><code>10</code></entry>
                              <entry>
                                Отключает/настраивает процесс автоматической
                                очистки (сборки мусора):
                                <code>0</code> означает, что автоматическая
                                чистка кэша не производится,
                                <code>1</code> означает систематическую очистку
                                кэша,
                                <code>x (integer) &gt; 1</code> означает, что
                                автоматическая чистка производится случайным
                                образом 1 раз на x записей кэша.
                              </entry>
                          </row>
                          <row>
                              <entry><code>ignore_user_abort</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>false</code></entry>
                              <entry>
                                  Если установлен в true, то ядро будет
                                  устанавливать флаг ignore_user_abort в методе
                                  save() во избежание порчи кэша в некоторых
                                  случаях.
                              </entry>
                          </row>
                      </tbody>
                  </tgroup>
              </table>
        </sect3>

        <sect3 id="zend.cache.core.examples">
            <title>Примеры</title>
            <para>
                Пример был дан в самом начале данного раздела руководства.
            </para>
            <para>
                Если вы храните в кэше только строки (с опцией
                <code>automatic_serialization</code> возможно хранить некоторые
                булевы значения), вы можете использовать более компактную
                конструкцию, как показано ниже:
            </para>
            <programlisting role="php"><![CDATA[
// предполагается, что переменная $cache уже установлена

$id = 'myBigLoop'; // идентификатор того, что мы хотим закэшировать

if (!($data = $cache->load($id))) {
    // промах кэша

    $data = '';
    for ($i = 0; $i < 10000; $i++) {
        $data = $data . $i;
    }

    $cache->save($data);

}

// [...] делаем что-либо с данными (отображение, передача и т.д.)
]]>
            </programlisting>
            <para>
                Если вы хотите закэшировать несколько блоков или экземпляров
                данных, то принцип будет тот же:
            </para>
            <programlisting role="php"><![CDATA[
// убедитесь, что используете уникальные идентификаторы:
$id1 = 'foo';
$id2 = 'bar';

// блок 1
if (!($data = $cache->load($id1))) {
    // промах кэша

    $data = '';
    for ($i=0;$i<10000;$i++) {
        $data = $data . $i;
    }

    $cache->save($data);

}
echo($data);

// эта часть не кэшируется
echo('НЕ КЭШИРУЕТСЯ! ');

// блок 2
if (!($data = $cache->load($id2))) {
    // промах кэша

    $data = '';
    for ($i=0;$i<10000;$i++) {
        $data = $data . '!';
    }

    $cache->save($data);

}
echo($data);]]>
            </programlisting>
            <para>
                Если вы хотите кэшировать специальные значения (булево
                значение через опцию "automatic_serialization") или пустую
                строку, то компактная форма, приведенная выше, уже не
                подходит. Проверка на наличие записи кэша должна производиться
                созданным для этого методом.
            </para>
            <programlisting role="php"><![CDATA[
// Копмпактная форма. Не подходит, если могут кэшироваться
// пустые строки и значения булевого типа
if (!($data = $cache->load($id))) {

    // промах кэша

    // [...] получаем данные и присваиваем их переменной $data

    $cache->save($data);

}

// делаем что-либо с данными

// [...]

// Полная форма, будет работать в любом случае
if (!($cache->test($id))) {

    // промах кэша

    // [...] получаем данные и присваиваем их переменной $data

    $cache->save($data);

} else {

    // попадание в кэш

    $data = $cache->load($id);

}

// делаем что-либо с данными
]]>
            </programlisting>
        </sect3>
    </sect2>

    <sect2 id="zend.cache.frontends.output">
        <title><code>Zend_Cache_Frontend_Output</code></title>
        <sect3 id="zend.cache.frontends.output.introduction">
            <title>Введение</title>
            <para>
                <code>Zend_Cache_Frontend_Output</code> является фронтэндом,
                собирающим выходные данные. Он использует буферизацию вывода
                (output buffering) в PHP для сохранения всего, что выводится
                между его методами <code>start()</code> и <code>end()</code>.
            </para>
        </sect3>
        <sect3 id="zend.cache.frontends.output.options">
            <title>Доступные опции</title>
            <para>
                Этот фронтэнд не имеет каких-либо специальных опций, отличных
                от опций <code>Zend_Cache_Core</code>.
            </para>
        </sect3>

        <sect3 id="zend.cache.frontends.output.examples">
            <title>Примеры</title>
            <para>
                Пример был дан в самом начале данного руководства. Здесь
                он с небольшими изменениями:
            </para>
            <programlisting role="php"><![CDATA[
// если имеет место промах кэша,
// то начинается буферизация вывода
if (!($cache->start('mypage'))) {

    // все выводится, как обычно
    echo 'Hello world! ';
    echo 'This is cached ('.time().') ';

    $cache->end(); // завершение буферизации вывода

}

echo 'This is never cached ('.time().').';
]]>
            </programlisting>
            <para>
                Используя эту форму, довольно легко установить кэширование
                вывода в уже работающем проекте с незначительным рефакторингом
                кода или совсем без него.
            </para>
        </sect3>
    </sect2>

    <sect2 id="zend.cache.frontends.function">
        <title><code>Zend_Cache_Frontend_Function</code></title>
        <sect3 id="zend.cache.frontends.function.introduction">
            <title>Введение</title>
            <para>
                <code>Zend_Cache_Frontend_Function</code> сохраняет в кэш
                результаты вызова функции. Он имеет единственный основной метод
                <code>call()</code>, который принимает имя функции и параметры
                вызова в виде массива.
            </para>
        </sect3>
        <sect3 id="zend.cache.frontends.function.options">
            <title>Доступные опции</title>
            <table id="zend.cache.frontends.function.options.table">
                <title>Опции <code>Zend_Cache_Frontend_Function</code></title>
                <tgroup cols="4">
                     <thead>
                          <row>
                            <entry>Опция</entry>
                            <entry>Тип данных</entry>
                            <entry>Значение по умолчанию</entry>
                            <entry>Описание</entry>
                        </row>
                     </thead>
                     <tbody>
                          <row>
                              <entry><code>cache_by_default</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>true</code></entry>
                              <entry>
                                  Если равен true, то вызовы функции по
                                  умолчанию кэшируются.
                              </entry>
                         </row>
                         <row>
                              <entry><code>cached_functions</code></entry>
                              <entry><code>array</code></entry>
                              <entry></entry>
                              <entry>
                                  Имена функций, которые всегда кэшируются.
                              </entry>
                         </row>
                         <row>
                              <entry><code>non_cached_functions</code></entry>
                              <entry><code>array</code></entry>
                              <entry></entry>
                              <entry>
                                  Имена функций, которые никогда не должны
                                  кэшироваться.
                              </entry>
                         </row>
                      </tbody>
                  </tgroup>
              </table>
        </sect3>

        <sect3 id="zend.cache.frontends.function.examples">
            <title>Примеры</title>
            <para>
                Функция <code>call()</code> используется так же, как и
                <code>call_user_func_array()</code> в PHP:
            </para>
            <programlisting role="php"><![CDATA[
$cache->call('veryExpensiveFunc', $params);

// $params является массивом
// Например, если нужно вызвать с кэшированием
// veryExpensiveFunc(1, 'foo', 'bar'),
// то вы должны использовать
// $cache->call('veryExpensiveFunc', array(1, 'foo', 'bar'))
]]>
            </programlisting>
            <para>
                <code>Zend_Cache_Frontend_Function</code> достаточно
                интеллектуален, чтобы кэшировать как возвращаемое функцией
                значение, так и данные, выводимые внутри нее.
            </para>
            <note>
                <para>
                    Вы можете передавать любые как встроенные, так и
                    определенные пользователем функции, за исключением
                    <code>array()</code>,
                    <code>echo()</code>, <code>empty()</code>,
                    <code>eval()</code>, <code>exit()</code>,
                    <code>isset()</code>, <code>list()</code>,
                    <code>print()</code> и <code>unset()</code>.
                </para>
            </note>
        </sect3>
    </sect2>

    <sect2 id="zend.cache.frontends.class">
        <title><code>Zend_Cache_Frontend_Class</code></title>
        <sect3 id="zend.cache.frontends.class.introduction">
            <title>Введение</title>
            <para>
                <code>Zend_Cache_Frontend_Class</code> отличается от
                <code>Zend_Cache_Frontend_Function</code> тем, что позволяет
                кэшировать объекты и статические вызовы методов.
            </para>
        </sect3>
        <sect3 id="zend.cache.frontends.class.options">
            <title>Доступные опции</title>
            <table id="zend.cache.frontends.class.options.table">
                <title>Опции <code>Zend_Cache_Frontend_Class</code></title>
                <tgroup cols="4">
                     <thead>
                          <row>
                            <entry>Опция</entry>
                            <entry>Тип данных</entry>
                            <entry>Значение по умолчанию</entry>
                            <entry>Описание</entry>
                        </row>
                     </thead>
                     <tbody>
                          <row>
                              <entry><code>cached_entity</code> (required)</entry>
                              <entry><code>mixed</code></entry>
                              <entry></entry>
                              <entry>
                                  Если установлен как имя класса, то будет
                                  кэшироваться абстрактный класс и будут
                                  использоваться только статические вызовы; если
                                  установлен как объект,
                                  то будут кэшироваться методы объекта.
                              </entry>
                         </row>
                         <row>
                              <entry><code>cache_by_default</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>true</code></entry>
                              <entry>
                                  Если установлен в <code>true</code>, то вызовы
                                  будут кэшироваться по умолчанию.
                              </entry>
                         </row>
                         <row>
                              <entry><code>cached_methods</code></entry>
                              <entry><code>array</code></entry>
                              <entry></entry>
                              <entry>
                                  Имена методов, которые должны всегда
                                  кэшироваться.
                              </entry>
                         </row>
                         <row>
                              <entry><code>non_cached_methods</code></entry>
                              <entry><code>array</code></entry>
                              <entry></entry>
                              <entry>
                                  Имена методов, которые никогда не должны
                                  кэшироваться.
                              </entry>
                         </row>
                      </tbody>
                  </tgroup>
              </table>
        </sect3>

        <sect3 id="zend.cache.frontends.class.examples">
            <title>Примеры</title>
            <para>
                Кэширование статических вызовов:
            </para>
            <programlisting role="php"><![CDATA[<?php
class Test {

    // Статический метод
    public static function foobar($param1, $param2) {
        echo "foobar_output($param1, $param2)";
        return "foobar_return($param1, $param2)";
    }

}

// [...]
$frontendOptions = array(
    'cached_entity' => 'Test' // имя класса
);
// [...]

// Кэшируемый вызов
$result = $cache->foobar('1', '2');
]]>
            </programlisting>
            <para>
                Кэширование обычных вызовов методов:
            </para>
            <programlisting role="php"><![CDATA[
class Test {

    private $_string = 'hello !';

    public function foobar2($param1, $param2) {
        echo($this->_string);
        echo "foobar2_output($param1, $param2)";
        return "foobar2_return($param1, $param2)";
    }

}

// [...]
$frontendOptions = array(
    'cached_entity' => new Test() // экземпляр класса
);
// [...]

// Кэшируемый вызов
$result = $cache->foobar2('1', '2');
]]>
            </programlisting>
        </sect3>
    </sect2>

    <sect2 id="zend.cache.frontends.file">
        <title><code>Zend_Cache_Frontend_File</code></title>
        <sect3 id="zend.cache.frontends.file.introduction">
            <title>Введение</title>
            <para>
                <code>Zend_Cache_Frontend_File</code> является фронтэндом,
                который управляется временем изменения "ведущего файла".
                Он очень полезен для кэширования конфигураций или шаблонов.
                Можно использовать несколько ведущих файлов.
            </para>
            <para>
                Например, у вас есть конфигурационный файл XML. Он парсится
                функцией, которая возвращает объект конфигурации
                (наподобие <code>Zend_Config</code>). С помощью
                <code>Zend_Cache_Frontend_File</code> вы можете сохранять объект
                конфигурации в кэш, чтобы избежать повторного парсинга
                конфигурационного файла XML. Время жизни кэша будет зависеть
                от ведущего файла - если конфигурационный
                файл XML изменится, то кэш сразу становится недействительным.
            </para>
        </sect3>
        <sect3 id="zend.cache.frontends.file.options">
            <title>Доступные опции</title>
            <table id="zend.cache.frontends.file.options.table">
                <title>Опции <code>Zend_Cache_Frontend_File</code></title>
                <tgroup cols="4">
                     <thead>
                          <row>
                            <entry>Опция</entry>
                            <entry>Тип данных</entry>
                            <entry>Значение по умолчанию</entry>
                            <entry>Описание</entry>
                        </row>
                     </thead>
                     <tbody>
                          <row>
                              <entry><code>master_file</code> (не рекомендуется к использованию)</entry>
                              <entry><code>string</code></entry>
                              <entry><code></code></entry>
                              <entry>
                                  Полные путь и имя ведущего файла
                              </entry>
                         </row>
                         <row>
                              <entry><code>master_files</code></entry>
                              <entry><code>array</code></entry>
                              <entry><code></code></entry>
                              <entry>
                                  Массив полных путей к ведущим файлам
                              </entry>
                         </row>
                         <row>
                              <entry><code>master_files_mode</code></entry>
                              <entry><code>string</code></entry>
                              <entry><code>Zend_Cache_Frontend_File::MODE_OR</code></entry>
                              <entry>
                                  <code>Zend_Cache_Frontend_File::MODE_AND</code> или <code>Zend_Cache_Frontend_File::MODE_OR</code>;
                                  если <code>MODE_AND</code>, то все ведущие файлы должны быть изменены для того, чтобы кэш стал недействительным
                                  если <code>MODE_OR</code>, то достаточно изменения одного ведущего файла, чтобы кэш стал недействительным
                              </entry>
                         </row>
                         <row>
                              <entry><code>ignore_missing_master_files</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>false</code></entry>
                              <entry>
                                  если равен <code>true</code>, то отсутствующие
                                  ведущие файлы игнорируются, иначе бросается
                                  исключение
                              </entry>
                         </row>
                      </tbody>
                  </tgroup>
              </table>
        </sect3>
        <sect3 id="zend.cache.frontends.file.examples">
            <title>Примеры</title>
            <para>
                Этот фронтэнд используется так же, как и
                <code>Zend_Cache_Core</code>. Специальные примеры не нужны,
                единственное, что надо сделать — это указать
                <code>masterFile</code> при использовании фабрики.
            </para>
        </sect3>
    </sect2>

    <sect2 id="zend.cache.frontends.page">
        <title><code>Zend_Cache_Frontend_Page</code></title>
        <sect3 id="zend.cache.frontends.page.introduction">
            <title>Введение</title>
            <para>
                <code>Zend_Cache_Frontend_Page</code> похож на
                <code>Zend_Cache_Frontend_Output</code>,
                но предназначена для кэширования целых страниц.
                <code>Zend_Cache_Frontend_Page</code>
                нельзя использовать для кэширования отдельных блоков.
            </para>
            <para>
                Идентификатор кэша вычисляется автоматически
                с использованием <code>$_SERVER['REQUEST_URI']</code> и
                (в зависимости от опций) <code>$_GET</code>,
                <code>$_POST</code>, <code>$_SESSION</code>,
                <code>$_COOKIE</code>, <code>$_FILES</code>.
                Кроме этого, вы используете только один метод для вызова
                (<code>start()</code>), потому что <code>end()</code> вызывается
                автоматически, когда страница заканчивается.
            </para>
            <para>
                На данный момент мы планируем добавить условную систему HTTP для
                сохранения пропускной способности (система будет отправлять
                HTTP 304 Not Modified, если есть попадание в кэш и броузер уже
                имеет правильную версию страницы).
            </para>
        </sect3>
        <sect3 id="zend.cache.frontends.page.options">
            <title>Доступные опции</title>
            <table id="zend.cache.frontends.page.options.table">
                <title>Опции <code>Zend_Cache_Frontend_Page</code></title>
                <tgroup cols="4">
                     <thead>
                          <row>
                            <entry>Опция</entry>
                            <entry>Тип данных</entry>
                            <entry>Значение по умолчанию</entry>
                            <entry>Описание</entry>
                        </row>
                     </thead>
                     <tbody>
                          <row>
                              <entry><code>http_conditional</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>false</code></entry>
                              <entry>
                                  Использовать условную систему HTTP (не
                                  реализовано на данный момент)
                              </entry>
                         </row>
                         <row>
                              <entry><code>debug_header</code></entry>
                              <entry><code>boolean</code></entry>
                              <entry><code>false</code></entry>
                              <entry>
                                  Если установлен в <code>true</code>, то
                                  отладочный текст вставляется перед каждой
                                  кэшируемой страницей.
                              </entry>
                         </row>
                         <row>
                              <entry><code>default_options</code></entry>
                              <entry><code>array</code></entry>
                              <entry><code>array(...смотрите далее...)</code></entry>
                              <entry>
                                  Ассоциативный массив опций, включаемых по
                                  умолчанию:
                                  <itemizedlist>
                                      <listitem>
                                          <para>
                                              (<code>boolean, true</code> по
                                              умолчанию) <code>cache</code>:
                                              если <code>true</code>, то
                                              кэширование включено
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, false</code> по
                                              умолчанию)
                                              <code>cache_with_get_variables</code>:
                                              если <code>true</code>, кэширование
                                              включено, даже если в массиве
                                              <code>$_GET</code> есть переменные
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, false</code> по
                                              умолчанию)
                                              <code>cache_with_post_variables</code>:
                                              если <code>true</code>, кэширование
                                              включено, даже если в массиве
                                              <code>$_POST</code> есть переменные
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, false</code> по
                                              умолчанию)
                                              <code>cache_with_session_variables</code>:
                                              если <code>true</code>, кэширование
                                              включено, даже если в массиве
                                              <code>$_SESSION</code> есть
                                              переменные
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, false</code> по
                                              умолчанию)
                                              <code>cache_with_files_variables</code>:
                                              если <code>true</code>, кэширование
                                              включено, даже если в массиве
                                              <code>$_FILES</code> есть переменные
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, false</code> по
                                              умолчанию)
                                              <code>cache_with_cookie_variables</code>:
                                              если <code>true</code>, кэширование
                                              включено, даже если в массиве
                                              <code>$_COOKIE</code> есть
                                              переменные
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, true</code> по
                                              умолчанию)
                                              <code>make_id_with_get_variables</code>:
                                              если <code>true</code>, то
                                              идентификатор кэша будет зависеть
                                              от содержимого массива
                                              <code>$_GET</code>
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, true</code> по
                                              умолчанию)
                                              <code>make_id_with_post_variables</code>:
                                              если <code>true</code>, то
                                              идентификатор кэша будет зависеть
                                              от содержимого массива
                                              <code>$_POST</code>
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, true</code> по
                                              умолчанию)
                                              <code>make_id_with_session_variables</code>:
                                              если <code>true</code>, то
                                              идентификатор кэша будет зависеть
                                              от содержимого массива
                                              <code>$_SESSION</code>
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, true</code> по
                                              умолчанию)
                                              <code>make_id_with_files_variables</code>:
                                              если <code>true</code>, то
                                              идентификатор кэша будет зависеть от
                                              содержимого массива
                                              <code>$_FILES</code>
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>boolean, true</code> по
                                              умолчанию)
                                              <code>make_id_with_cookie_variables</code>:
                                              если <code>true</code>, то
                                              идентификатор кэша будет зависеть от
                                              содержимого массива
                                              <code>$_COOKIE</code>
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>int, false</code> по
                                              умолчанию)
                                              <code>specific_lifetime</code>:
                                              если не <code>false</code>,
                                              то значение этой опции,
                                              обозначающей время жизни кэша,
                                              будет использоваться для выбранного
                                              регулярного выражения
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>array, array()</code> по
                                              умолчанию)
                                              <code>tags</code>:
                                              теги для записи в кэше
                                          </para>
                                      </listitem>
                                      <listitem>
                                          <para>
                                              (<code>int, null</code> по
                                              умолчанию)
                                              <code>priority</code>:
                                              приоритет. Действует только
                                              если выбранный бэкэнд поддерживает
                                              приоритеты.
                                          </para>
                                      </listitem>
                                  </itemizedlist>
                              </entry>
                         </row>
                         <row>
                              <entry><code>regexps</code></entry>
                              <entry><code>array</code></entry>
                              <entry><code>array()</code></entry>
                              <entry>
                                  Ассоциативный массив для установки опций
                                  только для некоторых REQUEST_URI. Ключами
                                  этого массива являются регулярные выражения
                                  (PCRE), значениями — ассоциативные массивы со
                                  специальными опциями, которые устанавливаются,
                                  если $_SERVER['REQUEST_URI']
                                  соответствует регулярному выражению
                                  (см. default_options в этом списке доступных
                                  опций). Если $_SERVER['REQUEST_URI']
                                  соответствует нескольким регулярным
                                  выражениям, то используется только последнее
                                  из них.
                              </entry>
                         </row>
                         <row>
                              <entry><code>memorize_headers</code></entry>
                              <entry><code>array</code></entry>
                              <entry><code>array()</code></entry>
                              <entry>
                                   Массив строк с именами HTTP-заголовков.
                                   Перечисленные заголовки будут сохранены в
                                   кэше и будут замещены при попадании в кэш.
                              </entry>
                         </row>
                      </tbody>
                  </tgroup>
              </table>
        </sect3>
        <sect3 id="zend.cache.frontends.page.examples">
            <title>Примеры</title>
            <para>
                Использование <code>Zend_Cache_Frontend_Page</code> довольно
                простое:
            </para>
            <programlisting role="php"><![CDATA[
// [...]

$cache->start();
// если есть попадание в кэш, то результат отправляется броузеру
// и выполнение скрипта на этом прекращается

// остальная часть страницы ...
]]>
            </programlisting>
            <para>
                Более сложный пример, показывающий способ создания
                централизованного управления кэшированием в загрузочном файле
                (например, для использования с <code>Zend_Controller</code>).
            </para>
            <programlisting role="php"><![CDATA[
/*
 * Вы должны избегать слишком большого количества строк кода перед этим участком
 * кэша. Например, для наибольшей производительности "require_once" или
 * "Zend_Loader::loadClass" должны находиться после кэшируемого участка
 */

$frontendOptions = array(
   'lifetime' => 7200,
   'debug_header' => true, // для отладки
   'regexps' => array(
       // кэширование всего IndexController
       '^/$' => array('cache' => true),

       // кэширование всего IndexController
       '^/index/' => array('cache' => true),

       // не кэшируем ArticleController...
       '^/article/' => array('cache' => false),

       // ...но кэшируем действие "view" контроллера ArticleController
       '^/article/view/' => array(
           'cache' => true,

           // кэшируем, даже если есть переменные $_POST
           'cache_with_post_variables' => true,

           // но кэш будет зависеть от массива $_POST
           'make_id_with_post_variables' => true,
       )
   )
);

$backendOptions = array(
    'cache_dir' => '/tmp/'
);

// получение объекта Zend_Cache_Frontend_Page
$cache = Zend_Cache::factory('Page',
                             'File',
                             $frontendOptions,
                             $backendOptions);

$cache->start();
// если есть попадание в кэш, результат отправляется броузеру,
// и выполнение скрипта на этом завершается

// [...] конец загрузочного файла
// (этот код не исполняется, если есть попадание в кэш)
]]>
            </programlisting>
        </sect3>
        <sect3 id="zend.cache.frontends.page.cancel">
            <title>Специальный метод отмены</title>
            <para>
                В некоторых случаях может потребоваться отменить текущий
                процесс кэширования - например, если используется код
                возврата, отличный от HTTP/200. Поэтому мы добавили метод
                <code>cancel()</code>:
            </para>
            <programlisting role="php"><![CDATA[
// [...]

$cache->start();

// [...]

if ($someTest) {
    $cache->cancel();
    // [...]
}

// [...]
]]>
            </programlisting>
        </sect3>
    </sect2>
</sect1>
<!--
vim:se ts=4 sw=4 et:
-->
