Phát triển web với PHP và MySQL - p 14 pot

Given the functions we have already looked at, we could use explodeor strtokto retrieve the individual words in the message, and then compare them using the ==operator or However, we cou

return a number greater than zero If str1is less than str2,strcmp()will return a number

less than zero This function is case sensitive

The function strcasecmp()is identical except that it is not case sensitive

The function strnatcmp()and its non-case sensitive twin,strnatcasecmp(), were added in

PHP 4 These functions compare strings according to a “natural ordering,” which is more the

way a human would do it For example,strcmp()would order the string “2”as greater than

the string “12”because it is lexicographically greater strnatcmp()would do it the other

way around You can read more about natural ordering at http://www.linuxcare.com.au/

projects/natsort/

Testing String Length with strlen()

We can check the length of a string with the strlen()function If you pass it a string, this

function return its length For example,strlen(“hello”)returns 5

This can be used for validating input data Consider the email address on our form, stored in

$email One basic way of validating an email address stored in $emailis to check its length

By my reasoning, the minimum length of an email address is six characters—for example,

a@a.toif you have a country code with no second level domains, a one-letter server name, and

a one-letter email address Therefore, an error could be produced if the address was not this

length:

if (strlen($email) < 6)

{

echo “That email address is not valid”;

exit; // finish execution of PHP script

}

Clearly, this is a very simplistic way of validating this information We will look at better ways

in the next section

Matching and Replacing Substrings with String

Functions

It’s common to want to check if a particular substring is present in a larger string This partial

matching is usually more useful than testing for equality

In our Smart Form example, we want to look for certain key phrases in the customer feedback

and send the mail to the appropriate department If we want to send emails talking about Bob’s

shops to the retail manager, we want to know if the word “shop” (or derivatives thereof) appear

in the message

4

Given the functions we have already looked at, we could use explode()or strtok()to retrieve the individual words in the message, and then compare them using the ==operator or

However, we could also do the same thing with a single function call to one of the string matching or regular expression matching functions These are used to search for a pattern inside a string We’ll look at each set of functions one by one

Finding Strings in Strings: strstr(), strchr(), strrchr(), stristr()

To find a string within another string you can use any of the functions strstr(),strchr(),

The function strstr()is the most generic, and can be used to find a string or character match within a longer string Note that in PHP, the strchr()function is exactly the same as

C version of this function In PHP, either of these functions can be used to find a string inside a string, including finding a string containing only a single character

The prototype for strstr()is as follows:

string strstr(string haystack, string needle);

You pass the function a haystackto be searched and a needleto be found If an exact match

of the needleis found, the function returns the haystackfrom the needleonwards, otherwise

it returns false If the needle occurs more than once, the returned string will start from the first occurrence of needle

For example, in the Smart Form application, we can decide where to send the email as follows:

$toaddress = “feedback@bobsdomain.com”; // the default value // Change the $toaddress if the criteria are met

if (strstr($feedback, “shop”))

$toaddress = “retail@bobsdomain.com”;

else if (strstr($feedback, “delivery”))

$toaddress = “fulfilment@bobsdomain.com”;

else if (strstr($feedback, “bill”))

$toaddress = “accounts@bobsdomain.com”;

This code checks for certain keywords in the feedback and sends the mail to the appropriate person If, for example, the customer feedback reads “I still haven’t received delivery of

my last order,” the string “delivery”will be detected and the feedback will be sent to

There are two variants on strstr() The first variant is stristr(), which is nearly identical

but is not case sensitive This will be useful for this application as the customer might type

“delivery”, “Delivery”, or “DELIVERY”.

The second variant is strrchr(), which is again nearly identical, but will return the haystack

from the last occurrence of the needleonwards

Finding the Position of a Substring: strpos(), strrpos()

The functions strpos()and strrpos()operate in a similar fashion to strstr(), except,

instead of returning a substring, they return the numerical position of a needlewithin a

haystack

The strpos()function has the following prototype:

int strpos(string haystack, string needle, int [offset] );

The integer returned represents the position of the first occurrence of the needle within the

haystack The first character is in position 0 as usual

For example, the following code will echo the value 4to the browser:

$test = “Hello world”;

echo strpos($test, “o”);

In this case, we have only passed in a single character as the needle, but it can be a string of

any length

The optional offset parameter is used to specify a point within the haystackto start searching

For example

echo strpos($test, “o”, 5);

This code will echo the value 7to the browser because PHP has started looking for the

charac-ter oat position 5, and therefore does not see the one at position 4

The strrpos()function is almost identical, but will return the position of the last occurrence

of the needlein the haystack Unlike strpos(), it only works with a single character needle

Therefore, if you pass it a string as a needle, it will only use the first character of the string to

match

In any of these cases, if the needleis not in the string,strpos()or strrpos()will return

false This can be problematic because falsein a weakly typed language such as PHP is

equivalent to 0, that is, the first character in a string

4

You can avoid this problem by using the ===operator to test return values:

$result = strpos($test, “H”);

if ($result === false) echo “Not found”

else echo “Found at position 0”;

Note that this will only work in PHP 4—in earlier versions you can test for false by testing the return value to see if it is a string (that is,false)

Replacing Substrings: str_replace(), substr_replace()

Find-and-replace functionality can be extremely useful with strings We have used find and replace in the past for personalizing documents generated by PHP—for example by replacing

censoring particular terms, such as in a discussion forum application, or even in the Smart Form application

Again, you can use string functions or regular expression functions for this purpose

The most commonly used string function for replacement is str_replace() It has the follow-ing prototype:

string str_replace(string needle, string new_needle, string haystack);

This function will replace all the instances of needlein haystack with new_needle For example, because people can use the Smart Form to complain, they might use some color-ful words As programmers, we can prevent Bob’s various departments from being abused in that way:

$feedback = str_replace($offcolor, “%!@*”, $feedback);

The function substr_replace()is used to find and replace a particular substring of a string It has the following prototype:

string substr_replace(string string, string replacement, int start, int

[length] );

This function will replace part of the string stringwith the string replacement Which part is replaced depends upon the values of the startand optional lengthparameters

The startvalue represents an offset into the string where replacement should begin If it is 0

or positive, it is an offset from the beginning of the string; if it is negative, it is an offset from the end of the string For example, this line of code will replace the last character in $test

with “X”:

$test = substr_replace($test, “X”, -1);

The lengthvalue is optional and represents the point at which PHP will stop replacing If you

don’t supply this value, the string will be replaced from startto the end of the string

If length is zero, the replacement string will actually be inserted into the string without

over-writing the existing string

A positive lengthrepresents the number of characters that you want replaced with the new

string

A negative lengthrepresents the point at which you’d like to stop replacing characters,

counted from the end of the string

Introduction to Regular Expressions

PHP supports two styles of regular expression syntax: POSIX and Perl The POSIX style of

regular expression is compiled into PHP by default, but you can use the Perl style by

compil-ing in the PCRE (Perl-compatible regular expression) library We’ll cover the simpler POSIX

style, but if you’re already a Perl programmer, or want to learn more about PCRE, read the

online manual at http://php.net

So far, all the pattern matching we’ve done has used the string functions We have been limited

to exact match, or to exact substring match If you want to do more complex pattern matching,

you should use regular expressions Regular expressions are difficult to grasp at first but can be

extremely useful

The Basics

A regular expression is a way of describing a pattern in a piece of text The exact (or literal)

matches we’ve done so far are a form of regular expression For example, earlier we were

searching for regular expression terms like “shop”and “delivery”

Matching regular expressions in PHP is more like a strstr()match than an equal comparison

because you are matching a string somewhere within another string (It can be anywhere

within that string unless you specify otherwise.) For example, the string “shop”matches the

regular expression “shop” It also matches the regular expressions “h”,“ho”, and so on.

We can use special characters to indicate a meta-meaning in addition to matching characters

exactly

For example, with special characters you can indicate that a pattern must occur at the start or

end of a string, that part of a pattern can be repeated, or that characters in a pattern must be of

a particular type You can also match on literal occurrences of special characters We’ll look at

each of these

4

Character Sets and Classes

Using character sets immediately gives regular expressions more power than exact matching

expressions Character sets can be used to match any character of a particular type—they’re

really a kind of wildcard

First of all, you can use the .character as a wildcard for any other single character except a new line (\n) For example, the regular expression

.at

matches the strings “cat”,“sat”, and “mat”, among others

This kind of wildcard matching is often used for filename matching in operating systems With regular expressions, however, you can be more specific about the type of character you would like to match, and you can actually specify a set that a character must belong to In the previous example, the regular expression matches “cat”and “mat”, but also matches “#at” If you want to limit this to a character between a and z, you can specify it as follows:

[a-z]

Anything enclosed in the special square brace characters [and ]is a character class—a set of characters to which a matched character must belong Note that the expression in the square

brackets matches only a single character.

You can list a set, for example

[aeiou]

means any vowel

You can also describe a range, as we just did using the special hyphen character, or a set of ranges:

[a-zA-Z]

This set of ranges stands for any alphabetic character in upper- or lowercase

You can also use sets to specify that a character cannot be a member of a set For example,

[^a-z]

matches any character that is not between a and z The caret symbol means not when it is

placed inside the square brackets It has another meaning when used outside square brackets, which we’ll look at in a minute

In addition to listing out sets and ranges, a number of predefined character classes can be used

in a regular expression These are shown in Table 4.3

T ABLE 4.3 Character Classes for Use in POSIX-Style Regular Expressions

[[:alnum:]] Alphanumeric characters

[[:alpha:]] Alphabetic characters

[[:lower:]] Lowercase letters

[[:upper:]] Uppercase letters

[[:digit:]] Decimal digits

[[:xdigit:]] Hexadecimal digits

[[:blank:]] Tabs and spaces

[[:space:]] Whitespace characters

[[:cntrl:]] Control characters

[[:print:]] All printable characters

[[:graph:]] All printable characters except for space

Repetition

Often you want to specify that there might be multiple occurrences of a particular string or

class of character You can represent this using two special characters in your regular

expres-sion The *symbol means that the pattern can be repeated zero or more times, and the +

sym-bol means that the pattern can be repeated one or more times The symsym-bol should appear

directly after the part of the expression that it applied to For example

[[:alnum:]]+

means “at least one alphanumeric character.”

Subexpressions

It’s often useful to be able to split an expression into subexpressions so you can, for example,

represent “at least one of these strings followed by exactly one of those.” You can do this using

parentheses, exactly the same way as you would in an arithmetic expression For example,

(very )*large

matches “large”,“very large”, “very very large”, and so on.

4

Counted Subexpressions

We can specify how many times something can be repeated by using a numerical expression in curly braces ( {}).You can show an exact number of repetitions ({3}means exactly 3 repeti-tions), a range of repetitions ({2, 4}means from 2 to 4 repetitions), or an open ended range of repetitions ({2,}means at least two repetitions)

For example,

(very ){1, 3}

matches“very”,“very very”and “very very very”

Anchoring to the Beginning or End of a String

You can specify whether a particular subexpression should appear at the start, the end, or both This is pretty useful when you want to make sure that only your search term and nothing else appears in the string

The caret symbol (^) is used at the start of a regular expression to show that it must appear at the beginning of a searched string, and $is used at the end of a regular expression to show that

it must appear at the end

For example, this matches bobat the start of a string:

^bob

This matches comat the end of a string:

com$

Finally, this matches any single character from a to z, in the string on its own:

^[a-z]$

Branching

You can represent a choice in a regular expression with a vertical pipe For example, if we want to match com,edu, or net, we can use the expression:

(com)|(edu)|(net)

Matching Literal Special Characters

If you want to match one of the special characters mentioned in this section, such as .,{, or $, you must put a slash (\) in front of it If you want to represent a slash, you must replace it with two slashes,\\

Summary of Special Characters

A summary of all the special characters is shown in Tables 4.4 and 4.5 Table 4.4 shows the

meaning of special characters outside square brackets, and Table 4.5 shows their meaning

when used inside square brackets

T ABLE 4.4 Summary of Special Characters Used in POSIX Regular Expressions

Outside Square Brackets

Character Meaning

^ Match at start of string

. Match any character except newline (\n)

| Start of alternative branch (read as OR)

{ Start min/max quantifier

T ABLE 4.5 Summary of Special Characters Used in POSIX Regular Expressions Inside

Square Brackets

Character Meaning

^ NOT, only if used in initial position

- Used to specify character ranges

Putting It All Together for the Smart Form

There are at least two possible uses of regular expressions in the Smart Form application The

first use is to detect particular terms in the customer feedback We can be slightly smarter

about this using regular expressions Using a string function, we’d have to do three different

searches if we wanted to match on “shop”,“customer service”, or “retail” With a regular

expression, we can match all three:

shop|customer service|retail

4

The second use is to validate customer email addresses in our application by encoding the stan-dardized format of an email address in a regular expression The format includes some

alphanumeric or punctuation characters, followed by an @symbol, followed by a string of alphanumeric and hyphen characters, followed by a dot, followed by more alphanumeric and hyphen characters and possibly more dots, up until the end of the string, which encodes as fol-lows:

^[a-zA-Z0-9_]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-\.]+$

The subexpression ^[a-zA-Z0-9_]+means “start the string with at least one letter, number, or underscore, or some combination of those.”

The @symbol matches a literal @ The subexpression [a-zA-Z0-9\-]+matches the first part of the host name including alphanu-meric characters and hyphens Note that we’ve slashed out the hyphen because it’s a special character inside square brackets

The \.combination matches a literal . The subexpression [a-zA-Z0-9\-\.]+$matches the rest of a domain name, including letters, numbers, hyphens, and more dots if required, up until the end of the string

A bit of analysis shows that you can produce invalid email addresses that will still match this regular expression It is almost impossible to catch them all, but this will improve the situation

a little

Now that you have read about regular expressions, we’ll look at the PHP functions that use them

Finding Substrings with Regular Expressions

Finding substrings is the main application of the regular expressions we just developed The two functions available in PHP for matching regular expressions are ereg()and eregi()

int ereg(string pattern, string search, array [matches]);

This function searches the searchstring, looking for matches to the regular expression in

pattern If matches are found for subexpressions of pattern, they will be stored in the array

matches, one subexpression per array element