Check if Object Instance of Class

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

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

✓ Built-in instanceof Check

⏱️ Time: O(d) Space: O(1)

Implement the instanceof logic by directly checking if the class function's prototype exists anywhere in the object's prototype chain using Object.getPrototypeOf.

Prototype Chain Traversal

⏱️ Time: O(d) Space: O(1)

Check if the object is an instance by traversing the prototype chain manually, comparing each prototype with the class's prototype until we find a match or reach null.

Built-in instanceof Check — Algorithm Steps

Step 1: Validate inputs are not null/undefined
Step 2: Use Object.getPrototypeOf to traverse chain
Step 3: Compare each prototype with classFunction.prototype

Visualization

Tap to expand

Step-by-Step Walkthrough

Validate

Check for null/undefined inputs

Get Prototype

Use Object.getPrototypeOf()

Compare & Traverse

Match against classFunction.prototype

Code -

solution.c — C

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

typedef struct {
    char name[100];
} MockFunction;

int solution(void* obj, MockFunction* classFunction, char* objType) {
    if (classFunction == NULL || obj == NULL) {
        return 0;
    }
    
    // Handle primitive types
    if (strcmp(objType, "number") == 0) {
        return strcmp(classFunction->name, "Number") == 0;
    } else if (strcmp(objType, "string") == 0) {
        return strcmp(classFunction->name, "String") == 0;
    } else if (strcmp(objType, "boolean") == 0) {
        return strcmp(classFunction->name, "Boolean") == 0;
    }
    
    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;
    MockFunction* classFunction = NULL;
    char objType[100] = "null";
    
    // Parse object
    if (strcmp(objStr, "null") != 0) {
        obj = (void*)1;
        if (strcmp(objStr, "5") == 0) {
            strcpy(objType, "number");
        } else if (strncmp(objStr, "{}", 2) == 0) {
            strcpy(objType, "object");
        } else {
            strcpy(objType, "string");
        }
    }
    
    // Parse class function
    if (strcmp(classStr, "null") != 0) {
        classFunction = malloc(sizeof(MockFunction));
        strcpy(classFunction->name, classStr);
    }
    
    int result = solution(obj, classFunction, objType);
    printf(result ? "true\n" : "false\n");
    
    if (classFunction != NULL) {
        free(classFunction);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d)

Where d is the depth of the prototype chain - same as brute force but more efficient

✓ Linear Growth

Space Complexity

O(1)

Only uses temporary variables for prototype references

✓ 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

Built-in instanceof Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler