Course contentsShow
← TypeScript
Lesson 1608 of 1,79637. Migrating JavaScript to TypeScriptFree lesson

Type Inference in JavaScript Files

Understand how TypeScript infers types from JavaScript code patterns, assignments, and usage contexts.

Type Inference in JavaScript Files

You'll learn how TypeScript analyzes plain JavaScript code to understand types even without explicit type annotations.

The Magic of Implicit Understanding

When TypeScript encounters JavaScript files (with allowJs enabled), it doesn't just ignore them—it actively infers types from how you write your code. Think of it like a detective examining clues: variable assignments, function usage patterns, and control flow all tell TypeScript what types are in play, even when you never write a single type annotation.

How TypeScript Infers from JavaScript Patterns

Assignment-Based Inference

When you assign a value to a variable in JavaScript, TypeScript immediately understands its type:

let count = 42;          // TypeScript infers: number
let name = "Alice";      // TypeScript infers: string
let isActive = true;     // TypeScript infers: boolean

Function Pattern Inference

TypeScript examines how you use parameters and what you return:

function add(a, b) {
  return a + b;  // Used with +, returns a value
}

// If called like: add(1, 2)
// TypeScript infers parameters are likely numbers

Object Shape Inference

Object literals reveal their structure:

const user = {
  id: 1,
  name: "Bob"
};

// TypeScript knows: { id: number; name: string }

Usage Context Inference

How you use values helps TypeScript narrow possibilities:

function greet(person) {
  console.log(person.name.toUpperCase());
  // TypeScript infers: person has a name property that's a string
}

The Power of Control Flow

TypeScript tracks how your code branches:

function process(value) {
  if (typeof value === "string") {
    return value.trim();  // TypeScript knows: string here
  }
  return value;          // Could be other types here
}

Limitations Without Annotations

While impressive, inference has boundaries. Without explicit types or JSDoc, TypeScript can't always know your intent—it only knows what the code demonstrates. Complex patterns or external APIs may need help through JSDoc comments.

Key Takeaway: TypeScript reads JavaScript code like a skilled analyst, inferring types from assignments, operations, and usage patterns—giving you type safety benefits even in plain .js files without requiring immediate conversion to TypeScript.