What is the diffence between unknown and any?

In TypeScript, both unknown and any types are used to represent values that could be of any type, but they differ in their intended use cases and type safety.

any Type

• Type Safety: any functions as an escape hatch in TypeScript's type system, where marking a value as any essentially tells the compiler: 'Trust me, I know what I'm doing; don't perform type checks on this value.' This means you forfeit most of TypeScript's type safety.

• Usage: any is typically used when you don't want or need type checking, such as during a gradual migration from a JavaScript project to TypeScript or when handling highly dynamic content, allowing you to code quickly without type system restrictions.

• Example: Consider a function from a third-party library that returns any.

typescript
function getDynamicData(): any {
  // Simulate fetching data from a dynamic source
  return "I could be anything!";
}

const dynamicData = getDynamicData();
dynamicData.foo(); // The compiler won't report an error, even if the foo method doesn't exist at runtime

unknown Type

• Type Safety: In contrast, unknown is a safer choice in TypeScript. It represents a value whose type is unknown, so you cannot perform arbitrary operations on it. Before performing most operations on unknown-typed values, you must first perform type checking or type assertion to ensure the operation is safe.

• Usage: When your function or variable may accept values of any type but you still want to retain TypeScript's type checking, using unknown is a good choice. It indicates that you need to validate the value's type before proceeding with operations.

• Example: Consider a function that accepts an unknown parameter and checks if it is a string.

typescript
function processUnknownValue(value: unknown) {
  if (typeof value === "string") {
    console.log(value.toUpperCase()); // Type checking ensures this is safe
  } else {
    console.log("Not a string");
  }
}

processUnknownValue("hello"); // Output: "HELLO"
processUnknownValue(42);      // Output: "Not a string"

In summary, the any type provides complete flexibility in TypeScript, allowing you to perform any operation without considering type safety. On the other hand, the unknown type offers a way to represent values of any possible type while still requiring type checking before operations to maintain type safety. In practice, preferring unknown is a better habit as it helps you write safer code.