Home
RegExprBuilder integrates regular expressions into the programming language, thereby making them easy to read and maintain. Regular Expressions are created by using chained methods and variables such as arrays or strings.
const builder = new RegExprBuilder();All public methods except getRegExpr() are chain-able.
Alias for then, sounds nicer at the beginning.
builder
.find("Hey, ")
.then("where do you go to get ")
.eitherFind("juice")
.orFind("milk");related: then()
Matches a single occurrence of the string.
builder
.startOfLine()
.then("Where do you go to get ")
.eitherFind("juice")
.orFind("milk");Specifies that there is at least one character and that each character must be one of those contained in the array of strings. Each string in the array must be a single character.
const digits = ["3", "7", "8"];
builder
.some(digits)
.then(".");The same as .some(array), except that there may be no characters at all, rather than at least one.
const digits = ["3", "7", "8"];
builder
.maybeSome(digits);Specifies that the string may or may not occur.
builder
.maybe("milk");Specifies that there is zero or more of any character.
builder
.anything();Specifies that there is zero or more of any character as long as the string of resulting characters does not start with the supplied string.
builder
.anythingBut("milk");Specifies that there is one or more of any character.
builder
.something();Specifies that there is a line break.
builder
.lineBreak();Specifies that there is a line break.
builder
.exactly(2)
.lineBreaks();If used alone, specifies that there is a single whitespace character.
builder
.whitespace();Specifies that there is a single tab.
builder
.tab();Specifies that there is a tab.
builder
.exactly(2)
.tabs();Specifies that there is a single digit.
builder
.digit();Specifies that there is a digit.
builder
.exactly(2)
.digits();Specifies that there is a single letter.
builder
.letter();Specifies that there is a letter.
builder
.exactly(2)
.letters();Specifies that there is a single lowercase letter.
builder
.lowerCaseLetter();Specifies that there is a lowercase letter.
builder
.exactly(2)
.lowerCaseLetters();Specifies that there is a single uppercase letter.
builder
.upperCaseLetter();Specifies that there is an uppercase letter.
builder
.exactly(2)
.upperCaseLetters();Matches the start of input.
builder
.startOfInput()
.min(1)
.of("milk");related: endOfInput()
Matches the start of input or start of a line.
builder
.startOfLine()
.min(1)
.of("milk");related: endOfLine()
Matches the end of input.
builder
.min(1)
.of("milk")
.endOfInput();related: startOfInput()
Matches the end of input or line.
builder
.min(1)
.of("milk")
.endOfLine();related: startOfLine()
Used with or. This method takes a new RegExprBuilder object.
const a = builder.exactly(1).of("milk");
const b = builder.exactly(2).of("juice");
builder
.eitherFind(a)
.orFind(b);related: orFind(RegExprBuilder)
Used after either. Multiple or methods can be chained together. This method takes a new RegExprBuilder object.
const a = builder.exactly(1).of("milk");
const b = builder.exactly(2).of("juice");
builder
.eitherFind(a)
.orFind(b);related: eitherFind(RegExpBuilder)
Used with or. This method takes a string.
builder
.eitherFind("milk")
.orFind("juice");related: orFind(string)
Used after either. Multiple or methods can be chained together. This method takes a string.
builder
.eitherFind("milk")
.orFind("juice");related: eitherFind(string)
Used with nor. This method takes a new RegExprBuilder object.
const a = builder.exactly(1)
.of("milk");
const b = builder.exactly(2)
.of("juice");
builder
.neither(p1)
.nor(p2);related: nor(RegExprBuilder)
Used after neither. Multiple nor methods can be chained together. This method takes a new RegExpBuilder object.
const a = builder.exactly(1)
.of("milk");
const b = builder.exactly(2)
.of("juice");
builder
.neither(p1)
.nor(p2);related: neither(RegExprBuilder)
Used with nor. This method takes a string.
builder
.neither("milk")
.nor("juice");related: nor(string)
Used after neither. Multiple nor methods can be chained together. This method takes a string.
builder
.neither("milk")
.nor("juice");related: neither(string)
Used to specify the exact number of times a pattern will repeat.
builder
.exactly(1)
.of("milk");related: min(number), max(number)
Used to specify the minimum number of times a pattern will repeat. This method can optionally occur before max()
builder
.min(1)
.of("milk");related: max(number)
Used to specify the maximum number of times a pattern will repeat. This method can optionally occur after min()
builder
.max(1)
.of("milk");related: min(number)
Used to match a string.
builder
.exactly(1)
.of("milk");related: from(array), notFrom(array), like(RegExprBuilder)
Match one of multiple strings.
builder
.startOfInput()
.min(2).max(5).letters
.anyOf([".jpg", ".gif", ".png"]);related: from(array), notFrom(array))
Used to match any character.
builder
.exactly(1)
.ofAny();related: anything()
Used to match a previously defined group.
builder
.exactly(3)
.of("milk")
.asGroup()
.exactly(1)
.of("juice")
.exactly(1)
.ofGroup(1);related: asGroup()
Used to match any of the characters contained in the array. It is equivalent to the regular expression [array].
builder
.exactly(3)
.from(["p", "q", "r"]);related: notFrom(array)
Used to match any characters other than those contained in the array. It is equivalent to the regular expression [^array].
builder
.exactly(3)
.notFrom(["p", "q", "r"]);related: from(array)
Used to nest patterns. This method takes a new RegExprBuilder object.
const pattern = builder.
.min(1)
.of("milk")
.min(2)
.of("juice");
builder
.getNew()
.exactly(2)
.like(pattern);Used to specify that the pattern is matched reluctantly. This means that the smallest possible match is found, rather than the largest possible match.
builder
.find("milk")
.anything()
.reluctantly()
.digit();Equivalent to the concept of look-aheads in regular expressions. This method takes a new RegExprBuilder object.
const pattern = builder
.exactly(1)
.of("juice");
builder
.getNew()
.exactly(1)
.of("fruit")
.ahead(pattern);related: notAhead(RegExpBuilder)
Equivalent to the concept of look-aheads in regular expressions. This method takes a new RegExprBuilder object.
const pattern = builder
.exactly(1)
.of("pqr");
builder
.getNew()
.exactly(1)
.of("milk")
.notAhead(pattern);related: ahead(RegExprBuilder)
Equivalent to the concept of capturing groups in regular expressions.
const regExp = builder
.min(1)
.max(3)
.of("p")
.exactly(1)
.of("milk")
.asGroup()
.exactly(1)
.from(["p", "q", "r"])
.getRegExpr();
const matches = regExpr.exec("pmilkq");
matches[1] === "milk"; //truerelated: ofGroup(number)
Used before calling getRegExp() to ensure that the regular expression ignores case.
builder
.min(1)
.max(3)
.of("Milk")
.ignoreCase()
.getRegExpr();Used before calling getRegExpr() to set multiline on the regular expression. Normally when start() or end() are called, they refer to the start or end of the input. When multiLine() is called, they refer to the start or end of a line instead.
builderA
.startOfLine()
.min(1)
.of("milk");
builderB
.min(1)
.like($builderA)
.multiLine()
.getRegExpr();Once you have finished building your regular expression, getRegExpr() should be called to get the actual RegExpr object.
const regExp = builder
.min(1)
.of("milk")
.multiLine()
.getRegExpr();
regExp.matches("milk"); //trueUsed to append patterns to the end of an existing pattern.
const a = builder
.min(1)
.of("fruit");
const b = builder
.min(2)
.of("juice");
a.append(b);The regular expression in the example below suggests that p1 must occur once, and then p2 might occur once.
const a = builder
.min(1)
.of("milk");
const b = builder
.min(2)
.of("juice");
a.optional(b);A RegExpr Object is returned by the getRegExpr() method of the builder.
const regExpr = builder.getRegExpr();Test string against current pattern
const regExp = builder
.find("abc")
.getRegExpr();
regExp.matches("abc"); //trueExecute preg_match return matches
const regExp = builder
.find("abc")
.getRegExpr();
const matches = regExp.findIn("abc");alias for findIn()
Replace matches for current pattern
const regExp = builder
.find("abc")
.getRegExpr();
const matches = regExp.replace("abcdef", (match) => match.toUpperCase());
// "ABCdef"