Creating Empty Typed Arrays in TypeScript

You will learn how TypeScript distinguishes one object from an array of objects, how to initialize an empty typed array, and how to safely create arrays with an intended size.

Criminal means one value whose type is Criminal.

Criminal[] means an array whose elements are Criminal values.

To create an empty typed array, put the array type after the variable name and assign an array value:

const criminals: Criminal[] = [];

The : Criminal[] part is a type annotation. It tells TypeScript what may be stored in the array. The [] part is an array expression: it creates an empty array at runtime.

This distinction matters because TypeScript types are mostly checked during development and then removed when JavaScript is produced. At runtime, JavaScript needs an actual value such as []; it cannot execute a type like Criminal[].

Think of Criminal as the label for one evidence folder.

Criminal[] is the label for a storage box that may hold many evidence folders.

• const criminal: Criminal = ... expects one folder.
• const criminals: Criminal[] = [] creates an empty box for folders.

Writing Criminal[] by itself is only a label describing a kind of box. It is not the box itself. To create the box, use [].

Use either Type[] or the generic Array<Type> syntax.

interface Criminal {
  name: string;
  motive: string;
}

const criminals: Criminal[] = [];

criminals.push({ name: "Alex", motive: "Money" });
criminals.push({ name: "Blair", motive: "Revenge" });

console.log(criminals);

criminals starts empty, but TypeScript permits only values matching the Criminal shape.

criminals.push({ name: "Casey" });
// Error: Property 'motive' is missing.

The equivalent generic form is:

const criminals: <> = [];

Consider this code:

interface Criminal {
  name: string;
  motive: string;
}

const suspects: Criminal[] = [];

suspects.push({ name: "Morgan", motive: "Jealousy" });

const firstSuspect = suspects[0];
console.log(firstSuspect.name);

1. The interface defines the required shape of a Criminal.
2. const suspects: Criminal[] = [] creates an empty JavaScript array and records that it should contain Criminal objects.
3. push adds an object with both required properties, so TypeScript accepts it.
4. suspects[0] reads the first object from the array.
5. The program prints Morgan.

With noUncheckedIndexedAccess enabled in tsconfig.json, TypeScript treats as possibly , because an array index may not exist. Check it before using it:

Typed arrays are useful whenever a program collects multiple values of one kind:

• Game state: store suspects, clues, cards, turns, or board cells.
• API data: represent a list returned from /users or /orders.
• Form validation: collect validation messages as string[].
• Data processing: build a Transaction[] while reading a file or database rows.
• UI rendering: store Product[] and render one item per product.

Example: collecting validation errors.

const errors: string[] = [];

if (!email.includes("@")) {
  errors.push("Enter a valid email address.");
}

if (password.length < 8) {
  errors.push("Password must contain at least 8 characters.");
}

In real projects, typed arrays commonly appear as function return types, object properties, and API models.

Return a list from a function

function findSuspiciousCriminals(criminals: Criminal[]): Criminal[] {
  return criminals.filter((criminal) => criminal.motive !== "None");
}

Store an initially empty list in application state

class GameState {
  readonly clues: string[] = [];
}

readonly prevents replacing the property with another array, though items can still be added to the existing array.

Validate before adding data

function addCriminal(list: Criminal[], criminal: Criminal): void {
  if (criminal.name.trim() === ) {
      ();
  }

  list.(criminal);
}

Using an element type instead of an array type

const criminals: Criminal = [];

This is incorrect because criminals is declared as one Criminal, but [] is an array.

const criminals: Criminal[] = [];

Treating a type as a runtime value

const criminals = Criminal[];

This is invalid. Criminal[] describes a type and cannot create an array. Use an array literal:

const criminals: Criminal[] = [];

Omitting the type when the empty array needs a known element type

const criminals = [];

The inferred type for an empty array can be too broad or depend on compiler settings and later usage. Add an annotation when the intended element type is known:

// Empty typed array
const items: Criminal[] = [];

// Equivalent generic syntax
const items: Array<Criminal> = [];

// Add a valid item
items.push({ name: "Alex", motive: "Money" });

// Function parameter and return type
function copy(items: Criminal[]): Criminal[] {
  return [...items];
}

// Create actual values with a factory
const items: Criminal[] = Array.from({ length: 3 }, (_, i) => ({
  name: `Suspect ${i + 1}`,
  motive: "Unknown"
}));

// Slots that may be unfilled
const slots: Array<Criminal | undefined> = ().();

How do I declare an empty array of objects in TypeScript?

Use an array type annotation and an empty array literal:

const criminals: Criminal[] = [];

Is Criminal[] the same as Array<Criminal>?

Yes. Both describe an array whose elements are Criminal. Criminal[] is usually more concise.

Why does const item: Criminal = [] fail?

Criminal describes one object, while [] is an array. Use Criminal[] for an array.

Can I use var instead of const?

You can, but const is usually preferred when the variable should always refer to the same array. You can still call push on a const array.

How do I preallocate an array in TypeScript?

For a fixed number of real initial values, use with a factory function. Avoid unless you specifically want empty slots.

• Type annotations — : Criminal[] explicitly documents and checks a variable's intended type.
• Interfaces — interfaces define the object shape that each array element must follow.
• Type inference — TypeScript can infer many types, but empty arrays often benefit from an explicit element type.
• Union types — Criminal | undefined models a value that may be missing.
• Array methods — push, map, filter, and find are standard ways to work with typed collections.
• Readonly arrays — readonly Criminal[] prevents adding, removing, or replacing elements through that reference.
• Null and undefined checks — array indexing can produce a missing value, especially with strict compiler settings.