TypeScript Let: Syntax, Usage, and Examples

The let keyword in TypeScript lets you declare variables with block scope. It behaves predictably inside loops, conditionals, and functions—making it the go-to choice when a variable needs to change. While var is still valid syntax, most developers now use let or const to write safer and more readable code.

How to Use Let in TypeScript

The syntax is straightforward:

let count = 0;
count += 1;

This declares a mutable variable named count and assigns it the value 0. You can reassign values to it later, which makes let perfect for variables that evolve over time—like counters, user input, or flags.

Unlike var, which leaks outside of blocks, let obeys block scope. That means when you declare a variable using let inside a block ({}), it stays inside that block.

Here’s an example:

function example() {
  if (true) {
    let message = "Inside block";
    console.log(message); // OK
  }
  // console.log(message); // Error: message is not defined
}

When to Use let in TypeScript

You should use let in TypeScript when:

• A variable’s value will change over time.
• You want clean scoping in loops or conditionals.
• You're working with iteration counters or temporary values.
• You need block scope to avoid side effects or variable leaks.

If you don’t plan to reassign the variable, use const instead. Otherwise, let is the safer and more readable choice for variables that evolve during execution.

Examples of Let in TypeScript

Example 1: Counting in a Loop

for (let i = 0; i < 5; i++) {
  console.log(i);
}

The variable i is scoped to the loop and doesn’t leak outside. Compare this with var, where the variable would still exist after the loop ends.

Example 2: Tracking User Input

let userInput = "";
userInput = "hello@example.com";

You’re allowed to reassign the value as needed, which is useful for storing dynamic values like form input, temporary filters, or session flags.

Example 3: Conditional Branches

let accessLevel = "";

if (user.isAdmin) {
  accessLevel = "admin";
} else {
  accessLevel = "user";
}

The variable accessLevel changes based on logic, and let fits that perfectly.

Learn More About TypeScript Let

Block Scope and Why It Matters

Unlike var, which ignores blocks, let respects them. That means variables declared with let stay inside {} brackets—whether they’re part of an if block, a loop, or a function.

if (true) {
  let name = "Jordan";
}
// console.log(name); // Error: name is not defined

This behavior avoids accidental overwriting or leakage of values into the wrong scope.

Reassignment vs Mutation

You can reassign let variables, but you can also mutate the values inside arrays or objects if the variable points to one.

let numbers = [1, 2, 3];
numbers.push(4); // Mutates the array
numbers = [5, 6]; // Reassigns to a new array

With let, both mutation and reassignment are allowed. That’s not the case with const, which doesn’t allow reassignment (though mutation is still possible).

Let vs Var in TypeScript

The TypeScript let vs var comparison almost always favors let. Here's why:

• let respects block scope. var does not.
• let avoids hoisting surprises. var hoists variables to the top of their function or global context.
• let behaves better inside loops. var reuses the same variable for each iteration, which can cause bugs.

Consider this classic example:

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100);
}
// Logs: 3, 3, 3

Now with let:

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100);
}
// Logs: 0, 1, 2

The loop works as expected with let. That’s why developers strongly prefer it over var in almost every modern TypeScript project.

Const vs Let in TypeScript

The const vs let in TypeScript discussion centers around one question: will the variable change?

• Use const when the value won’t change.
• Use let when it will.

For example:

const baseUrl = "https://api.example.com"; // This won’t change
let retries = 3; // This might change

Using const whenever possible helps you write safer code. But when you know you need to reassign, let is the right tool for the job.

Type Inference with Let

TypeScript infers types from let declarations automatically:

let name = "Taylor"; // TypeScript infers type: string

But you can also specify the type manually:

let age: number;
age = 28;

This makes let flexible—supporting both inferred and explicitly typed code.

Declaring Let Without Initializing

Unlike const, you can declare a let variable without giving it a value immediately:

let userId: number;

if (isLoggedIn) {
  userId = 42;
}

This flexibility is helpful for values that depend on branching logic or async results.

Let with Destructuring

You can also use let with object or array destructuring:

let [first, second] = ["a", "b"];
let { name, age } = { name: "Sam", age: 30 };

These bindings behave just like regular let variables—scoped and reassigned if needed.

Let in Function Parameters

While you don’t use let directly in parameter declarations, understanding how let works helps you manage inner variable declarations more effectively:

function greet(user: string) {
  let message = `Welcome, ${user}`;
  console.log(message);
}

The let keyword allows you to keep variables scoped tightly within the function.

Best Practices for Using Let

• Default to const. Use let only when you know reassignment is needed.
• Avoid var. The block scope of let makes code more predictable.
• Declare with type annotations when inference isn’t enough.
• Keep let variables as close as possible to where they’re used.
• Use let in loops and conditionals instead of var.

Here’s an example that ties everything together:

function processItems(items: string[]) {
  let total = 0;

  for (let i = 0; i < items.length; i++) {
    let item = items[i];
    total += item.length;
  }

  return total;
}

This function shows let being used for loop control, intermediate values, and accumulation—all scoped cleanly within the function.

The let keyword in TypeScript helps you write safer, cleaner, and more predictable code. It gives you flexibility without sacrificing structure. While older JavaScript relied on var, modern TypeScript emphasizes let and const for better scope control and fewer bugs.