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

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

for (let i = 0; i < colors.length; i++) {
  if (i === colors.length - 1) {
    console.log("This is the last item:", colors[i]);
  }
}

Example: check if an array is empty

const items = [];

if (items.length === 0) {
  console.log("The array is empty");
}

This is a common pattern when validating data.

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: 2 < 3 → true, so run the loop.
11. Print 2 30.
12. Increase i to 3.
13. Check: 3 < 3 → false, so the loop stops.

This is how JavaScript knows you have reached the end of the array: the index is no longer less than length.

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");
}

Reading data line by line

When processing imported CSV rows or log entries, developers often loop from 0 to rows.length - 1 to process each record safely.

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

const words = ["JavaScript", "arrays", "loops"];

for (let i = 0; i < words.length; i++) {
  const isLast = i === words.length - 1;
  console.log(words[i], isLast ? "(last)" : "");
}

Using higher-level methods

Even when developers use methods like map(), filter(), or forEach(), they still often check length before or after processing.

const completed = tasks.filter(task => task.done);
console.log(completed.length);

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:

const letters = ["a", "b", "c"];
console.log(letters[letters.length]); // undefined

Correct version:

console.log(letters[letters.length - 1]); // "c"

Mistake: assuming arrays start at 1

JavaScript arrays are zero-indexed.

const items = ["x", "y", "z"];
console.log(items[0]); // "x"

Mistake: checking truthiness instead of actual length intent

const arr = [];

if (arr) {
  console.log("This runs, because arrays are truthy");
}

If you want to know whether the array has items, check:

if (arr.length > 0) {
  console.log("Array has items");
}

length vs last index

• length is the count of elements
• last index is one less than the count

Example:

const items = ["a", "b", "c"];
console.log(items.length); // 3
console.log(items.length - 1); // 2

Traditional loop vs for...of

If your goal is specifically to detect the end of an array by index, a traditional for loop is often clearer.

// 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 arr[arr.length - 1].

Can the length of an array change?

Yes. If you add or remove items, the length updates automatically.

Is length a method?

No. It is a property, so you write arr.length, not arr.length().

Should I use a for loop or for...of?

Use a for loop when you need the index or need to detect the last element. Use for...of when you only need the values.

• 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.