Методы оптимизации JavaScript для более быстрой загрузки веб-сайта. Подробное руководство
год назад·11 мин. на чтение
Освойте оптимизацию JavaScript для повышения производительности веб-сайта: минимизируйте размеры файлов, уменьшите количество запросов, используйте кэширование и асинхронную загрузку, а также используйте лучшие практики для более быстрой загрузки и улучшения UX.
В современном быстро меняющемся цифровом мире производительность веб-сайта играет решающую роль в определении успеха любого онлайн-бизнеса. Быстрый, отзывчивый и удобный веб-сайт не только привлекает и удерживает посетителей, но и способствует повышению рейтинга в поисковых системах, повышению коэффициента конверсии и улучшению пользовательского опыта (UX). Как инженер-программист или веб-разработчик, важно расставить приоритеты в методах оптимизации производительности в своих проектах.
В этой статье рассмотрим различные методы оптимизации кода JavaScript, включая минимизацию размеров файлов, сокращение сетевых запросов, использование кэширования и асинхронной загрузки, а также использование лучших практик для обеспечения более быстрой загрузки и улучшения UX.
Заголовки
Двумя важными заголовками для управления кэшированием браузера являются
Использование атрибутов
Атрибуты Пример кода JavaScript: использование
Рассмотрим пример использования атрибутов
Минимизация размеров файлов
Одним из важнейших факторов, влияющих на время загрузки веб-сайта, является размер файлов, предоставляемых пользователю. Загрузка больших файлов занимает больше времени и может привести к медленной загрузке вашего веб-сайта, что приведет к неоптимальному взаимодействию с пользователем. Файлы JavaScript не являются исключением, и оптимизация их размеров является фундаментальным шагом в повышении производительности вашего сайта. Минификация — это процесс удаления ненужных символов (таких как пробелы, комментарии и разрывы строк) и сокращения имен переменных в коде JavaScript без ущерба для его функциональности. Это приводит к значительно меньшему размеру файла, что, в свою очередь, приводит к более быстрой загрузке и повышению производительности.Пример кода JavaScript: до и после минификации
Давайте посмотрим на простой пример, чтобы понять влияние минификации на размер файла: Перед минификацией:После минификации:// Функция вычисления суммы двух чисел function addNumbers(num1, num2) { return num1 + num2; } // Вызов функции для вычисления суммы 3 и 5 const sum = addNumbers(3, 5); // Вывод результата в консоль console.log("The sum is:", sum);
Как вы можете видеть, уменьшенная версия кода значительно меньше, с удаленными ненужными символами и сокращенными именами переменных. Это приводит к меньшему размеру файла и более быстрой загрузке, не влияя на функциональность кода.function addNumbers(n,e){return n+e}const sum=addNumbers(3,5);console.log("The sum is:",sum);
Сжатие файлов
Сжатие — это еще один метод, используемый для уменьшения размера файлов, что приводит к сокращению времени загрузки веб-сайта. Он работает, применяя алгоритмы для сжатия данных в файлах, делая их меньше без потери их функциональности. Когда браузер запрашивает сжатый файл, он распаковывается на лету, что позволяет правильно отображать и выполнять содержимое. Существует два широко используемых алгоритма сжатия файлов JavaScript: Gzip и Brotli. Gzip долгое время был стандартом де-факто, но Brotli, новый алгоритм сжатия, разработанный Google, становится все более популярным благодаря превосходной степени сжатия и скорости.Методы сжатия Gzip и Brotli
Gzip: Gzip — это широко распространенный алгоритм сжатия, который может значительно уменьшить размер файлов JavaScript. Gzip использует алгоритм Deflate, который сочетает в себе кодирование LZ77 и Huffman для эффективного сжатия данных. Brotli: Brotli — это более новый алгоритм сжатия, разработанный Google, обеспечивающий лучшую степень сжатия, чем Gzip. Brotli использует комбинацию LZ77, кодирования Хаффмана и новой техники моделирования контекста для достижения более высоких степеней сжатия. В большинстве случаев Brotli превосходит Gzip как по степени сжатия, так и по скорости, что делает его привлекательным вариантом для современных веб-приложений.Конфигурация на стороне сервера для сжатия
Для обслуживания сжатых файлов JavaScript необходимо настроить сервер на сжатие файлов с помощью Gzip или Brotli перед их отправкой клиенту. Конкретные шаги настройки различаются в зависимости от типа вашего сервера (например, Apache, Nginx или Node.js). Вот краткий обзор того, как включить сжатие на популярных типах серверов:- Apache: Включите модуль
mod_deflate
для сжатия Gzip илиmod_brotli
для сжатия Brotli и настройте соответствующие параметры в файле.htaccess
или конфигурации виртуального хоста. - Nginx: Используйте директивы
gzip
илиbrotli
в конфигурационном файле Nginx, чтобы включить сжатие и указать настройки. - Node.js: Для серверов на базе Node.js вы можете использовать промежуточное программное обеспечение (middleware), такое как
compression
для Gzip илиshrink-ray-current
для Brotli в сочетании с Express или аналогичным веб-фреймворком.
Бандлинг для сокращения сетевых запросов
Сокращение количества сетевых запросов имеет решающее значение для повышения производительности веб-сайта, поскольку каждый запрос увеличивает задержку и потребляет пропускную способность.Что такое бандлинг?
Бандлинг — это процесс объединения нескольких файлов JavaScript в один файл. Это уменьшает количество HTTP-запросов, которые необходимо сделать браузеру, тем самым ускоряя процесс загрузки. Объединение может значительно повысить производительность веб-сайта, особенно для веб-сайтов с большим количеством файлов JavaScript меньшего размера.Инструменты для бандлинга
Существует несколько популярных инструментов для объединения файлов JavaScript, каждый из которых имеет свои уникальные функции и преимущества. Вот несколько широко используемых инструментов для комплектации:- Webpack: Webpack — это мощный и гибкий сборщик модулей, который не только объединяет файлы JavaScript, но и обрабатывает другие ресурсы, такие как css и изображения. Он имеет надежную экосистему плагинов, позволяющую расширять его функциональность по мере необходимости.
- Rollup: Rollup — еще один популярный сборщик модулей JavaScript, ориентированный на простоту и производительность. Он особенно хорошо подходит для объединения библиотек и может выводить несколько форматов, включая модули CommonJS, AMD и ES.
Пример кода JavaScript: объединение нескольких файлов
Чтобы продемонстрировать процесс объединения, предположим, что у вас есть три отдельных файла JavaScript:// main.js import { greet } from './greeting.js'; import { calculate } from './math.js'; console.log(greet('John')); console.log(calculate(5, 3));
// greeting.js export function greet(name) { return `Hello, ${name}!`; }
Используя инструмент бандлинга, такой как Webpack или Rollup, вы можете объединить эти файлы в один связанный файл. Выходные данные могут выглядеть примерно так:// math.js export function calculate(x, y) { return x * y; }
Как видите, результирующий файл содержит весь необходимый код из исходных файлов в одном автономном блоке, что сокращает количество сетевых запросов, необходимых для загрузки скриптов. Минимизируя количество запросов, вы можете сократить время, необходимое браузеру для загрузки и обработки необходимых ресурсов, что приведет к более быстрой загрузке и более отзывчивому взаимодействию с пользователем.(function () { 'use strict'; function greet(name) { return `Hello, ${name}!`; } function calculate(x, y) { return x * y; } console.log(greet('John')); console.log(calculate(5, 3)); })();
Использование спрайтов для изображений и иконок
Использование спрайтов изображений — еще один метод сокращения сетевых запросов и повышения производительности веб-сайта. Спрайты — это, по сути, один файл изображения, содержащий несколько изображений меньшего размера, таких как значки или элементы пользовательского интерфейса.Что такое спрайт изображения
Спрайт изображения — это большое изображение, содержащее несколько изображений меньшего размера, расположенных в виде сетки. В коде CSS или JavaScript вы можете ссылаться на отдельные изображения в спрайте, указывая их положение и размеры. Этот метод позволяет загружать множество изображений с помощью всего одного HTTP-запроса, уменьшая задержку и сокращая время загрузки.Создание спрайтов изображений
Для создания спрайта изображения можно использовать различные инструменты, такие как:- Инструменты генератора спрайтов: Онлайн-инструменты, такие как SpritePad или Stitches, позволяют загружать несколько изображений и автоматически генерировать спрайт вместе с соответствующим кодом CSS.
- Программное обеспечение для редактирования изображений: такие программы, как Adobe Photoshop или GIMP, можно использовать для ручного создания спрайтов, упорядочивая меньшие изображения в новом файле и экспортируя результат в виде одного изображения.
Пример кода CSS: использование спрайтов изображений
Предположим, что есть изображение спрайта с именемicons.png
, содержащее несколько значков. Вы можете использовать следующий CSS код для отображения отдельных значков в качестве фоновых изображений для разных элементов:
Каждый класс значков определяет положение соответствующей иконки внутри спрайта, что позволяет отобразить нужное изображение без дополнительных HTTP-запросов. Объединяя эти меньшие изображения в один файл, браузеру нужно запросить только одно изображение, уменьшая количество HTTP-запросов..icon { width: 32px; height: 32px; background-image: url('icons.png'); } .icon-search { background-position: 0 0; } .icon-settings { background-position: -32px 0; } .icon-user { background-position: -64px 0; }
Ленивая загрузка ресурсов
Ленивая загрузка — это метод, который откладывает загрузку некритических ресурсов до тех пор, пока они действительно не понадобятся. Это означает, что вместо того, чтобы загружать все ресурсы заранее, вы загружаете только те, которые необходимы для немедленного просмотра, в то время как остальные извлекаются по мере их актуальности. Отложенная загрузка может значительно улучшить начальное время загрузки и воспринимаемую производительность веб-сайта, особенно при работе с большими ресурсами, такими как изображения или длинные скрипты.Пример кода JavaScript: реализация отложенной загрузки
Чтобы проиллюстрировать отложенную загрузку, давайте воспользуемся примером загрузки изображений только тогда, когда они становятся видимыми в окне просмотра. Это можно сделать с помощью APIIntersectionObserver
. Вот простая реализация:
Во-первых, добавьте data-src
к элементам изображения, содержащий фактический источник изображения:
Затем создайте скрипт, который настраивает<img data-src="path/to/image.jpg" class="lazy-load" alt="An example image">
IntersectionObserver
для загрузки изображений по мере их поступления в окно просмотра (viewport):
В этом примереdocument.addEventListener('DOMContentLoaded', function () { const lazyImages = [].slice.call(document.querySelectorAll('.lazy-load')); if ('IntersectionObserver' in window) { const lazyImageObserver = new IntersectionObserver(function (entries, observer) { entries.forEach(function (entry) { if (entry.isIntersecting) { const lazyImage = entry.target; lazyImage.src = lazyImage.dataset.src; lazyImage.classList.remove('lazy-load'); lazyImageObserver.unobserve(lazyImage); } }); }); lazyImages.forEach(function (lazyImage) { lazyImageObserver.observe(lazyImage); }); } });
IntersectionObserver
следит за тем, чтобы изображения .lazy-load
попадали в окно просмотра. При обнаружении изображения атрибуту src
присваивается атрибут data-src
, что приводит к фактической загрузке изображения. После загрузки образа класс .lazy-load
удаляется, и наблюдение за изображением останавливается (.unobserve()
).
Используя эту простую технику отложенной загрузки, вы можете гарантировать, что загружаются только те изображения, которые в данный момент находятся в поле зрения, уменьшая количество сетевых запросов и улучшая начальное время загрузки вашего веб-сайта.
Использование кэширования
Производительность веб-сайта является решающим фактором в обеспечении отличного пользовательского опыта. Одним из важных методов повышения производительности является кэширование, которое позволяет браузерам хранить копии ресурсов вашего веб-сайта, таких как изображения, таблицы стилей и скрипты. Это снижает потребность в повторных загрузках и ускоряет время загрузки. В этом разделе мы рассмотрим концепцию кэширования и то, как вы можете использовать его для повышения производительности вашего сайта.Кэширование браузера
Кэширование браузера — это механизм, который позволяет веб-браузерам локально хранить копии файлов веб-сайта. Когда пользователь повторно посещает ваш сайт, браузер может загружать эти ресурсы из кэша вместо того, чтобы загружать их снова, что приводит к более быстрой загрузке и снижению нагрузки на сервер. Настроив сервер на доставку соответствующих заголовков кэширования, можно контролировать, какие ресурсы кэшируются и на какой срок.Заголовки Cache-Control
и ETag
Двумя важными заголовками для управления кэшированием браузера являются Cache-Control
и ETag
. Заголовок Cache-Control
позволяет задать директивы кэша, такие как максимальный срок службы ресурса в кэше или необходимость его повторной проверки. Например, можно использовать Cache-Control: public, max-age=3600
, чтобы указать, что ресурс может кэшироваться в течение одного часа.
Заголовок ETag
предоставляет уникальный идентификатор (обычно хэш) для определенной версии ресурса. Когда браузер запрашивает ресурс, он отправляет значение ETag
, которое находится в его кэше. Если значение ETag
сервера совпадает со значением, отправленным браузером, сервер отвечает статусом 304 Not Modified
, и браузер использует кэшированную версию. Этот механизм помогает гарантировать, что браузер всегда имеет самую последнюю версию ресурса.
Настройка кэширования на стороне сервера
Чтобы включить кэширование браузера, необходимо настроить сервер на доставку соответствующих заголовков для ресурсов. Этот процесс зависит от программного обеспечения сервера. Например, на сервере Apache вы можете использовать файл.htaccess
для установки заголовков кэширования:
Эта конфигурация задает заголовок<filesMatch ".(css|js|jpg|png)$"> Header set Cache-Control "public, max-age=86400" </filesMatch>
Cache-Control
для файлов CSS, JS, JPG и PNG, что позволяет кэшировать их в течение 24 часов.
Используя кэширование браузера, вы можете значительно сократить объем данных, которые необходимо извлекать при повторном посещении пользователем вашего сайта, ускоряя время загрузки и улучшая общий пользовательский опыт.
Использование асинхронной загрузки
По мере усложнения веб-сайтов управление загрузкой файлов JavaScript становится все более важным для производительности. По умолчанию браузеры загружают скрипты синхронно, блокируя процесс отрисовки до тех пор, пока скрипт не будет полностью загружен и выполнен. Асинхронная загрузка позволяет загружать скрипты параллельно с другими ресурсами, предотвращая их блокировку рендеринга и сокращая общее время загрузки. В этом разделе мы обсудим, как использовать асинхронную загрузку файлов JavaScript для повышения производительности вашего веб-сайта.Асинхронная загрузка файлов JavaScript
Асинхронная загрузка позволяет браузерам загружать и выполнять файлы JavaScript, не блокируя рендеринг остальной части страницы. Такой подход не только ускоряет первоначальный рендеринг вашего веб-сайта, но и снижает риск того, что медленный или не отвечающий скрипт вызовет задержки. С помощью атрибутовasync
и defer
можно управлять загрузкой и выполнением файлов JavaScript.
Использование атрибутов Async
и Defer
Атрибуты async
и defer
можно добавить в тег <script>
, чтобы включить асинхронную загрузку:
async
: атрибутasync
указывает браузеру загрузить сценарий, не блокируя рендеринг. Как только скрипт будет загружен, браузер приостановит рендеринг для его выполнения. Это полезно для скриптов, которые не полагаются на другие скрипты или полную загрузку модели DOM.defer
: атрибутdefer
предписывает браузеру загрузить скрипт, не блокируя рендеринг, но откладывает выполнение до тех пор, пока модель DOM не будет полностью проанализирована. Это полезно для скриптов, зависящих от модели DOM или других скриптов.
Пример кода JavaScript: использование async
и defer
Рассмотрим пример использования атрибутов async
и defer
в HTML-файле:
В этом примере<!DOCTYPE html> <html> <head> <!-- Использование атрибута defer --> <script src="main.js" defer></script> </head> <body> <!-- Использование атрибута async --> <script src="analytics.js" async></script> </body> </html>
main.js
загружается с атрибутом defer
, гарантируя, что он не будет блокировать рендеринг и будет выполнен после полного анализа DOM. Между тем, analytics.js
загружается с атрибутом async
, что позволяет ему загружаться и выполняться независимо от остальной части страницы.
Используя асинхронную загрузку файлов JavaScript, вы можете свести к минимуму ресурсы, блокирующие рендеринг, и повысить производительность и удобство работы вашего веб-сайта.
Использование лучших практик для более быстрой загрузки и улучшения UX
Оптимизация веб-сайта — это непрерывный процесс, и для максимальной производительности важно идти в ногу с последними передовыми методами.Разделение кода
Разделение кода — это метод, который включает в себя разбиение кода JavaScript на более мелкие, более управляемые фрагменты, которые загружаются только при необходимости. Это уменьшает объем кода, который необходимо загрузить и проанализировать, что приводит к более быстрой начальной загрузке и более плавному взаимодействию. Разделение кода особенно полезно для одностраничных приложений (SPA) и больших веб-сайтов со сложной функциональностью. Несколько инструментов могут помочь вам реализовать разделение кода, например Webpack и React.lazy:- Webpack: Этот популярный сборщик предлагает встроенную поддержку разделения кода. Используя функцию динамического импорта
import()
, вы можете загружать модули JavaScript по запросу, сокращая время первоначальной загрузки. - React.lazy: Если вы используете React, функция React.lazy позволяет загружать компоненты лениво по мере необходимости, что еще больше оптимизирует ваше приложение.
Пример кода JavaScript: реализация разделения кода
Ниже приведен пример разделения кода с помощью Webpack и React:В этом примереimport React, { lazy, Suspense } from 'react'; // Ленивая загрузка компонента с React.lazy const MyComponent = lazy(() => import('./MyComponent')); function App() { return ( <div> <Suspense fallback={<div>Loading...</div>}> <MyComponent /> </Suspense> </div> ); } export default App;
MyComponent
загружается лениво, когда это необходимо, что не позволяет блокировать начальную отрисовку приложения.
Использование сетей доставки контента (CDN)
Сети доставки контента (CDN) — это мощный способ повысить производительность веб-сайта за счет распределения контента по нескольким серверам по всему миру. Это гарантирует, что пользователи смогут получить доступ к ресурсам вашего веб-сайта с сервера, расположенного рядом с их местоположением, что уменьшит задержку и ускорит время загрузки. Интеграция вашего веб-сайта с CDN может значительно улучшить взаимодействие с пользователем, особенно для пользователей в отдаленных географических точках.Оптимизация манипулирования DOM и обработки событий
Эффективное манипулирование DOM имеет решающее значение для повышения производительности веб-сайта. Модель DOM (Document Object Model) представляет структуру веб-страницы, и управление ею может быть ресурсоемким. Оптимизируя код JavaScript для работы с DOM, вы можете свести к минимуму влияние на производительность и создать более плавный пользовательский интерфейс.Пример кода JavaScript: эффективное манипулирование DOM
Ниже приведен пример оптимизации манипуляций с DOM:// Неэффективная работа с DOM const list = document.querySelector('#list'); for (let i = 0; i < 1000; i++) { const item = document.createElement('li'); item.textContent = `Item ${i}`; list.appendChild(item); }
В эффективном примере мы используем// Эффективная работа с DOM const list = document.querySelector('#list'); const fragment = document.createDocumentFragment(); for (let i = 0; i < 1000; i++) { const item = document.createElement('li'); item.textContent = `Item ${i}`; fragment.appendChild(item); } list.appendChild(fragment);
DocumentFragment
для пакетных операций DOM, уменьшая количество перекомпоновок и перерисовок и повышая производительность.
Инструменты разработчика браузера
Большинство современных браузеров поставляются со встроенными инструментами разработчика, которые помогут вам отслеживать и оптимизировать производительность вашего веб-сайта. Например, Chrome DevTools и Firefox Developer Tools предлагают такие функции, как профилирование производительности, мониторинг сети и отладка JavaScript. С помощью этих средств можно выявить узкие места и области, требующие улучшения в коде.Онлайн-инструменты
Существуют также онлайн-инструменты, которые помогут вам проанализировать и оптимизировать производительность вашего сайта. Некоторые популярные варианты включают в себя:- Google PageSpeed Insights: Этот инструмент анализирует ваш веб-сайт и предоставляет предложения по повышению его производительности. Он учитывает такие факторы, как время отклика сервера, оптимизация изображений и методы загрузки JavaScript.
- WebPageTest: WebPageTest — это комплексный инструмент тестирования производительности, который предоставляет подробную информацию о времени загрузки вашего веб-сайта, рендеринге и многом другом. Вы также можете сравнить производительность своего веб-сайта с другими сайтами или запустить тесты из разных мест и устройств.
Итоги
В этой статье мы рассмотрели методы оптимизации JavaScript, которые помогут вам повысить производительность вашего сайта и удобство для пользователей. От минимизации размеров файлов и сокращения сетевых запросов до использования кэширования и асинхронной загрузки — эти методы могут оказать значительное влияние на время загрузки вашего сайта.Что такое сайд эффекты в ES модулях и как они влияют на бандл?
год назад·6 мин. на чтение
В этой статье разберемся что такое сайд эффекты, рассмотрим поле sideEffects в package.json, и как его значение влияет на финальный бандл и на tree shaking.
Многие проекты используют webpack в качестве сборщика, который может уменьшить размер своих выходных бандлов с помощью встряхивания дерева (tree shaking, удаления мертвого кода). Однако встряхивание деревьев может работать эффективно только в том случае, если оно знает о побочных эффектах в вашем коде и в пакетах, которые вы используете. В этой статье разберемся, что такое побочные эффекты, почему webpack должен знать о них и что он делает с этими знаниями.
Однако, если бы это произошло внутри функции
Webpack поддерживает ряд сложных функций сопоставления, поэтому другой подход, который вы можете использовать, заключается в инвертировании вещей и объявлении путей без побочных эффектов, оставляя webpack предполагать, что все остальное может иметь побочные эффекты:
Что такое побочные эффекты?
Побочным эффектом (сайд эффект, side effect) в контексте модуля ECMAScript является код, который выполняет некоторое внешне видимое поведение (то есть поведение, видимое вне модуля) при загрузке модуля. Вот пример:import { registerThing } from 'thing-registry'; const store = registerThing( THING_KEY, { /* ... */ } );
registerStore
вызывается на верхнем уровне, что означает, что он будет запущен, как только модуль будет впервые импортирован. Эти изменения видны внешне, так как вещи модифицируются во внешнем хранилище, которое находится в другом модуле (thing-registry
). Другие примеры побочных эффектов включают установку глобальных значений в window
или добавление поведения браузера с помощью полифиллов (polyfills).
init
, которая не вызывается при загрузке модуля, то это больше не было бы побочным эффектом:
Объявление переменной или выполнение каких-либо изменений на верхнем уровне, которые влияют только на текущий модуль, также не является побочным эффектом, поскольку они содержатся в модуле:import { registerThing } from 'thing-registry'; export function init() { const store = registerThing( THING_KEY, { /* ... */ } ); } // `init` не вызывается на верхнем уровне модуля, // и таким образом импорт этого модуля не вызывает сайд эффектов.
import list from './list'; // не сайд эффект let localVariable = []; // тоже не сайд эффект for ( const entry of list ) { localVariable.push( processListEntry( entry ) ); }
Влияние побочных эффектов на сборку
Большинство современных сборщиков реализуют tree shaking, при котором неиспользуемый код удаляется из финальных бандлов, так как в этом нет необходимости. Это становится важным в библиотеках, которые предлагают множество различных функций, поскольку потребители этой библиотеки могут использовать только небольшую ее часть и не хотят, чтобы их бандлы были больше, чем необходимо. Таким образом, пакеты и библиотеки должны предпринять шаги для обеспечения того, чтобы их действительно можно было правильно встряхнуть. Это возвращает нас к побочным эффектам. Как мы видели, побочные эффекты — это код, который запускается просто в силу импорта модуля и оказывает какое-то внешнее влияние. Это означает, что код не может быть вытряхнут деревом; Он должен работать, потому что он изменяет вещи за пределами модуля, которые могут понадобиться в другом месте. К сожалению, побочные эффекты трудно определить автоматически, и некоторые сборщики (например, webpack) ошибаются в сторону осторожности, предполагая, что каждый модуль потенциально имеет побочные эффекты. Это становится проблемой дляindex
модулей, которые повторно экспортируют (ре-экспортируют) вещи из других модулей, поскольку это фактически означает, что все, что там есть, теперь должно быть объединено вместе:
// index.js export { a, b } from './module1'; export { c, d, e } from './module2'; export { f } from './module3'; // Tree shaking не может быть применен, т.к. сборщик не знает // имеют ли эти ре-экспортируемые модули сайд эффекты.
Рассказываем сборщикам о побочных эффектах
Поскольку сборщики не могут сами разобраться в побочных эффектах, нам нужно явно заявить о них. Это делается вpackage.json
пакетов.
Это означает, что объявление побочных эффектов является обязанностью пакета, и для пакетов, которые этого не делают, webpack, скорее всего, не сможет ничего стереть. Пользователи такого пакета могут в конечном итоге вытащить все это в свою сборку, даже если они используют только небольшую часть пакета, часто без простого способа обойти его.
Так как же заявить о побочных эффектах? Лучший способ сделать это зависит от того, насколько вы их используете и где они находятся в вашем коде.
Очень часто ваш пакет вообще не будет использовать никаких побочных эффектов. В этой ситуации вы можете просто установить sideEffects
значение false
:
Если в нем есть несколько файлов с побочными эффектами, вы можете перечислить их:{ "name": "package", "sideEffects": false }
Это позволяет сборщику предполагать, что только те модули, которые были объявлены, имеют побочные эффекты, а ничто другое не имеет. Конечно, это означает, что мы должны быть осторожны, чтобы включить все, что имеет побочные эффекты, или проблемы могут возникнуть в приложениях, использующих пакет.{ "name": "package", "sideEffects": [ "dist/store.js", "dist/polyfill.js" ] }
Приведенный выше пример говорит сборщику, что он должен предполагать, что все, что находится за пределами каталогов{ "name": "package", "sideEffects": [ "!(dist/(components|utils)/**)" ] }
components
и utils
, содержит побочные эффекты. Этот подход должен гарантировать, что все в components
и utils
может быть встряхнуто деревом без проблем с побочными эффектами и потенциально вызовет проблемы только в том случае, если один из файлов там использует побочные эффекты.
В некоторых ситуациях может быть предпочтительнее пометить конкретный вызов функции как не имеющий побочных эффектов, а не весь файл. Рассмотрим следующий пример:
Сборщик не может определить, содержит ли вызов верхнего уровняfunction noSideEffects() { // Do something. } noSideEffects();
noSideEffects
какие-либо побочные эффекты. Одним из решений было бы включение модуля в поле package.json
sideEffects
, как мы видели выше. Однако мы также можем обрабатывать его в коде с помощью подсказки PURE
:
function noSideEffects() { // Do something. } /*#__PURE__*/ noSideEffects();
Потеря побочных эффектов у потребителя
Рассмотрим другой случай. Теперь вы являетесь потребителем и импортируете пакет, в котором используются побочные эффекты. Вы хотите их использовать. На самом деле, вы полагаетесь на то, что эти побочные эффекты произойдут, иначе ваш код не будет работать правильно. Вы можете столкнуться с некоторыми ситуациями, когда побочные эффекты неожиданно пропадают. Вот пример:// index.js import 'side-effectful-module'; export { a, b } from './impl';
В// impl.js function a() { // что-то делает } function b() { // делает что-то, что зависит от произошедших сайд эффектов }
index.js
мы видим то, что часто называют “голым импортом” (naked import). Этот синтаксис означает, что мы не используем ни один из экспортов модуля, и нас фактически интересуют только его побочные эффекты. Голый импорт сам по себе не является побочным эффектом, но он является очень сильным сигналом о том, что побочные эффекты присутствуют во всем, что вы импортируете.
index.js
не делает ничего, кроме импорта side-effectful-module
, просто ре-экспортируя функции из impl.js
. Ключевым моментом здесь является то, что функции в impl.js
на самом деле зависят от побочного эффекта, который происходит в index.js
.
Если встряхивание деревьев отключено, например, в режиме разработки, все будет работать правильно. Однако, если встряхивание дерева включено, модуль index.js
может быть удален из дерева, оставив только фактические функции из impl.js
. Если это произойдет, побочный эффект будет потерян, и b
потерпит неудачу.
То же самое может произойти, если импорт выполняется в дочернем модуле:
// index.js import { unused } from './util'; function b() { // делает что-то, что зависит от произошедших сайд эффектов } // Этот модуль не использует функцию `unused`.
Поскольку// util.js import "side-effectful-module"; export function unused() { // делает что-то, что зависит от произошедших сайд эффектов }
unused
не используется в index.js
, он будет вытряхнут деревом. Это означает, что ничего из impl.js
больше не нужно, поэтому ничего из этого не будет загружено. В очередной раз мы теряем побочный эффект, хотя он необходим.
Предотвращение побочных эффектов при встряхивании деревьев
Поскольку эти побочные эффекты по существу являются автоматически выполняемыми безымянными зависимостями, мы должны рассматривать их как таковые. Если в модуле есть код, который зависит от побочного эффекта, мы должны быть уверены, что импортируем его туда. Второй пример можно легко исправить с помощью дополнительного импорта вindex.js
:
Это гарантирует, что// index.js import "side-effectful-module"; import { unused } from './util'; function b() { // делает что-то, что зависит от произошедших сайд эффектов } // этот модуль все еще не использует `unused`.
side-effectful-module
будет выполняться перед любым кодом в index.js
и не будет вытряхиваться из дерева.
Обратите внимание, что теперь мы импортируем побочный эффект в оба модуля, но это нормально! Модули ES запускаются только один раз, а это означает, что их побочные эффекты также будут запускаться только один раз, независимо от того, сколько файлов они импортированы.
Подведем итоги
В итоге получилась тонна информации, поэтому давайте попробуем обобщить практические советы:- Если ваша библиотека не содержит побочных эффектов, установите
sideEffects: false
вpackage.json
. - Если ваша библиотека содержит побочные эффекты, вы все равно можете включить встряхивания деревьев насколько это возможно. Перечислите файлы с побочными эффектами в явном виде или используйте обратные условия, чтобы перечислить пути, которые не имеют побочных эффектов.
- Если вы полагаетесь на побочные эффекты от внешнего модуля, обязательно импортируйте этот модуль везде, где вы их используете.