OOjs/ Namespace: OO

Use binary search to locate an element in a sorted array.

searchFunc is given an element from the array. searchFunc(elem) must return a number above 0 if the element we're searching for is to the right of (has a higher index than) elem, below 0 if it is to the left of elem, or zero if it's equal to elem.

To search for a specific value with a comparator function (a function cmp(a,b) that returns above 0 if a > b, below 0 if a < b, and 0 if a == b), you can use searchFunc = cmp.bind( null, value ).

Create a new object that is an instance of the same constructor as the input, inherits from the same object and contains the same own properties.

This makes a shallow non-recursive copy of own properties. To create a recursive copy of plain objects, use #copy.

var foo = new Person( mom, dad );
foo.setAge( 21 );
var foo2 = OO.cloneObject( foo );
foo.setAge( 22 );

// Then
foo2 !== foo; // true
foo2 instanceof Person; // true
foo2.getAge(); // 21
foo.getAge(); // 22

Recursively compare properties between two objects.

A false result may be caused by property inequality or by properties in one object missing from the other. An asymmetrical test may also be performed, which checks only that properties in the first object are present in the second object, but not the inverse.

If either a or b is null or undefined it will be treated as an empty object.

Create a plain deep copy of any kind of object.

Copies are deep, and will either be an object or an array depending on source.

Delete a deeply nested property of an object using variadic arguments, protecting against undefined property errors, and deleting resulting empty objects.

Generate a hash of an object based on its name and data.

Performance optimization: http://jsperf.com/ve-gethash-201208#/toJson_fnReplacerIfAoForElse

To avoid two objects with the same values generating different hashes, we utilize the replacer argument of JSON.stringify and sort the object by key as it's being serialized. This may or may not be the fastest way to do this; we should investigate this further.

Objects and arrays are hashed recursively. When hashing an object that has a .getHash() function, we call that function and use its return value rather than hashing the object ourselves. This allows classes to define custom hashing.

Sort objects by key (helper function for OO.getHash).

This is a callback passed into JSON.stringify.

Get an array of all property values in an object.

Get a deeply nested property of an object using variadic arguments, protecting against undefined property errors.

quux = OO.getProp( obj, 'foo', 'bar', 'baz' ); is equivalent to quux = obj.foo.bar.baz; except that the former protects against JS errors if one of the intermediate properties is undefined. Instead of throwing an error, this function will return undefined in that case.

Inherit from prototype to another using Object#create.

Beware: This redefines the prototype, call before setting your prototypes.

Beware: This redefines the prototype, can only be called once on a function. If called multiple times on the same function, the previous prototype is lost. This is how prototypal inheritance works, it can only be one straight chain (just like classical inheritance in PHP for example). If you need to work with multiple constructors consider storing an instance of the other constructor in a property instead, or perhaps use a mixin (see OO.mixinClass).

function Thing() {}
Thing.prototype.exists = function () {};

function Person() {
    Person.super.apply( this, arguments );
}
OO.inheritClass( Person, Thing );
Person.static.defaultEyeCount = 2;
Person.prototype.walk = function () {};

function Jumper() {
    Jumper.super.apply( this, arguments );
}
OO.inheritClass( Jumper, Person );
Jumper.prototype.jump = function () {};

Jumper.static.defaultEyeCount === 2;
var x = new Jumper();
x.jump();
x.walk();
x instanceof Thing && x instanceof Person && x instanceof Jumper;

Utility to initialize a class for OO inheritance.

Currently this just initializes an empty static object.

Assert whether a value is a plain object or not.

Test whether one class is a subclass of another, without instantiating it.

Every class is considered a subclass of Object and of itself.

Copy over own prototype properties of a mixin.

The 'constructor' (whether implicit or explicit) is not copied over.

This does not create inheritance to the origin. If you need inheritance, use OO.inheritClass instead.

Beware: This can redefine a prototype property, call before setting your prototypes.

Beware: Don't call before OO.inheritClass.

function Foo() {}
function Context() {}

// Avoid repeating this code
function ContextLazyLoad() {}
ContextLazyLoad.prototype.getContext = function () {
    if ( !this.context ) {
        this.context = new Context();
    }
    return this.context;
};

function FooBar() {}
OO.inheritClass( FooBar, Foo );
OO.mixinClass( FooBar, ContextLazyLoad );

Set a deeply nested property of an object using variadic arguments, protecting against undefined property errors.

OO.setProp( obj, 'foo', 'bar', 'baz' ); is equivalent to obj.foo.bar = baz; except that the former protects against JS errors if one of the intermediate properties is undefined. Instead of throwing an error, undefined intermediate properties will be initialized to an empty object. If an intermediate property is not an object, or if obj itself is not an object, this function will silently abort.

Compute the difference of two arrays (items in 'a' but not 'b').

Arrays values must be convertable to object keys (strings).

Compute the intersection of two arrays (items in both arrays).

Arrays values must be convertable to object keys (strings).

Compute the union (duplicate-free merge) of a set of arrays.

Arrays values must be convertable to object keys (strings).

By building an object (with the values for keys) in parallel with the array, a new item's existence in the union can be computed faster.

Get the unique values of an array, removing duplicates.