TypeScript is a superset of JavaScript that adds static typing. One of its core features is **type annotations** — a way to explicitly define the types of variables, function parameters, return values, and more. Type annotations enhance code readability, catch errors at compile time, and provide better tooling support. 

Type annotations let you specify the type of a variable or function component. This helps TypeScript understand the expected structure of your code and flag any inconsistencies.

```ts
const username: string = "Alice";
const age: number = 30;
const isLoggedIn: boolean = true;
```
Here, \`username\` must always be a string, \`age\` a number, and \`isLoggedIn\` a boolean.

TypeScript doesn’t require you to annotate everything thanks to type inference. Its built-in ability to automatically determine a variable’s type based on the value it’s assigned.


```ts
const username = "Alice";       // inferred as string
const age = 30;                 // inferred as number
const isLoggedIn = true;        // inferred as boolean
```
Writing const username: string = "Alice" is correct, but unnecessary. And in larger codebases, this kind of repetition can actually clutter your code.

You can annotate both parameters and return types in functions.

```ts
function greet(name: string): string {
  return `Hello, ${name}!`;
}

```

Without proper types, this function could be misused or produce unexpected behavior. Type annotations also work with optional parameters using \`?\`, and default values.

```ts
function log(
  message: string,          // required
  userId?: number,          // optional parameter
  level: string = "info"    // parameter with default value
): void {
  console.log(`[${userId ?? "anonymous"}] (${level}): ${message}`);
}
```

Complex structures like arrays and objects can also be annotated:

```ts
const user: { id: number; name: string } = {
  id: 1,
  name: "Alice"
};

const scores: number[] = [85, 90, 92];

```

 Special Built-in Types: **void**, **never**,  **any**, and **unknown**



Use **void** to indicate a function does **not return a value**.

```ts
function logMessage(message: string): void {
  console.log(message);
}
```

This helps TypeScript understand that return values are irrelevant here.


Use **never** when a function **never returns** — either because it throws an error or runs infinitely.

```ts
function throwError(message: string): never {
  throw new Error(message);
}

function infiniteLoop(): never {
  while (true) {}
}
```

**never** tells TypeScript that this code path will not continue normally.



The **any** type disables type checking for a variable — it's like opting out of TypeScript's safety.

```ts
let randomValue: any = 42;
randomValue = "Now it's a string";
randomValue = true;
```

Use **any** **minimally**, as it removes the benefits of TypeScript’s type system.

Prefer using **unknown** if you want type safety with flexibility. The **unknown** type is safer than **any**. It represents a value that could be anything, but you must perform type checks before using it.

```ts
let uncertainValue: unknown = 10;
uncertainValue = "hello";

// TypeScript error if you try to use it directly:
// console.log(uncertainValue.toUpperCase()); // Error!

if (typeof uncertainValue === "string") {
  // Now TypeScript knows it's a string
  console.log(uncertainValue.toUpperCase());
}
```

## Benefits of Type Annotations

- **Improved readability**: Makes code self-documenting.
- **Better IDE support**: Autocompletion and inline documentation.
- **Early error detection**: Catch mistakes before runtime.
- **Easier refactoring**: Code changes are safer and more predictable.

Use **type annotations** where they **add clarity** or are **required**, but rely on **inference** to reduce repetition for basic assignments. 


Type Annotations and Inference in TypeScript

How type annotations improve code clarity, safety, and developer experience in TypeScript.

Static typing

Type Annotations and Inference in TypeScript