Summary  
This chapter explains type inference, where TypeScript automatically deduces variable and function parameter types based on their assignments and usage, enabling static type checking without explicit annotations. It also notes that when inference is unclear, TypeScript may fall back to the `any` type, reducing type safety.

General domain of usage  
Static type checking in TypeScript codebases

When you declare variables or functions in TypeScript without explicitly stating their types, TypeScript uses **type inference** to determine the types for you. 

let message = "Hello, TypeScript!";
let count = 5;
let isActive = true;

function add(a, b) {
  return a + b;
}

const result = add(2, 3);

In the code above, `message` is assigned a string value, so TypeScript infers its type as `string`. The variable `count` is set to a number, so its type is inferred as `number`. Similarly, `isActive` is inferred as a `boolean` because it is assigned a boolean value.

For the function `add`, there are no explicit type annotations for its parameters or return value. TypeScript examines the function's implementation and its usage. When you call `add(2, 3)`, both arguments are numbers, so TypeScript infers that `a` and `b` are likely numbers, and the return type is also `number`. As a result, the variable `result` is inferred to be a `number`.

**Type inference** helps you write less code while still getting the benefits of static type checking. However, when TypeScript cannot infer a clear type, it may use the `any` type, which removes type safety. It is important to be aware of what TypeScript is inferring in your code to avoid unexpected behavior.

Which of the following best describes the type that TypeScript infers for the variable `result` in the code above?

Explore TypeScript's type system, guiding you from the basics of primitive types to advanced concepts like type inference, narrowing, and safe handling of any and unknown. Learn how TypeScript makes JavaScript code safer, more robust, and easier to maintain.

Explore how TypeScript brings structure and safety to JavaScript through its type system. Define clear type annotations, check your code for errors at compile time, and work confidently with primitive and special types to build a solid foundation.

Build expressive data models using TypeScript's complex type tools. Combine and organize information with objects, arrays, tuples, unions, intersections, and literal types to represent real-world structures in code.

Take advantage of TypeScript's intelligent type system to make your code safer and cleaner. Let the compiler infer types automatically, narrow them through control flow, and apply best practices using any, unknown, and type assertions for advanced safety and flexibility.

Type Inference

Awesome!

Type Inference