Как повысить эффективность приложения HTML5

Введение

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

В любом случае, когда вы работаете с анимацией, становится чрезвычайно важным, чтобы пользователи воспринимали эти анимации как плавные. Важно понимать, что плавность анимации не достигается простым увеличением количества кадров в секунду за пределы когнитивного порога. Наш мозг, к сожалению, умнее этого. Вы узнаете, что 30 кадров в секунду (fps) лучше, чем 60 fps с несколькими пропущенными кадрами. Люди ненавидят зазубренность.

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

Стратегия

Мы ни в коем случае не хотим отговаривать вас от создания потрясающих приложений на HTML5.

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

Улучшенная визуальная точность с HTML5

Аппаратное ускорение

Аппаратное ускорение – важный этап в повышении общей производительности рендеринга в браузере. Общая схема заключается в том, чтобы разгрузить задачи, которые в противном случае вычислялись бы основным ЦП, переложив их на графический процессор (GPU) в графическом адаптере вашего компьютера. Это может значительно повысить производительность и снизить потребление ресурсов на мобильных устройствах.

Эти аспекты документа можно ускорить с помощью графического процессора

  • Компоновка общего макета
  • Переходы CSS3
  • 3D-преобразования CSS3
  • Рисунок на холсте
  • Трехмерные рисунки WebGL

Хотя ускорение canvas и WebGL – это специальные функции, которые могут не применяться к вашему приложению, первые три аспекта могут помочь практически любому приложению работать быстрее.

Что можно ускорить?

Ускорение графического процессора работает за счет передачи четко определенных и конкретных задач специализированному оборудованию. Общая схема заключается в том, что документ разбивается на несколько "слоев", которые не зависят от ускоренных аспектов страницы. Эти слои отрисовываются с помощью традиционного конвейера рендеринга. Затем графический процессор объединяет слои в одну страницу, применяя эффекты, которые можно ускорить на лету. Возможный результат заключается в том, что анимированный объект на экране не требует единого "перекомпоновки" страницы во время анимации.

Главное, что нужно из этого вынести, – это то, что вы должны упростить для движка рендеринга определение того, когда он может применить свое волшебство ускорения графического процессора. Пример:

Хотя это работает, браузер на самом деле не знает, что вы выполняете что-то, что должно восприниматься человеком как плавная анимация. Посмотрите, что происходит, когда вы достигаете того же визуального эффекта, используя переходы CSS3:

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

Для отладки аппаратного ускорения в Chrome можно использовать два параметра командной строки:

  1. --show-composited-layer-borders показывает красную рамку вокруг элементов, которыми управляет графический процессор. Позволяет убедиться, что манипуляции происходят на уровне графического процессора.
  2. --show-paint-rects все изменения, не связанные с графическим процессором, отрисовываются, и вокруг всех перерисованных областей появляется светлая граница. Вы можете увидеть, как браузер оптимизирует области отрисовки.

В Safari есть похожие флаги, описанные здесь.

Переходы CSS3

Переходы CSS не только упрощают анимацию стилей для всех, но и повышают производительность. Поскольку переходы CSS управляются браузером, точность анимации может быть значительно улучшена, а во многих случаях – аппаратно ускорена. В настоящее время аппаратное ускорение преобразований CSS поддерживается в WebKit (Chrome, Safari, iOS), но скоро оно появится и в других браузерах и платформах.

Вы можете использовать события transitionEnd, чтобы создавать мощные комбинации, хотя сейчас для отслеживания всех поддерживаемых событий окончания перехода необходимо отслеживать webkitTransitionEnd transitionend oTransitionEnd.

Во многих библиотеках теперь есть API анимации, которые используют переходы, если они есть, и возвращаются к стандартной анимации в стиле DOM в противном случае. scripty2, YUI transition, jQuery animate enhanced.

Перевод CSS3

Уверен, вы уже анимировали положение элемента по осям X и Y. Вероятно, вы изменили свойства left и top встроенного стиля. При работе с двумерными преобразованиями для воспроизведения этого поведения можно использовать функцию translate().

Мы можем объединить это с анимацией DOM, чтобы использовать наилучший вариант

<div style="position:relative; height:120px;" class="hwaccel">

  <div style="padding:5px; width:100px; height:100px; background:papayaWhip;
              position:absolute;" id="box">
  </div>
</div>

<script>
document.querySelector('#box').addEventListener('click', moveIt, false);

function moveIt(evt) {
  var elem = evt.target;

  if (Modernizr.csstransforms && Modernizr.csstransitions) {
    // vendor prefixes omitted here for brevity
    elem.style.transition = 'all 3s ease-out';
    elem.style.transform = 'translateX(600px)';

  } else {
    // if an older browser, fall back to jQuery animate
    jQuery(elem).animate({ 'left': '600px'}, 3000);
  }
}
</script>

Мы используем Modernizr для тестирования функций CSS 2D Transforms и CSS Transitions. Если они поддерживаются, мы будем использовать translate для изменения позиции. Если для анимации используется переход, браузер, скорее всего, сможет применить аппаратное ускорение. Чтобы помочь браузеру, мы используем "волшебную пулю CSS", о которой говорилось выше.

Если браузер не поддерживает эту функцию, мы будем использовать jQuery для перемещения элемента. Чтобы автоматизировать этот процесс, можно использовать плагин jQuery Transform polyfill, созданный Луи-Реми Бабе (Louis-Remi Babe).

window.requestAnimationFrame

Метод requestAnimationFrame был представлен Mozilla и доработан WebKit, чтобы предоставить вам нативный API для запуска анимаций, будь то на основе DOM/CSS, <canvas> или WebGL. Браузер может оптимизировать параллельные анимации в единый цикл перекомпоновки и перерисовки, что приводит к более высокому качеству анимации. Например, анимация на основе JS, синхронизированная с переходами CSS или SVG SMIL. Кроме того, если цикл анимации выполняется на невидимой вкладке, браузер не будет поддерживать его работу. Это снижает нагрузку на ЦП, графический процессор и использование памяти, а также значительно продлевает время работы от батареи.

Подробнее о том, как и зачем использовать requestAnimationFrame, читайте в статье Пола Айриша (Paul Irish) requestAnimationFrame для умной анимации.

Профилирование

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

Профилирование JavaScript

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

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

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

Подробную информацию можно найти в документации по профилированию в Инструментах разработчика в Chrome.

DOM

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

function drawArray(array) {
  for(var i = 0; i < array.length; i++) {
    document.getElementById('test').innerHTML += array[i]; // No good :(
  }
}

Например, в приведенном выше коде на выполнение JavaScript почти не тратится время. Функция drawArray, скорее всего, по-прежнему будет отображаться в профилях, поскольку она взаимодействует с DOM очень неэффективно.

Полезные советы

Анонимные функции

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

$('.stuff').each(function() { ... });

переписать на:

$('.stuff').each(function workOnStuff() { ... });

Не все знают, что в JavaScript можно присваивать имена функциональным выражениям. Тогда они будут правильно отображаться в профилировщике. У этого решения есть одна проблема: именованное выражение фактически помещает имя функции в текущую лексическую область видимости. Это может привести к конфликту с другими символами, поэтому будьте осторожны.

Профилирование длинных функций

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

  1. Правильный метод: провести рефакторинг кода, чтобы в нем не было длинных функций.
  2. Злобный метод "сделай это": добавьте в код операторы в виде именованных самовызывающихся функций. Если вы будете осторожны, это не изменит семантику и заставит части вашей функции отображаться как отдельные функции в профилировщике: js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... } Не забудьте удалить эти дополнительные функции после завершения профилирования или даже использовать их в качестве отправной точки для рефакторинга вашего кода.

Профилирование DOM

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

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

Профилирование DOM

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

Подробнее о представлении в виде временной шкалы… В качестве альтернативного инструмента для профилирования в Internet Explorer можно использовать DynaTrace Ajax Edition.

Стратегии профилирования

Выделение аспектов

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

  1. Время запуска (активируйте профилировщик, перезагрузите приложение, дождитесь завершения инициализации, остановите профилировщик).
  2. Нажатие кнопки и последующая анимация (запустите профилировщик, нажмите кнопку, дождитесь завершения анимации, остановите профилировщик).
Профилирование графического интерфейса пользователя

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

Программный интерфейс

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

Начать профилирование с помощью:

console.profile()

Остановить профилирование с помощью:

console.profileEnd()

Повторяемость

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

  1. Таймер в вашем приложении, который срабатывает, пока вы измеряете что-то другое.
  2. Сборщик мусора выполняет свою работу.
  3. Другая вкладка в браузере выполняет сложную задачу в том же потоке.
  4. Другая программа на компьютере использует ЦП, что замедляет работу приложения.
  5. Внезапные изменения гравитационного поля Земли.

Также имеет смысл выполнить один и тот же путь выполнения несколько раз за один сеанс профилирования. Это позволит снизить влияние перечисленных выше факторов и выявить медленные части.

Измеряйте, улучшайте, измеряйте

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

Стратегии оптимизации

Минимизируйте взаимодействие с DOM

Чтобы повысить скорость работы клиентских веб-приложений, нужно минимизировать взаимодействие с DOM. Хотя скорость работы движков JavaScript увеличилась на порядок, доступ к DOM не стал быстрее с той же скоростью. По практическим причинам это невозможно (на макет и отрисовку элементов на экране требуется время).

Кеширование узлов DOM

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

Было:

function getElements() {
  return $('.my-class');
}

Стало:

var cachedElements;
function getElements() {
  if (cachedElements) {
    return cachedElements;
  }
  cachedElements = $('.my-class');
  return cachedElements;
}

Значения атрибута cache

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

Было:

setInterval(function() {
  var ele = $('#element');
  var left = parseInt(ele.css('left'), 10);
  ele.css('left', (left + 5) + 'px');
}, 1000 / 30);

После: js var ele = $('#element'); var left = parseInt(ele.css('left'), 10); setInterval(function() { left += 5; ele.css('left', left + 'px'); }, 1000 / 30);

Вынесите манипуляции с DOM за пределы циклов.

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

Было:

document.getElementById('target').innerHTML = '';
for(var i = 0; i < array.length; i++) {
  var val = doSomething(array[i]);
  document.getElementById('target').innerHTML += val;
}

Стало:

var stringBuilder = [];
for(var i = 0; i < array.length; i++) {
  var val = doSomething(array[i]);
  stringBuilder.push(val);
}
document.getElementById('target').innerHTML = stringBuilder.join('');

Перерисовка и перекомпоновка

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

  • Этап 1. Считывание значений DOM, необходимых для вашего кода
  • Этап 2. Изменение DOM

Не используйте шаблоны, подобные следующим:

  • Этап 1. Чтение значений DOM
  • Этап 2. Изменение DOM
  • Этап 3. Читайте больше
  • Этап 4. Изменение DOM в другом месте.

Было:

function paintSlow() {
  var left1 = $('#thing1').css('left');
  $('#otherThing1').css('left', left);
  var left2 = $('#thing2').css('left');
  $('#otherThing2').css('left', left);
}

Стало:

function paintFast() {
  var left1 = $('#thing1').css('left');
  var left2 = $('#thing2').css('left');
  $('#otherThing1').css('left', left);
  $('#otherThing2').css('left', left);
}

Этот совет следует учитывать для действий, происходящих в одном контексте выполнения JavaScript. (например, в обработчике событий, обработчике интервалов или при обработке ответа AJAX).

При выполнении функции paintSlow(), приведенной выше, создается следующее изображение:

paintSlow()

Если перейти на более быструю реализацию, получится следующее изображение:

Быстрая реализация

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

Подробнее: Отрисовка: перерисовка, перекомпоновка, изменение стиля (автор – Стоян Стефанов).

Перерисовка и цикл событий

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

Последствия

  1. Если циклы анимации JavaScript выполняются дольше 1/30 секунды, вы не сможете создать плавную анимацию, поскольку браузер не будет перерисовывать страницу во время выполнения JS. Если вы ожидаете, что вам также придется обрабатывать пользовательские события, вам нужно быть намного быстрее.
  2. Иногда бывает полезно отложить выполнение некоторых действий JavaScript. Пример: setTimeout(function() { ... }, 0). Это указывает браузеру, что обратный вызов нужно выполнить, как только цикл событий снова станет неактивным (некоторые браузеры будут ждать не менее 10 мс). Обратите внимание, что в этом случае будут созданы два цикла выполнения JavaScript, которые будут следовать друг за другом с очень небольшим интервалом. Оба этих действия могут привести к перерисовке экрана, что может удвоить общее время, затраченное на отрисовку. Будет ли это на самом деле запускать две отрисовки, зависит от эвристики в браузере.

Обычная версия:

function paintFast() {
  var height1 = $('#thing1').css('height');
  var height2 = $('#thing2').css('height');
  $('#otherThing1').css('height', '20px');
  $('#otherThing2').css('height', '20px');
}
Перерисовка и цикл событий

Добавим задержку:

function paintALittleLater() {
  var height1 = $('#thing1').css('height');
  var height2 = $('#thing2').css('height');
  $('#otherThing1').css('height', '20px');
  setTimeout(function() {
    $('#otherThing2').css('height', '20px');
  }, 10)
}
Задержка

В версии с задержкой показано, что браузер отрисовывает страницу дважды, хотя два изменения на странице происходят с разницей всего в 1/100 секунды.

Отложенная инициализация

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

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

До: js var things = $('.ele > .other * div.className'); $('#button').click(function() { things.show() });

После: js $('#button').click(function() { $('.ele > .other * div.className').show() });

Делегирование событий

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

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

В jQuery это можно легко выразить следующим образом:

$('#parentNode').delegate('.button', 'click', function() { ... });

Когда не следует использовать делегирование событий

Иногда может быть и наоборот: вы используете делегирование событий, но у вас возникают проблемы с производительностью. По сути, делегирование событий позволяет инициализировать время с постоянной сложностью. Однако проверять, представляет ли событие интерес, приходится при каждом его вызове. Это может быть дорого, особенно для событий, которые происходят часто, например mouseover или даже mousemove.

Типичные проблемы и их решения

В $(document).ready я делаю то, что занимает много времени

Личный совет Мальте: никогда не делайте ничего в $(document).ready. Постарайтесь предоставить документ в окончательном виде. Вы можете регистрировать прослушиватели событий, но только с помощью селектора идентификаторов и/или делегирования событий. Для ресурсоемких событий, таких как mousemove, отложите регистрацию до тех пор, пока они не понадобятся (событие mouseover для соответствующего элемента).

Если вам действительно нужно выполнить какие-то действия, например отправить запрос Ajax для получения актуальных данных, то покажите пользователю красивую анимацию. Если это анимированный GIF-файл или что-то подобное, вы можете включить анимацию в виде URI данных.

После добавления на страницу Flash-ролика все стало работать очень медленно

Добавление Flash на страницу всегда немного замедляет ее отрисовку, поскольку окончательный макет окна должен быть согласован между браузером и плагином Flash. Если вы не можете полностью отказаться от Flash, задайте для параметра wmode значение window (оно используется по умолчанию). В этом случае вы не сможете совмещать элементы HTML и Flash (например, размещать элементы HTML поверх Flash-ролика или делать Flash-ролик прозрачным). Это может быть неудобно, но значительно повысит эффективность. Например, на сайте youtube.com слои не размещаются поверх основного проигрывателя.

Я сохраняю данные в localStorage, и теперь мое приложение работает с перебоями

Запись в localStorage – это синхронная операция, которая включает запуск жесткого диска. Никогда не выполняйте "длительные" синхронные операции во время анимации. Переместите доступ к localStorage в ту часть кода, которая выполняется, когда пользователь бездействует и анимация не воспроизводится.

Профилирование указывает на то, что селектор jQuery работает очень медленно.

Сначала убедитесь, что селектор можно запустить через document.querySelectorAll. Это можно проверить в консоли JavaScript. Если это так, перепишите селектор, чтобы он не использовал специальные расширения фреймворка JavaScript. Это значительно ускорит работу селектора в современных браузерах.

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

  • Указывайте как можно более точные селекторы.
  • Используйте в качестве крайней правой части селектора название тега, которое вы редко используете.
  • Если ничего не помогает, подумайте о том, чтобы переписать код и использовать селектор идентификатора.

Все эти манипуляции с DOM занимают много времени

Множество вставок, удалений и обновлений узлов DOM может сильно замедлить работу. Обычно для оптимизации этого процесса создается большая строка HTML, а затем старый контент заменяется с помощью domNode.innerHTML = newHTML. Обратите внимание, что это может усложнить поддержку и привести к утечкам памяти в IE.

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

Инструменты

  1. JSPerf – тестирование небольших фрагментов кода JavaScript
  2. Firebug – для профилирования в Firefox
  3. Инструменты разработчика в Google Chrome (в Safari доступны как WebInspector)
  4. DOM Monster – для оптимизации производительности DOM
  5. DynaTrace Ajax Edition – для профилирования и оптимизации отрисовки в Internet Explorer.

Дополнительные сведения

  1. Google Speed
  2. Пол Айриш о производительности jQuery
  3. Максимальная производительность JavaScript (презентация)