Array length property in Javascript

Introduction

The array length property tells you how many items are in the array. It helps you know the size of the list you are working with.

When you want to count how many elements are in a list of items.

When you need to loop through all items in an array.

When you want to add or remove items and check the new size.

When you want to check if an array is empty or not.

When you want to limit actions based on the number of elements.

Syntax

Javascript

const array = ['item1', 'item2', 'item3'];
const size = array.length;

The length property is always one more than the highest index because arrays start at 0.

You can read length to get the number of items, or set it to change the array size.

Examples

Outputs 3 because there are three items in the array.

Javascript

const fruits = ['apple', 'banana', 'cherry'];
console.log(fruits.length);

Outputs 0 because the array has no items.

Javascript

const emptyArray = [];
console.log(emptyArray.length);

Outputs 1 because there is exactly one item.

Javascript

const oneItem = ['only'];
console.log(oneItem.length);

Setting length to 2 cuts the array to first two items: [10, 20].

Javascript

const numbers = [10, 20, 30, 40];
numbers.length = 2;
console.log(numbers);

Sample Program

This program shows how to get the length of an array, use it to loop through all items, and then change the length to remove items.

Javascript

const colors = ['red', 'green', 'blue', 'yellow'];
console.log('Original array:', colors);
console.log('Length:', colors.length);

// Loop through the array using length
for (let index = 0; index < colors.length; index++) {
  console.log(`Color at index ${index}:`, colors[index]);
}

// Change length to remove last two colors
colors.length = 2;
console.log('Array after changing length:', colors);
console.log('New length:', colors.length);

Important Notes

Accessing length is very fast, O(1) time complexity.

Changing length to a smaller number removes items from the end, which frees memory.

Common mistake: expecting length to count only non-empty or non-undefined items, but it counts all indexes.

Use length when you need to know or control the size of the array quickly.

Summary

The length property tells how many items are in an array.

You can read it to count items or set it to change the array size.

It is useful for loops, checks, and managing array size.

Practice

1.

What does the length property of a JavaScript array represent?

easy

A. The last element value in the array

B. The highest index number in the array

C. The total size in bytes of the array

D. The number of elements in the array

Solution

1. Step 1: Understand the length property

   The length property counts how many items are stored in the array.

2. Step 2: Differentiate from other properties

   It does not give the highest index or size in bytes, only the count of elements.

3. Final Answer:

   The number of elements in the array -> Option D

4. Quick Check:

   Array length = number of elements [OK]

Hint: Remember: length counts items, not indexes or sizes [OK]

Common Mistakes:

• Confusing length with highest index
• Thinking length gives memory size
• Assuming length returns last element

2.

Which of the following is the correct way to get the length of an array arr in JavaScript?

easy

A. arr.length()

B. arr.length

C. length(arr)

D. arr.size

Solution

1. Step 1: Recall the syntax for accessing length

   The length property is accessed without parentheses because it is a property, not a function.

2. Step 2: Check each option

   arr.length uses arr.length correctly. arr.length() uses parentheses incorrectly. Options C and D are not valid JavaScript syntax for array length.

3. Final Answer:

   arr.length -> Option B

4. Quick Check:

   Use property, not function: arr.length [OK]

Hint: Access length as property, no parentheses [OK]

Common Mistakes:

• Using arr.length() with parentheses
• Trying length(arr) like a function
• Using arr.size which doesn't exist

3.

What will be the output of the following code?

const fruits = ['apple', 'banana', 'cherry'];
console.log(fruits.length);

medium

A. undefined

B. 2

C. 3

D. Error

Solution

1. Step 1: Count the elements in the array

   The array fruits has three elements: 'apple', 'banana', and 'cherry'.

2. Step 2: Use the length property

   Accessing fruits.length returns the number of elements, which is 3.

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Array length = 3 [OK]

Hint: Count items inside brackets to find length [OK]

Common Mistakes:

• Counting indexes starting from 0
• Expecting length to be last index
• Confusing length with undefined

4.

Identify the error in the following code snippet:

let numbers = [1, 2, 3, 4];
numbers.length = 2;
console.log(numbers.length);
console.log(numbers[2]);

medium

A. Setting length to 2 removes elements after index 1

B. numbers.length cannot be changed

C. numbers[2] will print 3

D. Syntax error in setting length

Solution

1. Step 1: Understand setting length property

   Setting numbers.length = 2 truncates the array to first two elements, removing elements after index 1.

2. Step 2: Check the output of numbers[2]

   Since the array is truncated, numbers[2] is now undefined, not 3.

3. Final Answer:

   Setting length to 2 removes elements after index 1 -> Option A

4. Quick Check:

   Changing length truncates array [OK]

Hint: Changing length can cut off elements [OK]

Common Mistakes:

• Thinking length is read-only
• Expecting old elements to remain after truncation
• Assuming numbers[2] still holds value

5.

Given the array let data = [10, 20, 30, 40, 50];, which code snippet correctly doubles the array size by adding undefined elements at the end?

// Choose the correct code
A) data.length = data.length * 2;
B) data.length = data.length + data.length;
C) data.length = data.length * 2; data.fill(undefined, 5, data.length);
D) data.length = data.length * 2; data.fill(undefined);

hard

A. data.length = data.length * 2; data.fill(undefined, 5, data.length);

B. data.length = data.length + data.length;

C. data.length = data.length * 2;

D. data.length = data.length * 2; data.fill(undefined);

Solution

1. Step 1: Double the length property

   Setting data.length = data.length * 2 doubles the array size but new slots are empty (holes).

2. Step 2: Fill new slots with undefined

   Using data.fill(undefined, 5, data.length) fills the new slots from index 5 to the new length with undefined.

3. Step 3: Check other options

   A and B only change length but do not fill new slots, leaving holes. D uses data.fill(undefined) which fills from index 0, overwriting original data.

4. Final Answer:

   data.length = data.length * 2; data.fill(undefined, 5, data.length); -> Option A

5. Quick Check:

   Double length then fill new slots [OK]

Hint: Double length then fill new slots with fill(start, end) [OK]

Common Mistakes:

• Not filling new slots, leaving holes
• Overwriting existing elements with fill
• Using fill without end index