Check if Object Instance of Class - Practice Coding Problems

Check if Object Instance of Class - Problem

JavaScript Medium

Write a function that checks if a given value is an instance of a given class or superclass.

For this problem, an object is considered an instance of a given class if that object has access to that class's methods.

There are no constraints on the data types that can be passed to the function. For example, the value or the class could be undefined.

Input & Output

Example 1 — Basic Object Instance

$ Input: obj = {}, classFunction = Object

› Output: true

💡 Note: Empty object {} has Object.prototype in its prototype chain, so it's an instance of Object

Example 2 — Null Class Function

$ Input: obj = {}, classFunction = null

› Output: false

💡 Note: When classFunction is null, we can't check instanceof, so return false

Example 3 — Number Instance

$ Input: obj = 5, classFunction = Number

› Output: true

💡 Note: Number 5 is an instance of the Number constructor function

Constraints

No constraints on data types
obj or classFunction can be undefined/null
Must handle all JavaScript types

Visualization

Tap to expand

Understanding the Visualization

Input

Object and class function to check

Prototype Chain

Walk up the object's prototype chain

Match Check

Compare with class function's prototype

Key Takeaway

🎯 Key Insight: The instanceof operator works by walking up the prototype chain until it finds the constructor's prototype or reaches null

Asked in

G Google 35 f Facebook 28 a Amazon 22

The key insight is to traverse the prototype chain using Object.getPrototypeOf() and compare each prototype with classFunction.prototype. Best approach is optimized prototype traversal. Time: O(d), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Prototype Chain Traversal	O(d)	O(1)	Walk up the prototype chain step by step
Built-in instanceof Check	O(d)	O(1)	Use JavaScript's built-in instanceof operator logic

Prototype Chain Traversal — Algorithm Steps

Step 1: Handle edge cases (null, undefined)
Step 2: Walk up prototype chain using __proto__
Step 3: Compare each prototype with classFunction.prototype

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with object's prototype

Compare

Check if current prototype matches class.prototype

Traverse

Move up to next prototype or return result

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(void* obj, char* classFunction) {
    if (obj == NULL || classFunction == NULL || strcmp(classFunction, "null") == 0) {
        return 0;
    }
    
    // Simplified implementation for C
    // Real prototype chain checking would require complex runtime type info
    return 0;
}

int main() {
    char objStr[1000], classStr[1000];
    
    fgets(objStr, sizeof(objStr), stdin);
    objStr[strcspn(objStr, "\n")] = 0;
    
    fgets(classStr, sizeof(classStr), stdin);
    classStr[strcspn(classStr, "\n")] = 0;
    
    void* obj = NULL;
    
    if (strcmp(objStr, "null") != 0) {
        obj = (void*)1; // Placeholder
    }
    
    int result = solution(obj, classStr);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d)

Where d is the depth of the prototype chain - we traverse at most d levels

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current prototype

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

856 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

Prototype Chain Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler