effective-typescript-skills

Use when defining global types. Use when augmenting window. Use when typing environment variables. Use when working with build-time constants. Use when configuring type definitions.

Use when migrating JavaScript to TypeScript. Use when gradually adopting TypeScript. Use when working with mixed codebases. Use when converting large projects. Use when teams are learning TypeScript.

Use when writing asynchronous code. Use when tempted to use callbacks. Use when composing multiple async operations.

Use when creating types from example data. Use when types don't match all cases. Use when API responses vary.

Use when writing type annotations on variables. Use when TypeScript can infer the type. Use when code feels cluttered with types.

Use when defining array-like types. Use when tempted to use number as index type. Use when understanding array keys.

Use when functions have multiple parameters of same type. Use when parameter order is easy to confuse. Use when designing function signatures.

Use when writing generic functions or types. Use when reviewing type signatures. Use when a type parameter only appears once. Use when tempted to add generics for "flexibility".

Use when typing primitives. Use when tempted to use String, Number, Boolean. Use when wrapper types appear in errors.

Use when primitive types need semantic distinction. Use when string or number types have different meanings. Use when you need nominal typing.

Use when callbacks use this. Use when API provides this context. Use when typing event handlers. Use when library sets this in callbacks. Use when documenting callback context.

Use when confused about types at runtime. Use when trying to use instanceof with interfaces. Use when type errors don't prevent JavaScript output.

Use when types become extremely complex. Use when types mirror external schemas. Use when maintaining type-to-schema mappings. Use when types require extensive type-level logic. Use when types drift from data sources.

Use when build times are slow. Use when optimizing TypeScript projects. Use when configuring project references. Use when dealing with large codebases. Use when improving IDE responsiveness.

Use when typing functions with multiple return types. Use when function behavior depends on input type. Use when dealing with union type inputs. Use when considering function overloads.

Use when narrowing doesn't work as expected. Use when using variables for object properties. Use when refinements are lost.

Use when extracting values causes type errors. Use when callback types are wrong. Use when const assertions are needed.

Use when conditional types behave unexpectedly with unions. Use when boolean or never types cause surprises. Use when needing to prevent distribution over unions. Use when recursive generic types don't distribute.

Use when building objects incrementally. Use when adding properties after creation. Use when TypeScript errors on dynamic object construction.

Use when generic types aren't inferred. Use when builder patterns need better types. Use when creating new inference sites.

Use when tempted to reuse variables. Use when variable changes type. Use when using union types for multiple purposes.

Use when tempted to use -1 or "" as special values. Use when indexOf returns -1. Use when special cases need representation.

Use when working with DOM APIs. Use when typing element references. Use when creating DOM utilities. Use when handling events. Use when manipulating the DOM.

Use when naming types. Use when types describe structure not meaning. Use when domain experts won't understand type names.

Use when duplicating type definitions. Use when interfaces share common fields. Use when types can be derived from other types.

Use when choosing between TypeScript and ECMAScript features. Use when writing portable code. Use when considering enum or namespace. Use when targeting multiple JavaScript environments. Use when writing library code.

Use when debugging type inference. Use when types behave unexpectedly. Use when learning unfamiliar code.

Use when types change as code executes. Use when arrays are built incrementally. Use when working with any[] that narrows.

Use when assigning object literals to typed variables. Use when confused by "unknown property" errors. Use when extra properties are flagged on object literals but not variables.

Use when exactly one of several properties should be present. Use when modeling mutually exclusive options. Use when building component props with alternative configurations. Use when designing API parameters that have variants.

Use when handling tagged unions. Use when adding new cases to discriminated unions. Use when switch statements must cover all cases.

Use when publishing libraries. Use when types appear in public APIs. Use when users need to reference types. Use when building reusable components. Use when designing library interfaces.

Use when writing multiple functions with same signature. Use when implementing callbacks. Use when matching existing function types.

Use when building arrays in loops. Use when types don't flow through code. Use when considering map/filter/reduce.

Use when defining generic types or functions. Use when constraining type parameters. Use when writing type-level code. Use when documenting generic types.

Use when type assertions are necessary. Use when function implementations need any. Use when hiding unsafe code.

Use when types become too complex. Use when precision causes false positives. Use when accuracy is uncertain.

Use when defining object types with dynamic keys. Use when tempted to use index signatures. Use when parsing CSV or JSON data.

Use when iterating over object keys and values. Use when for...in loops produce type errors. Use when Object.entries returns any types. Use when dealing with prototype pollution concerns. Use when considering Map vs object.

Use when designing function signatures. Use when creating APIs. Use when parameters have optional fields but return types feel too broad.