Основы построения асинхронных приложений

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

Базовое описание асинхронного кода

Основными функциями асинхронного кода JavaScript являются setTimeout и setInterval. Функция setTimeout выполняет заданную функцию после истечения определенного временного интервала. Она принимает возвратную функцию в качестве первого аргумента и время (в миллисекундах) в качестве второго аргумента. Вот пример использования:

console.log( "a" );
setTimeout(function() {
    console.log( "c" )
}, 500 );
setTimeout(function() {
    console.log( "d" )
}, 500 );
setTimeout(function() {
    console.log( "e" )
}, 500 );
console.log( "b" );

Ожидается, что в консоли мы увидим “a”, “b”, а затем через примерно 500 мс -  “c”, “d”, и “e”. Я использую термин “примерно” потому, что в действительности setTimeout работает непредсказуемо. Даже в спецификации HTML5 указано: "Таким образом, API не гарантирует, что таймер выполнится точно по заданному расписанию. Вероятны задержки из-за нагрузки процессора, других задач и прочих факторов."

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

Цикл событий очередь возвратных функций. Когда асинхронная функция выполняется, возвратная функция ставится в очередь. JavaScript не запускает обработку цикла событий, пока код, запущенный после асинхронной функции выполняется. Данный факт означает, что код JavaScript не является многопоточным, хотя и кажется таковым. Цикл событий является очередью FIFO (первый пришел, первый вышел), что означает выполнение возвратных функций в порядке их поступления. JavaScript был выбран для платформы node.js именно по причине простого процесса разработки подобного кода.

AJAX

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

Асинхронное получение данных с помощью метода jQuery $.ajax является простым кросс-браузерным процессом, который скрывает реальный процесс. Например:

var data;       
$.ajax({
    url: "some/url/1",
    success: function( data ) {
        // Здесь работает.
        console.log( data );
    }
})
// А здесь не работает!
console.log( data );

Обычно, но неправильно, предполагается, что данные станут доступны сразу после вызова $.ajax. Но действительность выглядит иначе:

xmlhttp.open( "GET", "some/ur/1", true );
xmlhttp.onreadystatechange = function( data ) {
    if ( xmlhttp.readyState === 4 ) {
        console.log( data );
    }
};
xmlhttp.send( null );

Объект XmlHttpRequest (xmlhttp) отправляет запрос, а возвратная функция обрабатывает событие объекта readystatechange. Затем xmlhttp выполняет метод send. По мере работы xmlhttp, событие  readystatechange генерируется каждый раз при изменении свойства readyState, и только когда xmlhttp закончит получение ответа от удаленного хоста, будет выполняться возвратная функция.

Работа с асинхронным кодом

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

Многие функции в node.js являются асинхронными. Поэтому часто можно встретить подобную ситуацию:

var fs = require( "fs" );
 
fs.exists( "index.js", function() {
    fs.readFile( "index.js", "utf8", function( err, contents ) {
        contents = someFunction( contents ); // Делаем что-нибудь с содержанием
        fs.writeFile( "index.js", "utf8", function() {
            console.log( "Обработка завершена..." );
        });
    }); 
});
console.log( "Работаем..." );

А на клиентской стороне можно встретить такой код:

GMaps.geocode({
    address: fromAddress,
    callback: function( results, status ) {
        if ( status == "OK" ) {
            fromLatLng = results[0].geometry.location;
            GMaps.geocode({
                address: toAddress,
                callback: function( results, status ) {
                    if ( status == "OK" ) {
                        toLatLng = results[0].geometry.location;
                        map.getRoutes({
                            origin: [ fromLatLng.lat(), fromLatLng.lng() ],
                            destination: [ toLatLng.lat(), toLatLng.lng() ],
                            travelMode: "driving",
                            unitSystem: "imperial",
                            callback: function( e ){
                                console.log( "ANNNND FINALLY here's the directions..." );
                                // Делаем что-нибудь с e
                            }
                        });
                    }
                }
            });
        }
    }
});

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

Именованные функции

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

var fromLatLng, toLatLng;
 
var routeDone = function( e ){
    console.log( "ANNNND FINALLY here's the directions..." );
    // Делаем что-нибудь с e
};
 
var toAddressDone = function( results, status ) {
    if ( status == "OK" ) {
        toLatLng = results[0].geometry.location;
        map.getRoutes({
            origin: [ fromLatLng.lat(), fromLatLng.lng() ],
            destination: [ toLatLng.lat(), toLatLng.lng() ],
            travelMode: "driving",
            unitSystem: "imperial",
            callback: routeDone
        });
    }
};
 
var fromAddressDone = function( results, status ) {
    if ( status == "OK" ) {
        fromLatLng = results[0].geometry.location;
        GMaps.geocode({
            address: toAddress,
            callback: toAddressDone
        });
    }
};
 
GMaps.geocode({
    address: fromAddress,
    callback: fromAddressDone
});

Дополнительно библиотека async.js может помочь обработать множественные запросы/ответы AJAX. Например:

async.parallel([
    function( done ) {
        GMaps.geocode({
            address: toAddress,
            callback: function( result ) {
                done( null, result );
            }
        });
    },
    function( done ) {
        GMaps.geocode({
            address: fromAddress,
            callback: function( result ) {
                done( null, result );
            }
        });
    }
], function( errors, results ) {
    getRoute( results[0], results[1] );
});

Данный код выполняет две асинхронные функции, и каждая функция принимает возвратную функцию “done”, которая выполняется после завершения асинхронной функции. Когда обе возвратных функции “done” завершатся, возвратная функция для parallel выполнится для обработки всех ошибок или результатов обеих асинхронных функций.

Обещание (promise)

Обещание представляет событийное событие, возвращаемое из единичного завершения операции.

Существует много библиотек, которые имеют шаблон обещаний. jQuery использует отличный API обещаний. Объект Deferred появился в версии 1.5, и конструктор jQuery.Deferred используется в функциях, которые возвращают обещания. Функции, которые возвращают обещания, выполняют некоторый вид асинхронных операций.

var geocode = function( address ) {
    var dfd = new $.Deferred();
    GMaps.geocode({
        address: address,
        callback: function( response, status ) {
            return dfd.resolve( response );
        }
    });
    return dfd.promise();
};
 
var getRoute = function( fromLatLng, toLatLng ) {
    var dfd = new $.Deferred();
    map.getRoutes({
        origin: [ fromLatLng.lat(), fromLatLng.lng() ],
        destination: [ toLatLng.lat(), toLatLng.lng() ],
        travelMode: "driving",
        unitSystem: "imperial",
        callback: function( e ) {
            return dfd.resolve( e );
        }
    });
    return dfd.promise();
};
 
var doSomethingCoolWithDirections = function( route ) {
    // Делаем обработку route
};
 
$.when( geocode( fromAddress ), geocode( toAddress ) ).
    then(function( fromLatLng, toLatLng ) {
        getRoute( fromLatLng, toLatLng ).then( doSomethingCoolWithDirections );
    });

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

В данном коде метод geocode выполняется дважды и возвращает обещание. Затем выполняется асинхронная функция и вызывает resolve в своей возвратной функции. Затем, как только проходят оба вызова resolve, выполняется then, возвращающий результат первых двух вызовов geocode. Результаты передаются в getRoute, который также возвращает обещание. В завершение, когда обещание из getRoute разрешается, выполняется возвратная функция doSomethingCoolWithDirections.

События

События являются другим решением для связи, когда асинхронные возвратные функции заканчивают выполнение. Объект может стать эмиттером и генерировать событие, которое будет отлавливать другой объект. Такой тип работы с событиями называется шаблоном наблюдения (observer pattern). Библиотека backbone.js использует такой функционал с помощью Backbone.Events.

var SomeModel = Backbone.Model.extend({
   url: "/someurl"
});
 
var SomeView = Backbone.View.extend({
    initialize: function() {
        this.model.on( "reset", this.render, this );
 
        this.model.fetch();
    },
    render: function( data ) {
        // Обрабатываем данные
    }
});
 
var view = new SomeView({
    model: new SomeModel()
});

Существуют другие библиотеки, использующие такую модель работы с событиями, такие как jQuery Event Emitter, EventEmitter, monologue.js и node.js имеет модуль EventEmitter.

Схожий метод публикации событий используется в шаблоне с посредником (mediator pattern), который применяется в библиотеке postal.js. В шаблоне с посредником имеется доступный для всех объектов посредник, который ловит и  публикует события. При таком подходе один объект не имеет прямых ссылок на другой объект, а следовательно, все объекты отвязаны друг от друга.

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

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

var doSomethingCoolWithDirections = function( route ) {
    postal.channel( "ui" ).publish( "directions.done",  {
        route: route
    });
};

Такой подход позволяет другим областям приложения отвечать асинхронным возвратным функциям без прямых ссылок на объект, генерирующий запрос. что делает возможным обновление нескольких областей на странице когда получается направление. В обычной конфигурации jQuery Ajax при изменении п=направления требуется успешный вызов обратной функции. Такой подход трудно обслуживать, а использование сообщений существенно облегчает обновление множественных областей интерфейса пользователя.

var UI = function() {
    this.channel = postal.channel( "ui" );
    this.channel.subscribe( "directions.done", this.updateDirections ).withContext( this );
};
 
UI.prototype.updateDirections = function( data ) {
    // Маршрут доступен в data.route, теперь нужно просто обновить интерфейс
};    
 
app.ui = new UI();

Другие реализации шаблона с посредником используются в библиотеках amplify, PubSubJS и radio.js.

Заключение

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

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