feat: prototype-traversal of 2618 added

Author: shahadathhs

README.md

@@ -1,5 +1,5 @@
 # LeetCode JavaScript
 
-> JavaScript-only LeetCode questions with solutions, explanations, and concept-based tagging.
+> JavaScript-only LeetCode questions with solutions, and explanations.
 
 ---

package.json

@@ -41,6 +41,7 @@
     "@eslint/js": "^9.31.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^24.1.0",
+    "chalk": "^5.4.1",
     "eslint": "^9.31.0",
     "globals": "^16.3.0",
     "husky": "^9.1.7",

pnpm-lock.yaml

@@ -1,21 +1,58 @@
-import { checkIfInstanceOf } from '@/app/2618-check-if-object-instance-of-class'
+import {
+  checkIfInstanceOf,
+  checkIfInstanceOfUsingPrototype,
+} from '@/app/2618-check-if-object-instance-of-class'
 
 describe('Problem 2618: Check If Instance Of Class', () => {
-  test('Example 1: new Date() is an instance of Date', () => {
-    expect(checkIfInstanceOf(new Date(), Date)).toBe(true)
-  })
-
-  test('Example 2: Dog is an instance of Animal', () => {
-    class Animal {}
-    class Dog extends Animal {}
-    expect(checkIfInstanceOf(new Dog(), Animal)).toBe(true)
-  })
-
-  test('Example 3: Date constructor is not an instance of Date', () => {
-    expect(checkIfInstanceOf(Date, Date)).toBe(false)
-  })
+  const testCases: {
+    name: string
+    input: [any, any]
+    expected: boolean
+  }[] = [
+    {
+      name: 'Example 1: new Date() is an instance of Date',
+      input: [new Date(), Date],
+      expected: true,
+    },
+    {
+      name: 'Example 2: Dog is an instance of Animal',
+      input: (() => {
+        class Animal {}
+        class Dog extends Animal {}
+        return [new Dog(), Animal] as [any, any]
+      })(),
+      expected: true,
+    },
+    {
+      name: 'Example 3: Date constructor is not an instance of Date',
+      input: [Date, Date],
+      expected: false,
+    },
+    {
+      name: 'Example 4: Primitive 5 is an instance of Number (via wrapper)',
+      input: [5, Number],
+      expected: true,
+    },
+    {
+      name: 'Edge case: null value should return false',
+      input: [null, Number],
+      expected: false,
+    },
+    {
+      name: 'Edge case: undefined classFunction should return false',
+      input: [new Number(5), undefined],
+      expected: false,
+    },
+  ]
 
-  test('Example 4: Primitive 5 is an instance of Number (via wrapper)', () => {
-    expect(checkIfInstanceOf(5, Number)).toBe(true)
+  describe.each([
+    ['🔍 instanceof version', checkIfInstanceOf],
+    ['🔁 prototype-traversal version', checkIfInstanceOfUsingPrototype],
+  ])('%s', (_label, fn) => {
+    testCases.forEach(({ name, input, expected }) => {
+      test(name, () => {
+        expect(fn(...input)).toBe(expected)
+      })
+    })
   })
 })

src/__tests__/2618-check-if-object-instance-of-class.test.ts

@@ -1,6 +1,9 @@
 // * Title
 // 2618. Check if Object Instance of Class
 
+// * Concepts
+// Prototype Chain, Inheritance, instanceof, Type Checking
+
 // * Description
 /**
  *
@@ -26,18 +29,52 @@
 
 // * Solution
 function checkIfInstanceOf(obj: any, classFunction: any): boolean {
+  // If obj is null or undefined, it can't be an instance of anything
   if (obj === null || obj === undefined) return false
 
+  // If classFunction is not a function (i.e., not a constructor), return false
   if (typeof classFunction !== 'function') return false
 
+  // If the object is already an instance of the class, return true
   if (obj instanceof classFunction) return true
 
+  // Try converting the value to an object and check again using instanceof
+  // This handles edge cases like primitives (e.g., number, string)
   try {
     return Object(obj) instanceof classFunction
   } catch {
+    // If conversion or check fails (e.g., invalid input), return false
     return false
   }
 }
 
+function checkIfInstanceOfUsingPrototype(obj: any, classFunction: any): boolean {
+  // Return false if the input value is null or undefined
+  if (obj === null || obj === undefined) return false
+
+  // Return false if the classFunction is not a function (constructor)
+  if (typeof classFunction !== 'function') return false
+
+  // Get the prototype that we're trying to match
+  const targetPrototype = classFunction.prototype
+
+  // Convert obj to an object (handles primitives like numbers, strings, etc.)
+  let currentProto = Object(obj)
+
+  // Traverse up the prototype chain
+  while (currentProto !== null) {
+    // If the prototype matches the target, return true
+    if (Object.getPrototypeOf(currentProto) === targetPrototype) {
+      return true
+    }
+
+    // Move one level up the prototype chain
+    currentProto = Object.getPrototypeOf(currentProto)
+  }
+
+  // If we reach the end of the chain without a match, return false
+  return false
+}
+
 // * Export the function
-export { checkIfInstanceOf }
+export { checkIfInstanceOf, checkIfInstanceOfUsingPrototype }

src/app/2618-check-if-object-instance-of-class.ts

@@ -1,9 +1,30 @@
-import { checkIfInstanceOf } from '@/app/2618-check-if-object-instance-of-class'
+import chalk from 'chalk'
 
 function main() {
-  console.log('Hello, World!')
-  const dateInstance = new Date()
-  console.log(checkIfInstanceOf(dateInstance, Date)) // true
+  console.clear()
+  console.log(
+    chalk.green.bold('\n🚀 Welcome to ') + chalk.blueBright.bold('LeetCode JavaScript Practice!\n'),
+  )
+
+  console.log(
+    chalk.gray('📚 This is a curated collection of LeetCode problems with:') +
+      '\n' +
+      chalk.cyan('  • JavaScript-only solutions') +
+      '\n' +
+      chalk.cyan('  • Clear explanations') +
+      '\n' +
+      chalk.cyan('  • Concept-based tagging for deep learning\n'),
+  )
+
+  console.log(
+    chalk.yellow('✨ Run ') +
+      chalk.magenta('pnpm test') +
+      chalk.yellow(' to test all problems or ') +
+      chalk.magenta('pnpm test:problem') +
+      chalk.yellow(' to run a specific one.\n'),
+  )
+
+  console.log(chalk.green('Happy coding! 💻\n'))
 }
 
 main()