Ускоряем JavaScript

Кажется, всего несколько дней назад мы рассказывали вам об истории flickr, и вот - статья, написанная главным разработчиком этой компании Кэлом Хендерсоном. Статья довольно специфичная - это вполне конкретные советы по решению вполне конкретных проблем, с которыми может столкнуться практически любой веб-разработчик. Как правило, мы стараемся не публиковать материалы такого плана, однако и Веб 2.0 - штука довольно новая, и проблемы, которые поднимает Хендерсон, далеко не для всех очевидны (что уж говорить о способах их преодоления), и литературы, освещающей эти вопросы, тоже не очень много, - к сожалению, большинство авторов компьютерных книжек делает упор на подробное описание синтаксиса, избегая рассуждать о тонкостях применения тех или иных техник. Хендерсон на синтаксис не отвлекается. Не рассказывает он и о том, как делать приложения, активно использующие javascript и css. Его интересует другое - "как сделать эти приложения по-настоящему интерактивными и быстрыми". - В.Г.

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

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

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

Монолит

Раньше считалось, что максимальной производительности можно добиться, объединив многочисленные css- и javascript-файлы в более крупные блоки. Вместо десятка javascript-файлов по 5 Кбайт каждый мы делали один файл размером 50 Кбайт. Хотя общий размер кода при этом не менялся, мы сокращали накладные расходы на обработку http-запросов.

Также важен аспект распараллеливания. По умолчанию и ie и mozilla/firefox при использовании стабильного соединения загружают только два файла с одного домена (см. спецификацию http 1.1, секция 8.1.4). Это означает, что пока не загрузятся все скрипты, мы не загружаем картинки. Все это время пользователи видят страницу без изображений.

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

Исторически этот крупный недостаток такого подхода нечасто брался в расчет. Но для системы, в которой постоянные изменения содержимого статических файлов - обычное дело, это важно, поскольку любое изменение в большом едином блоке требует, чтобы клиент перегрузил себе полный рабочий набор css или javascript. Если приложение представляет собой монолитный исходник на javascript размером 100 Кбайт, значит, каждая мелочь приводит к принудительной загрузке лишних 100 Кбайт.

Один в поле не воин

В качестве альтернативного подхода постараемся придерживаться золотой середины. Разобъем наши css- и javascript-ресурсы на множество подфайлов, сохраняя в то же время количество этих файлов функционально невысоким. С одной стороны, нам удобно разрабатывать приложения, разбивая код на логические блоки. С другой стороны, для работы приложения важно, чтобы этих блоков было не слишком много (так что нам приходится объединять эти файлы). Компромисса можно добиться, сделав определенные добавления к системе сборки билдов (набор инструментов, превращающий "грязный" код разработки в рабочий, готовый для развертывания код).

Для прикладного окружения, в котором среда разработки и среда исполнения четко разделены, подойдут простые техники управления кодом. Пусть в среде разработки код для пущей ясности разбит на множество логических блоков. Создадим в smarty (язык шаблонов для php) простую функцию загрузки javascript:

smarty:
{insert_js files="foo.js,bar.js,baz.js"}

php:
function smarty_insert_js($args){
foreach (explode(‘,’, $args[‘files’]) as $file){

echo "<script type="text/javascript" src="/javascript/$file">script>n";
}
}

output:
<script type="text/javascript" src="/javascript/foo.js">script>
<script type="text/javascript" src="/javascript/bar.js">script>
<script type="text/javascript" src="/javascript/baz.js">script>

Пока все просто. Но затем мы во время сборки билда объединяем нужные файлы. Представьте, что в нашем примере мы должны объединить foo.js и bar.js в foobar.js, раз уж они почти всегда подгружаются вместе. Учтем этот факт при настройке нашего приложения и модифицируем код с учетом этой информации:

smarty:
{insert_js files="foo.js,bar.js,baz.js"}

php:
# map of where we can find .js source files after the build process
# has merged as necessary

$globals[‘config’][‘js_source_map’] = array(
‘foo.js’ => ‘foobar.js’,
‘bar.js’ => ‘foobar.js’,
‘baz.js’ => ‘baz.js’,
);
function smarty_insert_js($args){

if ($globals[‘config’][‘is_dev_site’]){

$files = explode(‘,’, $args[‘files’]);
}else{

$files = array();

foreach (explode(‘,’, $args[‘files’]) as $file){

$files[$globals[‘config’][‘js_source_map’][$file]]++;
}

$files = array_keys($files);
}

foreach ($files as $file){

echo "<script type="text/javascript" src="/javascript/$file">script>n";
}
}

output:
<script type="text/javascript" src="/javascript/foobar.js">script>
<script type="text/javascript" src="/javascript/baz.js">script>

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

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

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

Сжатие

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

accept-encoding: gzip,deflate

Видя такой заголовок, сервер сжимает отсылаемое содержимое методами gzip или deflate с тем, чтобы клиент распаковал его на месте. Это загружает процессор как на клиенте, так и на сервере, однако уменьшает объем передаваемых данных. Это нормально. Однако вот как работает mod_gzip: он сжимает данные во временный файл на диске, а после отсылки данных удаляет этот файл. На больших системах вы очень быстро столкнетесь с ограничениями скорости ввода/вывода. Этого можно избежать, используя вместо mod_gzip mod_deflate (только в apache 2), поскольку последний сжимает данные в оперативной памяти. Пользователи первой версии apache могут создать ram-диск и хранить временные файлы mod_gzip там - это не так быстро, как работа напрямую с оперативкой, но намного шустрее, чем писать все на жесткий диск.

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

mod_gzip_can_negotiate yes
mod_gzip_static_suffix .gz
addencoding gzip .gz

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

mod_gzip_update_static yes

Но не все так просто. Текущие версии netscape 4 (точнее, 4.06–4.08) в заголовке утверждают, что понимают содержимое, сжатое с помощью gzip, однако, на самом деле, не умеют распаковывать эти архивы. Прочие версии netscape 4 тоже испытывают разнообразные трудности с загрузкой сжатых скриптов и стилей. А значит, мы должны отсекать этих агентов на стороне сервера и подставлять им неупакованный контент. Это довольно просто. Куда интереснее проблемы, возникающие у internet explorer (версии с 4 по 6).

Загружая сжатый с помощью gzip javascript, internet explorer порой некорректно распаковывает его или прерывает распаковку в процессе, отдавая клиенту половину файла. Если для вас критична работоспособность javascript, вы должны избегать отсылки сжатых скриптов по запросу ie. Даже в тех случаях, когда ie способен загрузить сжатый javascript, он зачастую не кэширует его, независимо от указаний, записанных в тегах (актуально для некоторых версий ie 5.x).

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

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

Этих проблем можно избежать, сжимая код с помощью dojo compressor (alex.dojotoolkit.org/shrinksafe), использующий rhino (мозилловский javascript-движок, написанный на java) для построения дерева, которое оптимизируется перед работой с файлами. С работой dojo compressor справляется неплохо, ресурсов отнимает немного. Расширив наш процесс сборки билда с помощью этого инструмента, мы можем забыть об экономии, писать пространные комментарии, вставлять сколько угодно пробелов и т. д. На рабочем коде это нисколько не отразится.

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

#!/usr/bin/perl

my $data = ‘’;
open f, $argv[0] or die "can’t open source file: $!";
$data .= $_ while ;
close f;

$data =~ s!/*(.*?)*/!!g; # remove comments
$data =~ s!s+! !g; # collapse space
$data =~ s!} !}n!g; # add line breaks
$data =~ s!n$!!; # remove last break
$data =~ s! { ! {!g; # trim inside brackets
$data =~ s!; }!}!g; # trim inside brackets

print $data;

"Скормим" этому скрипту все имеющиеся у нас css по очереди:

perl compress.pl site.source.css > site.compress.css

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

Твой друг кэш

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

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

header("cache-control: private");
?>

Слишком просто, чтобы быть правдой? Ну, в общем-то, да - некоторые агенты порой игнорируют этот заголовок. Чтобы по-настоящему запретить браузеру кэшировать документ, следует быть немного более убедительным:

# ‘expires’ in the past
header("expires: mon, 26 jul 1997 05:00:00 gmt");

# always modified
header("last-modified: ".gmdate("d, d m y h:i:s")." gmt");

# http/1.1
header("cache-control: no-store, no-cache, must-revalidate");
header("cache-control: post-check=0, pre-check=0", false);

# http/1.0
header("pragma: no-cache");
?>

Это годится для контента, который мы не хотим кэшировать, но если контент не меняется при каждом запросе, нам нужно добиться от браузера обратного поведения. Для этого в заголовке запроса используется конструкция if-modified-since. Получив такой запрос, apache (или любой другой веб-сервер) может выдать код 304 (not modified), тем самым сообщая браузеру, что у того в кэше уже находится актуальная версия документа. Благодаря этому механизму, нам не приходится пересылать файл заново, однако лишний запрос обрабатывать все же пришлось. Гм.

Использование entity tags похоже на работу с конструкцией if-modified-since. apache на запрос к статическому ресурсу может отдавать заголовок etag, содержащий контрольную сумму, сгенерированную из размера файла, времени последнего изменения и номера индексного дескриптора. Браузер может запросить заголовок файла, чтобы проверить e-tag документа перед загрузкой. Очевидно, что использование e-tag сопряжено с теми же накладными расходами, что и механизм if-modified-since, - клиент все еще вынужден делать лишний http-запрос, чтобы определить валидность локальной копии.

Кроме того, нужно соблюдать осторожность с if-modified-since и e-tags, если выдача контента идет с нескольких серверов. В системе из двух хорошо сбалансированных серверов любой документ может быть запрошен одним и тем же агентом с любого из двух серверов - или с каждого (не одновременно). Это нормально. Для этого мы и выравнивали нагрузку. Однако если серверы генерируют разные e-tags или разные даты изменения документов, браузер не сможет нормально поддерживать актуальный кэш. По умолчанию e-tag генерируются с использованием индексных дескрипторов, которые на разных серверах разные. Это можно запретить с помощью следующей опции в настройках apache:

fileetag mtime size

Теперь apache для генерации e-tag будет использовать только время последнего изменения и размер файла. Это, к сожалению, приводит нас к другой проблеме использования e-tag, которая тоже актуальна для if-modified-since (хоть и в меньшей степени). Поскольку e-tag зависит от времени последнего изменения, нам необходимо следить за синхронизацией. Если мы распределяем файлы по разным веб-серверам, всегда остается шанс, что на один из серверов файл попадет на секунду или две позже, чем на другой. В этом случае e-tag, сгенерированные серверами, будут отличаться. Мы можем изменить настройки так, чтобы генерировать e-tag только на основании размера файла, но это означает, что файл не обновится в браузере, если мы изменим его содержимое, а размер останется неизменным. Тоже не идеально.

Твой лучший друг кэш

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

Или все же слегка иначе? Ведь перед отправкой любых javascript- или css-файлов клиент запрашивает страницу, которая на них ссылается с помощью тегов <script> и . И мы можем использовать реакцию сервера для информирования клиентов о любых изменениях, произошедших с этими ресурсами. Звучит немного загадочно, поэтому скажу прямо: если мы будем изменять названия javascript- и css-файлов при каждом изменении их содержания, то сможем разрешить клиенту хранить их в кэше вечно (ведь содержимое файла по отдельно взятому адресу не меняется).

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

header("expires: ".gmdate("d, d m y h:i:s", time()+315360000)." gmt");
header("cache-control: max-age=315360000");
?>

Так мы говорим браузеру, что содержимое файла останется неизменным в течение десяти лет (т.е. плюс-минус 315 360 000 секунд), поэтому, единожды загрузив файл, браузер может следующие десять лет использовать локальную копию. Конечно, необязательно использовать для отправки javascript и css именно php. Мы перейдем к этому через несколько минут.

Ошибка на ошибке

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

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

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

rewriteengine on
rewriterule ^/(.*.)v[0-9.]+.(css|js|gif|png|jpg)$ /$1$2 [l]

Это правило обрабатывает все url с указанными расширениями, которые также содержат суффикс версии. В процессе обработки правило переписывает url так, чтобы он указывал на путь к нужному файлу (исключая при этом суффикс). Например:

url Путь

/images/foo.v2.gif /images/foo.gif
/css/main.v1.27.css css/main.css
/javascript/md5.v6.js /javascript/md5.js

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

Вы можете поинтересоваться, почему мы просто-напросто не использовали динамические ссылки (например, /css/main.css?v=4)? Дело в том, что, согласно спецификации http, пользовательские агенты вообще не должны кэшировать такие url. И хотя ie и firefox это игнорируют, opera и safari точно следуют букве - поэтому, чтобы гарантировать корректную работу всех браузеров при кэшировании наших ресурсов, мы избегаем использовать динамические ссылки.

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

smarty:

php:
function smarty_version($args){

$stat = stat($globals[‘config’][‘site_root’].$args[‘src’]);
$version = $stat[‘mtime’];

echo preg_replace(‘!.([a-z]+?)$!’, ".v$version.$1", $args[‘src’]);
}
output:

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

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

$globals[‘config’][‘resource_versions’] = array(

‘/images/foo.gif’ => ‘2.1’,
‘/css/main.css’ => ‘1.27’,
‘/javascript/md5.js’ => ‘6.1.4’,
);
?>

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

function smarty_version($args){

if ($globals[‘config’][‘is_dev_site’]){

$stat = stat($globals[‘config’][‘site_root’].$args[‘src’]);
$version = $stat[‘mtime’];
}else{
$version = $globals[‘config’][‘resource_versions’][$args[‘src’]];
}

echo preg_replace(‘!.([a-z]+?)$!’, ".v$version.$1", $args[‘src’]);
}
?>

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

Собираем все вместе

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

Использовать для нашей цели php нетрудно. Мы просто должны изменить правила rewrite для статических файлов, чтобы они проходили через php-скрипт, и написать сам скрипт, который будет выдавать нужные заголовки, перед тем как передать эти файлы по запросу.

apache:

rewriterule ^/(.*.)v[0-9.]+.(css|js|gif|png|jpg)$ /redir.php?path=$1$2 [l]

php:

header("expires: ".gmdate("d, d m y h:i:s", time()+315360000)." gmt");
header("cache-control: max-age=315360000");

# ignore paths with a ‘..’
if (preg_match(‘!..!’, $_get[path])){ go_404(); }

# make sure our path starts with a known directory
if (!preg_match(‘!^(javascript|css|images)!’, $_get[path])){ go_404(); }

# does the file exist?
if (!file_exists($_get[path])){ go_404(); }

# output a mediatype header
$ext = array_pop(explode(‘.’, $_get[path]));
switch ($ext){
case ‘css’:
header("content-type: text/css");
break;
case ‘js’ :
header("content-type: text/javascript");
break;
case ‘gif’:
header("content-type: image/gif");
break;
case ‘jpg’:
header("content-type: image/jpeg");
break;
case ‘png’:
header("content-type: image/png");
break;
default:
header("content-type: text/plain");
}

# echo the file’s contents
echo implode(‘’, file($_get[path]));

function go_404(){
header("http/1.0 404 file not found");
exit;
}

Несмотря на то что такой подход работает, это не лучшее решение. php в сравнении с apache требует больше памяти и времени на исполнение. Кроме того, нам необходимо соблюдать осторожность из-за возможных эксплойтов. Дабы избежать всей этой головной боли, мы можем попытаться использовать apache напрямую. Директива rewriterule позволяет нам устанавливать значения переменных окружения при срабатывании директивы, тогда как директива header добавляет заголовки лишь в том случае, когда присвоенно значение заданной переменной. Комбинируя две эти директивы, мы легко можем составить нужную цепочку инструкций:

rewriteengine on
rewriterule ^/(.*.)v[0-9.]+.(css|js|gif|png|jpg)$ /$1$2 [l,e=versioned_file:1]

header add "expires" "mon, 28 jul 2014 23:30:00 gmt" env=versioned_file
header add "cache-control" "max-age=315360000" env=versioned_file

Из-за порядка исполнения apache, мы должны добавить строчку re-writerule в главный конфигурационный файл (httpd.conf), а не в .htaccess, иначе строчки header будут исполнены первыми, перед установкой переменной окружения. Сами строчки header могут быть размещены и в главном конфигурационном файле, и в .htaccess - их местоположение ни на что не влияет.