Pega 7 String manipulation can be implemented in data transforms and activities with expressions and library functions. The functions can be called called from within expressions. For this post, Pega 7.1.9 was used.
Summary
- Sample Data Transform and Debugging
- Examples of Pega 7 String Manipulation with Expressions and Functions
-
- Conversion to Upper- and Lower Case
- Extraction of Substrings
- String Comparison
- Substring Search
- Substring Replace
- String to Number Conversions
Related Posts
- Iterating over a Page List in Pega 7 Data Transform
- Sort Pega 7 Dropdown Options with a Data Transform
- Group Pega 7 Dropdown Options by Property
- Configure a Pega 7 Auto-Complete Control Backed by Data Table
- Example of Cascading Drop Downs in Pega 7
1 Sample Data Transform and Debugging
- For this example, a data transform with
7
input parameters was created:
- On the Definition tab, the Set action is used to assign new values to the parameters using expressions. Here,
Param.fullName
is set using concatenation and conversion to upper case.
- Use the gear icon at the end of each step row to open the Expression Builder.
- The data transform can be run by clicking on Actions > Run.
- Use the Trace button to start the Tracer. This allows to view the transformed input parameter values.
- The data transform’s execution page can be viewed by clicking on the FIRST row in the Tracer (…execution page state after running the data transform).
- Click on the
=unnamed=
link in the Parameter Page Name row to open the parameter page.
- Here, the parameter page shows the data transform’s parameters AFTER execution is completed.
2 Examples of Pega 7 String Manipulation with Expressions and Functions
- The Pega 7 String Library functions use the methods of the java.lang.String class. But, NOT ALL methods of java.lang.String are included in the Pega 7 String library.
A: Conversion to Upper- and Lower Case
- Changing the case of a String is straightforward. Here, a single input String is converted to upper case.
@String.toUpperCase(Param.firstName)

"ULYSSES"
- Likewise, a method exists for changing the case of a single input String to lower case.
@String.toLowerCase("Ulysses S. Grant")

"ulysses s. grant"
- The
+
operator can be used for concatenating multiple parameters to one input parameter:
@String.toLowerCase(Param.firstName + " " + Param.middleName + ". " + Param.lastName)

"ulysses s. grant"
B: Extraction of Substrings
- There are two overloaded
@String.substring
methods (same name, different input parameters) that can be used to extract a substring from a given string. The first one has 3 input parameters, the string (zero indexed) and a start-(inclusive) and end index (exclusive) and uses to the Java method substring(int beginIndex, int endIndex).
@String.substring("304-678-9185 EXT 776", 0, 12)

"304-678-9185"
- To extract the last 4 digits of the phone number:
@String.substring("304-678-9185 EXT 776", 8, 12)

"9185"
- The second substring method only has 2 input parameters, the string and the start index.
- To extract the extension in this example, use:
@String.substring("304-678-9185 EXT 776", 17)

"776"
- The result of a function can be passed as an input parameter to another function. Here, the 10-digit phone number is extracted first. Then, the area code is extracted:
@String.substring(@String.substring("304-678-9185 EXT 776", 0, 12), 0, 3)

"304"
@String.length
is used to obtain the length of a given string, i.e. the number of characters:
@String.length("Blueberry")

9
C: Comparison
@String.equalsIgnoreCase
is used to compare two Strings (case-insensitive). For example:
@String.equalsIgnoreCase(Param.firstName, Param.lastName)

false
@String.notEqualsIgnoreCase
is used to compare two Strings for INEQUALITY. For example:
@String.notEqualsIgnoreCase(Param.firstName, Param.lastName)

true
@String.equals
is used for CASE-SENSITIVE comparison:
@String.equals("Blue", "blue")

false
@String.notEquals
is used for CASE-SENSITIVE comparison for INEQUALITY:
@String.notEquals("Blue", "blue")

true
D: Substring Search
@String.contains
is used to search for the occurrence of a given substring within a string:- Here,
Param.street
is"Oak Hill Dr"
and the method is used to check if it contains"Hill"
.
@String.contains(Param.street, "Hill")

true
@String.pxContainsViaRegex
is used to search for the occurrence of a given substring within a string using a regular expression. For details on regular expressions, see the java.util.regex.Pattern class documentation.- In this example, a regular expression,
\d{3}-\d{3}-\d{4}
, is used to search for 10-digit phone numbers in a given String. Note that the\
character needs to be escaped as per Java syntax, using\\
.
@String.pxContainsViaRegex("phone=345-444-0001|name=smith", "\\d{3}-\\d{3}-\\d{4}", true)

true
@String.startsWith
is used to check if a string starts with a given substring.@String.endsWith
is used to check if a string ends with a given substring:
@String.endsWith(Param.street, "Dr")

true
@String.indexOf
can be used to get the start index of a substring within a given String.
@String.indexOf(Param.street, "Hill")

4
- If the given substring is NOT found,
@String.indexOf
returns-1
, for example:
@String.indexOf("Oak Hill Dr", "Blvd")

-1
@String.indexOf
is often used with@String.substring
.- For example,
Param.inputRow
is"Name=Warren"
. To extract the actual name:
@String.substring(Param.inputRow, @String.indexOf(Param.inputRow, "=") + 1)

"Warren"
E: Substring Replace
@String.replaceAll
is used to replace all occurrences of a given string with another string.- In this example, all of the hyphen characters are replaced with pipe characters:
@String.replaceAll("apple-banana-cherry-date", "-", "|")

"apple|banana|cherry|date"
@String.pxReplaceAllViaRegex
is used to replace all substrings that match the given regular expression. For details on regular expressions, see the java.util.regex.Pattern class documentation.- For example, to replace all 10-digit phone numbers in a String with
XXX-XXX-XXXX
:
@String.pxReplaceAllViaRegex(
"Mr.Smith's work phone number is 675-999-0017 and his cell phone is 778-000-9999.",
"\\d{3}-\\d{3}-\\d{4}",
"XXX-XXX-XXXX")

"Mr.Smith's work phone number is XXX-XXX-XXXX and his cell phone is XXX-XXX-XXXX."
F: String to Number Conversions
@String.isInteger
is used to validate that a given String represents a number of type Integer:
@String.isInteger("178")

true
@String.isDouble
is used to validate that a given String represents a number of type Double:
@String.isDouble("199.49")

true
- Strings that represent Integer and Double type numbers can be converted to
Integer
andBigDecimal
Java types:
@String.toInt("149")

149
- If the String does not contain a valid Integer value, the function returns
0
.
@String.toInt("99.99")

0
@String.toDecimal
supports thousands separators and a decimal point:
@String.toDecimal("1,250,599.39")

1250599.39
One thought on “Pega 7 String Manipulation with Expressions and Functions”