PricingLoginStart free
TypeScript Academy · Lesson

Tuples: Fixed-Length Typed Arrays

Define tuples for structured data with known positions.

Lesson 3 of 413 steps

Tuples: Fixed-Length Typed Arrays is a free TypeScript Academy lesson on CoddyKit. This is lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the TypeScript Academy learning path, and your progress syncs across the web and the CoddyKit app. The TypeScript Academy course includes 4 lessons in total.

Welcome

Tuples are arrays with a fixed number of elements where each position has a specific type. They are perfect for structured data like coordinates or key-value pairs.

Defining a Tuple

A tuple type lists the type of each element in order. The length is fixed and each position must hold the declared type.
const point: [number, number] = [10, 20];
const entry: [string, number] = ['age', 25];

Accessing Tuple Elements

Access tuple elements by index. TypeScript knows the type at each position.
const pair: [string, number] = ['Alice', 30];
const name: string = pair[0]; // string
const age: number = pair[1];  // number

Tuple Destructuring

Destructuring a tuple gives each variable a specific inferred type based on position.
const [x, y]: [number, number] = [5, 10];
console.log(x + y); // 15

Tuples vs Arrays

An array has a variable number of same-typed elements. A tuple has a fixed number of possibly different-typed elements at specific positions.
const arr: number[] = [1, 2, 3, 4];   // variable length
const tup: [number, string] = [1, 'a']; // fixed: 2 elements

Optional Tuple Elements

Mark a tuple element as optional with `?`. Optional elements must come after required ones.
type Named = [string, string?]; // name, optional nickname
const a: Named = ['Alice'];
const b: Named = ['Bob', 'Bobby'];

Rest Elements in Tuples

Tuples can have a rest element that captures a variable number of trailing elements of a specific type.
type StringAndNumbers = [string, ...number[]];
const data: StringAndNumbers = ['scores', 90, 85, 78];

Labeled Tuple Elements

TypeScript 4.0 added labeled tuple elements. Labels improve readability without affecting the type system.
type Range = [start: number, end: number];
const r: Range = [0, 100];

Readonly Tuples

Add `readonly` to prevent mutation of a tuple after creation.
const origin: readonly [number, number] = [0, 0];
// origin[0] = 5; // Error

Tuples as Function Return Values

Returning a tuple from a function is a pattern used in React hooks and utility functions to return multiple values with distinct types.
function useCounter(): [number, () => void] {
  let count = 0;
  return [count, () => { count++; }];
}

Inferring Tuples with as const

Without `as const`, a tuple literal may be widened to an array type. Use `as const` to infer the exact tuple type.
const pair = [1, 'hello'] as const;
// type: readonly [1, 'hello'] — not (number | string)[]

Quick Check

What does TypeScript infer for `const t = [1, 'hello']` without any annotation?
Answer it in the interactive lesson

Recap

Tuples define fixed-length arrays with typed positions. Use them for coordinates, key-value pairs, and multi-return functions. Add readonly to prevent mutation and as const to infer literal tuple types.
Free to start

Learn TypeScript with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses
101
Lessons
352
Start learning freeView the full course

Frequently Asked Questions

Is the “Tuples: Fixed-Length Typed Arrays” lesson free?

Yes — the full text of “Tuples: Fixed-Length Typed Arrays” is free to read here on the web. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the TypeScript Academy course, upgrade to CoddyKit PRO. The TypeScript Academy course includes 4 lessons in total.

What will I learn in “Tuples: Fixed-Length Typed Arrays”?

Define tuples for structured data with known positions. You practise TypeScript Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start TypeScript Academy?

No prior experience is required. TypeScript Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 3 of 4.

How long does the “Tuples: Fixed-Length Typed Arrays” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this TypeScript Academy lesson?

Yes. Every TypeScript Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Typed Arrays: T[] and Array
  2. Readonly Arrays and Immutable Data
  3. Tuples: Fixed-Length Typed Arrays
  4. Enums: Numeric and String Constants
← Back to TypeScript Academy