Главная Здоровье и красота Ленивая загрузка. Ленивая загрузка изображений с использованием IntersectionObserver. Ленивые загруженные объекты будут убраны прочь

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

Изображения на страницу загружаются двумя основными способами: посредством тега HTML и с помощью CSS свойства background-image . Поэтому мы сначала посмотрим на пример с тегом, а потом перейдем к рассмотрению фоновых изображений CSS .

Ленивая загрузка изображений с помощью тега img

Начнем с простой HTML разметки для вставки изображений на страницу.

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

Второй шаг заключается в том, чтобы избежать преждевременной загрузки изображения. Браузер использует атрибут src тега img для запуска загрузки изображения. И не имеет значения, является ли это изображение первым или тысячным по счету. Если браузер находит атрибут src в разметке, он немедленно запускает загрузку изображения, даже, если оно находится за пределами области видимости.

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

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

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

Первый метод. Запуск загрузки изображения, используя события JavaScript

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

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

Когда какое-либо из этих событий появляется, мы находим все изображения на странице, которые еще не загружены. Из этих изображений мы выбираем именно те, которые находятся в видимой области браузера. Выбор делается на основе расчетов верхнего смещения изображения, текущего верхнего положения документа и высоты окна. Поэтому, если изображение появилось в окне просмотра, мы выберем его URL-адрес из атрибута data-src и переместим его в атрибут src , после этого браузер загрузит изображение.

Обратите внимание, что мы через JavaScript выбираем все изображения, у которых есть класс lazy . Как только изображение загрузится, мы удалим этот класс, потому что нам больше не нужно запускать событие. А как только все изображения будут загружены, мы удалим все обработчики событий.

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

Вот рабочий пример этого подхода:

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

Перевод

В наши дни главным камнем преткновения на пути к высокой скорости загрузки сайтов являются изображения. Это особенно характерно для проектов из сферы электронной коммерции. На них изображения, обычно довольно «тяжёлые», составляют основную часть содержимого страниц. Это, как правило, приводит к тому, что для того, чтобы показать пользователю страницу, его браузеру требуется загрузить несколько мегабайт графических данных. Как ускорить загрузку страниц в такой ситуации? Ответу на этот вопрос и посвящён материал, перевод которого мы сегодня публикуем.

Общие положения Рассмотрим, для примера, стартовую страницу отдела Home на сайте Walmart.

Страница, на которой имеется множество изображений

Вот сведения о том, сколько изображений загружается для формирования этой страницы:

Изображения, загружаемые при формировании страницы

Как видите, тут 137 изображений! Это означает, что более 80% данных, необходимых для вывода страницы и передаваемых по сети, представлены в виде графических файлов.

Проанализируем теперь сетевые запросы, выполняемые при загрузке страницы:

Сетевые запросы, выполняемые при формировании страницы

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

Как это исправить? На самом деле, по-настоящему «исправить» это не получится, но можно сделать много всего для того, чтобы оптимизировать загрузку изображений. Существует немало подходов к оптимизации изображений, используемых на веб-страницах. Среди них - использование различных форматов графических файлов, сжатие данных, применение техники blur animation, использование CDN. Мне хотелось бы остановиться на так называемой «ленивой загрузке» изображений (lazy loading). В частности, речь пойдёт о том, как реализовать эту технику на React-сайтах, но, так как основана она на механизмах JavaScript, её можно интегрировать в любой веб-проект.

Экспериментальный проект Начнём с такого вот предельно простого React-компонента Image:

Class Image extends PureComponent { render() { const { src } = this.props; return ; } }
Он принимает, в качестве свойства, URL, и использует его для рендеринга HTML-элемента img . Вот соответствующий код на JSFiddle. На следующем изображении показана страница, содержащая этот компонент. Обратите внимание на то, что для того, чтобы увидеть выводимое им изображение, нужно прокрутить содержимое страницы.

Страница с компонентом, выводящим изображение

Для того чтобы реализовать в этом компоненте методику ленивой загрузки изображений нужно выполнить следующие три шага:

Не рендерить изображение сразу после загрузки.

Настроить средства обнаружения появления изображения в области просмотра содержимого страницы.

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

Разберём эти шаги.Шаг 1 На этом шаге изображение, сразу после загрузки не выводится.

Render() { return ; }

Шаг 2 Здесь мы настраиваем механизмы, которые позволяют обнаружить момент попадания изображения в область просмотра.

ComponentDidMount() { this.observer = new IntersectionObserver(() => { // тут будет код для реализации третьего шага }, { root: document.querySelector(".container") }); this.observer.observe(this.element); } .... render() { return this.element = el} />; }
Разберём этот код. Вот что здесь сделано:

К элементу img добавлен атрибут ref . Это позволяет позже обновить ссылку на изображение в src без необходимости проводить повторный рендеринг компонента.
Создан новый экземпляр IntersectionObserver (об этом мы поговорим ниже).
Объекту IntersectionObserver предложено наблюдать за изображением с использованием конструкции observe(this.element) .

Что такое IntersectionObserver ? Учитывая то, что слово «intersection» переводится как «пересечение», а «observer» - это «наблюдатель», уже можно догадаться о роли этого объекта. Если же поискать сведения о нём на MDN , то можно узнать, что API Intersection Observer позволяет веб-приложениям асинхронно следить за изменением пересечения элемента с его родителем или областью видимости документа viewport.

На первый взгляд такая характеристика API может показаться не особенно понятной, но, на самом деле, устроено оно очень просто. Экземпляру IntersectionObserver передаётся несколько параметров. В частности, мы использовали параметр root , который позволяет задать корневой DOM-элемент, рассматриваемый нами в качестве контейнера, о пересечении элемента с границей которого нам нужно узнать. По умолчанию это область, в которой находится видимый фрагмент страницы (viewport), но я явным образом установил его на использование контейнера, находящегося в элементе iframe JSFiddle. Сделано это для того, чтобы, позже, рассмотреть одну возможность, которая не рассчитана на использование элементов iframe .

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

Шаг 3 Теперь нам надо настроить коллбэк, вызываемый при обнаружении пересечения элемента target (this.element в нашем случае) с контейнером root (в нашем случае это div -элемент.container).

This.observer = new IntersectionObserver(entries => { entries.forEach(entry => { const { isIntersecting } = entry; if (isIntersecting) { this.element.src = this.props.src; this.observer = this.observer.disconnect(); } }); }, { root: document.querySelector(".container") }); ....
В коллбэк, при обнаружении пересечения, передаётся массив элементов entries , который напоминает набор снимков состояния всех целевых элементов, для которых обнаружено пересечение заданной границы. Свойство isIntersecting указывает на направление пересечения. Если элемент, за которым организовано наблюдение, попадает извне в корневой элемент, оно равно true . Если элемент покидает корневой элемент, то оно равно false .

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

Шаг 4 (секретный) Теперь, на четвёртом, секретном шаге нашей работы, можно полюбоваться результатом и порадоваться успеху. Вот код , в котором собрано то, о чём мы только что говорили.

Результат применения методики ленивой загрузки изображений

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

Поведение страницы при её быстрой прокрутке и замедлении скорости сетевого соединения

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

С этой проблемой, правда, справиться не так уж и сложно. Сделать это можно благодаря тому, что API Intersection Observer предоставляет разработчику возможность расширять или сужать границы корневого элемента (в нашем случае это элемент.container). Для того чтобы этой возможностью воспользоваться, достаточно добавить одну строчку кода туда, где осуществляется настройка корневого контейнера:

RootMargin: "0px 0px 200px 0px"
В свойство rootMargin надо записать строку, структура которой соответствует правилам CSS, используемым для настройки параметров отступов элементов. В нашем случае мы сообщаем системе о том, что нижнюю границу, используемую для обнаружения пересечения элемента с контейнером, нужно увеличить на 200 пикселей. Это означает, что соответствующий коллбэк будет вызван, тогда, когда элемент попадёт в область, которая на 200 пикселей ниже нижней границы корневого элемента (по умолчанию здесь используется значение 0).

Вот код, в котором реализована эта методика.

Совершенствование методики ленивой загрузки изображений

В результате оказывается, что когда мы прокручиваем страницу лишь к 4-му элементу списка, изображение загружается в области, которая на 200 пикселей ниже видимой области страницы.
Теперь, казалось бы, сделано всё, что нужно. Но это не так.

Проблема высоты изображения Если вы внимательно изучали приведённые выше GIF-иллюстрации, то вы могли заметить, что полоса прокрутки совершает «прыжок» после загрузки изображения. К счастью, с этой проблемой несложно справиться. Её причина заключается в том, что элемент, выводящий изображение, изначально имеет высоту 0, которая, после загрузки изображения, оказывается равной 300 пикселей. Поэтому для исправления проблемы достаточно задать элементу фиксированную высоту, добавив к изображению атрибут height={300} .О результатах оптимизации Каких результатов мы, в Walmart, добились после применения ленивой загрузки изображений на этой странице? На самом деле, конкретные результаты очень сильно варьируются в зависимости от множества обстоятельств, среди которых можно отметить скорость подключения клиента к сети, доступность CDN, количество изображений на странице и применяемые к ним правила обнаружения пересечения с корневым элементом. Другими словами, вам, для того, чтобы оценить воздействие ленивой загрузки изображений на собственный проект, лучше всего самим это реализовать и проверить. Но если вам всё же интересно взглянуть на то, что ленивая загрузка изображений дала нам, вот пара отчётов Lighthouse. Первый сформирован до оптимизации, второй - после.

Добавить метки

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

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

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

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

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

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

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

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

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

Разновидности ленивой загрузки

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

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

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

Как сделать ленивую загрузку?

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

5 вариантов ленивой загрузки для изображений

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

В упрощенной версии данный скрипт ленивой загрузки представляет собой замену атрибута src на data-src в теге img :

Элементы img , содержащие атрибуты data-src , скрыты в . После того, как картинки будут загружены, они плавно отображаются с применением переходов:

Img { opacity: 1; transition: opacity 0.3s; } img { opacity: 0; }

Затем JavaScript передает всем тегам img атрибут src , которые в итоге получают значение атрибута data-src . После загрузки всех изображений, data-src убирается из img :

ForEach.call(document.querySelectorAll("img"), function(img) { img.setAttribute("src", img.getAttribute("data-src")); img.onload = function() { img.removeAttribute("data-src"); }; });

Еще David Walsh предусмотрел фолбек в случае несрабатывания JavaScript, отличающийся эффективностью и простой реализацией. Однако его функции не предусматривают загрузку при скроллинге веб-страницы. Это значит, что браузер подгружает все изображения вне зависимости от того, «дошел» посетитель до них, либо нет. Да, фолбек позволяет показывать страницу быстрее, потому что картинки загружаются после HTML, однако экономии трафика не будет.

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

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

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

Она предоставляет юзерам простой доступ к материалам ресурса.

Для реализации метода нет необходимости в использовании плагинов и фреймворков.

Ленивая загрузка функционирует посредством скроллинга – фото не загрузятся, пока посетитель не докрутит страницу до соответствующего места.

Детальную информацию о решении Osborne можете узнать .

№3. Плагин bLazy.js на простом JS

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

Ленивую загрузку фоновых и добавляемых изображений.

Поддержку устаревших браузеров, в том числе IE 7 и 8 версии.

Загрузку картинок в прокручиваемом контейнере.

Использование CDN для размещения плагина вне сервера.

Загрузку всех элементов, содержащих атрибут src: скриптов, iframe и прочего.

Асинхронную загрузку фотографий с учетом разрешения и размера экрана.

Стандартная реализация. Разметка:

Тег img требуется поменять:

Добавить класс.b-lazy.

В виде значения src применить плейсхолдер. Сэкономить число запросов на сервер помогут прозрачные инлайновые gif с кодом base . Но учтите, что на других страницах, где будут применяться те же изображения, не будет кэширования.

Data-src показывает на картинку, которую требуется асинхронно загрузить.

JavaScript: укажите стандартный вызов bLazy и осуществите настройку объекта по карте опций:

Var bLazy = new Blazy({ //опции });

№4. Плагин Lazy Load XT jQuery

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

Для использования плагина на сайте, нужно перед закрывающим тегом добавить jQuery-библиотеку, указав jquery.lazyloadxt.js (упрощенная версия) или jquery.lazyloadxt.extra.js (расширенная):

Есть также альтернативный вариант, позволяющий не использовать весь плагин – облегченный скрипт jqlight.lazyloadxt.min.js :

В изображениях замените src на атрибут data-src :

Плагин может активироваться автоматически, либо вы можете сделать это самостоятельно. Для этого просто введите:

$(elements).lazyLoadXT();

Lazy Load XT jQuetry добавляет большое количество аддонов. К примеру:

Добавив jquery.lazyloadxt.spinner.css , в процессе загрузки картинки есть возможность показывать анимированный спиннер.

Подключив для сайта animate.min.css и указав в JS-файле $.lazyLoadXT.onload.addClass = ‘animated bounceOutLeft’; можно добавить из Animate.css различные эффекты для загрузки картинок.

Плюсы техники:

Работает с большим количеством браузеров.

Поддерживает CDN, поэтому скрипты можно не загружать на сервер.

Дает возможность асинхронно загружать медиа многих типов.

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

Изобилие вариантов использования lazy loading – на странице, в макетах со скроллингом по горизонтали или вертикали, в контейнере и т.д.

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

В материалах сообщается, как действовать в случае отключения в браузере JavaScript.

Просмотреть все аддоны и варианты можете по этой ссылке .

№5. Размытое изображение от Craig Buckler

Вы наверняка замечали на некоторых сайтах, как основное изображение статьи сначала размытое, а потом загружается четкая картинка высокого качества. Есть несколько вариантов загрузки фотографий методом размытого эффекта. Один из лучших – Craig Buckler.

Преимущества техники заключаются в:

Высокой производительности: чуть больше 1 байта JS-кода и 463 байта CSS.

Независимости от фреймворков и библиотек.

Поддержке ретина экранов.

Применении прогрессивного улучшения для сломанного JavaScript и устаревших браузеров.

Скачать код вы можете с хранилища сайта GitHub .

Для начала нужно подключить библиотеку jQuery:

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

Портфолио Показать еще...

Все довольно просто и понятно. Но нужно уделить внимание div с id=»smartPortfolio» , , потому что они находятся в важнейшем скрипте, отвечающем за загрузку контента со сторонних документов. «Контейнером» портфолио выступает SmartPortfolio. MoreButton – кнопка, нажимая на которую происходит загрузка еще одного фрагмента портфолио. LoadingDiv – часть страницы, где будет отображаться текст в случае полного открытия портфолио или возникновения какой-либо ошибки.

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

Вот и сам скрипт, для подключения которого нужно вставить код перед закрывающимся тегом body :

Var lazyload = lazyload || {}; (function($, lazyload) { "use strict"; var page = 2, buttonId = "#moreButton", loadingId = "#loadingDiv", container = "#smartPortfolio"; lazyload.load = function() { var url = "./pages/" + page + ".html"; $(buttonId).hide(); $(loadingId).show(); $.ajax({ url: url, success: function(response) { if (!response || response.trim() == "NONE") { $(buttonId).fadeOut(); $(loadingId).text("Портфолио полностью загружено"); return; } appendContests(response); }, error: function(response) { $(loadingId).text("К сожалению, возникла какая-то ошибка при запросе. Пожалуйста, обновите страницу."); } }); }; var appendContests = function(response) { var id = $(buttonId); $(buttonId).show(); $(loadingId).hide(); $(response).appendTo($(container)); page += 1; }; })(jQuery, lazyload);

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

Var url = "./pages/" + page + ".html";

Но при использовании иного пути важно заменить его в самом скрипте. То же самое нужно сделать, если вы применили другие ID:

ButtonId = "#moreButton", loadingId = "#loadingDiv", container = "#smartPortfolio";

Всем привет. Сегодня хочу поговорить с вами о том, как организовать «ленивую загрузку» контента на посадочных страницах.

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

Давненько уже написали в раздел «Ваши предложения», с просьбой написать статью о том, как реализовать такой эффект:

Вот и решил, заняться реализацией. Спасибо, что подкидываете идеи. Приступим…

Как и в большинстве случаев, начинаем с того, что подключаем библиотеку jQuery:

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

Теперь давайте создадим основной блок, например, с картинками наших работ. Предположим мы рисуем иконки, и будем подгружать их при клике по кнопке. Я создал такую структуру:

Портфолио Показать еще...

Как видите, все — просто. Но на что нужно обратить внимание? А обратить внимание нужно на div с id=»smartPortfolio», id=»moreButton» и id=»loadingDiv», так как они используются в скрипте, который и помогает нам загружать контент с других страниц. SmartPortfolio — это «контейнер» для нашего портфолио. MoreButton — это будет наша кнопка, при клике на которую загружается еще одна часть портфолио. LoadingDiv — область, в которую будет выводиться текст, когда портфолио будет полностью открыто, либо возникнет какая-нибудь ошибка.

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

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

Для тех, кто планирует вносить правки вот сам скрипт:

Итак, теперь стоит поговорить о тех файлах, из которых мы будем подгружать информацию. Скрипт предполагает, что это будут файла с именами 2.html…5.html и т.д. В которых лежит наша информация. Например, у меня первым подгружается файл 2.html и он имеет такое содержимое:

В моей структуре сайта, страницы из которых будет браться информация для последующей загрузке при клике, лежит в папке pages. Там три файла, два из которых заполнены, а последний — пустой. Это предполагает логика скрипта.

Путь в скрипте указан следующим образом:

Var url = "./pages/" + page + ".html";

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

ButtonId = "#moreButton", loadingId = "#loadingDiv", container = "#smartPortfolio";

И, как я уже говорил, перед закрывающимся тегом body подключаем сам скрипт:

Вот так на landing page можно реализовать «ленивую загрузку». Присылайте еще темы, на которые вы хотели-бы почитать статью на блоге. По мере возможности буду стараться публиковать не запланированный материал, а тот, о котором спрашиваете вы в разделе «Ваши предложения». А на сегодня — все. Пока!

Перевод
Tutorial

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

Использование контейнера для каждого изображения Простой способ, который можно применить к любому изображению на сайте. Заключается в том, что каждая картинка оборачивается в DIV, который предотвращает построчную загрузку:

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

Например, чтобы задать соотношение сторон 4:3, можно использовать следующий CSS:

Img_wrapper{ position: relative; padding-top: 75%; overflow: hidden; } .img_wrapper img{ position: absolute; top: 0; width: 100%; opacity: 0; }
Для того, чтобы изображение отображалось в браузере только после полной подгрузки, необходимо добавить событие onload для изображения и использовать JavaScript, который будет обрабатывать событие:

function imgLoaded(img){ var $img = $(img); $img.parent().addClass("loaded"); };
Код функции внутри тега HEAD должен быть расположен в самом конце, после любого jQuery или другого плагина. После полной подгрузки изображения его необходимо показать на странице:

Img_wrapper.loaded img{ opacity: 1; }
Для эффекта плавного появления картинки можно использовать CSS3 transition:

Img_wrapper img{ position: absolute; top: 0; width: 100%; opacity: 0; -webkit-transition: opacity 150ms; -moz-transition: opacity 150ms; -ms-transition: opacity 150ms; transition: opacity 150ms; }
Живой пример этого способа можно .

Использование контейнера для множества изображений Предыдущий способ хорошо подходит для отдельных изображений, а что если на странице их много, например галерея фотографий или слайдер? Подгружать сразу все нецелесообразно - картинки могут много весить. Для решения этой проблемы можно заставить JavaScript"ом загружать только нужные в данный момент времени изображения. Пример HTML-разметки для слайдшоу:

Используем функцию slideLoaded(), чтобы контролировать процесс:

Function slideLoaded(img){ var $img = $(img), $slideWrapper = $img.parent(), total = $slideWrapper.find("img").length, percentLoaded = null; $img.addClass("loaded"); var loaded = $slideWrapper.find(".loaded").length; if(loaded == total){ percentLoaded = 100; // INSTANTIATE PLUGIN $slideWrapper.easyFader(); } else { // TRACK PROGRESS percentLoaded = loaded/total * 100; }; };
Подгруженным изображениям присваивается класс loaded, а также отображается общий прогресс. И снова, JavaScript должен быть помещен в конец тега HEAD, после всего остального.

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

var heroArray = [ "/uploads/hero_about.jpg", "/uploads/hero_history.jpg", "/uploads/hero_contact.jpg", "/uploads/hero_services.jpg" ]
Когда посетитель заходит на сайт, после загрузки главной страницы, начинают загружаться изображения в кэш. Для того, чтобы кэширование не мешало отображению текущего контента, необходимо функционал JavaScript добавить в событие window load:

Function preCacheHeros(){ $.each(heroArray, function(){ var img = new Image(); img.src = this; }); }; $(window).load(function(){ preCacheHeros(); });
Такой способ улучшает удобство использования сайта, однако дает дополнительную нагрузку на сервер. Это нужно иметь в виду при внедрении подобного функционала. Кроме того, необходимо обязательно учитывать возможные пути посетителей на сайте и кэшировать изображения, расположенные на страницах, которые пользователь вероятнее всего посетит. Чтобы понять такие пути по сайту, необходимо анализировать статистику посещаемости.

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

Стоит заметить, что URL изображение задано в data-src, а не в src. Это необходимо, чтобы браузер не загружал картинку сразу. Вместо этого в src загружается прозрачный пиксель в GIF, заданный в base64, что уменьшает количество обращений к серверу.

Остается только при нужном событии изменить значение src на data-src. JavaScript позволяет загружать изображения постепенно:

Function lazyLoad(){ var $images = $(".lazy_load"); $images.each(function(){ var $img = $(this), src = $img.attr("data-src"); $img .on("load",imgLoaded($img)) .attr("src",src); }); }; $(window).load(function(){ lazyLoad(); };

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