Unknown Data Type in TypeScript

The unknown type in TypeScript is a safer alternative to the any type. It represents any value but requires type checking before performing operations on it. This type is useful for scenarios where you want to handle values whose type is not known ahead of time while ensuring type safety.

---

Understanding the `unknown` Type

The unknown type is a type-safe counterpart to any. While any allows you to perform any operation on a value without type checks, unknown forces you to perform type checking before accessing properties or invoking methods. This helps in avoiding runtime errors and makes your code more predictable.

let value: unknown = "Hello, TypeScript";

---

Common Use Cases for `unknown`

Here are some common scenarios where the unknown type is useful:

• Handling User Input: When dealing with user inputs or data from external sources where the exact type is not known beforehand.
• Implementing Type Guards: For implementing custom type guards to ensure type safety before performing operations.
• Handling External Data: When processing data from APIs or other external sources with uncertain types.

---

Examples of Using `unknown`

Basic Example

The unknown type ensures that you perform type checks before accessing or using the value:

let value: unknown = "Hello, TypeScript";
if (typeof value === "string") {
console.log(value.toUpperCase()); // Output: HELLO, TYPESCRIPT
}

Type Guards

Using type guards to safely handle values of type unknown:

function processValue(value: unknown) {
  if (typeof value === "number") {
    console.log(value.toFixed(2)); // Safe to use `toFixed` as we checked type
  } else if (typeof value === "string") {
    console.log(value.toUpperCase()); // Safe to use `toUpperCase` as we checked type
  } else {
    console.log("Unsupported type");
  }
}
processValue(123.456); // Output: 123.46
processValue("TypeScript"); // Output: TYPESCRIPT
processValue(true); // Output: Unsupported type

Working with External Data

Handling data from an API where the type of the data is unknown:

async function fetchData(): Promise {
  const response = await fetch("https://api.example.com/data");
  return response.json();
}
fetchData().then(data => {
if (typeof data === "object" && data !== null && "name" in data) {
console.log((data as { name: string }).name); // Safely access name property
} else {
console.log("Unexpected data format");
}
});

---

Conclusion

The unknown type in TypeScript offers a type-safe way to handle values of uncertain types. By requiring type checks before performing operations, unknown helps avoid runtime errors and ensures that your code handles unexpected or unknown values more predictably. Utilizing unknown effectively can improve the robustness and maintainability of your TypeScript code.