0Pricing
TypeScript Academy · Lesson

Tuples: Fixed-Length Typed Arrays

Define tuples for structured data with known positions.

Tuples: Fixed-Length Typed Arrays is a free TypeScript Academy lesson on CoddyKit — 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, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

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?

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.

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, and the TypeScript Academy course includes 4 lessons in total. 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.

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; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

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