hasPrototype

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

Usage

var hasPrototype = require( '@stdlib/assert/has-prototype' );

hasPrototype( 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 = hasPrototype( bar, Foo.prototype );
// returns true

Notes

  • The function returns false if provided a primitive value.

    var bool = hasPrototype( 5, Number.prototype );
    // returns false
    
    bool = hasPrototype( 'beep', String.prototype );
    // returns false
    
    bool = hasPrototype( 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 = hasPrototype( Object.create( null ), null );
    // throws <TypeError>
    
  • hasPrototype() 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 ) {
        // type error...
        console.error( error.message );
    }
    
    bool = hasPrototype( v, superProto );
    // returns true
    

Examples

var inherit = require( '@stdlib/utils/inherit' );
var hasPrototype = require( '@stdlib/assert/has-prototype' );

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 = hasPrototype( d, C.prototype );
// returns true

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

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

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

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

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

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

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

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

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

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

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