Using Patterns in SenseTalk

The SenseTalk pattern language lets you search for patterns within a source text with SenseTalk's natural language syntax. For a general description of the pattern language, see SenseTalk Pattern Language Basics. For complete information about how to define patterns, see Elements of the SenseTalk Pattern Language.

Below you will find information for how to use patterns in SenseTalk scripts.

Operators, Commands, and Functions for Pattern Matching

Patterns are supported by all SenseTalk operators that look for the presence or location of some specified text within a larger string, as well as commands and functions that work with text:

You can use any of the following operators, command, and functions with the pattern language:

• contains operator
• is in operator
• begins with operator
• ends with operator
• offset, range, every offset, every range functions
• replace command
• delete command
• split command, split by function
• number of occurrences of function

In addition, there are operators and functions specific for use with patterns.

Matches Operator

Use the matches operator to test whether a variable or expression is an exact match for a pattern. One of the operands must be a pattern, and the other is treated as a string value. This operator returns true if the pattern fully matches the entire string. If the pattern matches only part of the string or doesn't match at all, the result of the matches operator is false.

Example:

Note that the matches operator returns true if the pattern can potentially match the full value, even if the usual match of the pattern might not return the full string (due to lazy quantifiers being used):

For information about lazy and greedy matches as well as quantifiers, see Elements of the SenseTalk Pattern Language.

Match and Every Match Functions

Use the match and every match functions to locate a pattern within text. The match function finds the first occurrence of the specified pattern, and every match finds every occurrence of the pattern in the source.

When the match function finds a match for a pattern, it returns a match property list containing a number of properties, depending on the pattern. For a basic pattern, the property list includes text, which is the matched text, and text_range, which is the range where that text was found.

The every match function returns a list of property lists, where each property list includes the same information as the match function.

Example:

For detailed information about these functions, see Pattern Matching Functions.

Occurrence and Every Occurrence Functions

Use the occurrence and every occurrence functions to return the matched text for a defined pattern. The occurrence function returns the first match found, and every occurrence returns a list of every match found in the source text.

For detailed information about these functions, see Pattern Matching Functions.

Using Variables and Expressions in a Pattern

When you define a pattern, you can use any of the elements described in Pattern Elements. However, sometimes a pattern must include elements that vary from one use to the next.

For example, consider a simple date pattern that matches dates in the form 15-Aug-2018. The following pattern finds such dates:

But suppose you don't want to find every date, but only those in a particular month, which will be determined elsewhere in the script. In this case, you can use a variable in place of that element in the pattern. The pattern is constructed using the variable's value at runtime:

The value of the variable month is substituted in the pattern so only dates in October are valid matches for the pattern.

Here is a similar example that sets the month variable to the name of the current month by using the monthName() function:

You can also use an expression directly in a pattern, so the example above could be done like this:

More complex expressions involving operators must be enclosed in parentheses. To find dates in the current month from the previous year, this pattern could be used:

Embedded Patterns

In addition to variables that insert a specific string into the pattern (e.g., "Oct"), you can use pattern definitions in variables. This ability lets you embed patterns within larger pattern definitions. This technique is useful for constructing complex patterns, which can be built up in manageable pieces.

For example, you might need a pattern to find US phone numbers. A phone number in the US consists of a 3-digit area code and a 7-digit number (broken up into groups of 3 and 4 digits). The area code is optional within the local area, and there are several common ways of separating the groups of digits.

For this example, we'll construct a pattern that can match phone numbers like any of these:

Let's break it down into pieces, starting with the different ways the area code might appear:

We want to allow for either of these options, so we use or to construct our areaCode pattern:

Finally, we define the localNumber pattern and put it all together:

This approach results in code that is more readable and understandable than if we were to define the entire pattern at once, which would have looked like this:

 

This topic was last updated on August 19, 2021, at 03:30:51 PM.

Eggplantsoftware.com | Documentation Home | User Forums | Support | Copyright © 2022 Eggplant