How to Check if a Value Exists in an Array in Ruby

By the end of this page, you will understand how to check whether a value exists in a Ruby array using built-in methods like include?. You will also learn how Ruby performs this check internally, when to use related methods, and what mistakes beginners commonly make.

In Ruby, arrays come with built-in methods for searching and membership checks. The most direct way to test whether a specific value is present in an array is the include? method.

animals = ['Cat', 'Dog', 'Bird']
animals.include?('Dog')
# => true

This matters because checking whether a value exists is a very common task in programming:

• validating user input
• checking permissions
• matching tags or categories
• deciding whether to run some logic

Even though you do not write a loop yourself, Ruby still checks the array elements behind the scenes. The advantage is that you use a clear, readable method instead of manually iterating.

For arrays, include? checks whether any element is equal to the given value. In most cases, this is the simplest and most idiomatic Ruby solution.

Think of an array like a row of labeled boxes:

• box 1: Cat
• box 2: Dog
• box 3: Bird

When you ask Ruby:

animals.include?('Dog')

you are basically saying:

“Is there any box in this row that contains exactly 'Dog'?”

Ruby looks through the row for you and answers with either:

• true if it finds it
• false if it does not

So include? is like asking a yes-or-no question about the contents of the array.

Basic syntax

array.include?(value)

• array is the array you want to search
• value is the item you are looking for
• the result is true or false

Example 1: Check for a string

animals = ['Cat', 'Dog', 'Bird']

puts animals.include?('Dog')
# true

puts animals.include?('Fish')
# false

This checks whether each string appears in the array.

Example 2: Check for a number

numbers = [10, 20, 30]

puts numbers.include?(20)
# true

puts numbers.include?(99)
# false

include? works with numbers as well.

Example 3: Use in an if statement

animals = ['Cat', 'Dog', 'Bird']

if animals.include?('Dog')
  puts 'Dog is in the array'
else
  puts 'Dog is not in the array'
end

This is how membership checks are commonly used in real programs.

Consider this code:

animals = ['Cat', 'Dog', 'Bird']
result = animals.include?('Dog')
puts result

Step by step:

1. Ruby creates an array and stores it in animals:

   ['Cat', 'Dog', 'Bird']
   

2. Ruby runs:

   animals.include?('Dog')
   

3. Ruby checks the array elements until it finds a match.
4. Since 'Dog' is present, the expression returns true.
5. That true value is stored in result.
6. puts result prints:

   true
   

If the code were:

result = animals.include?('Fish')

then Ruby would not find a match, so result would be false.

Checking whether a value exists in an array appears in many everyday Ruby programs.

User role checks

roles = ['admin', 'editor', 'viewer']

if roles.include?('admin')
  puts 'Show admin dashboard'
end

Input validation

allowed_statuses = ['pending', 'approved', 'rejected']
status = 'approved'

unless allowed_statuses.include?(status)
  puts 'Invalid status'
end

Feature flags

enabled_features = ['chat', 'notifications', 'search']

if enabled_features.include?('search')
  puts 'Enable search UI'
end

Filtering by category

categories = ['books', 'music', 'games']
selected = 'music'

puts 'Valid category' if categories.include?(selected)

In all of these examples, the goal is the same: answer a simple yes-or-no question about membership.

In real Ruby codebases, include? is often used as part of small, readable checks.

Guard clauses

def process_status(status)
  allowed_statuses = ['pending', 'approved', 'rejected']
  return 'Invalid status' unless allowed_statuses.include?(status)

  "Processing #{status}"
end

This pattern exits early if the value is not allowed.

Validation logic

def valid_role?(role)
  ['admin', 'editor', 'viewer'].include?(role)
end

This keeps validation simple and reusable.

Configuration checks

SUPPORTED_FORMATS = ['json', 'xml', 'csv']

def export(format)
  raise 'Unsupported format' unless SUPPORTED_FORMATS.include?(format)

  "Exporting as #{format}"
end

Conditional behavior

premium_features = ['analytics', 'priority_support']

def feature_available?(feature, available_features)
  available_features.include?(feature)
end

Developers often combine include? with:

• return for early exits
• validation methods ending in ?
• constants that store allowed values
• conditionals like if, unless, and ternary expressions

1. Using the wrong capitalization

Strings in Ruby are case-sensitive.

animals = ['Cat', 'Dog', 'Bird']

puts animals.include?('dog')
# false

'dog' is not the same as 'Dog'.

To avoid this, normalize values if needed:

animals.map(&:downcase).include?('dog')
# true

2. Comparing strings and symbols

Strings and symbols are different types.

animals = ['Cat', 'Dog', 'Bird']
puts animals.include?(:Dog)
# false

If your array contains strings, search with strings.

3. Expecting include? to return the item itself

include? returns only true or false.

animals = ['Cat', 'Dog', 'Bird']
value = animals.include?('Dog')

puts value
# true

If you need the actual matching item, use find instead.

4. Thinking there is no loop involved at all

You do not write the loop, but Ruby still checks elements internally. include? is a cleaner way to express the intent.

5. Calling include? on nil

animals = nil
animals.include?('Dog')
# NoMethodError

Make sure the object is actually an array:

animals&.include?('Dog')
# nil

or provide a default:

Array(animals).include?('Dog')
# false

include? vs related methods

Example comparison

animals = ['Cat', 'Dog', 'Bird']

animals.include?('Dog')   # => true
animals.find { |a| a == 'Dog' }  # => "Dog"
animals.any? { |a| a.start_with?('D') } # => true
animals.index('Dog')      # => 1

When to choose which

• Use include? when you only need yes or no.
• Use find when you need the actual element.
• Use any? when the condition is more complex than exact equality.
• Use index when you need the element's position.

Quick syntax

array.include?(value)

Returns

• true if the value exists
• false if the value does not exist

Example

animals = ['Cat', 'Dog', 'Bird']
animals.include?('Dog')   # => true
animals.include?('Fish')  # => false

Common patterns

if animals.include?('Dog')
  puts 'Found it'
end

unless animals.include?('Fish')
  puts 'Not found'
end

Important rules

• Matching is case-sensitive
• Strings and symbols are different
• include? returns a boolean, not the matching item
• Ruby checks the array internally even if you do not write a loop

Related methods

array.find { |item| item == value }
array.any? { |item| condition }
array.index(value)

How do I check if a string exists in an array in Ruby?

Use include?:

animals.include?('Dog')

It returns true or false.

Does include? loop through the array in Ruby?

Internally, yes. You do not write the loop yourself, but Ruby still checks elements behind the scenes.

Is include? case-sensitive in Ruby?

Yes. 'Dog' and 'dog' are different strings.

What is the difference between include? and any? in Ruby?

include? checks for an exact value. any? checks whether any element matches a condition.

Can I use include? with numbers and symbols?

Yes, as long as the value type matches the elements in the array.

What if I need the matching item instead of true or false?

Use find instead of include?.

What happens if the array is empty?

include? simply returns false.

• Ruby arrays — include? is an array method, so understanding arrays is essential.
• Boolean values — include? returns true or false.
• Conditional statements — membership checks are often used with if and unless.
• Enumerable methods — methods like any?, find, and map are closely related.
• String comparison — case sensitivity matters when checking string values.
• Symbols vs strings — Ruby treats these as different types, which affects membership checks.