iOS Regular Expression nsregularexpression

Sometimes we may want to extract the data we want from our web pages, and we can usually use regular expressions (nsregularexpression), Scanners (Nsscanner) to parse them.

When using regular expressions, if you need to parse the HTML Web page source code, using Nsregularexpression matchesinstring method parsing may only return a result, this is caused by encountering a newline character, at this time only need to replace the. [\\s\\S], The parentheses mean to take out the part that matches the middle bracket, and the Nsrange value will be returned in the result. The returned result (Nstextcheckingresult array), each element is recorded to the entire pattern match to the information, and each pattern of parentheses to take the element is saved by each Nstextcheckingresult object, Rangeatindex (i) where i=0, the range to which the entire pattern is matched, i=1 the contents of the first parenthesis within the pattern, and so on.

1Let path = Nsbundle.mainbundle (). Pathforresource ("temp.string", Oftype:nil)2var Source =Try? String (contentsoffile:path!, encoding:nsutf8stringencoding)3Let pattern ="<table ([\\s\\s]*?) </table>"4Let RegularExpression =Try?nsregularexpression (Pattern:pattern, Options: [])5Let results = regularexpression!. Matchesinstring (source!, Options: [], Range:nsrange (location:0, Length: (source!. Characters.count )))6 7  forResultinchResults {8Let range = Result.rangeatindex (1)9Let resultstring = (source! asnsstring). Substringwithrange (range)Ten print (resultstring) One}

Schedule: Regular expression rules (Baidu Encyclopedia)

Metacharacters	Describe
\	The next character marker, or a backward reference, or an octal escape character. For example, "\\n" matches \ n. "\ n" matches the line break. The sequence "\ \" matches "\" and "\ (" Matches "(". is equivalent to the concept of "escape character" in many programming languages.
^	Matches the starting position of the input string. If the multiline property of the RegExp object is set, ^ also matches the position after "\ n" or "\ r".
$	Matches the end position of the input string. If the multiline property of the RegExp object is set, $ also matches the position before "\ n" or "\ r".
*	Matches the preceding sub-expression any time. For example, zo* can match "Z" and also match "Zo" and "Zoo".
+	Matches the preceding subexpression one or more times (greater than or equal to 1 times). For example, "zo+" can Match "Zo" and "Zoo", but not "Z". + equivalent to {1,}.
?	Matches the preceding subexpression 0 or one time. For example, "Do (es)?" You can match "do" in "do" or "does".?
N	N is a non-negative integer. Matches the determined n times. For example, "o{2}" cannot match "O" in "Bob", but can match two o in "food".
{N,}	N is a non-negative integer. Match at least n times. For example, "o{2,}" cannot match "O" in "Bob", but can match all o in "Foooood". "O{1,}" is equivalent to "o+". "O{0,}" is equivalent to "o*".
{N,m}	Both M and n are non-negative integers, where n<=m. Matches at least n times and matches up to M times. For example, "o{1,3}" will match the first three o in "Fooooood". "o{0,1}" is equivalent to "O?". Note that there can be no spaces between a comma and two numbers.
?	When the character immediately follows any other restriction (*,+,?,{n},{n,},{n,m}), the matching pattern is non-greedy. The non-greedy pattern matches the searched string as little as possible, while the default greedy pattern matches as many of the searched strings as possible. For example, for the string "Oooo", "o+?" A single "O" will be matched, and "o+" will match all "O".
. Point	Matches any single character except for "\ r \ n". To match any character that includes "\ r \ n", use a pattern like "[\s\s]".
(pattern)	Match pattern and get this match. The obtained matches can be obtained from the resulting matches collection, the Submatches collection is used in VBScript, and the $0...$9 property is used in JScript. To match the parentheses character, use "\ (" or "\").
(?:p Attern)	A non-fetch match that matches pattern but does not get a matching result and is not stored for later use. This is used in the or character "(|)" It is useful to combine the various parts of a pattern. For example, "Industr (?: y|ies)" is a more abbreviated expression than "industry|industries".
(? =pattern)	A non-fetch match, positive pre-check, matches the lookup string at the beginning of any string that matches the pattern, and the match does not need to be fetched for later use. For example, "Windows (? =95|98| nt|2000) "Can match" windows "in" Windows2000 ", but does not match" windows "in" Windows3.1 ". Pre-checking does not consume characters, that is, after a match occurs, the next matching search starts immediately after the last match, rather than starting with the character that contains the pre-check.
(?! Pattern	A non-fetch match, positive negation pre-check, matches the lookup string at the beginning of any mismatched pattern string, and the match does not need to be fetched for later use. For example, "Windows (?! 95|98| nt|2000) "Can match" windows "in" Windows3.1 ", but does not match" windows "in" Windows2000 ".
(? <=pattern)	Non-acquisition match, reverse positive pre-check, similar to positive pre-check, just the opposite direction. For example, "(? <=95|98| nt|2000) Windows can match "Windows" in 2000Windows, but not "windows" in "3.1Windows".
(? <!pattern)	Non-acquisition matching, reverse negation pre-check, similar to positive negative pre-check, just opposite direction. For example "(? <!95|98| nt|2000) Windows can match "Windows" in 3.1Windows, but not "windows" in "2000Windows". This place is not correct, there is a problem here or any item can not exceed 2 bits, such as "(? <!95|98| NT|20) Windows is correct, "(? <!95|980| NT|20) Windows error, if used alone there is no limit, such as (? <!2000) Windows correctly match
X|y	Match x or Y. For example, "Z|food" can match "Z" or "food" (please be cautious here). "(z|f) Ood" matches "Zood" or "food".
[XYZ]	The character set is combined. Matches any one of the characters contained. For example, "[ABC]" can Match "a" in "plain".
[^XYZ]	Negative character set. Matches any character that is not contained. For example, "[^ABC]" can match "Plin" in "plain".
[A-z]	The character range. Matches any character within the specified range. For example, "[A-z]" can match any lowercase alphabetic character in the range "a" to "Z". Note: The range of characters can be represented only if the hyphen is inside a character group and appears between two characters; If the beginning of the character group is out, only the hyphen itself can be represented.
[^a-z]	A negative character range. Matches any character that is not in the specified range. For example, "[^a-z]" can match any character that is not in the range "a" to "Z".
\b	Match a word boundary, that is, the position between the word and the space (that is, the "match" of the regular expression has two concepts, one is the match character, the other is the match position, here the \b is the match position). For example, "er\b" can Match "er" in "never", but cannot match "er" in "verb".
\b	Matches a non-word boundary. "er\b" can Match "er" in "verb", but cannot match "er" in "Never".
\cx	Matches the control character indicated by X. For example, \cm matches a control-m or carriage return. The value of x must be one of a-Z or a-Z. Otherwise, c is considered to be a literal "C" character.
\d	Matches a numeric character. equivalent to [0-9]. grep to add-p,perl regular support
\d	Matches a non-numeric character. equivalent to [^0-9]. grep to add-pperl regular support
\f	Matches a page break. Equivalent to \x0c and \CL.
\ n	Matches a line break. Equivalent to \x0a and \CJ.
\ r	Matches a carriage return character. Equivalent to \x0d and \cm.
\s	Matches any invisible character, including spaces, tabs, page breaks, and so on. equivalent to [\f\n\r\t\v].
\s	matches any visible character. equivalent to [^ \f\n\r\t\v].
\ t	Matches a tab character. Equivalent to \x09 and \ci.
\v	Matches a vertical tab. Equivalent to \x0b and \ck.
\w	Matches any word character that includes an underscore. Similar but not equivalent to "[a-za-z0-9_]", where the "word" character uses the Unicode character set.
\w	Matches any non-word character. Equivalent to "[^a-za-z0-9_]".
\xn	Match N, where n is the hexadecimal escape value. The hexadecimal escape value must be two digits long for a determination. For example, "\x41" matches "A". "\x041" is equivalent to "\x04&1". ASCII encoding can be used in regular expressions.
\num	Matches num, where num is a positive integer. A reference to the obtained match. For example, "(.) \1 "matches two consecutive identical characters.
\ n	Identifies an octal escape value or a backward reference. n is a backward reference if \ n is preceded by at least one of the sub-expressions obtained. Otherwise, if n is the octal number (0-7), N is an octal escape value.
\nm	Identifies an octal escape value or a backward reference. If at least NM has obtained a subexpression before \nm, then NM is a backward reference. If there are at least N fetches before \nm, then n is a backward reference followed by the literal m. If none of the preceding conditions are met, if both N and M are octal digits (0-7), then \nm will match the octal escape value nm.
\nml	If n is an octal number (0-7) and both M and L are octal digits (0-7), the octal escape value NML is matched.
\un	Match N, where N is a Unicode character represented by four hexadecimal digits. For example, \u00a9 matches the copyright symbol (&copy;).
\P{P}	The lowercase p is the property's meaning, which represents the Unicode attribute, which is used for the prefix of the Unicode positive expression. The "P" inside the brackets represents one of the seven character attributes of the Unicode character set: punctuation characters. Other six properties: L: Letters, M: Mark symbols (usually not appearing alone), Z: separators (such as spaces, line breaks, etc.); S: Symbols (such as mathematical symbols, currency symbols, etc.); N: Numbers (such as Arabic numerals, Roman numerals, etc.); C: Other characters. * Note: This syntax is not supported in some languages, for example: JavaScript.
< >	The start (<) and end (>) of the matching word (word). For example, the regular expression <the> can match "the" in the string "for the wise", but cannot match "the" in the string "otherwise". Note: This meta-character is not supported by all software.
( )	The expression between (and) is defined as a group, and the characters that match the expression are saved to a staging area (up to 9 in a regular expression), which can be referenced using \1 to \9 symbols.
|	Perform a logical or (or) operation on the two matching criteria. For example, the regular expression (Him|her) matches "It belongs to him" and "it belongs to her", but does not match "it belongs to them." Note: This meta-character is not supported by all software.
+	Match 1 or more of that character just before it. For example, the regular expression + + matches 9, 99, 999, and so on. Note: This meta-character is not supported by all software.
?	Match 0 or 1 of that character just before it. Note: This meta-character is not supported by all software.
{i} {i,j}	Matches the specified number of characters, which are defined in the expression preceding it. For example, the regular expression a[0-9]{3} can match the character "A" followed by a string of exactly 3 numeric characters, such as A123, A348, etc., but does not match A1234. A regular expression [0-9]{4,6} matches any 4, 5, or 6 consecutive digits

Reference:

1. https://objccn.io/issue-9-4/(String parsing)

Code Environment:

xcode7.3.1 Swift2.2

iOS Regular Expression nsregularexpression