How to Type an Array of Objects in TypeScript

By the end of this page, you will understand how to type collections of objects in TypeScript, especially the difference between a true array and an object with numeric keys. You will learn when to use inline types, type aliases, interfaces, arrays, tuples, and Record, and how these choices affect autocomplete and error checking.

In TypeScript, the first thing to notice is that your example is not actually an array. It is an object whose keys are strings that look like numbers:

const userTestStatus = {
  "0": { id: 0, name: "Available" },
  "1": { id: 1, name: "Ready" },
  "2": { id: 2, name: "Started" }
};

A real array would look like this:

const userTestStatus = [
  { id: 0, name: "Available" },
  { id: 1, name: "Ready" },
  { id: 2, name: "Started" }
];

That difference matters because TypeScript uses different type systems for:

• arrays: ordered lists, accessed by index
• objects: key-value collections, accessed by property name or index signature

If your data is meant to be a list of statuses, an array is usually the best choice.

If your data is meant to be a lookup table keyed by IDs, then an object or may be better.

Think of this as choosing the right storage container:

• An array is like a row of boxes in order: box 0, box 1, box 2.
• An object is like a cabinet with labeled drawers: drawer "0", drawer "1", drawer "2".

Both can store similar data, but they mean different things.

If you want “a list of statuses in order,” use an array. If you want “a dictionary of statuses by key,” use an object.

TypeScript then acts like a label checker:

• it checks whether each box contains the right shape
• it checks whether property names like name are spelled correctly
• in some cases, it can even check whether a drawer key exists

If you want a real array of objects, define a type for one object and then use that type in an array.

type Status = {
  id: number;
  name: string;
};

const userTestStatus: Status[] = [
  { id: 0, name: "Available" },
  { id: 1, name: "Ready" },
  { id: 2, name: "Started" }
];

This is the most common solution.

TypeScript will now allow:

userTestStatus[0].name

and flag:

userTestStatus[0].nammme

because nammme does not exist on Status.

Inline type

You can also write the type inline:

Consider this example:

type Status = {
  id: number;
  name: string;
};

const userTestStatus: Status[] = [
  { id: 0, name: "Available" },
  { id: 1, name: "Ready" },
  { id: 2, name: "Started" }
];

const firstName = userTestStatus[0].name;

Step by step:

1. type Status = ... defines the shape of one status object.

   • every Status must have:
     • id: number
     • name: string

2. const userTestStatus: Status[] means:

   • userTestStatus is an array

Typing arrays and object collections is common in almost every TypeScript codebase.

API responses

type User = {
  id: number;
  name: string;
};

const users: User[] = await fetchUsers();

This helps you safely access users[0].name.

Dropdown options

type Option = {
  id: number;
  label: string;
};

const options: Option[] = [
  { id: 1, label: "Small" },
  { id: 2, label: "Medium" },
  { id: 3, label: "Large" }
];

Status lookup tables

  = {
  : ;
  : ;
};

 : <, > = {
  : { : , :  },
  : { : , :  }
};

In real projects, developers usually separate two concerns:

1. the type of one item
2. the type of the collection

Example:

interface Status {
  id: number;
  name: string;
}

const statuses: Status[] = [
  { id: 0, name: "Available" },
  { id: 1, name: "Ready" }
];

This pattern makes code easier to reuse.

Common patterns

Validation before use

function printStatus(status: Status) {
  console.log(status.name);
}

Array methods

Once your array is typed, methods like map, filter, and find become safer:

1. Calling an object an array

This is very common.

Broken idea:

const data = {
  0: { id: 0, name: "Available" },
  1: { id: 1, name: "Ready" }
};

This is an object, not an array.

A real array uses square brackets:

const data = [
  { id: 0, name: "Available" },
  { id: 1, name: "Ready" }
];

2. Repeating inline types everywhere

This works:

const a: { id: number; name: string }[] = [];

But repeating it many times makes code harder to maintain. Prefer a reusable type:

type Status = {
  : ;
  : ;
};

// One object type
type Status = {
  id: number;
  name: string;
};

// Array of objects
const list: Status[] = [
  { id: 0, name: "Available" }
];

// Inline array type
const list2: { id: number; name: string }[] = [
  { id: 1, name: "Ready" }
];

// Object lookup by numeric key
const map: Record<number, Status> = {
  0: { id: 0, name: "Available" }
};

// Fixed-size tuple
const tuple: [Status, Status] = [
  { id: 0, name: "Available" },
  { id: , :  }
];

Is { "0": ..., "1": ... } an array in TypeScript?

No. That is an object with keys that look like numbers. A real array uses square brackets: [...].

How do I type an array of objects in TypeScript?

Define the item shape, then use []:

type Status = { id: number; name: string };
const statuses: Status[] = [];

Can I declare the type inline instead of creating a separate type?

Yes.

const statuses: { id: number; name: string }[] = [];

This is fine for small cases.

Should I use type or interface for object arrays?

Either is fine here. Use whichever style is preferred in your codebase.

Why does TypeScript catch .nammme but not always ?

• Type aliases — useful for naming reusable object shapes like Status.
• Interfaces — another way to describe object structure in TypeScript.
• Arrays in TypeScript — important for understanding Type[] and indexed access.
• Tuples — useful when the number and order of items are fixed.
• Record utility type — useful for typing key-value objects.
• Index signatures — relevant when objects are accessed through dynamic keys.
• Optional chaining — helpful when an indexed value might be undefined.
• Type inference — explains when TypeScript can figure out types without explicit annotations.