Type Annotation / Type Inference

let variableName: type = value;

// Type annotations for function parameters and return value
function functionName(param: type, param: type): returnType {
	return value;
}

// Type inference: the type is determined automatically from the initial value (no annotation needed).
let variableName = value; // The type of the value becomes the type of the variable.

let userName: string = "Yagami Iori";
let age: number = 20;
let isActive: boolean = true;

// Type inference: the annotation can be omitted when an initial value is provided.
let city = "New York"; // Inferred as type string.
let score = 95; // Inferred as type number.
// score = "excellent"; // Error: score is type number, so a string cannot be assigned.

// Function type annotations: explicitly specify parameter and return types.
function add(a: number, b: number): number {
	return a + b;
}
console.log(add(3, 5)); // Outputs 8.

// Return type inference: the type is determined automatically from the return statement.
function greet(name: string) { // Return type is automatically inferred as string.
	return `Hello, ${name}!`;
}
console.log(greet("Kusanagi Kyo")); // Outputs "Hello, Kusanagi Kyo!".

// Type annotation on an arrow function.
const multiply = (x: number, y: number): number => x * y;
console.log(multiply(4, 6)); // Outputs 24.

// Type assertion (as): specify a more concrete type explicitly.
// const input = document.getElementById("name") as HTMLInputElement; // Browser environment only
// input is treated as HTMLInputElement rather than HTMLElement.

// Type annotation on an object literal.
let product: { name: string; price: number } = {
	name: "Introduction to Programming",
	price: 2800,
};
console.log(`${product.name}: $${product.price}`);
// Outputs "Introduction to Programming: $2800".

Running the above produces the following output:

npx ts-node ts_type_annotation.ts
8
Hello, Kusanagi Kyo!
24
Introduction to Programming: $2800

A type annotation attaches type information to a variable, parameter, or return value using the : typeName syntax. This allows TypeScript to detect type mismatches at compile time, and also enables editor autocompletion and serves as inline documentation.

Type inference is the mechanism by which TypeScript automatically determines the type from context. Writing let count = 0; is enough for TypeScript to treat count as number, so no annotation is needed. As a general style guideline, rely on inference when the type is obvious from the initial value, and write an explicit annotation when the type is not clear — such as for function parameters or variables declared without an initial value.

Note: Type assertions (as) forcibly override TypeScript's type system. Specifying the wrong type can lead to runtime errors. Use them only when you are certain about the type.