Lecture 2 Callbacks, Events, and Asynchronous Programming

Size: px

Start display at page:

Download "Lecture 2 Callbacks, Events, and Asynchronous Programming"

Beatrice Ethel Scott
5 years ago
Views:

1 Lecture 2 Callbacks, Events, and Asynchronous Programming 1 / 13

2 What is asynchronous programming? So far, most (if not all) of the programs you've written are synchronous programs. You write code, and each line is executed one after another. However, this isn't a good model for situations where you need to wait for soemething to happen, or when you want two things to happen at once. In that case, you need asynchronous programming. This is surprisingly common: User clicking on a button Making an HTTP request to a website Fetching data from a database 2 / 13

3 Real World Example Let's say you and a friend want to go to WaWa. The synchronous way - You leave the dorm, then walk to WaWa. You order your sandwich. You wait till it's ready, pay at the register, then walk home. Now your friend leaves your dorm and walks to WaWa... The asynchronous way - You meet your friend outside of WaWa. You both order your sandwich at the same time, and pay at different registers. Once you've both picked up your sandwiches you walk back to the dorm. 3 / 13

4 JavaScript is built for async Thanks to its functional nature, JavaScript makes asynchronous programming pretty easy. We can bind functions to asynchronous calls, then handle the data we get back. The simplest unit of async control flow is a callback. 4 / 13

5 What is a callback? A callback is a function that's bound to a single asynchronous call. It is passed as an argument to another function, with the expectation that it will be executed once some async task is finished. Here's a very simple example using the built-in settimeout function. It runs its callback after waiting a specified amount of time. var cb = function () { console.log('callback ran!'); }; // wait 500ms, then run the callback settimeout(cb, 500); // --> 'callback ran!' 5 / 13

6 Node-Style Callbacks Since so many operations rely on callbacks, a standard callback style has emerged in NodeJS: var cb = function (err, results...) {...} err contains an error, if one occurred; otherwise it should be null After err, there can be any number of results arguments containing data for the callback to consume. This standardization makes it possible to transform callbacks into more expressive formats. 6 / 13

7 The Async Library: Motivations Let's say I have several asynchronous functions that need to execute in series (i.e., one after the other). This would be necessary if, say, I'm writing logs to a file and I want them in order. We could do it by chaining callbacks, but this quickly gets messy: writelogline('this is the first line', function () { writelogline('this is the second line', function () { writelogline('this is the third line', function () { console.log('done writing the logs.'); }); }); }); And I'm not even handling errors here. That would make this even messier. 7 / 13

8 The Async Solution We can do better than this by taking advantage of the standard callback format. Rather than those 'marching callbacks', we'll pass an array of functions into async.series. async.series([ function (callback) { writelogline('this is the first line', callback); }, function (callback) { writelogline('this is the second line', callback); }, function (callback) { writelogline('this is the third line', callback); } ], function () { console.log('done writing the logs'); }); * A higher-order function that generates callbacks could save us some work here - do you see how? 8 / 13

9 Wait, how does that work? The idea behind async.series is actually quite simple. The trick is to call the asynchronous functions recursively. Here's a simple implementation that doesn't handle errors: var series = function (arr, finalcb) { var serieshelper = function (index) { if (index === arr.length) { finalcb(null); } else { arr[index](function () { serieshelper(index + 1); }); } }; serieshelper(0); }; 9 / 13

10 Live Coding, Anyone? Let's write another useful function, async.map. 10 / 13

11 Event-Driven Programming Event-driven programming is another type of asynchronous programming. Unlike the examples we've seen, the callback functions (called event listeners) can be called many times. Events are registered on an object called the event bus which implements the event interface. Here's how to create a simple event bus in Node: var events = require('events'); var bus = new events.eventemitter(); This doesn't work on the frontend, however. You need to import a library like Backbone with event support. 11 / 13

12 The Event Interface The core event interface is simple. You use bus.on(eventname, listener) to register an event with a certain name. Then, calling bus.emit(args) or, in some frameworks, bus.trigger(args) will run listener with the given arguments. var bus = new require('events').eventemitter(); bus.on('foo', function () { console.log('event emitted!'); }); bus.emit('foo'); // --> 'Event emitted!' There some other, self-explanatory methods as well - for example, removealllisteners(eventname). Check the API for a full list. 12 / 13

13 Next time 1. Object-Oriented JavaScript 13 / 13

NODE.JS MOCK TEST NODE.JS MOCK TEST I

NODE.JS MOCK TEST NODE.JS MOCK TEST I http://www.tutorialspoint.com NODE.JS MOCK TEST Copyright tutorialspoint.com This section presents you various set of Mock Tests related to Node.js Framework. You can download these sample mock tests at