| Title | Created | Resolved | |
|---|---|---|---|
| Service Maintenance: Microsoft Exchange | Friday, May 24, 2013 - 10:00pm | Friday, May 24, 2013 - 11:59pm | VIEW |
| Service Maintenance: UCB Files | Friday, May 24, 2013 - 10:00pm | Friday, May 24, 2013 - 11:59pm | VIEW |
| Service Maintenance: Mediasite Classroom Capture | Saturday, May 25, 2013 - 6:00am | Saturday, May 25, 2013 - 6:00pm | VIEW |
| Service Maintenance: Router Upgrade (Network Outages) | Thursday, May 30, 2013 - 6:00am | Thursday, May 30, 2013 - 7:00am | VIEW |
D2L - Understanding Regular Expressions
The Quizzes tool uses regular expressions to give users grading a quiz the ability to evaluate answers for short answer and fill-in-the-blank questions against a set of acceptable values.
A regular expression uses alpha-numeric and special characters, known as meta-characters to create a pattern that describes one or more strings to match when searching a body of text. The regular expression is a template for matching a character pattern in the text you are searching. This helps automate the grading process for course designers for short answer and fill-in-the-blank questions.
*Note: Short answer and fill-in-the-blank questions are the only two question types for which you can use regular expressions.
Using Regular Expressions
To use regular expressions:
- In a short answer (SA) or fill-in-the-blank (FIB) question, select the Regular Expression radio button under Evaluation.
- For short answer questions choose the size of the answer field using the Rows and Columns drop-down menus.
- Type the answer in the Answer field using meta-characters to set the allowable values. If you have multiple blanks in a FIB question type repeat this to fill all Answer fields.
- Click Save (or click Preview, to see the question before it is saved).
Meta-characters and their behavior
| Character | Description | Example |
| \ | Marks the next character as a special character, a literal, a back reference, or an octal escape. |
The sequence '\\' matches "\" and "\(" matches "(". n matches the character n. \n matches a new-line character. |
| ^ | Matches the position at the beginning of the input string. If the RegExp object’s Multi-line property is set, ^ also matches the position following '\n' or '\r'. | ^cat matches strings that begin with cat |
| $ | Matches the position at the end of the input string. If the RegExp object’s Multi-line property is set, $ also matches the position preceding '\n' or '\r'. | cat$ matches any string that ends with cat |
| * |
Matches the preceding character or sub-expression zero or more times. * equals {0,} |
be* matches b or be or beeeeeeeeee zo* matches z and zoo. |
| + |
Matches the preceding character or sub-expression one or more times. + equals {1,}. |
be+ matches be or bee but not b |
| ? |
Matches the preceding character or sub-expression zero or one time. ? equals {0,1} |
abc? matches ab or abc colou?r matches color or colour but not colouur do(es)? matches the do in do or does. |
| ? | When this character immediately follows any of the other quantifiers (*, +, ?, {n}, {n,}, {n,m}), the matching pattern is non-greedy. A non-greedy pattern matches as little of the searched string as possible, whereas the default greedy pattern matches as much of the searched string as possible. | In the string oooo, o+? matches a single o, while o+ matches all os. |
| () | Parentheses create a sub-string or item that you can apply meta-characters to. | a(bee)?t matches at or abeet but not abet |
| {n} | n is a non-negative integer. Matches exactly n times. |
[0-9]{3} matches any three digits o{2} does not match the o in Bob, but matches the two os in food. b{4} matches bbbb |
| {n,} | n is a non-negative integer. Matches at least n times. |
[0-9]{3,} matches any three or more digits o{2,} does not match the "o" in "Bob" and matches all the o's in "foooood". 'o{1,}' is equivalent to 'o+'. 'o{0,}' is equivalent to 'o*'. |
| {n,m} |
m and n are non-negative integers, where n <= m. Matches at least n and at most m times. *Note: You cannot put a space between the comma and the numbers. |
[0-9]{3,5} matches any three, four, or five digits "o{1,3}" matches the first three o's in "fooooood". 'o{0,1}' is equivalent to 'o?'. c{2, 4} matches cc, ccc, cccc |
| . |
Matches any single character except "\n". To match any character including the '\n', use a pattern such as '[\s\S]'. |
cat. matches catT and cat2 but not catty |
| (?!) | Makes the remainder of the regular expression case insensitive. | ca(?i)se matches caSE but not CASE |
| (pattern) |
Matches pattern and captures the match. The captured match can be retrieved from the resulting Matches collection, using the SubMatches collection in VBScript or the $0$9 properties in JScript. To match parentheses characters ( ), use '\(' or '\)'. |
(jam){2} matches jamjam. First group matches jam. |
| (?:pattern) |
Matches pattern but does not capture the match, that is, it is a non-capturing match that is not stored for possible later use. This is useful for combining parts of a pattern with the "or" character (|). |
'industr(?:y|ies) is a more economical expression than 'industry|industries'. |
| (?=pattern) |
Positive lookahead matches the search string at any point where a string matching pattern begins. This is a non-capturing match, that is, the match is not captured for possible later use. Lookaheads do not consume characters, that is, after a match occurs, the search for the next match begins immediately following the last match, not after the characters that comprised the lookahead. |
'Windows (?=95|98|NT|2000)' matches "Windows" in "Windows 2000" but not "Windows" in "Windows 3.1". |
| (?!pattern) |
Negative lookahead matches the search string at any point where a string not matching pattern begins. This is a non-capturing match, that is, the match is not captured for possible later use. Lookaheads do not consume characters, that is, after a match occurs, the search for the next match begins immediately following the last match, not after the characters that comprised the lookahead. |
'Windows (?!95|98|NT|2000)' matches "Windows" in "Windows 3.1" but does not match "Windows" in "Windows 2000". |
| x|y | Matches x or y. |
July (first|1st|1) will match July 1st but not July 2 'z|food' matches "z" or "food". '(z|f)ood' matches "zood" or "food". |
| [xyz] | A character set. Matches any one of the enclosed characters. |
gr[ae]y matches gray or grey '[abc]' matches the 'a' in "plain". |
| [^xyz] | A negative character set. Matches any character not enclosed. |
1[^02] matches 13 or 11 but not 10 or 12 '[^abc]' matches the 'p' in "plain". |
| [a-z] | A range of characters. Matches any character in the specified range. |
[1-9] matches any single digit EXCEPT 0 '[a-z]' matches any lowercase alphabetic character in the range 'a' through 'z'. |
| [^a-z] |
A negative range characters. Matches any character not in the specified range. |
'[^a-z]' matches any character not in the range 'a' through 'z' |
| \b | Matches a word boundary, that is, the position between a word and a space. | 'er\b' matches the 'er' in "never" but not the 'er' in "verb". |
| \B | Matches a nonword boundary. | 'er\B' matches the 'er' in "verb" but not the 'er' in "never". |
| \cx |
Matches the control character indicated by x. The value of x must be in the range of A-Z or a-z. If not, c is assumed to be a literal 'c' character. |
\cM matches a Control-M or carriage return character. |
| \d |
Matches a digit character. Equivalent to [0-9] |
|
| \D |
Matches a non-digit character Equivalent to [^0-9] |
|
| \f |
Matches a form-feed character. Equivalent to \x0c and \cL |
|
| \n |
Matches a new-line character. Equivalent to \x0a and \cJ |
|
| \r |
Matches a carriage return character. Equivalent to \x0d and \cM |
|
| \s | Matches any white space character including space, tab, form-feed, etc. Equivalent to [ \f\n\r\t\v] |
Can be combined in the same way as [\d\s], which matches a character that is a digit or whitespace. |
| \S |
Matches any non-white space character. Equivalent to [^ \f\n\r\t\v] |
|
| \t |
Matches a tab character. Equivalent to \x09 and \cI |
|
| \v |
Matches a vertical tab character. Equivalent to \x0b and \cK |
|
| \w |
Matches any word character including underscore. Equivalent to '[A-Za-z0-9_]' |
|
| \W |
Matches any non-word character. Equivalent to '[^A-Za-z0-9_]' You should only use \D, \W and \S outside character classes. |
|
| \Z | Matches the end of the string the regular expression is applied to. Matches a position, but never matches before line breaks. | .\Z matches k in jol\hok |
| \xn |
Matches n, where n is a hexadecimal escape value. Hexadecimal escape values must be exactly two digits long. Allows ASCII codes to be used in regular expressions. |
'\x41' matches "A". '\x041' is equivalent to '\x04' & "1" |
| \num |
Matches num, where num is a positive integer. A reference back to captured matches. |
'(.)\1' matches two consecutive identical characters |
| \n |
Identifies either an octal escape value or a back-reference. If \n is preceded by at least n captured sub-expressions, n is a back-reference. Otherwise, n is an octal escape value if n is an octal digit (0-7). |
“\11” and “\011” both match a tab character. “\0011” is the equivalent of “1”. |
| \nm |
Identifies either an octal escape value or a back-reference. If \nm is preceded by at least nm captured sub-expressions, nm is a back-reference. If \nm is preceded by at least n captures, n is a back-reference followed by literal m. If neither of the preceding conditions exists, \nm matches octal escape value nm when n and m are octal digits (0-7). |
|
| \nml | Matches octal escape value nml when n is an octal digit (0-3) and m and l are octal digits (0-7). | |
| \un | Matches n, where n is a Unicode character expressed as four hexadecimal digits. | For example, \u00A9 matches the copyright symbol (©). |