photoshop cs2 v9.0 green Chinese version php control statement

1. IF statement
The IF statement is an important feature in most languages. It executes program segments based on conditions. PHP's IF statement is similar to C:
　if (expr)
　statement
　As discussed in expressions, expr is evaluated to its truth value. If expr is TRUE, PHP executes the corresponding statement, if it is FALSE it ignores it.
If $a is greater than $b, the following example will print 'a is bigger than b':
　if ($a > $b)
　print "a is bigger than b";
　Generally, you want to perform more than a statement. Of course, there is no need to add an IF judgment to every statement. Instead, multiple statements can be grouped into a statement group.
　 If statements can be nested in other IF statements, allowing you to flexibly and conditionally execute various parts of the program.
2. ELSE statement
Usually you want to execute one statement when a specific condition is met, and another statement when the condition is not met. ELSE is used to do this. ELSE extends the IF statement and executes another statement when the IF statement expression is FALSE. For example, the following program will display 'a is bigger than b' if $a is greater than $b, otherwise it will display 'a is NOT bigger than b':
　if ($a>$b) {
　print "a is bigger than b" ";
　　　}
　 else {
　　print "a is NOT bigger than b";
　　Execute other statements when the IF expression is FALSE. But unlike ELSE, it only executes other statements when the ELSEIF expression is also TRUE.
　You can use multiple ELSEIF statements in one IF statement. The first statement whose ELSEIF expression is TRUE will be executed. In PHP 3, you can also write 'else if' (written as two words) and 'elseif' (written as one word) with the same effect. It's just a small difference in the way it's written (if you're familiar with C, it's the same), the result is exactly the same.
　The ELSEIF statement is only executed when the IF expression and any previous ELSEIF expression are FALSE, and the current ELSEIF expression is TRUE.
　The following is a nested IF statement containing ELSEIF and ELSE:
if ($a==5):
print "a equals 5";
print "..."; elseif ($a==6 ):
　　　print "a equals 6";
　　print "!!!";
　　else:
　　　print "a is neither 5 nor 6";
　endif; cycle. Just like in C. The basic format of the WHILE statement is:
　　WHILE(expr) statement
　The meaning of the WHILE statement is very simple. It tells PHP to execute the nested statement repeatedly as long as the WHILE expression is TRUE. The value of the WHILE expression is checked at the beginning of each loop, so even if its value is changed within the nested statement, this execution will not terminate until the end of the loop (each time PHP runs a nested statement is called a loop ). Similar to the IF statement, you can use curly brackets to enclose a group of statements and execute multiple statements in the same WHILE loop:
　WHILE(expr): statement ... ENDWHILE;
　The following examples are exactly the same, both type the number 1 to 10:
　 /* example 1 */
　　$i=1;
　while ($i　　print $i++; /* the printed value would be $i before the increment (post-　　
　　 increment) * /
　}
　/* example 2 */
　　$i=1;
　　while ($i　　print $i; WHILE is very similar to the WHILE loop, except that it checks whether the expression is true at the end of each loop rather than at the beginning of the loop. The main difference between it and a strict WHILE loop is that the first loop of DO..WHILE must be executed (the truth expression is only checked at the end of the loop), instead of a strict WHILE loop (checked at the beginning of each loop) Truth expression, if it is FALSE at the beginning, the loop will terminate execution immediately).
　　DO..WHILE loop has only one form:
　　$i = 0;
　　do {
　　　print $i;
　　　} while ($ i>0);
The above loop is only executed once, because after the first loop, when the truth expression is checked, it is calculated to be FALSE ($i is not greater than 0) and the loop execution terminates.
　6. FOR loop statement
　The FOR loop is the most complex loop in PHP. Just like in C. The syntax of the FOR loop is:
　　FOR (expr1; expr2; expr3) statement
　The first expression (expr1) is unconditionally evaluated (executed) at the beginning of the loop.
　Each time through the loop, the expression expr2 is evaluated. If the result is TRUE, loops and nested statements continue to execute. If the result is FALSE, the entire loop ends.
　 At the end of each loop, expr3 is evaluated (executed). Each expression can be null. If expr2 is empty, the number of loops is variable (PHP defaults to TRUE, like C).Don't do this unless you want to end the loop with a conditional BREAK statement in place of the FOR truth expression.
Consider the following example. They all display the numbers 1 to 10:
　　 /* example 1 */
　　 for ($i=1; $i　　　print $i;
　　}
　　/* example 2 */
　　for ( $i = 1;;$i++) {
　　　if ($i > 10) {
　　　　break;
　　　　　}
　　　/ $i = 1;
　　for (;; ) {
　　　if ($i > 10) {
　　　　break;
　　　　}
　　　print $i; , but with this you can find that in the FOR loop Empty expressions can be used in many situations.
Other languages ​​have a foreach statement to iterate over an array or hash table. PHP uses while statements and list(), each() functions to achieve this function.
　7. SWITCH selection statement
　The SWITCH statement is like a series of IF statements for the same expression. Many times, you want to compare the same variable (or expression) with many different values, and execute different program segments based on different comparison results. This is what the SWITCH statement is for.
　The following two examples do the same thing in different ways, one using a set of IF statements and the other using a SWITCH statement:
　/* example 1 */
　if ($i == 0) {
　　print "i equals 0 ";　
　　　}
　　if ($i == 1) {
　　print "i equals 1";
　　}
　if ($i == 2) {
　　print "i equals 2";
　　}
　　/* example 2 * /
　　switch ($i) {
　　case 0:
　　print "i equals 0";
　break;
　case 1:
　　print "i equals 1";
　　break;
　　case 2:
　　print "i equal s 2";
　　break;
　　}
(2), REQUIRE statement
　 The REQUIRE statement replaces itself with the specified file, much like the preprocessing #include in C.
　This means that you cannot put the require() statement in a loop structure in order to include the contents of a different file each time you call the function. To do this, use the INCLUDE statement.
　　require('header.inc');
(3), INCLUDE statement
　The INCLUDE statement includes the specified file.
　Every time an INCLUDE is encountered, the INCLUDE statement will include the specified file. So you can use the INCLUDE statement in a loop structure to include a series of different files.
　　$files = array('first.inc', 'second.inc', 'third.inc');
　　 for ($i = 0; $i 　　 include( $files[$i]);
　　 }
(IV), Function
　 Functions can be defined through the following syntax:
　　function foo( $arg_1, $arg_2, ..., $arg_n ) {
　　　echo "Example function.\ n";
　　 return $retval;
　　}
Any valid PHP3 code can be used in the function, even other function or class definitions
　1. Function return value
　 Functions can return values ​​through the optional return statement. The return value can be of any type, including lists and objects.
　 function my_sqrt( $num ) {
　 return $num * $num;
　　}
　 echo my_sqrt( 4 ); // outputs '16'.
　 The function cannot return multiple values ​​at the same time, but it can be achieved by returning a list. :
　　function foo() {
　　return array( 0, 1, 2 );
　　}
　 list( $zero, $one, $two ) = foo();
2. Parameters
　 External information can be passed through the parameter list into a function; the argument list is a comma-separated series of variables and/or constants.
　PHP3 supports value-shaped parameters (default), variable parameters, and default parameters. Variable-length parameter lists are not supported, but can be implemented by transferring arrays.
3. Associated parameters
　By default, function parameters are passed by value. If you allow a function to modify the value of an incoming argument, you can use variable arguments.
　If you want a formal parameter of a function to always be a variable parameter, you can prefix the formal parameter with (&) when defining the function:
　function foo( &$bar ) {
　 $bar .= ' and something extra.'
　For the default function (its formal parameters are not variable parameters), you can add (&) prefix to the actual parameters when calling the function:
　function foo( $bar ) {
　　$bar .= ' and something extra.';
　　}
　$str = 'This is a string, ';
　foo( $str );
　echo $str; // outputs 'This is a string, '
　foo( &$str );
　echo $str; // outputs 'This is a string, and something extra.'
4. Default value
　The function can define a C++-style default value, as follows:
　function makecoffee( $type = "cappucino" ) {
　　echo "Making a cup of $type. \n";
　　}
　echo makecoffee();
　echo makecoffee( "espresso" );
　The output of the above code is:
　Making a cup of cappucino.
　Making a cup of espresso.
　Note that when using the default parameters, all parameters with default values ​​should be defined after parameters without default values; otherwise, it will not work as expected.
　 5. CLASS (Class)
A class is a collection of variables and functions. Classes are defined with the following syntax: class Cart {
var $items; // Items in our shopping cart
{
　　　$this->items[$artnr] += $num; >items[$artnr] > $num) {
　　　　　$this->items[$artnr] -= $num;
　　　　}
　　　}
　　　?> ;
The above defines a class called Cart, which includes an associative array and two functions for adding and removing items from the cart.
　Classes are primitive models of actual variables. You create a variable of the required type through the new operator.
　　$cart = new Cart;
　　$cart->add_item("10", 1);
This creates an object of Cart class $cart. The object's function add_item() is called to add 1 to the 10th item.
　Classes can be extended from other classes. An extended or derived class has all the variables and functions of the base class and what you define in the extension definition. This is done using the extends keyword.
　class Named_Cart extends Cart {
　　var $owner;
　　function set_owner($name) {
　　　$this->owner = $name; Variables and functions also add a variable $owner and a function set_owner(). The variable of the named_cart class you created can now set the owner of the carts. You can still use the normal cart functions in the named_cart variable:
　$ncart = new Named_Cart; // Create a named cart
　$ncart->set_owner("kris"); // Name that cart
　print $ncart-> ;owner; // print the cart owners name
　$ncart->add_item("10", 1); // (inherited functionality from cart)
The variable $this in the function means the current object. You need to use the $this->something form to access all variables or functions of the current object.
　The constructor in a class is a function that is automatically called when you create a new variable of a certain class. The function in the class with the same name as the class is the constructor.
　 class Auto_Cart extends Cart {
　　 function Auto_Cart() {
　　　 $this->add_item("10", 1);
　　 }
　　 }
Here defines a class Auto_Cart, which adds a new value to the Cart class every time a new operation is performed Set up the constructor for item 10 to initialize variables. Constructors can also have parameters, which are optional, which makes them very useful.
　 class Constructor_Cart {
　 function Constructor_Cart($item = "10", $num = 1) {
　　 $this->add_item($item, $num);
　　}
　　}
　 　　 // Shop the same old boring stuff.
　 $default_cart = new Constructor_Cart;
　　 // Shop for real...
　 $different_cart = new Constructor_Cart("20", 17);

The above introduces the control statements of photoshop cs2 v9.0 green Chinese version PHP, including the content of photoshop cs2 v9.0 green Chinese version. I hope it will be helpful to friends who are interested in PHP tutorials.