Check if Object Instance of Class - Practice Coding Problems

Check if Object Instance of Class - Problem

JavaScript Medium

Write a function that determines if a given value is an instance of a given class or its superclass. This problem tests your understanding of JavaScript's prototype chain and inheritance model.

For this problem, an object is considered an instance of a class if:

The object has access to that class's methods through the prototype chain
The class appears anywhere in the object's prototype hierarchy

Important: Your function must handle any data types - including undefined, null, primitives, objects, functions, or classes. This makes the problem more challenging than simply using the built-in instanceof operator.

Goal: Return true if the value is an instance of the class, false otherwise.

Input & Output

example_1.js — Basic Class Inheritance

$ Input: checkIfInstanceOf(new Date(), Date)

› Output: true

💡 Note: A Date instance is indeed an instance of the Date class, so we return true

example_2.js — Null/Undefined Cases

$ Input: checkIfInstanceOf(null, Array)

› Output: false

💡 Note: Null values are not instances of any class, so we return false

example_3.js — Custom Class Inheritance

$ Input: class Animal {} class Dog extends Animal {} checkIfInstanceOf(new Dog(), Animal)

› Output: true

💡 Note: A Dog instance inherits from Animal through the prototype chain, so it's considered an instance of Animal

Constraints

The function must handle null and undefined values
The class parameter can be any type, not just functions
Must work with built-in classes like Date, Array, Object
Must work with custom classes and inheritance chains
No use of built-in instanceof operator allowed

Visualization

Tap to expand

Understanding the Visualization

Validate Inputs

Check if object exists and class is a valid function

Get Starting Point

Obtain the object's immediate prototype using Object.getPrototypeOf()

Walk the Chain

Follow prototype links upward, comparing each level with target

Match or End

Return true if match found, false if we reach null

Key Takeaway

🎯 Key Insight: JavaScript's prototype chain creates a natural hierarchy that we can traverse upward to check inheritance relationships without using the instanceof operator.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution traverses the prototype chain using Object.getPrototypeOf() to check inheritance relationships. Key insights: handle null/undefined edge cases, verify the class is a function, and walk up the chain comparing each prototype with the target class prototype until finding a match or reaching null.

Common Approaches

Approach	Time	Space	Notes
✓ Manual Prototype Chain Traversal	O(d)	O(1)	Manually walk up the prototype chain checking each level

Manual Prototype Chain Traversal — Algorithm Steps

Handle edge cases: null/undefined values or non-function classes
Start with the object's immediate prototype
Walk up the prototype chain using __proto__
At each level, check if current prototype matches the class prototype
Continue until match found or chain ends (null)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Object

Begin with the object whose inheritance we want to check

Get Prototype

Move to the object's immediate prototype

Compare

Check if current prototype matches target class prototype

Continue Up

If no match, move to next prototype in chain

End or Found

Stop when we find a match or reach null

Code -

solution.c — C

// C doesn't have classes or inheritance like JavaScript
// This is a conceptual equivalent using function pointers
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    void* data;
    char* type_name;
} Object;

int checkIfInstanceOf(Object* obj, char* class_name) {
    if (obj == NULL || class_name == NULL) {
        return 0;
    }
    
    // Simple string comparison for type checking
    return strcmp(obj->type_name, class_name) == 0;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d)

Where d is the depth of the prototype chain (usually small)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for traversal

✓ Linear Space

23.8K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Manual Prototype Chain Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler