TS Classes, types, keywords, etc.

Question 1

What is the static keyword in TypeScript Classes?

Answer 1

• Definition: Defines members belonging to the Class constructor, not the instance.
• Access: Called via ClassName.member (not this.member).
• Memory: Exists once per class; does not require new to access.

Question 2

Distinguish between Static and Instance members.

Answer 2

• Static: Shared across all instances; used for utilities or global class state (e.g., User.count).
• Instance: Unique to each object; used for individual data (e.g., user.email).
• Constraint: Static methods cannot access instance data via this.

Question 3

Name two advanced TS/JS features of static beyond simple properties.

Answer 3

• Static Blocks: static { ... } for complex, one-time initialization logic.
• Factory Methods: Static methods that return new instances (e.g., User.fromJSON(data)).
• Inheritance: Static members are inherited by subclasses via the prototype chain.

Question 4

When is using static considered a “code smell” or bad practice?

Answer 4

• Overuse as Namespaces: If a method doesn’t use class state, an exported function is better (allows for tree-shaking).
• Memory Bloat: Static properties live for the app’s entire lifecycle; avoid using them for large caches.

Tip for the Assessment:

If an evaluator asks you to refactor a class full of static methods that don’t share data, suggest moving them to standalone functions.

This is the “functional” approach preferred in modern React/TS environments because it results in smaller bundle sizes.

Question 5

What is a TypeScript Abstract Class and when is it used?

Answer 5

• Definition: A base class that cannot be instantiated directly (new X() fails).
• Purpose: Defines a contract/template for subclasses to implement.
• Abstract Methods: Methods marked abstract have no body; subclasses must implement them.
• Evaluator Tip: Use when multiple classes share some logic but need unique implementations for core steps.

Question 6

How do Abstract Classes differ from Interfaces in TS?

Answer 6

• Interface: Purely a type (erased at runtime); defines structure only.
• Abstract Class: A real class (exists at runtime); can contain actual code/logic (methods with bodies).
• Rule: Use an Interface for simple shape definitions; use an Abstract Class if you want to provide shared functionality.

Question 7

When is an Abstract Class considered “poor” design in modern React?

Answer 7

• Composition over Inheritance: Modern React prefers Hooks and Composition for sharing logic.
• Bloat: Abstract classes can create deep, rigid hierarchies that are hard to refactor.
• Verdict: If you just need a type, use an Interface; if you just need shared logic, use a Hook.

Question 8

What is the primary technical difference between interface and type?

Answer 8

• Interface: Extendable via Declaration Merging (defining the same name twice merges them). Better for Public APIs and Class Shapes.
• Type: Can define Unions (string | number), Tuples, and Primitives. Better for Complex Logic and Function Signatures.
• Performance: interface is slightly faster for the TS compiler to check in large codebases.

Question 9

What is a Discriminated Union and why is it used in React?

Answer 9

• Definition: A Union type where every object has a common literal property (the “tag”).
• Example: { type: 'success', data: T } | { type: 'error', error: string }
• Benefit: Enables Exhaustive Checking in switch statements; prevents accessing properties that don’t exist in a specific state.

Question 10

What do keyof and Record<K, T> do?

Answer 10

• keyof T: Returns a Union of all keys in an object (e.g., "id" | "name").
• Record<K, T>: Maps keys K to values T.
• Use Case: Creating a strictly typed Lookup Table or Config object.

Question 11

When is using any or non-null assertion (!) considered a “Fail”?

Answer 11

• any: Disables the compiler; always suggest unknown + Type Guard instead.
• ! (Non-null): Assumes data exists without checking; leads to runtime “Cannot read property of null.”
• Fix: Use Optional Chaining (?.) or Nullish Coalescing (??).