Indraft This page is for anyone writing expressions in which you need to match string patterns.

Overview

When you are writing Jep expressions you may need to find patterns within strings or arrays. To do this, you can add a regular expression (commonly abbreviated to regexp) as an argument to your Jep expression. Some functions that take a regexp as an argument are replaceAll , replaceFirst and matches.

If you are unfamiliar with regexps, there are many resources on the internet that can get you started, such as:

This page provides information and examples of common uses of regular expressions in PhixFlow. Tables showing regexp constructs and what they match are at the end of the page.

Key Things to Know

When using a regexp in a PhixFlow expression,

strings must be contained inside quotes, for example "match this text", except:
- in PhixFlow variables that contain strings,
- in functions that return strings.
two backslashes: \\

Examples

Finding Barcodes

A bigstring of text contains barcodes that need to be replaced with something else. Every barcode has a different number, but barcodes have the same pattern. An example barcode is the string ##167891546325##. We can’t match an exact sequence as every barcode is different. However we can use a regular expression to match the pattern.

replaceAll(listToCheck, “##” + “[0-9]{12}” + “##”, “barcode discontinued”)

The regular expression “##” + “[0-9]{12}” + “##” matches the pattern of:

two hashes
followed by 12 numbers
followed by two hashes.

Finally, Jep expression replaceAll() replaces any matches to the text barcode discontinued.

Sections on this page

Finding File Names

Regexp	Purpose
`"inputFile_[0-9]{3}\\.txt"`	Match file names with the format: inputFile_NNN.txt e.g. inputFile_034.txt where N are digits.
`"inputFile_[0-9]{3}\\.txt"`	Match file names with the format: inputFile_NNN.txt eg. inputFile_034.txt where N are digits.
`"inputFile_" + $fileSeq + "\\.txt"`	Match file names with the format: inputFile_$fileSeq.txt e.g. inputFile_034.txt where $fileSeq="034"

Rexexp Arguments in Jep Expressions

if(!matches(value,"[\\p{Alnum}\\p{Space}]+"),error('Please only enter alpha numeric characters')

Checks whether any characters are not (!) alphanumeric characters or spaces. If any are not, matches() will evaluate to 1, and the error message will be presented. The + is a greedy quantifier, so it can match more than once. This means value can contain as many alphanumeric characters or spaces as it likes, so long as it does not contain anything else.

$xml = replaceAll($xml, "<sc_tower_torqueing/type><id.*?<name>", "<type>"),
$xml = replaceAll($xml, "</name></sc_tower_torqueing/type>", "</type>"),

The first line matches text with the pattern:

sc_tower_torqueing/type><id.
followed by
- any character, indicated by the wildcard *
- however many times it appears, indicated by ?
followed by the text <name> to finish.

In matching pattern is changed to the text <type>.

The second line matches the exact text </name></sc_tower_torqueing/type> and changes any occurrence to “</type>". As the exact text is known, this does not require a regexp.

Escaping Special Characters

In regular expressions, some characters, called meta-characters, have special meanings, for example quote marks “ mark the the start and endof a string; see Regular expression metacharacters for a full list and their function. To use a meta-character as if it is a normal character, use an escape character so that the regexp can ignore its special meaning.

Use To escape For example

2 backslashes

\\

. () [] {}

* ^ + $ | ?

\\.\\]\\^

3 backslashes

\\\

a backslash \

quote marks "

\\\\

\\\"

For example, the following regexp shows some characters are escaped and some are not.

replaceAll(JSON Code,"[^\\p{Space}0-9A-Za-z!:\\\"%&\\[*()\\],-/_\\\\{}\\.]","")

This regexp checks text to make sure it does not contain any unusual characters by defining a list of allowed characters:

paragraph end marks: \\p
spaces: {Space}
numbers 0-9: 0-9
uppercase or lowercase alphabetic characters: A-Za-z
other characters: ! : % & * ( ) , - / _ { }
special characters, preceded by backslashes to escape them: " [ ] \ .

Characters with special meaning are:

quotes and square brackets: “[ and ]"indicate the start and the end of the string
caret ^ means NOT, so match anything that is NOT in the following list.

This expression ignores any of the allowed characters. If it finds any character not in the list, it replaces them with nothing, indicated by "".

A double backslash \\ can also make an alphanumeric character a construct. For example, \\n means newline; see Finding Characters below. Escaping an alphabetic character that does not form construct causes an error.

For information about escaping characters in PhixFlow expressions and macros, rather than in regexps, see Escaping Characters.

Groups and Capturing

Capturing groups are numbered by counting their opening parentheses from left to right. For example, ((A)(B(C))) contains 4 groups:

1	((A)(B(C)))
2	(A)
3	(B(C))
4	(C)

Group zero always stands for the entire expression.

During a match, each sub-sequence of the input sequence that matches a group is saved. The captured sub-sequence may be used later in the expression, via a back reference. In PhixFlow, a back reference has the format $n, where n is the number of the capturing group; replaceFirst for some examples.

The captured input associated with a group is always the sub-sequence that the group most recently matched. If a group is evaluated a second time because of a quantifier, then any previously captured value is retained if the second evaluation fails. For example, matching the string "aba" against the expression (a(b)?)+ leaves group two set to "b". All captured input is discarded at the beginning of each match.

Groups beginning with (? are pure, non-capturing groups that do not capture text and do not count towards the group total.

Regular Expression Constructs

The following table shows the different characters and what they match.

Construct Characters

Construct	Matches
x	The character x
\\\\	The backslash character
\\/	The forward slash character
\\\"	The double quote character
\\0n	The character with octal value 0n (0 <= n <= 7)
\\0nn	The character with octal value 0nn (0 <= n <= 7)
\\0mnn	The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7)
\\xhh	The character with hexadecimal value 0xhh
\uhhhh	The character with hexadecimal value 0xhhhh
\\t	The tab character ('\u0009')
\\n	The newline (line feed) character ('\u000A')
\\r	The carriage-return character ('\u000D')
\\f	The form-feed character ('\u000C')
\\a	The alert (bell) character ('\u0007')
\\e	The escape character ('\u001B')
\\cx	The control character corresponding to x

Line Terminators

A one- or two-character sequence that marks the end of a line of the input character sequence.

Construct	Indicates
\\n	newline (line feed)
\\r	carriage-return
\\r\\n	carriage-return followed immediately by a newline
\\u0085	next-line
\\u2028	line-separator
\\u2029	paragraph-separator

Character Classes

Construct	Matches
[abc]	a, b, or c (simple class)
[^abc]	Any character except a, b, or c (negation)
[a-zA-Z]	a through z or A through Z, inclusive (range)
[a-d[m-p]]	a through d, or m through p: [a-dm-p] (union)
[a-z&&[def]]	d, e, or f (intersection)
[a-z&&[^bc]]	a through z, except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]]	a through z, and not m through p: [a-lq-z](subtraction)

Predefined Character Classes

Construct	Matches
`.`	Any character This may or may not match line terminators
\\d	A digit: [0-9]
\\D	A non-digit: [^0-9]
\\s	A whitespace character: [ \\t\\n\\x0B\\f\\r]
\\S	A non-whitespace character: [^\\s]
\\w	A word character: [a-zA-Z_0-9]
\\W	A non-word character: [^\\w]

POSIX Character Classes (US-ASCII only)

Construct	Matches
\\p{Lower}	A lower-case alphabetic character: [a-z]
\\p{Upper}	An upper-case alphabetic character:[A-Z]
\\p{ASCII}	All ASCII:[\\x00-\\x7F]
\\p{Alpha}	An alphabetic character:[\\p{Lower}\\p{Upper}]
\\p{Digit}	A decimal digit: [0-9]
\\p{Alnum}	An alphanumeric character:[\\p{Alpha}\\p{Digit}]
\\p{Punct}	Punctuation: One of !"#$%&'()*+,-./:;<=>?@[\]^_`{\|}~
\\p{Graph}	A visible character: [\\p{Alnum}\\p{Punct}]
\\p{Print}	A printable character: [\\p{Graph}]
\\p{Blank}	A space or a tab: [ \\t]
\\p{Cntrl}	A control character: [\\x00-\\x1F\\x7F]
\\p{XDigit}	A hexadecimal digit: [0-9a-fA-F]
\\p{Space}	A whitespace character: [ \\t\\n\\x0B\\f\\r]

Back References

Construct	Matches
$n	Whatever the n^thcapturing group matched; see Groups and Capturing, above.

Classes for Unicode Blocks and Categories

Construct	Matches
\\p{InGreek}	A character in the Greek block (simple block)
\\p{Lu}	An uppercase letter (simple category)
\\p{Sc}	A currency symbol
\\P{InGreek}	Any character except one in the Greek block (negation)
[\\p{L}&&[^\\p{Lu}]]	Any letter except an uppercase letter (subtraction)

Boundaries

Construct	Matches
^	The beginning of a line
$	The end of a line
\\b	A word boundary
\\B	A non-word boundary
\\A	The beginning of the input
\\G	The end of the previous match
\\Z	The end of the input but for the final, if any
\\z	The end of the input

Quantifiers

Construct			Matches
Greedy longest possible match	Reluctant (lazy) shortest possible match	Possessive
X?	X??	X?+	X, once or not at all
X*	X*?	X*+	X, zero or more times
X+	X+?	X++	X, one or more times
X{n}	X{n}?	X{n}+	X, exactly n times
X{n,}	X{n,}?	X{n,}+	X, at least n times
X{n,m}	X{n,m}?	X{n,m}+	X, at least n but not more than m times

Logical Operators

Construct	Matches
XY	X followed by Y
X\|Y	Either X or Y
(X)	X, as a capturing group; see Groups and Capturing, above.

Special Constructs (Non-capturing)

Construct	Matches
(?:X)	X, as a non-capturing group
(?idmsux-idmsux)	Nothing, but turns match flags on - off
(?idmsux-idmsux:X)	X, as a non-capturing group with the given flags on - off; see Groups and Capturing, above.
(?=X)	X, via zero-width positive lookahead
(?!X)	X, via zero-width negative lookahead
(?<=X)	X, via zero-width positive lookbehind
(?<!X)	X, via zero-width negative lookbehind
(?>X)	X, as an independent, non-capturing group

Quotation

Construct	Matches
\\	Nothing, but quotes the following character
\\Q	Nothing, but quotes all characters until \\E
\\E	Nothing, but ends quoting started by \\Q

RexExp2