JS101: Function

02 Jul 2012 | By Alex Young | Comments | Tags js101 tutorials language beginner

We’ve already been using functions and methods (remember the difference?) as part of this series, but it’s time to take a deeper look at one of my favourite parts of the language. Prepare to have your mind blown by two incredible facts about the humble function.

Functions are Objects

The ECMAScript Language Specification defines three ways to create functions. The first is a function declaration:

function sum(a, b) {
  return a + b;
}

A Function object will be instantiated behind the scenes, and returned as the result of this expression. With that in mind, the following should make complete sense:

var sum = function(a, b) {
  return a + b;
};

The function expression results in a value being returned, and it can be assigned as required. That’s because the function’s identifier is optional, and also because a Function object is returned.

The Function constructor isn’t hidden away by the interpreter, however. It can be used like this:

var sum = new Function('a', 'b', 'return a + b');

That brings us to an important point: functions are objects. They’re not a pre-OO construct that’s used to somehow build JavaScript’s object-oriented features – they’re actually objects themselves and can be manipulated as such.

When functions are passed as arguments or set to variables, they’re colloquially known as anonymous functions. This term isn’t used within the ECMAScript specification, but you’ll see it referred to when people discuss popular APIs like jQuery:

$('selector').each(function() {
  // Inside the anonymous function passed to jQuery's `each` method
});

Closures

Functions can be created anywhere an expression can appear, which means they can appear inside other functions:

function sum(a, b) {
  function max() {
    return a > 100 || b > 100;
  }

  if (max()) {
    throw new ArgumentError('Value too large');
  }
  return a + b;
}

We’ve already used this when creating “private” functions inside prototype methods and constructors. However, notice how the arguments to sum are visible inside the max function. Internally, the function is passed the VariableEnvironment of the current context, which is otherwise known as the scope.

The fact these inner functions receive access to the variables in their containing function’s scope is useful, and known as a closure:

Let closure be the result of creating a new Function object as specified in 13.2 with parameters specified by FormalParameterListopt and body specified by FunctionBody. Pass in funcEnv as the Scope.

Next

Next week we’ll look at functions in more depth.

References

LZF Compression, Nekoreader, Backbone.BindTo

29 Jun 2012 | By Alex Young | Comments | Tags libraries backbone.js html5 filesystem

LZFjs

LZFjs (GitHub: pkalogiros / LZFjs, License: GPL3) by Pantelis Kalogiros is a compression library based on LibLZF that uses the File API to compress files in client-side JavaScript:

The script is converted from the C version of LZF and works surprisingly fast and well. Both its functions (compress/decompress) accept and return an arraybuffer.

Even though it’s been converted from C, the JavaScript is surprisingly easy to follow.

Nekoreader

Nekoreader (GitHub: nekoreader / nekoreader.github.com) is a client-side feed reader created by Vincent Grastic. It uses JSONP, and Google’s Feed API to handle feeds. It has an API that allows a list of feeds to be specified in a JSON file. A template file and CSS can also be supplied to style the results.

Although people have been using Google’s Feed API for a while for similar projects, I like the fact the author’s example shows how to configure an entirely client-side app using services like GitHub and Dropbox.

Backbone.BindTo

Radoslav Stankov’s Backbone.BindTo (License: MIT) is a Backbone.js extension that makes it easier to bind models to views. The author’s example compares standard Backbone.js code with his extension:

window.UserCardView = Backbone.View.extend({
  initialize: function() {
    this.model.bind('change:name',  this.renderName,  this);
    this.model.bind('change:email', this.renderEmail, this);
  },
  remove: function() {
    this.model.unbind('change:name',  this.renderName,  this);
    this.model.unbind('change:email', this.renderEmail, this);
    Backbone.View.prototype.remove.apply(this, arguments);
  },
  renderName:  function() { /* ... code ... */ },
  renderEmail: function() { /* ... code ... */ }
});

Using Backbone.BindTo makes this feel less like boilerplate:

window.UserCardView = Backbone.View.extend({
  bindToModel: {
    'change:name':  'renderName',
    'change:email': 'renderEmail'
  },
  renderName:  function() { /* ... code ... */ },
  renderEmail: function() { /* ... code ... */ }
});

Events will be unbound when views are removed, and there’s also Backbone.BindTo.noConflict for using the extension without modifying Backbone.View.

The same author has also recently released Backbone.Handlebars, which helps integrate Backbone.js and Handlebars.js.

More ES6 Modules Reactions, Dojo 1.8 Calendar, Maria, Brackets

28 Jun 2012 | By Alex Young | Comments | Tags libraries mvc ES6 dojo apps editors

More ES6 Modules Reactions

Yesterday I mentioned Isaac Schlueter’s post about ES6 modules, and now James Burke has responded with Comments on Isaac’s ES modules post. James’ comments are interesting given his background with RequireJS, and it’s easy to see how much his thoughts are influenced by AMD.

James has also written ES Modules: suggestions for improvement, in which he states “I want AMD and RequireJS to go away”:

They solve a real problem, but ideally the language and runtime should have similar capabilities built in.

New Dojo Components

Dojo calendar

The new Dojo calendar and gauges are explored in Introducing new visualization components in Dojo 1.8. A lot of client-side developers have asked me about full-blown calendar libraries over the years, and this one looks extremely elaborate.

The calendar documentation shows off how simple the API is:

require(["dojo/parser", "dojo/ready", "dojox/calendar/Calendar"],
  function(parser, ready, Calendar){
    ready(function(){
      calendar = new Calendar({
                   dateInterval: "day",
                   style: 'position:relative;width:500px;height:500px'
                }, 'someId');
              }
          )}
  );

There’s also a stunning amount of documentation, with examples, diagrams, and CSS styling details.

Maria

I really love the TodoMVC project by Addy Osmani. It showcases lots of client-side MVC frameworks. However, seeing as most people seem to misinterpret what MVC means, Peter Michaux has created Maria to set the record straight:

An MVC framework for JavaScript applications. The real MVC. The Smalltalk MVC. The Gang of Four MVC.

In Maria, models are event targets that can be observed by any other objects (including views, controllers, and other models). Views observe models and represent their current state. Controllers determine what happens when users interact with views.

There’s a TodoMVC example for Maria that breaks down like this:

The view files change elements based on models, but you won’t see a fragment of HTML in them. In Maria, the concept of a view is distinct from a template. For example, TodoTemplate.js contains the list element HTML fragment.

This stricter interpretation of MVC may be beneficial because views become easier to reuse, and the event-based design seems natural in JavaScript.

Now, you’re probably not going to replace your Backbone.js projects with Maria anytime soon, but it’s definitely worth trying out Peter’s project to see how it can better inform development with your MVC-style library of choice.

Brackets

Brackets

Brackets (GitHub: adobe / brackets, License: MIT) from Adobe is an open source editor aimed at web developers. There’s detailed blog post all about it here: Building a Desktop-Quality App on Web Technologies.

Although it’s built with web technology, it includes a native desktop application to make working with local files easier. It seems like they’ll be working to remove this dependency in the future, and there’s always the possibility of using something like Filepicker.io for accessing files from services like Dropbox.

Coincidentally, Cloud9 IDE has been updated with new collaboration features, compilation (gcc) and interpreter support (Ruby, Python) support, and offline editing.

Node Roundup: 0.8, ES6 Modules, Kapitalize, Avatars.io

27 Jun 2012 | By Alex Young | Comments | Tags node modules bitcoin images apis
You can send in your Node projects for review through our contact form or @dailyjs.

Node 0.8

Node 0.8 has been released, and Isaac Schlueter has written up a detailed post with some impressive benchmarks: Node v0.8.0. In terms of compatibility, reports from the community seem positive so far. As always, keeping an eye on the nodejs Google Group is a wise idea to gauge potential issues.

As I’ve been researching material for the Windows and Node series, I’m excited about the future of cross-platform addons:

GYP was used already in Node v0.6 to build on Windows, but now it defines the build on all platforms. Node is still in the process of migrating external addon modules to GYP, and node-gyp is included with npm. In future releases, node-waf will be officially deprecated.

The REPL has been improved – long lines now wrap correctly, and built-in modules are automatically loaded without needing a require. For example, typing net will automatically return the net module. There’s no magic to this, repl.js now defines a list of built-in modules that are automatically loaded when a command matches one.

Work has already started on 0.9, and Isaac mentions the long talked about HTTP refactoring. However, 0.6 releases will continue to the end of 2012, so don’t fret if you’re still heavily invested in 0.6.

ES6 Modules: A Simpler Proposal

The ECMAScript Modules Proposal represents a major point of contention in the JavaScript community. Frustrated at discussing it in 140 characters, Isaac Schlueter finally wrote what he really thinks of it all in On ES 6 Modules.

This isn’t politics. We’re not voting for parties. The goal is to figure out the best API, which is a complex thing. The solution space is wide, and it is naive to reduce it to a boolean prematurely.

The discussion is ongoing, but Brendan Eich responded directly here: ES Modules: suggestions for improvement

Static module systems are static, in dependency prefetching, in binding, and in export vs. import checking.

Kapitalize

Kapitalize (License: MIT, npm: kapitalize) is a Bitcoin client that has a chainable API and supports the Bitcoin API.

var kapitalize = require('kapitalize')()

kapitalize
.auth('Macintyre', 'mypassword')
.set('host', '127.0.0.1')
.set({
    port:8332
})
.getNewAddress()
.getBalance()

The module includes tests, and documentation can be found in the readme.

Avatars.io

Avatars.io is a new service that makes avatars easier to work with for developers. The Avatars.io client library (License: MIT, npm: avatars.io) by Vadim Demedes is a Node module that works with this service:

AvatarsIO.upload('path/to/image.jpg', function(err, url) {
  // url is a URL of just uploaded avatar
});

On a related note, Chute (npm: chute) by the same author is a client for Chute, which allows sets of photos to be uploaded and managed using a simple API.

jQuery Roundup: jQuery 1.8: Beta 1, AttC, DPB, Iframe Height

26 Jun 2012 | By Alex Young | Comments | Tags jquery plugins iframes graphs
Note: You can send your plugins and articles in for review through our contact form or @dailyjs.

jQuery 1.8: Beta 1

jQuery 1.8: Beta 1 is out, and there’s going to be more jQuery news to follow over the coming weeks:

There will be even more exciting jQuery news at the jQuery Conference in San Francisco later this month, with blog posts to follow.

Custom jQuery builds are now supported through Grunt. That means the ajax, css, dimensions, effects, and offset modules can be safely removed, and even replaced with another library.

In addition, the animation code has been cleaned up, and CSS transitions are supported. Interestingly, by jQuery 1.9 $.browser will be dropped:

Ever since jQuery 1.4, we’ve been evangelizing that browser detection via the user agent string is a bad idea. Yet we’ve been an enabler of bad practice by continuing to offer $.browser. As of jQuery 1.9 we’ll remove it entirely and you’ll need to use the 1.9 compat plugin.

As usual there’s a full list of changes in the blog post: jQuery 1.8: Beta 1.

AttC

AttC (License: Apache 2.0) is a jQuery plugin that converts HTML tables to graphs using the Google Visualization API.

The jQuery part is a simple method call, $(selector).attc(), but configuration is performed through the corresponding HTML using data attributes. The authors have written a guide to basic usage for AttC.

DPB

DPB (License: GPL) by Dannie Hansen is a dynamic popup plugin that supports iframes and modal popups. An overlay can be displayed that dims the page, and there are callbacks for the open and close events:

$(selector).DPB({
  animation: 'topSlide'
, type: 'inline'
, width: 200
, height: 100
, top: 20
, selector: $('.inlineElement')
});

Iframe Height

Iframe Height Jquery Plugin by Ilker Guller sets the height of an iframe based on the content, and includes a fix for cross-domain iframe resizing. The plugin is invoked with $('#autoIframe').iframeHeight, and the options available are as follows:

$(selector).iframeHeight({
  resizeMaxTry: 2
, resizeWaitTime: 300
, minimumHeight: 100
, defaultHeight: 500
, heightOffset: 90
, exceptPages: ''
, debugMode: false
, visibilitybeforeload: true
, blockCrossDomain: true
});

JS101: Call, Apply, and Bind

25 Jun 2012 | By Alex Young | Comments | Tags js101 tutorials language beginner

Last week we looked at this, and how it can be assigned and manipulated. The example I gave showed that a function inside another function (or method) will resolve this to the global object, and I used var self = this to reference the intended object.

Reader n1k0 pointed out another solution: Function.prototype.call:

Shape.prototype = {
  move: function(x, y) {
    this.x += x;
    this.y += y;

    function checkBounds() {
      if (this.x > 100) {
        console.error('Warning: Shape out of bounds');
      }
    }

    checkBounds.call(this);
  }
};

The call and apply Methods

In JS101: Object.create, I mentioned how Function.prototype.call can be used to chain constructors. Let’s take a deeper look at these methods of Function.

The difference between the two is we generally use call when we know what a function’s arguments are, because they’re supplied as arguments. Conversely, apply expects an array of parameters:

Shape.prototype = {
  move: function(x, y) {
    this.x += x;
    this.y += y;

    function checkBounds(min, max) {
      if (this.x < min || this.x > max) {
        console.error('Warning: Shape out of bounds');
      }
    }

    checkBounds.call(this, 0, 100);
    checkBounds.apply(this, [0, 100]);
  }
};

These methods have been around since ECMAScript 3rd Edition, and you’ll see them used a lot. Take a look at the source for any popular JavaScript project and you’ll find one of these methods being used:

Why are these methods so popular? Basically it comes down to functions being a first class citizen in JavaScript. I’ve been talking about the importance of objects for weeks, but learning how to manipulate functions is the key to mastering JavaScript.

JavaScript allows us to pass functions around, then execute them in different contexts by taking advantage of call and apply.

This is an example from the beginning of jQuery’s documentation:

$('div.foo').click(function() {
  $(this).slideUp();
});

Here, this refers to the relevant DOM object. We’ve supplied our own callback, but this points to something that makes sense within the context of jQuery’s API.

Binding

In the comments for the previous post, Andres Descalzo pointed out that Function.prototype.bind can also be used to change this. The bind method of Function was introduced in ECMAScript 5th Edition, and it returns a new function that’s bound to a different this:

Shape.prototype = {
  move: function(x, y) {
    this.x += x;
    this.y += y;

    function checkBounds(min, max) {
      if (this.x < min || this.x > max) {
        console.error('Warning: Shape out of bounds');
      }
    }

    var checkBoundsThis = checkBounds.bind(this);
    checkBoundsThis(0, 100);
  }
};

Notice that a new variable has to be created for the newly bound function. The comment Andres posted uses an anonymous function to remove the extra variable:

Shape.prototype = {
  move: function(x, y) {
    this.x += x;
    this.y += y;

    var checkBounds = function(min, max) {
      if (this.x < min || this.x > max) {
        console.error('Warning: Shape out of bounds');
      }
    }.bind(this);

    checkBounds(0, 100);
  }
};

I like Mozilla’s bind documentation, because it shows how some built-in methods like setTimeout require less syntax when used with methods. The lesson here isn’t really due to the design of setTimeout but more general: using bind is a convenient way to pass a method to another function.

Summary

When working with methods, the value of this is important. By using the apply, call, and bind methods of Function, we can:

  • Change this inside a function, enabling flexible APIs to be created as demonstrated by popular projects like jQuery, Backbone.js, and Express
  • Reduce syntactical overhead when using functions inside methods, and passing methods to other functions
  • Chain calls to constructors (see JS101: Object.create)

Jam, js-schema, Chai Plugins

22 Jun 2012 | By Alex Young | Comments | Tags libraries modules package-managers testing

Jam

Jam

Jam (GitHub: caolan / jam, npm: jamjs) by Caolan McMahon is a client-side package manager, with a focus on AMD. It can be used to download client-side libraries, and compile them for deployment. Packages will be installed to ./jam.

Usage looks like this:

$ npm install -g jamjs
$ jam install jquery
$ jam install backbone
$ ls jam
backbone          jquery            require.js
jam.json          require.config.js underscore
$ jam ls
* backbone 0.9.2
* jquery 1.7.2
  underscore 1.3.3-jam.1

Running jam compile will output a file containing selected modules and RequireJS. RequireJS can be swapped for a lightweight replacement. That means certain modules could be bundled separately so your application can load them when required, taking advantage of asynchronous resource.

Jam also supports version locking. I kept looking for a manifest file or package.json, but it’s done like this:

$ jam lock jquery@1.7.2
$ jam ls
* backbone 0.9.2
* jquery 1.7.2 [locked 1.7.2]
  underscore 1.3.3-jam.1

js-schema

js-schema (License: MIT, npm: js-schema) by Gábor Molnár allows schemas to be defined using simple JavaScript, and can work with the JSON Schema format. It’ll work in Node and browsers as well. Schemas are defined in terms of nine rules, which includes things like matching regular expressions and objects.

This basic example from the readme demonstrates how it works:

var schema = require('js-schema');
// or <script src="js-schema.min.js"></script> in the browser

var Duck = schema({          // A duck
  quack: Function,           //  - can quack
  feed: Function,            //  - can be fed
  age: Number.min(0).max(5), //  - is 0 to 5 years old
  color: ['yellow', 'brown'] //  - has either yellow or brown color
});

Notice that this adds methods to the built-in constructors, and the author hasn’t yet included unit tests. Purists may prefer to see schema.Number, as in other validation frameworks.

Chai 1.0

Chai 1.0 (GitHub: chaijs / chai, License: MIT) was released recently. There’s been a lot of bug fixes and improvements since the 0.5.x releases, and the developers have improved the API so it’s easier to extend Chai with plugins.

The Chai Plugin Directory can be used to find plugins, and it even shows if the plugin is intended to work with Node or a browser. Each plugin page includes documentation and installation details, for example: chai-jquery.

Windows and Node: PowerShell

21 Jun 2012 | By Alex Young | Comments | Tags node tutorials windows windows-and-node
To read previous posts in this series, view the windows-and-node tag.

This article is aimed at Unix-oriented developers who are interested in learning a little bit about Windows scripting. It also demonstrates an easy way of calling PowerShell from Node.

Windows PowerShell is comprised of three parts: a command-line shell, a scripting language, and an integration layer with the .NET Framework. It supports both COM and WMI, so combined with the scripting facilities it’s a perfect tool for administrative task automation. There are quite a few Node modules that include shell scripts – PowerShell is a Windows-friendly way of achieving similar goals.

Modules that include man pages for Unix systems can support Windows by including Windows PowerShell Help, which are essentially just XML files. I’m not sure if it’s sensible to use this to document a Node program because it seems focused on PowerShell modules themselves, but it seems worth mentioning.

If you’re a Unix-based Node developer who’s looking to support Windows users, then it’s a good idea to familiarise yourself with the basics of PowerShell. PowerShell can be used to execute programs, which will run as a separate process (just like a Unix shell). .NET programs designed specifically for PowerShell are called cmdlets – these are considered “native” commands and execute within the current PowerShell process. They can actually support input and output as objects, which means collections of objects like arrays can be read and written using pipes.

Using PowerShell

Loading PowerShell

The Windows PowerShell binary itself can be found in the Start menu under All Programs, Accessories. There’s also Windows PowerShell ISE (Integrated Scripting Environment), which is an IDE for writing PowerShell scripts.

Once it’s loaded, you can try issuing some commands. The help pages I mentioned can be accessed with get-help, so try typing get-help get-service:

Loading PowerShell

Tab completion is supported, so typing Get- and pressing tab will cycle through each matching command. Completion also works for parameters.

PowerShell also features aliases to Unix commands. The Get-ChildItem cmdlet lists files and directories, much like ls in Unix. Fortunately, Get-ChildItem is aliased to ls, which makes things a little bit easier for those versed in Unix shells. There are lots of other aliases for DOS and Unix commands:

  • Get-Content: cat
  • Get-Help: man, help
  • Set-Location: cd

Using PowerShell with Node

What I’ve been building to here is how to take advantage of PowerShell’s convenience and integration with Window-specific APIs and interfaces like COM from within Node programs. This program will list the current directory using Node’s child_process module:

var exec = require('child_process').exec;

// List a directory
exec('powershell.exe -Command "Get-ChildItem"', function(err, stdout, stderr) {
  console.log(stdout);
})
.stdin.end();

The basic pattern is powershell.exe -Command "...". The result should look like this:

PowerShell from Node

Meanwhile, accessing objects using COM is also supported by PowerShell:

var exec = require('child_process').exec
  , script;

// Use COM objects to get filesystem information
script = '$f = new-object -com "scripting.filesystemobject"; $f.drives | where {$_.drivetype -eq 2} | Select Path,AvailableSpace,FreeSpace,TotalSize';

exec('powershell.exe -Command "' + script + '"', function(err, stdout, stderr) {
  console.log(stdout);
})
.stdin.end();

Where might this come in useful? Well, I have a feeling that certain modules that depend on Unix-specific binaries could be ported to Windows more easily by using PowerShell. And Windows developers could use it to interface with native services without building native addons.

Summary

  • PowerShell is a command-line shell, scripting language, and integration layer with .NET
  • It supports help files and is extensible
  • Commands often work with objects rather than text, and objects can be pipelined
  • Forking using the PowerShell binary is possible, which may help port modules that depend on Unix binaries

Node Roundup: 0.7.12, nd, futoncli

20 Jun 2012 | By Alex Young | Comments | Tags node modules couchdb databases documentation
You can send in your Node projects for review through our contact form or @dailyjs.

Node 0.7.12: Prepare for 0.8!

Node 0.7.12 is here, and Isaac Schlueter said Node 0.8.0 will be released later this week:

Please try out this release. There will be very virtually no changes between this and the v0.8.x release family. This is the last chance to comment before it is locked down for stability. The API is effectively frozen now.

That means it’s crunch time! Efforts have been made to preserve support for binary addons that use libeio and libev, but libev will be officially deprecated in 0.8 and gone in 0.9.

The 0.6 era feels like halcyon days – a time when Node received a huge amount of attention from the mainstream technology press, and stronger than ever developer interest. I’d like to wish the core team the best of luck with the 0.8 release.

nd

Back in April, TJ Holowaychuk released mad(1), an alternative manual page system based on Markdown. Now Russ Frank has released nd (License: MIT, npm: nd), which is similar to mad but focused on displaying documentation for npm modules and is written in JavaScript.

Typing nd module will display the documentation associated with module. The project’s readme contains lots of tips for finding documentation within modules and displaying it, and it also points out that it supports Windows – it’ll run fine in the standard cmd.exe command interpreter.

futoncli

Futon

If you’re working with CouchDB, then futoncli (License: Apache 2.0, npm: futon) by Nuno Job may be useful. It’s a command-line tool for managing CouchDB, and is based on the author’s nano database driver.

Once installed, the futon binary will accept commands, and configuration can be persisted to the ~/.futoncliconf file. The author has made a video of futoncli to demonstrate the main features.

jQuery Roundup: Bootstrap Extensions, IndexedDB Polyfill, Backbone UI

19 Jun 2012 | By Alex Young | Comments | Tags jquery plugins backbone.js bootstrap databases indexeddb
Note: You can send your plugins and articles in for review through our contact form or @dailyjs.

Nijiko’s Bootstrap Extensions

Nijiko Yonskai sent us two new Bootstrap extensions: Notifications (GitHub: Nijikokun / bootstrap-notify, License: Apache 2.0) and Toggle Switches (GitHub: Nijikokun / bootstrap-toggle, License: Apache 2.0).

The Notifications extension uses the same look and feel as Bootstrap’s built-in alerts, but displays them as popups instead. It works like a typical jQuery plugin:

$('.notifications').notify({
  message: { text: 'Here is a simple message' },
  type: 'success'
}).show(); // for the ones that aren't closable and don't fade out there is a .close() function.

The Toggle Switches extension turns checkboxes into a larger more graphical switch that looks a bit like the iOS UISwitch. The author has included the required CSS as well.

IndexedDB Polyfill

The current state of client-side databases is confusing, mainly because there are major browsers that still don’t support IndexedDB. However, the IndexedDB Polyfill (GitHub: axemclion / IndexedDBShim, License: GPL2/BSD) by Parashuram Narasimhan allows browsers that still support Web SQL Database to use Indexed Database API instead. It also works with the author’s JQuery IndexedDB Plugin.

Including this polyfill on a page allows applications to use window.indexedDB as a single point into the IndexedDB API. The author has written some additional material about the plugin on his blog:

Backbone UI

Backbone UI (GitHub: perka / backbone-ui, License: MIT) by Joe Stelmach allows Backbone models and collections to be displayed as UI components. By using data binding, the UI is kept up-to-date, and it’s pretty easy to change the components using CSS.

The authors have attempted to make it work more closely with the DOM rather than using HTML templates. This is possible in part due to Joe’s Laconic library. The focus is on JavaScript-heavy client-side applications rather than traditional server-side generated templates.

The documentation includes a sample to-do list application, and the source is surprisingly easy to follow and concise.

JS101: this

18 Jun 2012 | By Alex Young | Comments | Tags js101 tutorials language beginner

So far in JS101, our examples have mentioned this and functions that take advantage of its behaviour, like Function.prototype.apply and Function.prototype.call. However, before approaching other aspects of the language, we should first address this and execution contexts.

Methods and Functions

In this article I refer to both methods and functions. Method is defined in the ECMAScript specification as follows:

… function that is the value of a property.

NOTE When a function is called as a method of an object, the object is passed to the function as its this value.

We typically think of functions as a standalone subroutine, while methods are properties of an object that happen to be functions. This nomenclature is used widely within the community.

Execution Context

According to the ECMAScript 5.1 specification, an executing program is formed of “execution contexts”. These execution contexts support the language constructs we need to manage scope – the visibility of variables and function declarations from other parts of a program.

The execution context contains references to various elements that enable state within a program to be managed according to the current logical scope – for the exact details, see Execution Contexts in the specification. What we’re interested in is how the current value of this is determined.

Global Context and Constructors

Try running the following code in Node or a browser:

function add(x, y) {
  console.log(this);
  return x + y;
}

add(1, 1);

The second line will cause the global context to be displayed: global in Node, or window in a browser. If I inserted 'use strict' after the line that reads function add..., then this would be undefined instead.

Now consider what happens when a constructor is executed:

function Shape() {
  this.x = 0;
  this.y = 0;
}

var shape = new Shape();

When control enters the Shape constructor as a result of new Shape(), the this value will refer to the current object. Keep this in mind when writing object-oriented code: if a function is called as a method on an object, or by using new, then the value of this will be the current instance of the object, otherwise it will be the global context (or undefined in strict mode). The lesson here is the value of this is dependent on how a function is called.

Common Mistakes

Be careful when nesting functions inside methods. Read the following example and try to figure out the value of this inside checkBounds:

function Shape() {
  this.x = 0;
  this.y = 0;
}

Shape.prototype = {
  move: function(x, y) {
    this.x += x;
    this.y += y;

    function checkBounds() {
      if (this.x > 100) {
        console.error('Warning: Shape out of bounds');
      }
    }

    checkBounds();
  }
};

var shape = new Shape();
shape.move(101, 1);

The checkBounds function is defined inside the move method, but the console.error line will never be reached. This is because the value of this will be set to the global context, which is correct according to the specification but understandably confusing and represents a common source of bugs.

Fortunately, this is a value so we can reference it by using another variable:

Shape.prototype = {
  move: function(x, y) {
    var self = this;

    this.x += x;
    this.y += y;

    function checkBounds() {
      if (self.x > 100) {
        console.error('Warning: Shape out of bounds');
      }
    }

    checkBounds();
  }
};

Here self now points to the ThisBinding assigned when move executes, so checkBounds will work the way we intend it to. The name self can be anything, but it’s a popular convention. It’s not a reserved word, but your editor may highlight it.

Summary

When working with this, remember the following rules:

  • It’s set based on how a function is called: new MyConstructor or myObject.method() will refer to an instance, while this inside a function refers to the global context
  • Strict mode causes this to evaluate to undefined instead of the global context inside functions
  • this can be referenced by a variable, and self is the conventionally used name

If you want to read lower-level details on this topic, start by looking at how the ECMAScript 5.1 specification defines the algorithms that are used to determine this for various situations: entering global code, executing eval code, and entering functions.

WebModular, Intravenous, Sindre's Grunt Tasks

15 Jun 2012 | By Alex Young | Comments | Tags grunt audio libraries

WebModular

WebModular

WebModular is a modular synthesiser built using JavaScript and the Web Audio API. It’s a bit like the Google Doogle for Robert Moog’s birthday, except it’s a bit more powerful. This synth includes a pair of VCOs, VCFs, VCAs, envelopes, LFOs, and a ring modulator. It’s also got a little mixer built-in, and a keyboard. The keyboard has CV and gate outputs.

It’s a mind-blowing piece of work, and makes me wonder if we’ll ever see the likes of the Korg and Yamaha iOS apps ported to browsers.

Intravenous

Intravenous (GitHub: RoyJacobs / intravenous, License: MIT, npm: intravenous) by Roy Jacobs is an inversion of control library for browsers and Node. It’s distributed as a CommonJS module, but it’ll also work with AMD and in browsers without AMD. The idea behind this library is to reduce coupling between components by using a system of containers that help manage object lifecycles and manage their relationships. Containers can be nested, which seems like it would help manage objects in single page applications.

Containers are created, then services are registered with them, then classes can be defined along with their dependencies:

var container = intravenous.create();
container.register('logger', loggerClass);
container.register('someGlobalData', { data: 'hello' });

function ExampleClass(logger, someGlobalData) {
  /* use logger here */
}

ExampleClass.$inject = ['logger', 'someGlobalData'];
container.register('ExampleClass', ExampleClass);

There’s a lot more to it, but the author has written detailed examples in the project’s documentation.

Sindre’s Grunt Tasks

Sindre Sorhus has been writing quite a few Grunt tasks:

Node Overflow: Countly, Prelude, fibonacci-async

14 Jun 2012 | By Alex Young | Comments | Tags node modules express apps addons functional
You can send in your Node projects for review through our contact form or @dailyjs.

Countly

Countly

Countly (GitHub: Countly / countly-server, License: Countly Community Edition License) from the Countly team based in Turkey is a mobile analytics server that has SDKs for iOS and Android. The web interface and API are separated into two applications – the front-end is built with Express, and the API is a lightweight server. MongoDB is used to store data and sessions. The Express application is a fairly straightforward monolithic implementation.

In terms of client-side code, the Express app uses ejs for templates, and jQuery UI.

The authors have included an installation script, bin/countly.install.sh, which helps get the server-side component up and running. If you want to try it out without installing it, there’s a demo on count.ly.

Prelude.ls

Prelude.ls (GitHub: gkz / prelude-ls, License: MIT, npm: prelude-ls) by George Zahariev is a functional programming library written with LiveScript, which is a bit like a more functional CoffeeScript.

The author has provided examples of every single function the library provides in both JavaScript and LiveScript. All functions are curried, so supplying an incomplete list of arguments will return a partially applied function:

var takeFour = take(4);
takeFour('hello there'); //=> 'hell'

The API feels quite lightweight in places because certain functions accept objects where a function might be used in similar libraries:

reject([false, true], {a: 0, b: 1, c: 0});
//=> {a: 0, c: 0}

The author has included tests written with LiveScript.

fibonacci-async

fibonacci-async (License: MIT, npm: fibonacci-async) by Enno Boland is a response to certain well-known blog posts berating Node’s performance at potentially unfair benchmarks. It’s an asynchronous C++ Fibonacci series generator, which strikes me as something potentially useful as an educational example for those interested in writing Node addons.

Node Roundup: Broom, cmbn, archie, Templato

13 Jun 2012 | By Alex Young | Comments | Tags node modules templating
You can send in your Node projects for review through our contact form or @dailyjs.

Broom

Broom (License: MIT, npm: broom) by Bolgov Roman is an “application-level flow control library”. It’s designed to help split applications into small modules that can be executed in parallel or in serial. The intent is to help avoid using too many deeply nested callbacks, but to also make it easier to write tests.

The reason I think Broom is interesting is the author has combined flow control concepts with separation of concerns to address program design at a high level. Although there are a lot of flow control libraries, I think we need more effort in application architecture.

cmbn

cmbn (License: MIT, npm: cmbn) by Gamaiel Zavala allows client-side assets to be served from a single URL. It comes with middleware that will work with Express. Rather than making requests to several CDNs, URLs can be generated that look like this:

http://cmbn.us/~cj;require.js,1.0.8,require.min.js/~gg;jquery,1.7.2,jquery.min.js

The author suggests using this with CloudFlare CDN to improve performance.

archie

archie (License: Apache 2.0, npm: archie) by Ian Macalinao is an “archetype system”. Given a folder, archie will replace values within each file, then output a new folder with these changes. It can be used as a command-line tool like this:

archie gen -a simple -n myproject

The author has based this module on Apache Maven, which uses archetypes for project templating.

Templato

Templato (License: MIT, npm: templato) by Vadim Demedes is a unified API for several templating modules that also works in browsers. It currently works with EJS, Eco, Jade, and Mustache.

The author has included Mocha tests, and these will run in a browser as well.

jQuery Roundup: Joconut, jQuery Table Sort, jQuery.pushevent

12 Jun 2012 | By Alex Young | Comments | Tags jquery plugins html5 history pjax tables
Note: You can send your plugins and articles in for review through our contact form or @dailyjs.

Joconut

Joconut (License: MIT) by Vadim Demedes is an alternative implementation of Chris Wanstrath’s pjax plugin. Joconut is about 1K smaller (I compared them both gzipped and minified myself), and it also loads JavaScript and CSS automatically.

Adding Joconut to a page will cause requests to the current host to load using $.ajax. To maintain history, it uses history.pushState, and degrades to onhashchange. Several internal events can be bound to, which is useful for things like error handling:

$.joconut.on('error', function() {
  alert('Error while loading new page!');
});

Stupid jQuery Table Sort

Stupid jQuery Table Sort (GitHub: joequery / Stupid-Table-Plugin, License: MIT) by Joseph McCullough is a simple table sorting plugin based around Array.prototype.sort:

As long as you understand basic JavaScript sorting, you can make this plugin do as much or as little as you want.

Callbacks can be supplied for custom sorting based on type. In Joseph’s example, he’s set a th class of type-date, then passed in a date callback:

$('#complexTable').stupidtable({
  'date': function(a,b) {

jQuery.pushevent

jQuery.pushevent (License: GPL) by “yeikos” helps manage the order events will be fired. This example causes the order of the events to be swapped:

$('button').on('click.first', function() {
  alert('1');
}).on('click.second', function() {
  alert(2);
}).pushEvent('click.second');

The author also sent in two more plugins:

JS101: Constructor Functions

11 Jun 2012 | By Alex Young | Comments | Tags js101 tutorials language beginner

The ECMAScript 5.1 specification defines the behaviour of calling “built-in” constructors as if they were functions. That means not only can new Array(1, 2) be used, but also Array(1, 2):

When Array is called as a function rather than as a constructor, it creates and initialises a new Array object. Thus the function call Array(...) is equivalent to the object creation expression new Array(...) with the same arguments.

15.4.1 The Array Constructor Called as a Function

Object() is documented as performing a type conversion, and String() also does this:

var a = new String(1);
// { '0': '1' }
var b = String(1);
// '1'

The Date constructor technically performs a type conversion, but this is sometimes a source of confusion for beginners who just want a readable string representation of a date:

var a = new Date(2012, 0, 1);
// Sun, 01 Jan 2012 00:00:00 GMT
Date(2012, 0, 1)
// 'Sun Jun 10 2012 11:28:03 GMT+0100 (BST)'

In the first case, a Date object is returned, in the second a primitive string value is returned instead.

Returning Objects from Constructors

In section 13.2.2, the behaviour of returning objects from constructors is defined:

If Type(result) is Object then return result.

This prevents the constructor from returning an instance, so another object can be returned instead.

function Shape() {
  return {
    x: 1, y: 1
  };
}

Shape.prototype = {
  move: function() {}
};

var shape = new Shape();
shape.move();
// TypeError: Object #<Object> has no method 'move'

It’s possible to use instanceof to determine if the constructor has been called as a function:

function Shape() {
  if (this instanceof Shape) {
    // An object is being instantiated
  } else {
    return {
      a: 'b'
    };
  }
}

Shape.prototype = {
  move: function() {}
};

var shape = new Shape();
shape.move();

Shape(); // Returns { a: 'b' }

jQuery uses a similar approach to instantiate jQuery.Event objects without requiring the new keyword:

jQuery.Event = function( src, props ) {
  // Allow instantiation without the 'new' keyword
  if ( !(this instanceof jQuery.Event) ) {
    return new jQuery.Event( src, props );
  }

This factory-style behaviour may suit certain APIs – Dojo also uses it in NodeList.

Conclusion

Calling built-in constructors as functions is used for type conversion, but some constructors behave as if the new keyword had been used. To avoid bugs caused by missing new keywords, try to remember that these forms are not equivalent.

When writing constructors, this behaviour can be exploited to create factory-like APIs. That’s because it’s possible to detect when a constructor has been called as a function.

To read more about this topic, searching the ECMAScript specification for “called as a function” is a good starting point.

Physijs, SCION, mmd, Sorting

08 Jun 2012 | By Alex Young | Comments | Tags libraries webgl physics SCXML

Physijs Tutorial

Physijs

Jerome Etienne has written some introductory tutorials on physics and WebGL. In 3D Physics With Three.js and Physijs, he discusses using Physijs with his tQuery project.

The tutorial includes creating a world with lighting, textures, object spawning, and using collision events.

SCION

SCION (License: Apache 2, npm: scion) by Jacob Beard is an implementation of State Chart XML (SCXML).

SCXML provides a declarative markup for Statecharts, a powerful modelling language for developing complex, timed, reactive, state-based systems, and can offer elegant solutions to many problems faced in development of JavaScript-based applications across various domains.

The project’s documentation demonstrates how to use SCXML to implement drag and drop in browsers using XML. SCION can load this XML with scion.urlToModel, then interpret it and connect the relevant event listeners in an asynchronous callback. The project also works with Rhino 1.7R3.

mmd

mmd by Alex Lawrence is a small patch to enable AMD modules to function when an AMD implementation isn’t available (or perhaps desired). When the author sent us this project he lamented the fact it’s 143 characters long – three characters over a tweet’s limit.

Can anyone make it shorter?

Sorting - We’re Doing It Wrong

Rodney Rehm has written a detailed guide to sorting in JavaScript: Sorting - We’re Doing It Wrong. He covers sorting different types, sorting strings, sorting DOM elements, boosting jQuery’s performance, and more besides.

The post has some interesting comments about the finer points raised in the article, and Rodney has included some benchmarks on jsPerf.

Preparing for Node 0.8

07 Jun 2012 | By Alex Young | Comments | Tags node

Node 0.8 will be released soon:

v0.8 is around the corner. There’s only 1, maybe 2 more 0.7 releases, and then we’re going stable. Test your stuff against master now!

@nodejs

The API changes are relatively straightforward, as we’ve seen with previous Node releases.

If you’ve been following our Windows and Node posts, then of particular interest is the move to node-gyp as the addon build system. This makes building addons easier for Windows users, but at the same time more people are starting to bundle binaries. I’ve found a few node-gyp modules that build successfully in Windows while researching articles for DailyJS, so hopefully the transition won’t be too painful.

Domains will be included in 0.8 – notice how the documentation already refers to 0.8. I remember reading about domains in Ryan Dahl’s Node v0.8 roadmap:

Domains provide a lightweight isolation mechanism for all i/o related to a particular network connection (e.g. an incoming http request). If an unhandled error is encountered, all i/o local to that particular domain is canceled and all handles are cleaned up.

Isaac Schlueter said it’s likely that 0.8 will include V8 v3.10 rather than 3.11. The last time I checked, Node 0.6 was on V8 3.6.6.25, and since then V8 has seen performance improvements, bug fixes, and better ECMAScript 5 conformance.

Preparations

  • If you’re a module author, now is a good time to migrate node-waf projects to node-gyp
  • If possible, tag or branch the last working 0.6 version of your modules so people can still install a legacy version – it’s awkward to run multiple versions of Node in Windows
  • Ensure your test suites pass, and follow the API changes to convert legacy code
  • Update your package.json files to refer to the correct version of Node under the engines property

Node Roundup: Boxcars, password-reset, Kraken

06 Jun 2012 | By Alex Young | Comments | Tags node modules express middleware images
You can send in your Node projects for review through our contact form or @dailyjs.

Boxcars

Boxcars (npm: boxcars) by Azer Koçulu is a library for fetching remote or local resources:

boxcars('http://google.com', '/var/log/foo.log', 'http://github.com')(function(error, homepages) {
  // Prints the homepage of google.com
  console.log(homepages[0]);
});

It can also be used to define collections of resources, or cache them through preloading. The author has included tests written with his highkick and lowkick modules.

password-reset

password-reset (License: MIT/X11, npm: password-reset) by James Halliday is middleware for dealing with password resets that will work with Express.

It’s built with James’ pony module which sends emails, and a full example including the required Express routes is included in the project’s documentation.

Kraken

Kraken (License: MIT, npm: kraken) by Przemek Matylla is a client for the Kraken Web Optimizer.

Image URLs or uploads can be optimised using this module, and a Kraken Account is required to use it.

Kraken itself was built with Node, and there are a few details about their implementation on the Kraken About page.

jQuery Roundup: jQuery++, Wtwui, jSignature

05 Jun 2012 | By Alex Young | Comments | Tags jquery plugins svg ui widgets
Note: You can send your plugins and articles in for review through our contact form or @dailyjs.

jQuery++

jQuery++ (GitHub: jupiterjs / jquerypp) from Chicago-based JavaScript consulting firm Bitovi, is a collection of DOM and event-related jQuery plugins. The project’s site has a tool for creating a single file that contains all of the plugins that you want, but they can also be loaded using an AMD module loader like RequireJS.

Highlights include a CSS3 version of $.fn.animate, a text range plugin, swipe gesture support, and a version of jQuery.event.fix that uses ECMAScript 5 getters.

There are discussions about the project on Hacker News:

Wtwui

Wtwui (GitHub: wtw-software / wtwui, License: MIT) from WTW Software is a collection of UI widgets influenced by UIKit by TJ Holowaychuk. It currently includes a dialog, overlays, tooltips, and a confirmation box. It’s built using AMD, so each component can be loaded using RequireJS.

The project is tested with Jasmine, and it includes a build script built with Node.

jSignature

jSignature (GitHub: willowsystems / jSignature, License: MIT) is a fork of brinley / jSignature with additions and tweaks by Daniel Dotsenko.

jSignature allows signatures to be captured in a browser, and works on touchscreen devices as well. Older version of IE are supported by FlashCanvas. A special effort has been made to capture smooth-looking signatures, and it supports extra editing options like undoing the last stroke.