How to check whether a string contains a substring in Ruby?

String operations are central to many everyday tasks in Ruby—everything from parsing file content to analyzing web requests involves checking if one string contains another. Thankfully, Ruby offers several straightforward ways to accomplish this. Below are the most common and idiomatic approaches for determining whether one string (the “substring”) appears in another (the “main string”).

1. Using `include?`

Ruby’s built-in String#include? method is the simplest way to check for a substring. It returns a boolean value:

main_string = "Hello, Ruby World!"
substring   = "Ruby"

if main_string.include?(substring)
  puts "Yes, the substring was found."
else
  puts "No, the substring was not found."
end

Returns true or false
Case-Sensitive: If you need a case-insensitive match, you’ll have to convert both strings (e.g., downcase) before checking.

2. Using Regular Expressions

For more complex pattern matching, regular expressions are extremely powerful:

main_string = "Hello, Ruby World!"
pattern = /ruby/i  # The 'i' flag makes the match case-insensitive

if main_string =~ pattern
  puts "Pattern found."
else
  puts "Pattern not found."
end

`=~` and `match?` Methods

=~ returns the starting index of the match or nil if not found.
String#match? (introduced in Ruby 2.4) returns a boolean without creating a MatchData object, making it more performant if you only need a yes/no result:
```
if main_string.match?(pattern)
  puts "Pattern found."
else
  puts "Pattern not found."
end
```

3. Handling Case Sensitivity

Convert Both Strings to the Same Case

If you want case-insensitive matching using include?, just convert both strings:

main_string = "Hello, Ruby World!"
substring   = "ruby"

if main_string.downcase.include?(substring.downcase)
  puts "Match found (case-insensitive)."
end

For regex-based solutions, add the i flag to make the search case-insensitive, as shown above (/ruby/i).

4. Substring vs. Subsequence

When we talk about a “substring” in most programming contexts, we mean a consecutive set of characters in a string. Ruby’s include? and regex methods only check consecutive characters. If you need to check if characters appear in order but not necessarily consecutively (a “subsequence”), you’d need a different approach—usually involving iteration or dynamic programming. For simple substring checks, though, include? and regex are sufficient.

Further Learning

Strengthening your understanding of strings, arrays, and more advanced data structures is crucial if you’re preparing for coding interviews. Here are a few courses from DesignGurus.io that can help:

Grokking the Coding Interview: Patterns for Coding Questions
Develop a thorough understanding of common coding patterns frequently tested in interviews.
Grokking the System Design Interview
Ideal for gaining expertise in architecting scalable, high-performance systems—especially if you’re aiming for senior roles or top-tier tech companies.

For a more hands-on experience, consider setting up a Coding Mock Interview or System Design Mock Interview where you’ll receive personalized feedback from ex-FAANG engineers.

Conclusion

Checking if a string contains a substring in Ruby is straightforward with methods like include?, regex operators (=~, match?), and case conversion when necessary. For most basic use cases, main_string.include?(substring) will do the trick. If you need more advanced pattern matching, Ruby’s powerful regular expressions are your go-to solution. By mastering these techniques—and continuing to sharpen your overall coding and system design skills—you’ll be well on your way to writing efficient, maintainable Ruby applications.

CONTRIBUTOR

TechGrind