Что за файл main js
Обновлено: 30.06.2024
Подключение js-файлов нужно для выполнения в браузере скриптов, написанных на языке JavaScript.
Если в каком-либо шаблоне нужен скрипт, написанный на языке JavaScript, его можно вынести в отдельный js-файл, и дать файлу имя, совпадающее с именем шаблона. Сам файл нужно поместить в папку templates. Больше никаких настроек не требуются – файл будет подключаться автоматически.
Допустим, в шаблоне menu.tpl нужно применять скрипт выпадающего подменю. Создаем файл menu.js со скриптом, который будет подключаться автоматически при каждом выводе блока с шаблоном menu.tpl.
Файл _main.js
По аналогии с файлом _main.css, существует и файл _main.js. В этот файл можно собрать js-скрипты, необходимые для всех страниц.
Правда, такой файл на практике используется редко, так как обычно js-скрипты относятся к шаблонам.
В этот файл рекомендуется помещать уникальные скрипты, созданные именно для данного сайта. Скрипты же из сторонних файлов (например: jquery.js) собирать в файл _main.js не нужно — для этих целей применяйте подключение с помощью метода Blox::addToHead().
Конфликты js-скриптов
Не рекомендуется js-скрипты записывать в html-код (то есть, в шаблоны). Может так случиться, что какой-то шаблон будет назначен на одной странице в двух блоках, и тогда возникнут накладки.Все js-скрипты лучше записывать в js-файлы, как в файлы вида шаблон.js, так и в самостоятельные. Последние нужно подключать с помощью метода Blox::addToHead(). В обоих случаях система будет блокировать вторичное подключение одного и того же файла.
Метод Blox::addToHead() вместе с методом Blox::addToFoot() позволяют гибко управлять очередностью подключения файлов.
Все, что было сказано по поводу очередности подключения css-файлов относится и js-файлам.
См. также
- Подключение js-файлов означает, что в разделе заголовка документа (элемент head), который находится в главном шаблоне, будут автоматически сгенерированы соответствующие html-коды для подключения этих файлов. Сам главный шаблон желательно не редактировать.
- О том, как ссылаться на изображения (логотип, фоновое изображение и т.п.) из js-файлов, читайте в статье "Абсолютные и относительные URL".
Обычно между щелчком мыши по веб-странице и изменением на ней существует некоторая задержка по времени, необходимая, для того чтобы компьютер пользователя отправил запрос на веб-сервер, а затем получил готовую страницу. C помощью JavaScript можно мгновенно вносить изменения в веб-страницу, так как скрипты выполняются тут же на компьютере, а не на сервере. Скрипты могут быть внедрены как в саму страницу (шаблоны), так и записаны в отдельные файлы .js.
Чаще всего JavaScript используют для организации выпадающих меню, предварительной проверки данных форм, небольших интерактивных элементов страницы, разных "красивостей" типа эффекта падающего снега, шлейфа за указателем мыши и т.п.
Представляю вашему вниманию перевод статьи «Understanding (all) JavaScript module formats and tools» автора Dixin.
При создании приложения часто возникает желание разделить код на части, логические или функциональные блоки (модули). Однако JavaScript изначально не имел поддержки модулей. Это привело к появлению различных модульных технологий. В настоящей статье обсуждаются все основные понятия, шаблоны, библиотеки, синтаксис и инструменты для работы с модулями в JavaScript.
IIFE модуль: шаблон JS модуля
Определяя переменную в JS, мы определяем ее как глобальную переменную. Это означает, что такая переменная будет доступна во всех файлах JS, загружаемых на текущей странице:
Для того, чтобы избежать загрязнения глобального пространства имен, можно использовать анонимную функцию:
Вуаля, глобальных переменных больше нет. Однако код внутри функции не выполняется.
IIFE: немедленно вызываемое функциональное выражение
Для того, чтобы выполнить код внутри функции f , ее необходимо вызвать с помощью () как f() . Для выполнения кода внутри анонимной функции (() => <>) следует также использовать () . Это выглядит так (() => <>)() :
Это называется IIFE (немедленно вызываемым функциональным выражением). Модуль может быть определен следующим образом:
Мы оборачиваем код модуля в IIFE. Анонимная функция возвращает объект. Это заменяет интерфейс экспорта. Присутствует только одна глобальная переменная — название модуля (или его пространство имен). Впоследствии название модуля может использоваться для его вызова (экспорта). Это называется шаблоном JS модуля.
Примеси импорта
При определении модуля могут потребоваться некоторые зависимости. При использовании модульного шаблона каждый зависимый модуль — глобальная переменная. Зависимые модули могут определяться внутри анонимной функции или передаваться ей в качестве аргументов:
Ранние версии популярных библиотек, таких как jQuery, использовали этот шаблон (в последней версии jQuery используется UMD модуль).
Открытый модуль: шаблон открытого JS модуля
Шаблон открытого модуля был придуман Christian Heilmann. Этот шаблон также является IIFE, но акцент в нем делается на определении всех интерфейсов как локальных переменных внутри анонимной функции:
Такой синтаксис облегчает понимание того, за что отвечает (или что делает) каждый интерфейс.
CJS модуль: CommonJS модуль или Node.js модуль
CommonJS, первоначально названный ServerJS, это шаблон для определения и использования модулей. Он встроен в Node.js. По умолчанию каждый JS файл — это CJS. Переменные module и exports обеспечивают экспорт модуля (файла). Функция require обеспечивает загрузку и использование модуля. Следующий код демонстрирует определение модуля счетчика на синтаксисе CommonJS:
Вот как этот модуль используется:
В среде выполнения (движке) Node.js этот шаблон используется путем оборачивания кода внутри файла в функцию, которой в качестве параметров передаются переменные exports, module и функция require :
AMD модуль или RequireJS модуль
AMD (асинхронное определение модуля) — это шаблон для определения и использования модулей. Он используется в библиотеке RequireJS. AMD содержит функцию define для определения модуля, которая принимает название модуля, названия зависимостей и фабричную функцию:
Он также содержит функцию require для использования модуля:
require AMD отличается от require CommonJS тем, что в качестве аргументов функции принимает названия модулей и сами модули.
Динамическая загрузка
Функция define также имеет другое назначение. Она принимает функцию обратного вызова и передает похожую на CommonJS require этой функции. Внутри функции обратного вызова require вызывается для динамической загрузки модуля:
AMD модуль из CommonJS модуля
Приведенная выше функция define , кроме require , может принимать в качестве аргументов переменные exports и module . Поэтому внутри define может выполняться код из CommonJS:
UMD модуль: универсальное определение модуля или UmdJS модуль
UMD (универсальное определение модуля) — набор шаблонов для обеспечения работы модуля в разных средах выполнения.
UMD для AMD (RequireJS) и браузера
Следующий код обеспечивает работу модуля как в AMD (RequireJS), так и в браузере:
Выглядит сложно, но это всего лишь IIFE. Анонимная функция определяет наличие функции define из AMD/RequireJS.
- Если define обнаружена, фабричная функция вызывается через нее.
- Если define не обнаружена, фабричная функция вызывается напрямую. В этот момент аргумент root — это объект Window браузера. Он получает зависимые модули из глобальных переменных (свойств объекта Window). Когда factory возвращает модуль, он также становится глобальной переменной (свойством объекта Window).
UMD для AMD (RequireJS) и CommonJS (Node.js)
Следующий код обеспечивает работу модуля как в AMD (RequireJS), так и в CommonJS (Node.js):
Не пугайтесь, это снова всего лишь IIFE. При вызове анонимной функции, происходит «оценка» ее аргумента. Оценивание аргумента позволяет определить среду выполнения (определяется наличие переменных module и exports из CommonJS/Node.js, а также функции define из AMD/RequireJS).
- Если средой выполнения является CommonJS/Node.js, аргумент анонимной функции вручную создает функцию define .
- Если средой выполнения является AMD/RequireJS, аргументом анонимной функции является функция define из этой среды. Выполнение анонимной функции гарантирует работу функции define . Внутри анонимной функции для создания модуля вызывается функция define .
ES модуль: ECMAScript2015 или ES6 модуль
В 2015 году в 6 версии спецификации JS был представлен новый модульный синтаксис. Данная сецификаци получила название ECMAScript 2015 (ES2015) или ECMAScript 6 (ES6). Основа нового синтаксиса — ключевые слова import и export . Следующий код демонстирует использование ES модуля для именованного и «дефолтного» (по умолчанию) импорта/экспорта:
Для использования модульного файла в браузере необходимо добавить тег <script> и определить его как модуль: <script type="module" src="https://habr.com/ru/post/501198/esCounterModule.js"></script> . Для использования этого модуля в Node.js меняем его расширение на .mjs :
Для обратной совместимости в браузере можно добавить тег <script> с атрибутом nomodule :
ES динамический модуль: ECMAScript2020 или ES11 динамический модуль
В последней 11 версии спецификации JS 2020 года представлена встроенная функция import для динамического использования ES модулей. Данная функция возвращает промис, поэтому использовать модуль можно с помощью then :
Благодаря тому, что функция import возвращает промис, в ней может использоваться ключевое слово await :
Системный модуль: SystemJS модуль
SystemJS — это библиотека для обеспечения работы ES модулей в старых браузерах. Например, следующий модуль написан с использованием синтаксиса ES6:
Этот код не будет работать в браузерах, не поддерживающих синтаксис ES6. Одним из решений данной проблемы является транспиляция кода с помощью интерфейса System.register библиотеки SystemJS:
Нового модульного синтаксиса ES6 больше нет. Зато код будет прекрасно работать в старых браузерах. Эта транспиляция может быть выполнена автоматически с помощью Webpack, TypeScript и т.д.
Динамическая загрузка модуля
SystemJS также содержит функцию import для динамического импорта:
Webpack модуль: транспиляция и сборка CJS, AMD и ES модулей
Webpack — это сборщик модулей. Его транспилятор объединяет CommonJS, AMD и ES модули в единый сбалансированный модульный шаблон и собирает весь код в один файл. Например, в следующих 3 файлах определяются 3 модуля с помощью различного синтаксиса:
Следующий код демонстрирует использование этого модуля:
Webpack способен объединить эти файлы, несмотря на то, что они представляют собой разные модульные системы, в один файл main.js :
Поскольку Webpack основан на Node.js, он использует модульный синтаксис CommonJS. В webpack.config.js :
Для транспиляции и сборки необходимо выполнить следующие команды:
В результате Webpack создаст файл main.js . Следующий код из main.js отформатирован для улучшения читаемости:
И снова это всего лишь IIFE. Код из 4 файлов преобразован в массив из 4 функций. И этот массив передается анонимной функции в качестве параметра.
Babel модуль: транспиляция ES модуля
Babel — это еще один транспилятор для обеспечения работы ES6+ кода в старых браузерах. Приведенный выше ES6+ модуль может быть преобразован в Babel модуль следуюшим образом:
А вот код в index.js , демонстрирующий использование этого модуля:
Это транспиляция по умолчанию. Babel также умеет работать с другими инструментами.
Babel и SystemJS
SystemJS может использоваться как плагин для Babel:
Данный плагин должен быть добавлен в babel.config.json :
Теперь Babel может работать с SystemJS для транспиляции CommonJS/Node.js, AMD/RequireJS и ES модулей:
Весь синтаксис AMD, CommonJS и ES модулей транспилирован в синтаксис SystemJS:
TypeScript модуль: транспиляция CJS, AMD, ES и SystemJS модулей
TypeScript поддерживает все разновидности синтаксиса JS, включая ES6. При транспиляции синтаксис ES6 модуля может быть сохранен или преобразован в другой формат, в том числе CommonJS/Node.js, AMD/RequireJS, UMD/UmdJS или SystemJS согласно настройкам транспиляции в tsconfig.json :
Модульный синтаксис ES, поддерживаемый TypeScript, получил название внешних модулей.
Внутренние модули и пространство имен
TypeScript также имеет ключевые слова module и namespace . Они называются внутренними модулями:
Оба транспилируются в JS объекты:
TypeScript module и namespace могут иметь несколько уровней вложенности через разделитель . :
Sub module и sub namespace транспилируются в свойства объекта:
TypeScript module и namespace также могут использоваться в операторе export :
Приведенный код также транспилируется в sub module и sub namespace:
Заключение
Фронтенд-разработчики каждый день используют модули. Это может быть функция из локального файла или сторонняя библиотека из node_modules. Сегодня я кратко расскажу об основных модульных системах в JavaScript и некоторых нюансах их использования.
Синтаксис систем модулей
В современном JavaScript осталось два основных стандарта модульных систем. Это CommonJS, которая является основной для платформы Node.js, и ESM (ECMAScript 6 модули), которая была принята как стандарт для языка и внесена в спецификацию ES2015.
История развития модульных систем JavaScript хорошо описана в статьях «Эволюция модульного JavaScript» и «Путь JavaScript-модуля».
Если вам хорошо известен весь синтаксис модульных систем ESM и CommonJS, то можно пропустить следующую главу.
ESM-модули
Именованный импорт/экспорт
В случае, когда необходимо экспортировать несколько сущностей из модуля, применяется именованный экспорт. Он выполняется с помощью инструкции export .
export можно использовать в момент объявления функции, переменной или класса:
Для больших модулей удобнее использовать группированный экспорт, это позволяет наглядно увидеть все экспортируемые сущности внутри модуля:
Чтобы импортировать какой-либо метод, необходимо воспользоваться инструкциeй import , указав интересующие части модуля и путь до него:
Импорт/Экспорт по умолчанию
В случае, когда из файла модуля экспортируется только одна сущность, удобнее использовать экспорт по умолчанию. Для этого необходимо добавить default после инструкции export :
Импорт модуля в случае экспорта по умолчанию:
Дополнительные возможности
Переименование. Для изменения имени метода в момент импорта/экспорта существует инструкция as :
Импорт этой функции будет доступен только по новому имени:
Переименование в момент импорта:
Этот синтаксис полезен для случаев, когда имя импортируемой части уже занято. Также можно сократить имя функции/переменной/класса, если она часто используется в файле:
Инициализация модуля без импорта его частей. Используется, когда необходимо выполнить импорт модуля для выполнения кода внутри него, но не импортировать какую-либо его часть:
Импорт всего содержимого модуля. Можно импортировать всё содержимое модуля в переменную и обращаться к частям модуля как к свойствам этой переменной:
Такой синтаксис не рекомендуется использовать, сборщик модулей (например, Webpack) не сможет корректно выполнить tree-shaking при таком использовании.
Реэкспорт. Существует сокращенный синтаксис для реэкспорта модулей. Это бывает полезно, когда нужно собрать модули из разных файлов в одном экспорте:
при таком реэкспорте наименования частей модуля будут сохраняться, но можно изменять их с помощью инструкции as :
Аналогичным способом можно реэкспортировать значения по умолчанию:
Динамические импорты. Кроме «статических» импортов можно загружать модули ассинхронно, для этого есть специальное выражение import() . Пример использования:
Это выражение возвращает promise , который при успешном завершении возвращает объект со всеми экспортами модуля, а при исключении — ошибку выполнения импорта. В Webpack синтаксис динамических импортов используется для создания отдельных чанков.
Использование модулей в браузере
Современные браузеры нативно поддерживают модули. Для того, чтобы браузер понимал, что мы экспортируем не просто исполняемый JS-файл, а модуль, необходимо в тэг script , где импортируется модуль, добавить атрибут type="module" .
Рассмотрим на примере небольшого проекта.
Импорт модуля внутри index.html:
По атрибуту type="module" браузер понимает, что экспортирует файл с модулями, и корректно его обработает. Стоит отметить, что пути импорта, указанные в main.js (./dist/module1 и ./dist/module2), будут преобразованы в абсолютные пути относительно текущего расположения, и браузер запросит эти файлы у сервера по адресам /dist/module1 и /dist/module2 соответственно. Практического применения у этой возможности не так много, в основном в проектах используется сборщик (например Webpack), который преобразует ESM-модули в bundle. Однако использование ESM-модулей в браузере может позволить улучшить загрузку страницы за счет разбиения bundle-файлов на маленькие части и постепенной их загрузки.
CommonJS
Экспорт. Для экспорта в CommonJS используются глобальные объекты module и exports . Для этого необходимо просто добавить новое поле в объект exports .
Для удобства экспорта части фунциональности в глобальной области существует переменная exports , которая является ссылкой на module.exports . Поэтому возможен и такой синтаксис экспорта:
В CommonJS cуществует что-то схожее с импортом по умолчанию, для этого необходимо просто присвоить module.exports значению экспортируемой функции:
Сохранение значения в exports напрямую, в отличие от именованного экспорта, не будет работать:
Стоит обратить внимание, что если были экспортированы части модуля, они затрутся и будет экспортировано только последнее значение module.exports :
Импорт. Для импорта необходимо воспользоваться конструкцией require() и указать путь до модуля:
Можно воспользоваться деструктуризацией и получить значение необходимой функции сразу после импорта:
Работа с модулями в Node.js
Поддержка ESM-модулей
До недавнего времени Node.js поддерживал только CommonJS, но с версии 13.2.0 команда разработчиков анонсировала поддержку ESM (с версии 8.5.0 поддержка модулей ECMAScript 6 была скрыта за экспериментальным флагом). Подробно о том, как работать с модулями ECMAScript 6 в Node.js, можно прочитать в анонсе команды разработчиков Node.js.
Поиск модулей
Все относительные пути, начинающиеся c './' или '../' будут обрабатываться только относительно рабочей папки проекта. Пути с '/' будут обрабатываться как абсолютные пути файловой системы. Для остальных случаев Node.js начинает поиск модулей в папке проекта node_modules (пример: /home/work/projectN/node_modules). В случае, если интересующий модуль не был найден, Node.js поднимается на уровень выше и продолжает свой поиск там. И так до самого верхнего уровня файловой системы. Поиск необходимой библиотеки будет выглядеть следующим образом:
Если в папках node_modules не удалось обнаружить искомый модуль, то в запасе у Node.js есть еще места, которые он анализирует в поисках необходимой библиотеки. Это так называемые GLOBAL_FOLDERS . В них добавляются пути, переданные через переменную окружения NODE_PATH , и три дополнительных пути, которые существуют всегда:
При желании можно посмотреть все возможные директории, где Node.js ищет модули из папки проекта, обратившись к методу paths() внутри require.resolve .
Дополнительные свойства у module и require
У module и require есть дополнительные свойства, которые могут быть полезны.
module.id — уникальный идентификатор модуля. Обычно это полностью определенный путь до модуля.
require.cache — представляет из себя объект с информацией о каждом импортированном модуле. Если при импорте модуля Node.js находит его в кеше, код модуля не будет выполняться повторно, а экспортируемые сущности будут взяты из закешированного значения. При необходимости повторного «чистого» импорта модуля необходимо сбросить закешированное значение, удалив его из кеша:
Что происходит в момент импорта ES-модуля
В момент выполнения файла Javascript-движок выполняет несколько этапов загрузки модулей:
- построение графа зависимостей;
- оценка расположения модулей и загрузка файлов;
- анализ модулей;
- запись информации о модулях и создание полей всех экспортируемых значений (без их состояний);
- выполнение сценария модулей для получение состояний;
- запись состояний экспортируемых частей модулей.
Структура данных, содержащая информацию о модуле (уникальный идентификатор, список зависимостей и состояния всех экспортируемых значений) называется Module Records.
При выполнении скрипта строится граф зависимостей и создается запись по каждому импортируемому модулю внутри него. В момент каждого импорта, вызывается метод Evaluate() внутри модуля Module Records. При первом вызове этой функции выполняется сценарий для получения и сохранения состояния модуля. Подробнее об этом процессе можно прочитать в статье «Глубокое погружение в ES-модули в картинках».
Что происходит при повторном импорте модуля
В предыдущей главе мы упомянули метод Evaluate() . При очередном импорте модуля Evaluate() вызывается повторно, но если импорт модуля был успешно выполнен до этого, то метод возвращает undefined и сценарий модуля запущен не будет. Поэтому запись состояния модуля происходит единожды.
Но остался открытым вопрос, создаётся ли новая сущность Module Records при повторном импорте? Например в данном случае:
За получение Module Records для каждого import отвечает метод HostResolveImportedModule, который принимает два аргумента:
- referencingScriptOrModule — идентификатор текущего модуля, откуда происходит импорт;
- specifier — идентификатор импортируемого модуля, в данном случае ./modulePath .
В спецификации говорится, что для одинаковых парах значений referencingScriptOrModule и specifier возвращается один и тот же экземпляр Module Records.
Рассмотрим еще один пример, когда один и тот же модуль импортируется в нескольких файлах:
Будут ли здесь создаваться дублирующие Module Records для moduleB.js ? Для этого обратимся к спецификации:
Multiple different referencingScriptOrModule, specifier pairs may map to the same Module Record instance. The actual mapping semantic is host-defined but typically a normalization process is applied to specifier as part of the mapping process. A typical normalization process would include actions such as alphabetic case folding and expansion of relative and abbreviated path specifiers
Таким образом, даже если referencingScriptOrModule отличается, а specifier одинаков, может быть возвращен одинаковый экземпляр Module Records.
Однако этой унификации не будут подвержены импорты с дополнительными параметрами в specifier :
Циклические зависимости
При большой вложенности модулей друг в друга может возникнуть циклическая зависимость:
Для наглядности, эту цепочку зависимостей можно упростить до:
ES-модули нативно умеют работать с циклическими зависимостями и корректно их обрабатывать. Принцип работы подробно описан в спецификации. Однако, ESM редко используются без обработки. Обычно с помощью транспилятор (Babel) сборщик модулей (например, Webpack) преобразует их в CommonJS для запуска на Node.js, или в исполнямый скрипт (bundle) для браузера. Циклические зависимости не всегда могут быть источником явных ошибок и исключений, но могут стать причиной некорректного поведения кода, которое трудно будет отловить.
Есть несколько хаков, как можно обходить циклические зависимости для некоторые ситуаций, но лучше просто не допускать их возниковения.
Заключение
В этой статье я собрал всю основную информацию о модульных системах в Javascript, чтобы у читателя не осталось пробелов относительно того, как их использовать и как они работают. Надеюсь, у меня это получилось, и статья оказалась вам полезной. Буду рад обратной связи!
При разработке front-end части приложения на языке JavaScript, мы можем столкнуться с рядом традиционных проблем. Все они решаются при помощи модульных подходов. Ниже мы рассмотрим самые популярные подходы для описания модулей в JavaScript, которые существуют на сегодняшний день.
Итак, какие проблемы имеются в виду:
Большие файлы. Довольно часто возникает такая ситуация, когда в проекте есть файлы, названные в стиле app.js или common.js, в которых все просто свалено в одну кучу: функции, хелперы, виджеты и т.д. Работать и поддерживать код в таких файлах довольно тяжело. Приходится постоянно прокручивать туда-сюда, выискивая нужный кусочек кода, ставить много закладок при помощи IDE, чтобы не потерять нужные места в файле. Также есть тенденция, что чем больше размер файла, который содержит в себе кучу общей логики, тем быстрее он продолжает расти. Плюс ко всему, в большой команде это может стать причиной постоянных конфликтов в системе контроля версий.
Зависимости и порядок подключения. Зачастую JS-код в приложении разбит на несколько файлов. Мы используем плагины, которые зависят от библиотек; библиотеки, которые зависят от других библиотек; а код, написанный собственноручно, зависит уже и от того, и другого. Поэтому разработчик вынужден строго следить за порядком подключения JS-файлов и регулярно тратить время и энергию на их упорядочивание. Если нарушен порядок, то получаем ошибку. В любом случае, ошибки, которые возникают в связи с неправильным порядком подключения файлов, обычно достаточно легко заметить. В таком случае чаще всего мы просто получим исключение в браузере, например, $ is undefined .
Более трудной в обнаружении причиной ошибок может стать дублирование подключения одних и тех же файлов. Например, есть файл с куском кода, который вешает обработчик события на какой-либо dom-элемент. Ваш коллега может не заметить, что этот файл уже был подключен, и подключает его еще раз. В результате обработчик будет выполняться два раза, что может привести к неприятной ошибке, которую довольно трудно заметить сразу.
Переменные в глобальной области видимости. Проблемы с глобальными переменными заключаются в том, что они будут доступны во всем коде вашего приложения или страницы. Они находятся в глобальном пространстве имен, и всегда есть шанс возникновения коллизий именования, когда две разных части приложения определяют глобальные переменные с одинаковым именем, но для разных целей. Плюс ко всему, объявляя переменные в глобальной области видимости мы загрязняем объект window . И обращаясь каждый раз к глобальной переменной, интерпретатору JS приходится искать ее в раздутом объекте window , что сказывается на производительности кода.
Неструктурированный и не очевидный код. Еще одна довольно неприятная ситуация — когда нет четких границ, разделяющих логические куски кода. Когда, не вникая в код, сразу и не скажешь, какие другие части приложения он использует.
Первые модули
Изначально в JS не было возможности создавать настоящие модули. Хотя раньше это и не требовалось: на сайтах было относительно маленькое количество JS-кода. В основном нужно было где-то «прикрутить карусель», где-то красивое анимированное меню, и на этом все. Но затем web-приложения по сложности интерфейса и насыщенной функциональности начали догонять традиционные настольные. И тогда стал популярным так называемый паттерн «модуль».
Этот подход работает достаточно просто: создается немедленно-вызываемая анонимная функция-обертка, которая возвращает публичный интерфейс модуля, а вся остальная реализация инкапсулирована в замыкании. Это помогает решить две проблемы из вышеперечисленных: количество глобальных переменных сильно уменьшается, а сам код становится немного нагляднее благодаря тому, что мы разграничиваем его на логические куски. Но проблема управления зависимостями и порядком подключения файлов остается открытой.
CommonJS
Первый стандарт, который описывает API для создания и подключения модулей, был разработан рабочей группой CommonJS. Этот стандарт был придуман для использования в серверном JS, и его реализацию можно увидеть, например, в node.js.
Для подключения зависимостей используется глобальная функция require() , которая принимает первым параметром строку с путем к модулю. Для экспортирования интерфейса модуля мы используем свойство exports объекта module . И когда этот модуль будет подключен как зависимость с помощью функции require , где-то в коде другого модуля, то эта же функция вернет экспортируемый объект.
Данный подход решает все вышеперечисленные проблемы. Никаких оберток делать не нужно, каждый файл — это отдельный модуль со своей областью видимости. Исходный код можно разбивать на мелкие логические единицы. И каждый модуль четко определяет все свои зависимости.
НО! В браузере, просто так, такой синтаксис не заработает. Для этого нужно использовать специальный сборщик. Например, популярны browserify или Brunch, которые работают на node.js. Эти инструменты довольно удобны, их функциональность не ограничивается только лишь возможностью создавать CommonJS-модули, и многие разработчики предпочитают использовать их в своих проектах. Суть у них одинакова: сборщик проходится по дереву зависимостей модулей и собирает все в один файл, который в свою очередь будет загружаться браузером. Даже при разработке в debug-режиме нужно постоянно запускать сборщик из командной строки, или, что удобнее, запускать watcher, который будет следить за изменениями в файлах и автоматически производить сборку. Стоит заметить, что отлаживать приходится не исходные файлы, а то, что сгенерирует сборщик. Если вы не планирует отлаживать ваш код в старых браузерах, то это не будет проблемой, потому что сборщики умеют генерировать Source Maps, благодаря которым результирующий сжатый файл будет связан с исходниками. Это позволит вести отладку так, как будто вы работаете с самим исходным кодом. Также, сборка в один файл — это не всегда хорошо. Например, если мы хотим подгружать модуль удаленно, с CDN, или загружать часть кода только по требованию.
Будущее уже наступило
В новом стандарте ECMAScript 6, помимо всяких крутых штук, описан новый синтаксис для создания и подключения модулей.
Один модуль, как и в CommonJS, — это один файл. Область видимости также ограничена этим файлом. Ключевое слово export экспортирует нужные значения в остальные части программы. Его можно использовать где угодно: посреди кода модуля или в конце, экспортируя все скопом.
Для подключения модуля используются ключевые слова import , from и as . Можно импортировать только одно нужное вам значение…
…или сразу несколько.
Либо можно импортировать весь модуль в качестве объекта со всеми экспортированными значениями.
Есть возможность изменять имена переменных с импортируемыми значениями, что может быть полезным, если импортируются значения с одинаковым именем из разных модулей.
Для того, чтобы, например, отводить один файл под один класс, удобно определять экспортируемое значение по умолчанию.
Чтобы импортировать значение по умолчанию, достаточно лишь не использовать фигурные скобки.
В приведенных примерах использовался так называемый декларативный синтаксис. Также есть возможность использовать программный интерфейс, что позволяет загружать модули асинхронно и по условию. Для этого используется System.import() .
В качестве единственного параметра необходимо передавать путь к модулю. В результате выполнения System.import() возвращается объект Promise. Таким образом, поток выполнения не блокируется и код, который не имеет отношения к импорту модуля, будет выполняться дальше.
Браузеры еще толком не поддерживают новый синтаксис, но возможность использовать уже есть. В этом вам поможет один из специальных трансляторов, например, Babel. Как и в случае с CommonJS, нужно запускать транслятор из командной строки или ставить watcher, благодаря которому исходники, написанные на ES6, при изменении будут преобразовываться в кроссбраузерную форму.
Некоторые разработчики уже сейчас используют новый синтаксис, и точно можно сказать, что за этим подходом будущее. Большинство же не решаются пока использовать новую технологию в реальных проектах.
Вот уже несколько лет подход под названием Asynchronous Module Definition позволяет разбивать код приложений на модули во всех популярных браузерах (IE6+), используя при этом только возможности браузера.
AMD — это подход к разработке, который позволяет создавать модули таким образом, чтобы они и их зависимости могли быть загружены асинхронно и параллельно. Это позволяет ускорить загрузку страницы, так как загрузка JS-модулей не будет блокировать загрузку остального контента сайта. Плюс, AMD дает возможность загружать модули по мере их востребованности. Например, есть страница со сложным модальным окном, в котором сосредоточено много логики: разные «визарды», несколько форм и т.д. При этом предполагается, что окно будет использоваться крайне редко. В таком случае, AMD позволяет загружать JS-код для этого окна не со страницей, а перед тем, как оно будет открыто пользователем.
Проще говоря, подход AMD сводится к описанию модулей с помощью функции define и подключению их с помощью require .
Самая популярная реализация подхода AMD — библиотека RequireJS.
RequireJS
В RequireJS методы require и define имеют несколько вариаций.
Метод define может принимать три параметра:
Первый параметр — это id модуля. id можно использовать вместо пути к файлу, чтобы подключить модуль как зависимость другого модуля, но только когда файл с кодом модуля уже был загружен в браузере. На самом деле, это необязательный параметр. И не просто необязательный, его даже нежелательно использовать в разработке. Он, скорее, нужен для корректного управления зависимостями в том случае, если в одном файле определено сразу несколько модулей. Оптимизационный инструмент, использующийся для сборки модулей в один файл для production, автоматически добавляет эти id.
define может принимать только остальные два параметра:
В данном случае первый параметр — это массив зависимостей модуля. Чтобы определить зависимость, нужно просто добавить в массив строку, содержащую путь к модулю или его id. Последний параметр — функция-фабрика, которая занимается созданием модуля. Эта функция выполнится только тогда, когда все зависимости модуля будут загружены, и принимает в качестве аргументов экспортированные значения со всех зависимостей. Внутри функции находится реализация модуля, которая не доступна извне. В конце с помощью вызова return экспортируется сам модуль. Экспортировать можно все, что угодно: обычную функцию, конструктор, объект, строку; в общем, любой тип данных. Важно понимать, что функция-фабрика выполняется только один раз, когда мы впервые подключаем модуль как зависимость. Остальные модули, которые тоже подключат эту зависимость, получат уже закешированное значение модуля.
Есть одна проблема — вызов define может выглядеть вот так:
Это довольно неудобно. Нужно следить, чтобы порядок указанных зависимостей в массиве совпадал с порядком аргументов, которые принимает функция-фабрика. Поэтому в RequireJS есть еще один вариант define , который позволяет передавать только один параметр — функцию-конструктор.
Этот вариант напоминает подход CommonJS. В качестве первого аргумента будет передана так называемая локальная функция require . Подключать зависимости модуля теперь можно с помощь вызова этой функции, а возвращать она будет те значения, которые экспортирует подключаемый модуль. Нужно помнить, что такой синтаксис функционально не отличается от предыдущего. Все файлы зависимостей, подключенные с помощью вызова require , будут загружены до того, как начнет выполнятся функция-фабрика модуля. Это происходит потому, что, когда файл модуля загружен в браузер, загрузчик ищет все локальные вызовы require с помощью регулярных выражений. По этой причине локальный вызов require нельзя использовать, например, для загрузки модуля по условию.
Также можно определить модуль как простой объект.
Такие модули удобно использовать как набор констант.
Для того, чтобы начать выполнение клиентской логики, нужно вызвать глобальную функцию require .
Этот вариант функции require отличается от локального варианта набором принимаемых параметров. В этом случае первым параметром нужно передавать массив подключаемых модулей. Даже если нужно подключить только один модуль, все равно нужно передавать его в массиве, иначе библиотека распознает его как локальный вызов и будет ошибка, так как локальные вызовы возможны только внутри определения модуля. Второй необязательный параметр — callback-функция, которая, как и в случае с define , выполнится сразу, как только будут загружены все необходимые зависимости.
Есть возможность делать вложенные вызовы require внутри callback-функции или внутри определения модуля.
Еще одно существенное отличие такого варианта вызова require заключается в том, что подключаемые файлы начнут загружаться только тогда, когда поток выполнения дойдет до вызова функции. Благодаря этому есть возможность загружать модули только по требованию или по условию.
Подключение
Для работы понадобится всего один единственный тег
Указанный в data-main атрибуте файл main.js (расширение .js для краткости в RequireJS всегда опускается) является своеобразной точкой входа для выполнения JS-кода приложения.
RequireJS имеет ряд параметров, которыми можно его сконфигурировать, поэтому перед началом выполнения кода они должны быть указаны с помощью метода requirejs.config .
При помощи первого параметра baseUrl можно указать путь, относительно которого будут загружаться все JS-файлы. Если файлы вдруг переедут в другое место, то достаточно в одном месте поменять корневой путь. Если его не указать, то базовой будет директория, в которой находится файл самой библиотеки require.js. Параметр path позволяет «мапить» пути к модулям, чтобы использовать потом более короткие варианты.
Многие сторонние библиотеки и плагины уже оформлены в стиле AMD, то есть определены как модули с помощью функции define . Но есть такие, которые еще так не оформлены. Подключая подобные файлы, RequireJS не знает об их зависимостях и экспортируемом значении. Для таких модулей есть параметр shim , благодаря которому можно указать deps (зависимости) и exports (экспортируемое значение).
RequireJS позволяет загружать не только JS-файлы, но и, например, HTML, используя плагин text.
В данном примере require загрузит файл module.html и вернет строку, содержащую HTML-код файла. Это удобно для работы с клиентскими шаблонами, не нужно мучатся с HTML-кодом внутри JS-файлов.
Сборка
Загружать много мелких файлов удобно при разработке и отладке, но не очень производительно, поэтому не подходит для production. И тут на помощь приходит утилита оптимизации r.js, которая идет в поставке с require.js.
Работает эта утилита на JS, поэтому на компьютере должен быть установлен node.js. Перед тем как запускать оптимизацию, нужно ее сконфигурировать. Для этого в приложении нужно создать файл app.build.js, который будет содержать обычный JS-объект с набором параметров.
Параметр baseUrl назначается так же, как описывалось выше. dir — директория для результирующего файла. main — путь к файлу, который содержит конфигурацию RequireJS. preserveLicenseComments — удалить комментарии о лицензиях, wrapShim — обернуть все shim-модули функцией define . Остальные возможные параметры можно посмотреть здесь: example.build.js.
Запустить сборку можно командой >node r.js -o app.build.js
Будет удобно добавить эту команду, например, в pre-build event в Visual Studio, чтобы JS-код собирался в тот же момент, когда запускается компиляция проекта.
Читайте также: