IOS Nspredicate and regular expressions

Description: Cocoa provides nspredicate for specifying filtering criteria, which is a function that represents the calculation of true and false values in a computer, which is used somewhat like a SQL query condition, primarily for sorting out eligible objects from a collection, or for regular matching of strings.

Definitions (most commonly used methods):

1. Nspredicate *ca = [nspredicate predicatewithformat: (NSString *), ...];

Format:
(1) comparison operator >,<,==,>=,<=,!=
Available for numeric and string
Example: @ "number > 100"


(2) Scope operator: in, between
Example: @ "number between {1,5}"
@ "address in {' Shanghai ', ' Beijing '}"


(3) string itself: Self
Example: @ "self = = ' APPLE '"


(4) String correlation: Beginswith, ENDSWITH, CONTAINS
Example: @ "name CONTAIN[CD] ' ang '"//contains a string
@ "name Beginswith[c] ' sh '"//start with a string
@ "name Endswith[d] ' ang '"//End with a string
Note: [c] case insensitive [d] does not distinguish between pronounced symbols and no accent marks [CD] are neither case sensitive nor pronounced.


(5) wildcard character: like
Example: @ "name LIKE[CD] ' *er* '"//* represents a wildcard, like also accepts [CD].
@ "name LIKE[CD] '??? Er* ' "

(6) Regular expression: MATCHES
Example: NSString *regex = @ "^a.+e$"; Start with a, E end
@ "Name MATCHES%@", regex

predicates and regular expressions

Prior to iOS4.0, developers were typically implemented through predicates (Nspredicate) and third-party libraries (such as: Regexkitlite) that joined regular expressions. In fact, starting from the iOS4.0 system has natively supported the use of regular expressions, the system through its own class nsregularexpression and nstextcheckingresult to achieve the creation and screening of regular expressions. In the form verification, we often use the regular, because we need to use it to determine whether the characters entered by the user is legitimate, if it is not legal, then the user should be prompted to enter an error, not to submit to the server. We can also filter from the user input string and get the specific part we want through regular expressions. In a word, regular expressions are very powerful.

Method one, predicate (nspredicate) creates a regular expression

Use it to determine whether a user-entered string is legitimate:

 @ "^[a-z0-9a-z]*$";  An expression that creates a predicate object and sets the condition nspredicate *predicate = [nspredicate predicatewithformat:@ "SelfMATCHES%@", regex];  @ "Hello100";  the string is judged if ([predicate evaluatewithobject:str]) {NSLog (@ "Match");}     

The string Hello100 is rule-compliant, so this example will "match" in the log output. If we replace "Hello100" with other characters (for example, "-, ="), the above example will not output anything.

Method Two, the Nsregularexpression class creates the regular expression

In the preface it is also said that we can use the regular to filter and get the specific parts we want, the implementation method is very simple, you can use the Nsregularexpression this class implementation:

NSString *url =@"[email protected] "; Nserror *error;//Create a Nsregularexpression object and specify the regular expression nsregularexpression *regex = [nsregularexpression       Regularexpressionwithpattern:@"[^@]*\\."      Options0      error:&error];if (!error) {//If there are no errors //Get the range of a specific stringNstextcheckingresult *match = [Regex firstmatchinstring:url            Options0             Range:nsmakerange (0, [url length]) ];  if (match) {  // intercept specific strings   NSString *result = [url SubstringWithRange:match.range];   NSLog (@ "%@", result); }} else {// If there is an error, print out the error  NSLog (@ "error-%@", error);}      

This example is retrieved from the string with "@" beginning with "." End of the interval string, the last retrieved string end includes ".", so this example finally outputs the result "QQ."

Method Three, the Nsregularexpression class to fetch multiple results

When a string has more than one character that matches a particular rule, we can get the characters that match a specific rule, respectively:

NSString*regex =@ "\\-\\d*\\."*str = @ " -34023242.-34203020."; Nserror *ERROR; Nsregularexpression *regular = [nsregularexpression Regularexpressionwithpattern:regex Options:nsregularexpressioncaseinsensitive error:&error]; //str string matching nsarray *matches = [regular Matchesinstring:str options:< Span class= "number" >0 Range:nsmakerange (0, str.length)]; Traverse each record after matching for (nstextcheckingresult *match in matches) {Nsrange Range = [Match range]; NSString *mstr = [str substringwithrange:range]; NSLog (@ "%@  

Gets the "-" beginning with "." from the specified string. At the end of the character, because there may be multiple strings that match a particular rule, so we need to iterate over them, and the output is as follows:

[1748:467,732]-34023242. [

Method four, using rangeofstring:option: Direct search

NSString *searchText = @ "// Do any additional setup after loading the view, typically from a nib." ;  NSRange range = [searchText rangeOfString:@ "(?:[^,])*\\." options:NSRegularExpressionSearch];  if (range.location != NSNotFound) {       NSLog(@ "%@" , [searchText substringWithRange:range]);  }

The set nsregularexpressionsearch in options means that a regular expression match is used to return the position of the first matching result.

Summary: In general, to determine whether the user input characters are legitimate, only need to use the method one. If you need to capture the specific content of user input, you can use method two or method three, if it is possible to have multiple capture results, then you can use method three, otherwise use method two, if you want to retrieve and get the part we want, you can also use method four, method four is more concise, but only the first match results.

Finally, enclose some meta-characters of the regular expression:

Metacharacters	Describe
\	Marks the next character as a special character, or a literal character, or a backward reference, or an octal escape. For example, "\\n" matches \ n. "\ n" matches the line break. The sequence "\ \" matches "\" and "\ (" Matches "(".
^	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 0 or more times (greater than or equal to 0 times). For example, zo* can match "Z", "Zo" and "Zoo". * Equivalent to {0,}.
+	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)	Matches pattern but does not get a matching result, which means that this is a non-fetch match 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)	Positive pre-check to match the find string at the beginning of any string matching pattern. This is a non-fetch match, which means that the match does not need to be acquired 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	Forward negation, matching the lookup string at the beginning of any mismatched pattern string. This is a non-fetch match, which means that the match does not need to be acquired for later use. For example, "Windows (?! 95|98| nt|2000) "Can match" windows "in" Windows3.1 ", but does not match" windows "in" Windows2000 ".
(? <=pattern)	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)	Reverse negation is similar to positive negative pre-checking, except in the opposite direction. For example "(? <!95|98| nt|2000) Windows can match "Windows" in 3.1Windows, but not "windows" in "2000Windows".
X|y	Match x or Y. For example, "Z|food" can match "Z" or "food". "(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	Matches a word boundary, which is the position between a word and a space. 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].
\d	Matches a non-numeric character. equivalent to [^0-9].
\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 whitespace character, including spaces, tabs, page breaks, and so on. equivalent to [\f\n\r\t\v].
\s	Matches any non-whitespace 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. Equivalent to "[a-za-z0-9_]".
\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;).
\< \>	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 group, and the character that matches the expression is saved to a staging area (up to 9 in a regular expression), which can be referenced by a \1 to \9 symbol.
|	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

IOS Nspredicate and regular expressions