String searching (contains, strfind) in MATLAB - Deep Dive

Overview - String searching (contains, strfind)

What is it?

String searching means finding if a smaller piece of text exists inside a bigger text. In MATLAB, functions like contains and strfind help you check if one string is inside another. contains returns true or false, while strfind gives the exact positions where the smaller text appears. This helps you quickly locate or verify text in data.

Why it matters

Without string searching, you would have to read through text manually or write complex code to find words or patterns. This slows down data analysis and makes it hard to automate tasks like filtering or cleaning data. String searching lets you quickly find important information hidden in text, saving time and reducing errors.

Where it fits

Before learning string searching, you should know basic MATLAB syntax and how to work with strings or character arrays. After this, you can learn about pattern matching with regular expressions or text processing for advanced data cleaning and analysis.

Mental Model

Core Idea

String searching is like scanning a long sentence to find if and where a smaller word or phrase appears inside it.

Think of it like...

Imagine looking for a word in a book by flipping through pages and checking each line until you find the word. contains tells you if the word is anywhere in the book, while strfind tells you the exact page and line numbers.

Main String: ┌─────────────────────────────┐
             │  'The quick brown fox'      │
             └─────────────────────────────┘

Search String: 'brown'

contains -> true or false
strfind -> [11] (position where 'brown' starts)

Positions: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Characters: T h e   q u i c k   b  r  o  w  n   f  o  x

Build-Up - 7 Steps

1

Foundation

Understanding MATLAB strings basics

Concept: Learn what strings are in MATLAB and how to create them.

In MATLAB, strings can be created using double quotes, like s = "hello". Older versions use character arrays with single quotes, like s = 'hello'. Strings store text data and can be manipulated with functions.

Result

You can create and store text data in variables to use for searching.

Knowing how to create and store strings is essential before searching inside them.

2

Foundation

Simple string searching with contains

Concept: Use contains to check if one string exists inside another, returning true or false.

Example: s = "hello world"; result = contains(s, "world"); This returns true because "world" is inside s. contains is case-sensitive by default but can be made case-insensitive.

Result

result = true

contains gives a quick yes/no answer, perfect for filtering or conditions.

3

Intermediate

Finding positions with strfind

🤔Before reading on: do you think strfind returns true/false or the exact positions? Commit to your answer.

Concept: strfind returns the starting indices where the search string appears inside the main string.

Example: s = 'abracadabra'; positions = strfind(s, 'abra'); positions will be [1 8] because 'abra' starts at positions 1 and 8. If the substring is not found, strfind returns an empty array [].

Result

positions = [1 8]

Knowing exact positions helps when you want to extract or highlight parts of text.

4

Intermediate

Case sensitivity and options

🤔Before reading on: do you think contains and strfind ignore case by default? Commit to your answer.

Concept: By default, contains and strfind are case-sensitive, but contains supports options to ignore case.

Example: s = "Hello World"; contains(s, "world") % returns false contains(s, "world", 'IgnoreCase', true) % returns true strfind does not have built-in ignore case; you must convert strings to lower or upper case first.

Result

contains with IgnoreCase true returns true; strfind returns empty if cases differ.

Understanding case sensitivity prevents bugs when searching text with mixed capitalization.

5

Intermediate

Searching in string arrays and cell arrays

Concept: You can search for substrings inside arrays of strings or cell arrays of character vectors.

Example: strArray = ["apple", "banana", "cherry"]; result = contains(strArray, "an"); result will be [false true false] because only "banana" contains "an". For cell arrays: cellArray = {'apple', 'banana', 'cherry'}; result = contains(cellArray, 'an'); Works similarly.

Result

Logical array showing which elements contain the substring.

Searching multiple strings at once is useful for filtering or batch processing text data.

6

Advanced

Combining strfind with indexing

🤔Before reading on: do you think you can use strfind results to extract substrings? Commit to your answer.

Concept: Use the positions from strfind to extract or manipulate parts of the string.

Example: s = 'abracadabra'; pos = strfind(s, 'cad'); extracted = s(pos:pos+2); extracted will be 'cad' because it slices the string from the found position. This technique helps to isolate or replace parts of text.

Result

extracted = 'cad'

Using positions to extract text enables precise text manipulation beyond simple searching.

7

Expert

Performance and limitations of contains vs strfind

🤔Before reading on: which do you think is faster for large text, contains or strfind? Commit to your answer.

Concept: contains is optimized for quick yes/no checks and supports options like ignore case, while strfind gives detailed positions but can be slower on large data.

For very large strings or many searches, contains is usually faster and simpler. strfind is more flexible but requires more processing if you only need presence. Also, strfind does not support ignore case directly, so you must preprocess strings. Choosing the right function depends on your exact need.

Result

contains is faster for presence checks; strfind needed for positions but slower.

Knowing performance tradeoffs helps write efficient code for big data or real-time applications.

Under the Hood

MATLAB stores strings as arrays of characters or string objects. contains internally scans the main string for the search substring and returns a logical true if found anywhere. strfind scans the string and records all start indices where the substring matches exactly. contains uses optimized algorithms and supports options like case ignoring, while strfind is a straightforward search returning indices. Both work by comparing characters sequentially but differ in output and flexibility.

Why designed this way?

contains was introduced to provide a simple, fast way to check substring presence with options like case insensitivity. strfind is older and designed to give detailed location info, useful for extraction or replacement. MATLAB kept both to serve different needs: quick checks vs detailed indexing. This separation avoids complexity in one function and allows users to pick the right tool.

┌─────────────┐
│ Main String │
└─────┬───────┘
      │
      ▼
┌─────────────────────────────┐
│ contains: returns true/false │
└─────────────────────────────┘
      │
      ▼
┌─────────────────────────────┐
│ strfind: returns positions   │
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does contains return the positions of the substring? Commit yes or no.

Common Belief: contains returns the exact positions where the substring appears.

Reality: contains only returns true or false indicating presence, not positions.

Why it matters: Using contains when you need positions leads to missing critical information for extraction or highlighting.

Quick: Does strfind ignore case by default? Commit yes or no.

Common Belief: strfind ignores case and finds substrings regardless of capitalization.

Reality: strfind is case-sensitive and will not find substrings if cases differ.

Why it matters: Assuming case insensitivity causes missed matches and bugs in text processing.

Quick: If strfind returns empty, does it mean the substring is definitely not present? Commit yes or no.

Common Belief: An empty result from strfind means the substring is not in the string.

Reality: Yes, empty means no match found, but if the substring is empty, strfind returns all positions, which can be confusing.

Why it matters: Misunderstanding empty results can cause incorrect assumptions about data presence.

Quick: Is contains always faster than strfind? Commit yes or no.

Common Belief: contains is always faster than strfind for any string search.

Reality: contains is faster for presence checks, but strfind can be more efficient if you need positions and handle large data carefully.

Why it matters: Choosing the wrong function for performance needs can slow down applications.

Expert Zone

1

contains supports string arrays and cell arrays seamlessly, but strfind behaves differently with cell arrays, returning cell arrays of positions.

2

Using lower() or upper() to preprocess strings before strfind is a common pattern to simulate case-insensitive search.

3

strfind returns overlapping matches separately, which can be surprising when searching repeated patterns.

When NOT to use

Avoid contains and strfind when you need complex pattern matching like wildcards or regular expressions; use MATLAB's regexp function instead. Also, for very large text data, consider specialized text search tools or databases.

Production Patterns

In real-world MATLAB code, contains is often used for quick filtering of datasets or conditional checks, while strfind is used when extracting or replacing substrings. Combining strfind with logical indexing and string slicing is common in text cleaning pipelines.

Connections

Regular expressions (regexp)

Builds-on

Understanding simple substring search prepares you to use powerful pattern matching with regular expressions for flexible text analysis.

Database LIKE queries

Similar pattern

String searching in MATLAB is conceptually similar to SQL LIKE queries, helping you filter or find data based on text patterns.

Human visual search

Analogous process

Knowing how humans scan text visually helps understand why substring search algorithms scan character by character.

Common Pitfalls

#1 Assuming contains returns positions of substring.

Wrong approach:

positions = contains('hello world', 'world'); % expecting positions

Correct approach:

found = contains('hello world', 'world'); % returns true/false
positions = strfind('hello world', 'world'); % returns [7]

Root cause:

Confusing the output type of contains with strfind.

#2 Using strfind without handling case sensitivity.

Wrong approach:

positions = strfind('Hello World', 'world'); % returns []

Correct approach:

positions = strfind(lower('Hello World'), lower('world')); % returns [7]

Root cause:

Not realizing strfind is case-sensitive and needs preprocessing.

#3 Using strfind on cell arrays expecting a numeric array.

Wrong approach:

positions = strfind({'apple', 'banana'}, 'an'); % expecting numeric array

Correct approach:

positions = strfind({'apple', 'banana'}, 'an'); % returns cell array {[ ] [2]}

Root cause:

Not understanding strfind returns cell arrays for cell input.

Key Takeaways

String searching helps find if and where smaller text appears inside bigger text.

contains returns a simple true or false, while strfind returns exact positions of matches.

Both functions are case-sensitive by default; use options or preprocessing for case-insensitive search.

Choosing between contains and strfind depends on whether you need presence or position information.

Understanding these tools is essential for efficient text analysis and data cleaning in MATLAB.