How to Find the Length of an Array in JavaScript

By the end of this page, you will understand how to get the number of items in a JavaScript array using the length property, how to check whether you are at the end of an array, and how this is commonly used in loops and real programs.

In JavaScript, arrays have a built-in length property. This tells you how many elements the array currently holds.

const fruits = ["apple", "banana", "orange"];
console.log(fruits.length); // 3

The length property is important because it lets you:

• count how many items are in an array
• control loops safely
• detect the last valid index
• avoid going past the end of the array

A key detail is that array indexes start at 0, not 1. So if an array has a length of 3, its valid indexes are:

• 0
• 1
• 2

That means the last item is always at:

array.length - 1

This matters in real programming because arrays are everywhere:

• lists of users from an API
• rows of data from a file
• product items in a shopping cart
• messages in a chat app

If you know the length, you can process every item correctly and stop at the right time.

Think of an array like a row of numbered boxes on a shelf.

• length tells you how many boxes exist
• the first box is numbered 0
• the last box is not length, but length - 1

So if there are 5 boxes:

• total boxes = 5
• positions = 0, 1, 2, 3, 4

If you try to open box 5, it is outside the shelf.

That is why loops usually continue while the index is less than array.length.

The basic syntax is:

array.length

Example: get the number of items

const colors = ["red", "green", "blue"];
console.log(colors.length); // 3

This array contains 3 values.

Example: loop through an array safely

const colors = ["red", "green", "blue"];

for (let i = 0; i < colors.length; i++) {
  console.log(colors[i]);
}

This works because:

• i starts at 0
• the loop continues while i < colors.length
• when i becomes 3, the loop stops

Example: detect the last element

Consider this code:

const numbers = [10, 20, 30];

for (let i = 0; i < numbers.length; i++) {
  console.log(i, numbers[i]);
}

Here is what happens step by step:

1. numbers is created with 3 values.
2. numbers.length is 3.
3. The loop starts with i = 0.
4. Check: 0 < 3 → true, so run the loop.
5. Print 0 10.
6. Increase i to 1.
7. Check: 1 < 3 → true, so run the loop.
8. Print 1 20.
9. Increase i to 2.
10. Check: → , so run the loop.

Here are common real-world uses of array length:

Showing counts in a UI

const notifications = ["New message", "Password changed"];
console.log(`You have ${notifications.length} notifications.`);

Processing API results

const users = [{ name: "Ava" }, { name: "Liam" }];

if (users.length === 0) {
  console.log("No users found");
} else {
  console.log(`Loaded ${users.length} users`);
}

Checking whether a shopping cart is empty

const cart = ["Laptop", "Mouse"];

if (cart.length > 0) {
  console.log("Proceed to checkout");
}

In real projects, developers use array.length in several common patterns.

Guard clauses

function printFirstItem(items) {
  if (items.length === 0) {
    return "No items available";
  }

  return items[0];
}

This avoids errors by checking for an empty array first.

Loop boundaries

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

This is one of the most common loop patterns in JavaScript.

Validation

function validateTags(tags) {
  if (tags.length > 5) {
    return "Too many tags";
  }
  return "Valid";
}

Last-item formatting

Mistake: using <= instead of <

Broken code:

const numbers = [10, 20, 30];

for (let i = 0; i <= numbers.length; i++) {
  console.log(numbers[i]);
}

Problem:

• numbers.length is 3
• valid indexes are 0, 1, 2
• numbers[3] is outside the array, so it prints undefined

Correct version:

for (let i = 0; i < numbers.length; i++) {
  console.log(numbers[i]);
}

Mistake: confusing length with last index

Broken idea:

length vs last index

• length is the count of elements

// Number of items in an array
array.length

// Last item
array[array.length - 1]

// Check if empty
array.length === 0

// Check if not empty
array.length > 0

// Safe loop
for (let i = 0; i < array.length; i++) {
  console.log(array[i]);
}

// Check if current index is the last one
i === array.length - 1

Rules to remember

• Arrays are zero-indexed.
• length is the total count, not the last index.
• The last valid index is length - 1.
• Use < array.length, not <= array.length, in most loops.
• An empty array has length equal to 0.

How do I get the number of elements in a JavaScript array?

Use the length property:

const arr = [1, 2, 3];
console.log(arr.length); // 3

How do I know if I am at the last item in an array?

Compare the current index to array.length - 1.

if (i === arr.length - 1) {
  console.log("Last item");
}

How do I check if an array is empty?

if (arr.length === 0) {
  console.log("Empty array");
}

Why does arr[arr.length] return undefined?

Because length is one more than the last valid index. The last item is at .

• Arrays — length is a core array feature.
• Zero-based indexing — helps explain why the last index is length - 1.
• for loops — commonly use array.length as the stopping condition.
• for...of loops — useful when you want values without manual index tracking.
• Array methods — methods like map(), filter(), and forEach() often work with array sizes.
• Conditional statements — useful for checking empty arrays or last-element logic.
• Undefined — helps explain what happens when you access an index outside the array.