OverviewHistoryStatsSecurity
npx skills add ...
Documentation
SKILL.md
npx skills add marius-townhouse/effective-typescript-skills --skill precise-any-variants
Use when forced to use any. Use when any is too broad. Use when function types need any.
npx skills add marius-townhouse/effective-typescript-skills --skill precise-any-variants
If you must use any, make it as specific as possible.
Plain any accepts everything. But any[], Record<string, any>, or () => any are narrower and still provide some type checking.
Remember:
any[] checks that it's an arrayRecord<string, any> checks that it's an object() => any checks that it's a functionunknown is even safer than any variantBenefits:
.length access is type-checkednumber, not anyThe return type matters for downstream code!
| Type | Accepts | Rejects |
|---|---|---|
any | Everything | Nothing |
any[] | Arrays | Non-arrays |
Record<string, any> | Objects | Primitives, null |
() => any | Functions | Non-functions |
object | Objects, arrays | Primitives, null |
unknown | Everything | Everything (without check) |
unknown is even safer:
With unknown, you can't do anything without first checking the type.
Sometimes you genuinely need any:
Even then, hide it inside functions with good type signatures (Item 45).
Pressure: "Just use any and move on"
Response: any disables ALL type checking. Specific variants preserve some safety.
Action: Use the most specific variant that works.
Pressure: "The type is truly dynamic"
Response: unknown is safer for truly unknown types.
Action: Use unknown, then narrow before using.
any as function parameter (use specific variant)any as return type (prefer unknown)any for objects (use Record<string, any> or object)any for arrays (use any[])| Excuse | Reality |
|---|---|
| "It's too dynamic to type" | unknown handles truly dynamic data |
| "Specific variants are verbose" | A few characters save runtime errors |
| "any is fine for internal code" | Internal code still has bugs |
If you must use any, make it specific.
any[], Record<string, any>, and () => any preserve some type checking while still allowing flexibility. But consider whether unknown is a safer choice.
Based on "Effective TypeScript" by Dan Vanderkam, Item 44: Prefer More Precise Variants of any to Plain any.
function getLength(array: any[]) {
return array.length; // Type checked!
}
getLength([1, 2, 3]); // OK
getLength(/regex/);
// ~~~~~~~
// Argument of type 'RegExp' is not assignable to parameter of type 'any[]'function hasKey(obj: Record<string, any>, key: string): boolean {
return key in obj;
}
hasKey({ a: 1 }, 'a'); // OK
hasKey(null, 'a');
// ~~~~
// Argument of type 'null' is not assignable to parameter of type 'Record<string, any>'type Fn0 = () => any; // No params
type Fn1 = (arg: any) => any; // One param
type FnN = (...args: any[]) => any; // Any params
function callTwice(fn: FnN) {
fn();
fn();
}
callTwice(() => console.log('hi')); // OK
callTwice(123);
// ~~~
// Argument of type 'number' is not assignable to parameter of type '(...args: any[]) => any'// any rest parameter: return type is any
const numArgsBad = (...args: any) => args.length;
// ^? (...args: any) => any
// any[] rest parameter: return type is number
const numArgsBetter = (...args: any[]) => args.length;
// ^? (...args: any[]) => numberfunction process(data: unknown) {
// Must narrow before using
if (Array.isArray(data)) {
data.length; // OK, data is any[]
}
if (typeof data === 'object' && data !== null) {
// data is object
}
}// Don't return any
function parseBad(json: string): any {
return JSON.parse(json);
}
// Better: return unknown
function parseGood(json: string): unknown {
return JSON.parse(json);
}
// Caller must narrow:
const data = parseGood('{"x": 1}');
if (typeof data === 'object' && data !== null && 'x' in data) {
console.log(data.x);
}// Wrapping a library that uses any internally
function wrapLibrary<T>(input: T): T {
return (library as any).process(input);
}
// Type assertion in implementation
function merge<T>(a: Partial<T>, b: Partial<T>): T {
return { ...a, ...b } as any as T;
}// DON'T: Plain any
function f(x: any): any { ... }
// DO: Specific variants
function getLength(arr: any[]): number { ... }
function getKeys(obj: Record<string, any>): string[] { ... }
function call(fn: (...args: any[]) => any): void { ... }
// BEST: unknown when possible
function process(data: unknown): void {
if (Array.isArray(data)) { ... }
}