Check Whether a Value Is an Array in Ruby and Count Items

You will learn how Ruby identifies arrays, how to check a value safely with is_a?(Array), and how to count array elements using length, size, or count.

Ruby values are objects, and every object has a class. An array such as ["something", "else"] is an instance of Array, while "something" is an instance of String.

Use is_a?(Array) to ask whether an object is an array:

"something".is_a?(Array)             # => false
["something", "else"].is_a?(Array)  # => true

Once you know you have an array, use length or size to get its number of elements:

items = ["something", "else"]
items.length # => 2
items.size   # => 2

Checking a value's type matters when input may come from JSON, APIs, forms, configuration files, or method arguments. It helps your program avoid calling array-only methods on a string, number, or nil.

Think of an Array as a labelled container with several slots.

• is_a?(Array) checks the label on the container: “Is this an Array?”
• length counts how many slots currently contain elements.

A string is not an array container, even though it can contain multiple characters. Therefore, a string fails the array check and should not be handled as a list of items unless you deliberately convert it.

Use is_a?(Array) for a normal Ruby type check.

value = ["red", "green", "blue"]

if value.is_a?(Array)
  puts "This is an array with #{value.length} items."
else
  puts "This is not an array."
end

Output:

This is an array with 3 items.

You can also write the type check with Array === value:

Array === [1, 2]  # => true
Array === "text" # => false

However, value.is_a?(Array) is usually easier for beginners to read.

To count elements in an array:

numbers = [10, 20, 30]

numbers.length # => 3
numbers.size   # => 3
numbers.count  # => 3

For an array with no elements, all three return 0:

[].length # => 0

Consider this method that accepts either an array or another kind of value:

def describe_items(value)
  return "Not an array" unless value.is_a?(Array)

  "Array contains #{value.length} item(s)"
end

puts describe_items("something")
puts describe_items(["something", "else"])

Step by step:

1. describe_items("something") receives a String.
2. value.is_a?(Array) is false.
3. The unless condition returns early with "Not an array".
4. describe_items(["something", "else"]) receives an Array.
5. The type check is true, so execution continues.
6. value.length counts the two elements.
7. The method returns "Array contains 2 item(s)".

Output:

Not an array
Array contains 2 item(s)

• JSON API responses: Confirm that a field such as tags is an array before iterating over it.
• Form parameters: Handle a field that may arrive as one value or as a list of selected values.
• Configuration: Validate that a setting like allowed_hosts contains a list.
• Data imports: Check a CSV or parsed data value before treating it as a collection.
• Method inputs: Give a clear error when a method requires a list of records or IDs.

Example API-style validation:

def process_tags(tags)
  return [] unless tags.is_a?(Array)

  tags.map { |tag| tag.to_s.downcase }
end

process_tags(["Ruby", "Web"]) # => ["ruby", "web"]
process_tags("Ruby")            # => []

In production Ruby code, type checks are commonly paired with validation and guard clauses.

A guard clause handles invalid input immediately, keeping the main code path simple:

def total_price(prices)
  raise ArgumentError, "prices must be an Array" unless prices.is_a?(Array)

  prices.sum
end

When an array is optional, a default may be more appropriate:

def send_notifications(recipients)
  recipients = [] unless recipients.is_a?(Array)

  recipients.each do |recipient|
    puts "Sending notification to #{recipient}"
  end
end

Developers often use array methods after validation:

users = [{ active: true }, { active: false }, { active: true }]
active_users = users.select { |user| user[:active] }

active_users.count # => 2

If a method's contract clearly says it receives an array, repeated type checks inside that method may be unnecessary. Validate at the boundary where external input enters the application.

Calling length on a value before checking it

A string has a length too, but it means character count rather than item count:

value = "hello"
value.length # => 5, not an array item count

Check for an array first when array semantics matter.

value.length if value.is_a?(Array)

Calling array methods on nil

This raises an error:

value = nil
value.length
# NoMethodError

Use a guard clause or a default:

items = value.is_a?(Array) ? value : []
items.length # => 0

Using instance_of?(Array) when subclasses should count

value.instance_of?(Array)

instance_of? is stricter: it only returns true when the object's direct class is exactly Array. Usually, is_a?(Array) is the better choice because it also supports subclasses.

Confusing count with length

Without arguments, count returns the number of elements. With an argument or block, it counts matching elements:

[1, 2, 2, 3].count      # => 4
[1, 2, 2, 3].count(2)   # => 2
[1, 2, 2, 3].count(&:even?) # => 2

Use length or size when you simply need the total number of elements.

length and size are interchangeable for Ruby arrays. Many developers use length when emphasizing a count and size when discussing a collection's size; both are valid.

# Type check
value.is_a?(Array)

"text".is_a?(Array) # => false
[1, 2].is_a?(Array)  # => true

# Total number of array elements
array.length
array.size
array.count

["a", "b"].length # => 2
[].size              # => 0

# Count matching elements
[1, 2, 2, 3].count(2)          # => 2
[1, 2, 2, 3].count(&:even?)    # => 2

# Safe fallback when input might not be an array
items = value.is_a?(Array) ? value : []

• Prefer is_a?(Array) for ordinary array checks.
• Prefer length or size for the total item count.
• count can also count only elements that match a value or condition.
• Do not assume nil, strings, hashes, and arrays support the same methods.

How do I check if something is an array in Ruby?

Use value.is_a?(Array). It returns true for arrays and false for values such as strings, integers, hashes, and nil.

What is the difference between length, size, and count for an array?

With no arguments, all return the number of elements. count is additionally useful with an argument or block to count only matching elements.

Does a Ruby string count as an array?

No. A string is a String object, not an Array, even though it contains characters.

What happens when I call length on an empty array?

It returns 0.

Should I use is_a?(Array) or instance_of?(Array)?

Usually use is_a?(Array). It is more flexible because it accepts instances of Array subclasses too.

How can I safely treat a non-array as an empty array?

Use a conditional fallback:

items = value.is_a?(Array) ? value : []

Can I count only particular values in an array?

Yes. Use count with a value or block:

["a", "b", "a"].count("a") # => 2

• Ruby classes and objects — Explains why values respond to is_a? and belong to classes such as Array and String.
• Conditionals (if and unless) — Used to choose what to do after an array check.
• Guard clauses and early returns — Keep methods safe and readable when input is invalid.
• Array iteration with each — Process every item after confirming a value is an array.
• map, select, and filter patterns — Transform or select items from arrays.
• nil handling — Prevent errors when a value is missing.
• Ruby method arguments — Define clear expectations for values passed into methods.