TypeScript - typeof vs instanceof

Introduction: Unwrap the mysteries of type assertions in TypeScript with two powerful operators: typeof and instanceof. Understanding these can be a game-changer for anyone starting with TypeScript, providing clearer code and fewer type-related errors.

Why Type Checking Matters in TypeScript: TypeScript's superpower lies in its ability to catch errors at compile time, ensuring that the types match what's expected. This leads to safer and more predictable code, which is essential in large-scale applications or when working on a team.

Diving into typeof: typeof is a straightforward operator used for determining the type of a variable. It's especially handy with JavaScript's primitive types – like string, number, and boolean. Here’s how it works:

let age: any = 25;

if (typeof age === 'number') {
  console.log('Age is a number.');
}

// Output: Age is a number.
        

Remember, typeof cannot tell arrays from plain objects or distinguish null values, since these are all considered "objects" in JavaScript.

Exploring instanceof: instanceof is slightly more nuanced, used for checking whether an object is an instance of a class or constructor function. It’s mostly relevant when working with classes and more complex data types:

class Person {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

const jane = new Person('Jane');

console.log(jane instanceof Person);

// Output: true
        

instanceof is great when dealing with instances of classes but doesn't apply to primitive values.

typeof vs instanceof: Choosing the Right Tool: Both typeof and instanceof have their place:

• Use typeof for basic type queries and to ensure variables are the correct primitive type.
• Use instanceof when you want to confirm an object is a certain class or conforms to an expected structure, which is important for more complex object-oriented programming.

Best Practices and Tips: While these operators are powerful, they're not without their quirks. Always consider the following:

• Use typeof for primitives and instanceof for class instances.
• Remember that instanceof checks won't work as expected if you have multiple execution contexts (like in an iframe or web worker).
• Consider using custom type guards for more complex type checking beyond the capabilities of typeof and instanceof.

Conclusion: Mastering typeof and instanceof will take you a long way in ensuring your types are correct and your TypeScript code is clean and stable. Practice using these, and you'll confidently navigate TypeScript's type system.