Suggest an editImprove this articleRefine the answer for “Why doesn't TS always require writing types explicitly?”. Your changes go to moderation before they’re published.Approval requiredContentWhat you’re changing🇺🇸EN🇺🇦UAPreviewTitle (EN)Short answer (EN)TypeScript itself "understands" types from context: when you declare a variable and assign it a value, TypeScript **analyzes that value** and **automatically assigns** it the corresponding type. This process is called **type inference**. **Key point:** the type is inferred from the assigned value, so writing it explicitly is not always required.Shown above the full answer for quick recall.Answer (EN)Image## 1. TypeScript itself "understands" types from context When you declare a variable and assign it a value, TypeScript **analyzes that value** and **automatically assigns** it the corresponding type. ```javascript let name = "Alice"; // TS understands: name has type string ``` > So writing `let name: string = "Alice"` is not necessary. > TypeScript will infer the type `string` from the assigned value itself. --- ## 2. This is called **type inference** TypeScript can "guess" a type: - from the **assigned value** (`let count = 5` -> `number`); - from the **return value of a function**; - from the **type of function arguments**; - from the **call context** (for example, in callbacks, destructuring, and so on). Example: ```javascript function greet(name = "guest") { return `Hello, ${name}!`; } // TypeScript infers: name is string, the return type is string ``` --- ## 3. Example: a function with return type inference ```javascript function add(a: number, b: number) { return a + b; } ``` TypeScript automatically determines that the function returns `number`, because `a` and `b` are numbers. > That means you do not have to write `: number` after the parentheses - the type is inferred on its own. --- ## 4. Example with arrays and objects ```javascript let numbers = [1, 2, 3]; // TypeScript infers the type: number[] let user = { id: 1, name: "Tim" }; // TypeScript infers the type: { id: number; name: string; } ``` > If you later try to add a string to `numbers`, the compiler will not allow it, > because it already knows this is an array of numbers. --- ## 5. Why this is useful 1. **Less code** - no need to duplicate obvious types. 2. **Cleaner, more readable code** - types stay where they are actually needed. 3. **The types still exist** - even if you do not write them, TypeScript keeps them "in mind". 4. **IDE autocomplete** still works (TS knows the inferred types). --- ## 6. But sometimes you need to write types explicitly TypeScript cannot always infer the type precisely, for example: - when initializing a variable without a value; - when returning complex types (`Promise`, `union`, `generic`); - when it is important to **lock in** a type (so it does not change dynamically). Example: ```javascript let id; // type any - without an annotation TypeScript does not know what it is id = 5; // now number id = "5"; // also allowed - the type became any // Better explicitly: let id: number; ``` --- ## 7. The "reasonable redundancy" rule TypeScript tries **not to force you to write what is already obvious**. Types are needed where: - the compiler cannot infer them, - or where they matter for a **clear contract** between parts of the code (for example, interfaces, functions, APIs). --- ## Summary > TypeScript **does not always require writing types**, > because it can **automatically infer them** from the code's context - > this process is called **type inference**. > > This makes the code **clean, but still safe**, > keeping all the benefits of typing without redundancy.For the reviewerNote to the moderator (optional)Visible only to the moderator. Helps review go faster.