Do JavaScript Arrays Start at 0 A Practical Guide
Explore whether JavaScript arrays start at index zero, how zero based indexing works, and practical examples to avoid off by one errors in loops and slices. Learn with clear explanations, code examples, and best practices for reliable array handling in JavaScript.
JavaScript array indexing refers to the position numbers used to access array elements, which start at zero. The first element is index 0, the second is 1, and so on.
What zero-based indexing means in JavaScript
According to JavaScripting, JavaScript arrays use zero-based indexing, meaning the first element lives at index 0. This convention affects how you read, write, and loop through data. For example:
const nums = [10, 20, 30];
console.log(nums[0]); // 10
console.log(nums[1]); // 20
console.log(nums[nums.length - 1]); // 30The length of an array is the count of elements it contains, and valid indices run from 0 up to length minus 1. Accessing an index outside that range returns undefined. Modern JavaScript also provides Array.prototype.at, which allows negative indexing: nums.at(-1) returns the last element. This is a helpful pattern to avoid off-by-one mistakes when you need elements from the end of an array. Remember that strings are similarly zero-based, so 'hello'[0] is 'h'.
This introductory concept sets the stage for more advanced techniques such as slicing, mapping, and reducing arrays, all of which rely on accurate indexing. When you write loops, use a condition that checks i < arr.length to stay inside bounds. When in doubt, log the length and inspect a few indices to confirm your understanding.
Questions & Answers
Do JavaScript arrays start at index 0?
Yes. In JavaScript, array indexing is zero-based, so the first element is at index 0, the second at index 1, and so on. Accessing an index outside the range returns undefined. The last element, if you know the length, is at length minus one.
Yes. JavaScript arrays use zero-based indexing, so the first element is at index zero and the last is at length minus one.
What happens if I access arr[length]?
Accessing arr[length] yields undefined because valid indices run from 0 to length minus one. To safely get the last element, use arr[length - 1] or the newer arr.at(-1) method.
Accessing arr[length] gives undefined; use arr[length - 1] or arr.at(-1) for the last item.
How do I loop through an array without off by one errors?
A reliable pattern is to loop with for (let i = 0; i < arr.length; i++) and access arr[i]. Avoid using i <= arr.length, which would overshoot the end. You can also use for...of to iterate values directly, though you lose the index.
Use a for loop with i less than length, or use for...of for values; avoid using a less-than-or-equal condition.
How can I get the last element safely?
Use arr.at(-1) in modern JavaScript or arr[arr.length - 1] for older syntax. Both retrieve the last element without needing a separate length calculation.
Use arr.at(-1) or arr[arr.length - 1] to read the last element safely.
Are there any exceptions where indexing behaves differently?
Zero-based indexing is standard for arrays and strings in JavaScript. Some methods expose elements or slices using different semantics, but the underlying indexing remains zero-based. Always check method documentation for exclusive end behavior in slice and similar operations.
Indexing is generally zero-based; some methods have special rules but indexing itself stays at zero for arrays and strings.
What to Remember
- Start indices at zero and the last index is length minus one
- Use i < arr.length in loops to avoid out of bounds errors
- Access from the end with arr.at(-1) or arr[arr.length - 1]
- Slice uses zero-based, end-exclusive indexing
- Strings in JavaScript share the same zero-based indexing system