How to Check Whether a String Contains a Substring in Ruby

By the end of this page, you will understand how to check whether one string appears inside another in Ruby. You will learn the simplest method with include?, when to use regular expressions instead, how multiline matching works, and what common mistakes to avoid with newline characters and spacing.

In Ruby, a substring is just a smaller string that appears inside a larger string. If you want to know whether a string contains another string exactly, the most direct tool is:

big_string.include?(small_string)

This returns:

• true if the substring exists
• false if it does not

This matters because substring checks are common in real programs:

• searching logs
• validating file contents
• parsing generated output
• checking API responses
• detecting commands or patterns in text

In your case, the main idea is that Ruby treats a multiline string as a normal string containing newline characters (\n). That means you can search for a block of text across multiple lines the same way you search for a single word, as long as the text matches exactly.

If you need exact text matching, use include?.

If you need pattern matching such as flexible spacing, optional text, or wildcards, use a regular expression with match? or =~.

Think of a string like one long strip of paper.

Even if it looks like multiple lines on the screen, Ruby still sees it as a sequence of characters:

• letters
• symbols
• spaces
• newline characters

Checking for a substring is like asking:

Does this smaller strip of paper appear somewhere inside the larger strip, character for character?

If every character matches in the same order, including \n, Ruby returns true.

If even one newline, space, or character is different, the match fails.

Basic syntax

string.include?(substring)

Simple example

message = "Hello Ruby world"
puts message.include?("Ruby")
# true

puts message.include?("Python")
# false

include? checks for an exact substring.

Multiline example

var_message = \
  "hi/thsid/sdfhsjdf/dfjsd/sdjfsdn\n" \
  "/my/name/is/balaji.so\n" \
  "call::myFunction(int const&)\n" \
  "void::secondFunction(char const&)\n" \
  "this/is/last/line/library.so"

target = \
  "hi/thsid/sdfhsjdf/dfjsd/sdjfsdn\n" \
  "/my/name/is/balaji.so\n" \
  "call::myFunction(int const&)\n"

puts var_message.include?(target)
# true

Because the first three lines appear exactly in var_message, Ruby returns true.

Using a heredoc for readability

For multiline text, heredocs are often easier to read:

Example

text = "apple\nbanana\ncarrot\n"
part = "banana\ncarrot\n"

puts text.include?(part)

Step-by-step

1. text stores one string:

   apple\nbanana\ncarrot\n
   

2. part stores another string:

   banana\ncarrot\n
   

3. Ruby checks whether the exact characters from part appear somewhere inside text.

4. It compares character sequences, including newline characters.

5. It finds this exact section inside text:

   banana\ncarrot\n
   

6. include? returns true.

What if one newline is missing?

Where this is used

• Log scanning: check whether a log contains a known error block
• API testing: verify that a response body contains expected text
• Code generation tools: confirm generated output includes required lines
• File processing: search configuration files for a section
• Security checks: detect dangerous commands or suspicious input
• Build scripts: verify compiler or test output contains expected markers

Example: checking a log snippet

log = File.read("app.log")

if log.include?("ERROR: database connection failed")
  puts "Found database error"
end

Example: checking multiline output

output = <<~TEXT
  Step 1 completed
  Step 2 completed
  Deployment successful
TEXT

expected = <<~TEXT
  Step 2 completed
  Deployment successful
TEXT

puts output.include?(expected)
# true

In real Ruby projects, developers usually choose the substring method based on how strict the match must be.

Common pattern: exact text check

if response.body.include?("success")
  puts "Request worked"
end

Use this when the text must appear exactly.

Common pattern: guard clause

def process_output(text)
  return unless text.include?("call::myFunction")

  puts "Function call found"
end

This avoids extra nesting and exits early when the required text is missing.

Common pattern: file validation

content = File.read("config.txt")
required_block = "start\nvalue=true\nend\n"

raise "Missing config block" unless content.include?(required_block)

Common pattern: regex for flexible matching

if output.match?()
  puts 

1. Forgetting that newlines matter

Broken example:

text = "a\nb\nc\n"
part = "a b c"

puts text.include?(part)
# false

Why it fails:

• text contains newline characters
• part contains spaces instead

Fix:

part = "a\nb\nc"

2. Using == instead of include?

Broken example:

puts text == part

== checks whether both strings are completely identical. It does not check whether one is contained inside the other.

Fix:

puts text.include?(part)

3. Ignoring Windows line endings

Some text uses \r\n instead of \n.

Quick reference

Exact substring check

text.include?(part)

Get position of substring

text.index(part)
# returns integer or nil

Regex check

text.match?(/pattern/)

Multiline strings

text = <<~TEXT
  line1
  line2
TEXT

Important rules

• include? checks exact characters
• Newlines like \n are part of the string
• Spaces must match exactly
• == checks whole-string equality, not containment
• Normalize line endings if text may use \r\n

Useful normalization

text = text.gsub("\r\n", "\n")

If you need a boolean result

• include? returns or

How do I check if a string contains another string in Ruby?

Use include?:

text.include?(part)

It returns true or false.

Can Ruby search for a multiline substring?

Yes. A multiline string is still just a string with newline characters. If the exact sequence appears, include? will return true.

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

• include? checks exact text
• match? checks a regular expression pattern

Use include? unless you need flexible matching.

Why is my substring check failing even though the text looks correct?

Common reasons:

• different newline characters (\n vs \r\n)
• extra spaces
• missing punctuation
• case differences

How can I ignore line ending differences in Ruby?

• Ruby strings — Substring searching depends on understanding how strings store characters and newlines.
• Escape sequences — Sequences like \n and \r\n affect matching.
• String comparison — Useful for understanding include? vs ==.
• Regular expressions in Ruby — Helpful when exact text matching is not enough.
• Heredocs in Ruby — A readable way to write multiline strings.
• File reading in Ruby — Many substring checks happen after loading file contents.
• Nil in Ruby — Important when using methods like index, which may return nil.