Модули JavaScript



    Это третья публикация по материалам нашей внутренней конференции Sync.NET. Первая публикация была посвящена многопоточности в .NET, вторая — реактивным расширениям.

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

    Итак, какие проблемы имеются в виду:

    Большие файлы. Довольно часто возникает такая ситуация, когда в проекте есть файлы, названные в стиле app.js или common.js, в которых все просто свалено в одну кучу: функции, хелперы, виджеты и т.д. Работать и поддерживать код в таких файлах довольно тяжело. Приходится постоянно прокручивать туда-сюда, выискивая нужный кусочек кода, ставить много закладок при помощи IDE, чтобы не потерять нужные места в файле. Также есть тенденция, что чем больше размер файла, который содержит в себе кучу общей логики, тем быстрее он продолжает расти. Плюс ко всему, в большой команде это может стать причиной постоянных конфликтов в системе контроля версий.

    Зависимости и порядок подключения. Зачастую JS-код в приложении разбит на несколько файлов. Мы используем плагины, которые зависят от библиотек; библиотеки, которые зависят от других библиотек; а код, написанный собственноручно, зависит уже и от того, и другого. Поэтому разработчик вынужден строго следить за порядком подключения JS-файлов и регулярно тратить время и энергию на их упорядочивание. Если нарушен порядок, то получаем ошибку. В любом случае, ошибки, которые возникают в связи с неправильным порядком подключения файлов, обычно достаточно легко заметить. В таком случае чаще всего мы просто получим исключение в браузере, например, $ is undefined.

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

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

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

    Первые модули


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

    var SomeModule = (function() {
        var count = 0;
    
        function notNegative(num) {
            return num < 0 ? 0 : num;
        }
    
        return {
            getCount: function() {
                return count;
            },
    
            setCount: function(newCount) {
                count = notNegative(newCount);
            }
        };
    })();
    

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

    CommonJS


    Первый стандарт, который описывает API для создания и подключения модулей, был разработан рабочей группой CommonJS. Этот стандарт был придуман для использования в серверном JS, и его реализацию можно увидеть, например, в node.js.

    var logger = require('../utils/logger');
    var MyDependency = require('MyDependency');
    
    var count = 0;
    
    function notNegative(num) {
        return num < 0 ? 0 : num;
    }
    
    module.exports = {
        getCount: function() {
            return count;
        },
    
        setCount: function(newCount) {
            count = notNegative(newCount);
            logger.log('Count changed to {0}', count);
        }
    };
    

    Для подключения зависимостей используется глобальная функция require(), которая принимает первым параметром строку с путем к модулю. Для экспортирования интерфейса модуля мы используем свойство exports объекта module. И когда этот модуль будет подключен как зависимость с помощью функции require, где-то в коде другого модуля, то эта же функция вернет экспортируемый объект.

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

    НО! В браузере, просто так, такой синтаксис не заработает. Для этого нужно использовать специальный сборщик. Например, популярны browserify или Brunch, которые работают на node.js. Эти инструменты довольно удобны, их функциональность не ограничивается только лишь возможностью создавать CommonJS-модули, и многие разработчики предпочитают использовать их в своих проектах. Суть у них одинакова: сборщик проходится по дереву зависимостей модулей и собирает все в один файл, который в свою очередь будет загружаться браузером. Даже при разработке в debug-режиме нужно постоянно запускать сборщик из командной строки, или, что удобнее, запускать watcher, который будет следить за изменениями в файлах и автоматически производить сборку. Стоит заметить, что отлаживать приходится не исходные файлы, а то, что сгенерирует сборщик. Если вы не планирует отлаживать ваш код в старых браузерах, то это не будет проблемой, потому что сборщики умеют генерировать Source Maps, благодаря которым результирующий сжатый файл будет связан с исходниками. Это позволит вести отладку так, как будто вы работаете с самим исходным кодом. Также, сборка в один файл — это не всегда хорошо. Например, если мы хотим подгружать модуль удаленно, с CDN, или загружать часть кода только по требованию.

    Будущее уже наступило


    В новом стандарте ECMAScript 6, помимо всяких крутых штук, описан новый синтаксис для создания и подключения модулей.

    // lib/math.js
    let notExported = 'abc';
    export function sum(x, y) {
        return x + y;
    }
    export const PI = 3.14;
    

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

    // lib/calc.js
    let notExported = 'abc';
    function square(x) {
        return x * x;
    }
    const PI = 3.14;
    
    export {square, PI};
    

    Для подключения модуля используются ключевые слова import, from и as. Можно импортировать только одно нужное вам значение…

    //app.js
    import {sum} from 'lib/math';
    console.log(sum(3, 5));
    

    …или сразу несколько.

    //app.js 
    import {sum, PI} from 'lib/math';
    console.log('2π =' + sum(PI, PI));
    

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

    //app.js 
    import 'lib/calc' as calc;
    console.log(calc.square(calc.PI));
    

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

    //app.js 
    import {square} from '../shapes';
    import {square as sq} from 'lib/calc';
    console.log(sq(3));
    

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

    // models/User.js
    export default class {
        constructor(id, name) {
            this.id = id;
            this.name = name;
        }
    }
    

    Чтобы импортировать значение по умолчанию, достаточно лишь не использовать фигурные скобки.

    //app.js
    import User from 'models/User';
    var user = new User(12, 'John');
    

    В приведенных примерах использовался так называемый декларативный синтаксис. Также есть возможность использовать программный интерфейс, что позволяет загружать модули асинхронно и по условию. Для этого используется System.import().

    import $ from 'lib/jquery';
    
    if($('html').hasClass('ie')) {
        System.import('lib/placeholder').then(function(placeholder){                    
            placeholder($('input'));
        });
    }
    
    $('.logo').show(600);
    

    В качестве единственного параметра необходимо передавать путь к модулю. В результате выполнения System.import() возвращается объект Promise. Таким образом, поток выполнения не блокируется и код, который не имеет отношения к импорту модуля, будет выполняться дальше.

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

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

    AMD


    Вот уже несколько лет подход под названием Asynchronous Module Definition позволяет разбивать код приложений на модули во всех популярных браузерах (IE6+), используя при этом только возможности браузера.

    AMD — это подход к разработке, который позволяет создавать модули таким образом, чтобы они и их зависимости могли быть загружены асинхронно и параллельно. Это позволяет ускорить загрузку страницы, так как загрузка JS-модулей не будет блокировать загрузку остального контента сайта. Плюс, AMD дает возможность загружать модули по мере их востребованности. Например, есть страница со сложным модальным окном, в котором сосредоточено много логики: разные «визарды», несколько форм и т.д. При этом предполагается, что окно будет использоваться крайне редко. В таком случае, AMD позволяет загружать JS-код для этого окна не со страницей, а перед тем, как оно будет открыто пользователем.

    Проще говоря, подход AMD сводится к описанию модулей с помощью функции define и подключению их с помощью require.

    define([id], [dependencies], callback);
    
    require(modules, [callback]);
    

    Самая популярная реализация подхода AMD — библиотека RequireJS.

    RequireJS


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

    В RequireJS методы require и define имеют несколько вариаций.

    Метод define может принимать три параметра:

    // app/index.js
    define('app', ['jquery', 'utils/print'], function($, print) {
        var $body = $('body');
    
        var App = function(name) {
            this.name = name;
            this.content = $body;
        };
    
        App.prototype.init = function() {
            print(this.name + 'body', this.content);
        }
    
        return new App('MyApp');
    });
    

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

    define может принимать только остальные два параметра:

    // app/index.js
    define(['jquery', 'utils/print'], function($, print) {
        var $body = $('body');
    
        var App = function(name) {
            this.name = name;
            this.content = $body;
        };
    
        App.prototype.init = function() {
            print(this.name + 'body', this.content);
        };
    
        return new App('MyApp');
    });
    

    В данном случае первый параметр — это массив зависимостей модуля. Чтобы определить зависимость, нужно просто добавить в массив строку, содержащую путь к модулю или его id. Последний параметр — функция-фабрика, которая занимается созданием модуля. Эта функция выполнится только тогда, когда все зависимости модуля будут загружены, и принимает в качестве аргументов экспортированные значения со всех зависимостей. Внутри функции находится реализация модуля, которая не доступна извне. В конце с помощью вызова return экспортируется сам модуль. Экспортировать можно все, что угодно: обычную функцию, конструктор, объект, строку; в общем, любой тип данных. Важно понимать, что функция-фабрика выполняется только один раз, когда мы впервые подключаем модуль как зависимость. Остальные модули, которые тоже подключат эту зависимость, получат уже закешированное значение модуля.

    Есть одна проблема — вызов define может выглядеть вот так:

    // app/index.js
    define(['jquery', 'utils/print', 'modules/Module1', 'modules/Module2', 'modules/Module3', 'modules/Module4', 'modules/Module5', 'modules/Module6', 'modules/Module7', 'modules/Module8', 'modules/Module9'],
    function($, print, Module1, Module2, Module3, Module4, Module5,    Module6, Module7, Module8, Module9) {
        var $body = $('body');
    
        var App = function(name) {
            this.name = name;
            this.content = $body;
        };
    
        // ...
    });
    

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

    // app/index.js
    define(function(require) {
        var $ = require('jquery'),
            print = require('utils/print');
        var $body = $('body');
    
        var App = function(name) {
            this.name = name;
            this.content = $body;
        };
    
        App.prototype.init = function() {
            print(this.name + 'body', this.content);
        };
    
        return new App('MyApp');
    });
    

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

    Также можно определить модуль как простой объект.

    // modules/module.js
    define({
        id: 123,
        key: 'jquery',
        getValue: function() {
            return this.key;
        }
    });
    

    Такие модули удобно использовать как набор констант.

    Для того, чтобы начать выполнение клиентской логики, нужно вызвать глобальную функцию require.

    // main.js
    require(['app/index'], function(app) {
        app.init();
    });
    

    Этот вариант функции require отличается от локального варианта набором принимаемых параметров. В этом случае первым параметром нужно передавать массив подключаемых модулей. Даже если нужно подключить только один модуль, все равно нужно передавать его в массиве, иначе библиотека распознает его как локальный вызов и будет ошибка, так как локальные вызовы возможны только внутри определения модуля. Второй необязательный параметр — callback-функция, которая, как и в случае с define, выполнится сразу, как только будут загружены все необходимые зависимости.

    Есть возможность делать вложенные вызовы require внутри callback-функции или внутри определения модуля.

    // main.js
    require(['app/index', 'utils/browserName'], function(app, browserName) {
        app.init();
    
        if(browserName == 'IE') {
            require(['app/fix-' + browserName]);
        }
    });
    

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

    Подключение


    Для работы понадобится всего один единственный тег
     в HTML-коде страницы. Остальную работу по подключению JS-файлов сделает загрузчик.

    <!DOCTYPE html> <html> <head> <script data-main="./main" src="lib/require.js"></script> </head> <body> <h1>RequireJS Example</h1> <form> <input /> </form> </body> </html>

    Указанный в data-main атрибуте файл main.js (расширение .js для краткости в RequireJS всегда опускается) является своеобразной точкой входа для выполнения JS-кода приложения.

    RequireJS имеет ряд параметров, которыми можно его сконфигурировать, поэтому перед началом выполнения кода они должны быть указаны с помощью метода requirejs.config.

    // main.js
    requirejs.config({
        baseUrl: 'Scripts',
        paths: {
            jquery: 'jquery-1.11.2',
            modules: 'app/modules',
            utils: 'app/utils'
        },
        shim: {
            'jquery.validate.unobtrusive': {
                deps: ['jquery', 'jquery.validate'],
                exports: '$.validator.unobtrusive'
            }
        }
    });
    
    require(['app/index'], function (app) {
        app.init();
    });
    

    При помощи первого параметра baseUrl можно указать путь, относительно которого будут загружаться все JS-файлы. Если файлы вдруг переедут в другое место, то достаточно в одном месте поменять корневой путь. Если его не указать, то базовой будет директория, в которой находится файл самой библиотеки require.js. Параметр path позволяет «мапить» пути к модулям, чтобы использовать потом более короткие варианты.

    Многие сторонние библиотеки и плагины уже оформлены в стиле AMD, то есть определены как модули с помощью функции define. Но есть такие, которые еще так не оформлены. Подключая подобные файлы, RequireJS не знает об их зависимостях и экспортируемом значении. Для таких модулей есть параметр shim, благодаря которому можно указать deps (зависимости) и exports (экспортируемое значение).

    Text


    RequireJS позволяет загружать не только JS-файлы, но и, например, HTML, используя плагин text.

    // app/views/module.html
    <h3>Module:</h3>
    <h2>"{name}" is loaded</h2>
    
    // module.js
    define(function (require) {
        var view = require('text!app/views/module.html');
    
        var name = 'First Module';
    
        return {
            getHTML: function () {
                return view.replace('{name}', name);
            },
    
            getName: function () {
                return name;
            }
        };
         
    });
    


    В данном примере require загрузит файл module.html и вернет строку, содержащую HTML-код файла. Это удобно для работы с клиентскими шаблонами, не нужно мучатся с HTML-кодом внутри JS-файлов.

    Сборка


    Загружать много мелких файлов удобно при разработке и отладке, но не очень производительно, поэтому не подходит для production. И тут на помощь приходит утилита оптимизации r.js, которая идет в поставке с require.js.

    Работает эта утилита на JS, поэтому на компьютере должен быть установлен node.js. Перед тем как запускать оптимизацию, нужно ее сконфигурировать. Для этого в приложении нужно создать файл app.build.js, который будет содержать обычный JS-объект с набором параметров.

    // app.build.js
    ({
        baseUrl: ".",
        dir: '../Scripts-build',
        mainConfigFile: 'main.js',
        name: "main",
        preserveLicenseComments: false,
        wrapShim: true 
    })
    

    Параметр baseUrl назначается так же, как описывалось выше. dir — директория для результирующего файла. main — путь к файлу, который содержит конфигурацию RequireJS. preserveLicenseComments — удалить комментарии о лицензиях, wrapShim — обернуть все shim-модули функцией define. Остальные возможные параметры можно посмотреть здесь: example.build.js.

    Запустить сборку можно командой >node r.js -o app.build.js

    Будет удобно добавить эту команду, например, в pre-build event в Visual Studio, чтобы JS-код собирался в тот же момент, когда запускается компиляция проекта.

    Profit


    Итак, выгоды, которые дает использование RequireJS:

    • Автономные модули
    • Структурированный и наглядный код
    • Позволяет избежать загрязнения глобальной области видимости
    • Управление зависимостями
    • Асинхронная загрузка и загрузка по требованию
    • Плагины, в том числе для работы с HTML-шаблонами
    • Не нужна сборка при работе в debug-режиме
    • Оптимизированный код в релиз
    NIX
    Компания

    Комментарии 19

      +5
      А почему не webpack? Он аналогично поддерживает AMD плюс CommonJS, нарезание файлов на чанки, быстрее пересборка, чем r.js. Ну а плагинами вообще доруливается все что угодно. Хоть сборка стилей на проекте.
        0
        На сколько я помню, в webpack нет возможности загружать модули по требованию, это только сборщик модулей (module bundler), а не загрузчик модулей (module loader), как requirejs. В статье описано несколько кейсов, когда динамическая загрузка модулей очень полезна.
      0
      В нативных ES6 модулях можно ли так организовать сборку чтобы было разденение как миниумум на 2 итоговых JS файла, один для кода приложения и один для библиотек? То есть код приложения ведь в любом случае будет ссылаться на библиотечный функицонал (импортировать), но при этом помещать библиотеки внутрь итогового JS файла приложения не нужно. При этом пречислять все модули для склеивания в один файл не хочется, нужно чтобы сборщик сам построил дерево зависимостей и собрал в один файл. Такая возможность есть при использовании browserify (опция/метод external).
        0
        Еще как можно.
          0
          Это не совсем то, насколько я понял таким образом в shared-bundle.js будут пересекающиеся модули (используемые и в first и в second деревьях), а нужно чтобы в shared-bundle.js были только библиотеки third-party/vendor (явное указание). Но плагаю что средства есть и для этого, просто я не сталкивался с ними, и хотел сразу узнать по опыту бывалых, без гугления.
            0
            github.com/webpack/docs/wiki/list-of-plugins#commonschunkplugin
            ES6-модули грузятся через бабель, сборку осуществляет webpack/
              0
              Вебпак хорош функциональностью, но очень уж у него раздутый (многословный) код конфигурации. Я сам перепробовав вообще все, что было, на System.js остановился из за простоты и из за того, что его API работы с модулями — это, по сути, полифилл будущей нативной реализации браузерами.
              0
              Совершенно верно, и с помощью System.js и Webpack можно достичь желаемого. Тут нужно пробовать, конечно.

              С помощью SystemJS Builder можно, например:

              // Отдельно построить vendor-бандл
              builder.build('third-party/vendor/**/*', 'shared-bundle.js', { minify: true, sourceMaps: true });
              
              // И исключить модули shared-bundle.js из app.js
              builder.build('app/**/* - shared-bundle', 'app.js', { minify: true, sourceMaps: true });
              
            0
            В Browserify можно, я дроблю так:
            var dependencies = [
                'react',
                'react-router',
                'react-bootstrap',
                'react-router-bootstrap',
                'moment'
            ];
            var watcher  = browserify({
                    entries: [path.ENTRY_POINT],
                    debug: options.development,
                    cache: {}, packageCache: {}, fullPaths: false
                });
                watcher.external(dependencies);
            //....
            var vendorsBundler = browserify({
                    debug: options.development,
                    require: dependencies
                });
            /....
            


            То-есть я в одном говорю, что они внешние, в другом говорю, что подключи только их.
              0
              Я выше писал что в Browserify можно, отсюда вопрос и возник можно ли не в Browserify.
            +1
            r.js берет на себя слишком многое, поэтому плохо интегрируется, к примеру, в gulp.js.

            Да и вообще — зачем использовать require.js, когда у нас давно есть SystemJSSystemJS Builder), которые совершенно прозрачно и без лишних усилий «умеют» все модули, включая ES6 (через Babel, Traceur или TypeScript)?
              0
              Кроме интеграции у r.js есть другой недостаток — он не режет require/define. Придётся либо тащить сам require на клиент, либо заменять на что-то минималистичное типа almond.js. Есть вариант дописать скрипт который при сборке будет резать эти функции. В старом jquery 1.11 такую штуку реализовали для сборки. Если любопытно, можно посмотреть тут: github.com/jquery/jquery/blob/1.11-stable/build/tasks/build.js.
                0
                Ну как по мне — «компиляция» в AMD и какой-нибудь минималистичный define/require — вполне себе вариант за неимением альтернативы. Я, напротив, обычно вижу необходимость добавлять всяческие define-обертки (например, над js-файлами, написанными как CommonJS-модули), а не обрезать их (иначе зачем их тогда вообще писать?).
                  0
                  Бывают обёртки, обеспечивающие линковку в девелопе. При билде их целесообразно выпилить вместе с линковшиком.
                  StealJS — типичный представитель. Билдер в итоге написали свой.
              0
              Отличная сравнительная таблица webpack.github.io/docs/comparison.html показывает, что и какой сборщик модулей умеет. Особенно впечатляет параметр Runtime overhead у webpack.
                0
                Если я не ошибаюсь, то по тестируемости веб приложений, подход AMD уступает CommonJS. AMD приходится тестировать в браузере или при помощи phantomjs тогда как CommonJS можно тестировать как обычные node.js модули.
                  +1
                  Вот еще не слишком популярная, но рабочая библиотека для commonjs модулей, умеет подгружать модули синхронно и асинхронно.
                    0
                    Поправьте, пожалуйста, после «Для работы понадобится всего один единственный тег» разметку, хорошо бы тэг обернуть как код, чтобы не было полпоста моноширинным шрифтом

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

                    Самое читаемое