isPrototypeOf

Test if an object's prototype chain contains a provided prototype.

Usage

var isPrototypeOf = require( '@stdlib/assert/is-prototype-of' );

isPrototypeOf( obj, prototype )

Tests if an object's prototype chain contains a provided prototype.

var inherit = require( '@stdlib/utils/inherit' );

function Foo() {
    return this;
}

function Bar() {
    return this;
}
inherit( Bar, Foo );

var bar = new Bar();

var bool = isPrototypeOf( bar, Foo.prototype );
// returns true

Notes

The function returns false if provided a primitive value.

var Number = require( '@stdlib/number/ctor' );

var bool = isPrototypeOf( 5, Number.prototype );
// returns false

bool = isPrototypeOf( 'beep', String.prototype );
// returns false

bool = isPrototypeOf( true, Boolean.prototype );
// returns false

The function throws a TypeError if provided a prototype value which is neither an object (except null) or a function.
```
var bool = isPrototypeOf( Object.create( null ), null );
// throws <TypeError>
```

isPrototypeOf() is generally more robust than the instanceof operator. Consider the following example which does not use constructors:

// Functionally similar to `Object.create()`...
function createObject( proto ) {
    function Ctor() {
        // Empty constructor...
    }
    Ctor.prototype = proto;
    return new Ctor();
}
var superProto = {
    'beep': 'beep'
};

var subProto = createObject( superProto );
subProto.boop = 'boop';

var v = createObject( subProto );

var bool;
try {
    bool = ( v instanceof superProto );
} catch ( error ) {
    // Encountered a type error...
    console.error( error.message );
}

bool = isPrototypeOf( v, superProto );
// returns true

Examples

var inherit = require( '@stdlib/utils/inherit' );
var isPrototypeOf = require( '@stdlib/assert/is-prototype-of' );

function A() {
    return this;
}

function B() {
    return this;
}
inherit( B, A );

function C() {
    return this;
}
inherit( C, B );

function D() {
    return this;
}
inherit( D, C );

var a = new A();
var b = new B();
var c = new C();
var d = new D();

var bool = isPrototypeOf( d, C.prototype );
// returns true

bool = isPrototypeOf( d, B.prototype );
// returns true

bool = isPrototypeOf( d, A.prototype );
// returns true

bool = isPrototypeOf( c, B.prototype );
// returns true

bool = isPrototypeOf( c, A.prototype );
// returns true

bool = isPrototypeOf( c, D.prototype );
// returns false

bool = isPrototypeOf( b, A.prototype );
// returns true

bool = isPrototypeOf( b, C.prototype );
// returns false

bool = isPrototypeOf( b, D.prototype );
// returns false

bool = isPrototypeOf( a, B.prototype );
// returns false

bool = isPrototypeOf( a, C.prototype );
// returns false

bool = isPrototypeOf( a, D.prototype );
// returns false