Creating a composition-based class structure using `augment`

{{>yui-augment}}

Using `augment`

``` YUI().use('node', function(Y) { // This method is in the 'oop' module. Since we require 'node' // for this example, and 'node' requires 'oop', the 'oop' module // will be loaded automatically. ```

The example: Any class can be an `EventTarget`

This example creates a custom class, then augments it with `EventTarget`. Using the packaged functionality of `EventTarget`, the code for `Foo` is able to focus on the functionality unique to its purpose.

``` {{>yui-augment-js}} ```

Composition, not inheritance

If `Foo` were a part of a class hierarchy, it would be improper to include `EventTarget` in the inheritance chain, because its custom event functionality is not an intrinsic characteristic but rather an ancillary, generic capability that many classes share.

Unlike `extend`ed classes, the relationship between a class and the classes augmenting it is not an indication of type hierarchy. The intent of `augment` is to aid in extracting nonessential behaviors or behaviors shared by many classes, allowing for a composition-style class architecture.

Diagram showing class hierarchy, highlighting has-a relationship

This may appear similar to multiple inheritance, but it's not. `augment` simply adds the public methods and members from one class prototype to another class prototype. Instances of the augmented class will not pass `instanceof` tests for the class(es) which augmented it.

``` YUI().use('oop', function(Y) { function Foo() {} Foo.prototype.doSomething = function () { /* something */ }; function Bar() {} Y.augment(Bar, Foo); var b = new Bar(); if (b instanceof Bar) {} // true if (b instanceof Foo) {} // FALSE }); ```