Eliminando any; preferindo unknown e redução

Introdução

Armadilhas de any

// any hides bugs
function avgBad(values: any): number {
  // Compiles even if values is not an array of numbers
  return values.reduce((a: number, b: number) => a + b, 0) / values.length
}

// Runtime crash examples:
// avgBad(123)
// avgBad(["1","2"]) // string addition!

unknown + estreitamento

// unknown forces checks
function avg(values: unknown): number {
  if (!Array.isArray(values)) throw new Error("values must be an array")
  const nums = values.filter((v): v is number => typeof v === "number")
  if (nums.length === 0) throw new Error("no numbers")
  const sum = nums.reduce((a, b) => a + b, 0)
  return sum / nums.length
}

// avg([1,2,3]) → 2; avg("oops") throws early with a clear message

Proteções de tipo

// Small predicate to reuse narrowing
export type User = { id: string; name: string }

export function isUser(x: unknown): x is User {
  return typeof x === "object" && x !== null
    && typeof (x as any).id === "string"
    && typeof (x as any).name === "string"
}

export function hello(x: unknown) {
  if (!isUser(x)) throw new Error("invalid user")
  return `Hello, ${x.name}`
}

Funções de asserção

// Assertion function throws or narrows
function assertUser(x: unknown): asserts x is { id: string; name: string } {
  if (typeof x !== "object" || x === null) throw new Error("not an object")
  const o = x as Record<string, unknown>
  if (typeof o.id !== "string" || typeof o.name !== "string") throw new Error("bad user")
}

export function greetUnsafe(x: unknown) {
  assertUser(x) // now x is narrowed after this call
  return `Hi ${x.name}`
}

Plano de rigor

Verificação de unknown versus any

Recapitulação