PHP Introductory Tutorials-php variables

(i), internal variables

There are mainly integers (interger), floating-point numbers (Float-point numbers), strings (string), arrays (array), objects (object).

1 Initialization variables

To initialize a variable in PHP, you simply assign it a value. For most types, this is the most straightforward. For arrays and objects, you can use other methods.

2 Initializing an array

Arrays can be assigned using one of two methods: Using a series of consecutive values, or using the array () function to construct (see the array Functions section).
To add a continuous number to an array, you simply assign the value to an array variable without the subscript. The value is added to the array as the last element of the array.
Cases:

$names [] = "Jill"; $names [0] = "Jill"
$names [] = "Jack"; $names [1] = "Jack"

Similar to C and Perl, array subscripts start at 0.

3 Initializing objects

To initialize an object, you need to establish a variable of that type with the new statement.

class Foo {
function Do_foo () {
echo "doing foo.";
}
}
$bar = new Foo;
$bar->do_foo ();

4 variable Scopes

The scope of a variable is its valid range. For most PHP variables there is only one scope. Local variable scopes are used in user-defined functions. Variables used within a function are set to local variables by default. For example:

$a = 1; /* Global Scope * *
Function Test () {
echo $a; /* Reference to local scope variable * *
}
Test ();

This program does not output anything because the Echo statement outputs a local variable $a, and the $a within the function has never been assigned a value. You may notice that this is a little bit different from C, where a global variable can be referenced directly within a function unless it is overwritten by a local variable. This makes it possible to change the value of a global variable without notice. There must be an explicit description of the use of global variables within a function in PHP. For example:

$a = 1;
$b = 2;
Function Sum () {
Global $a, $b;
$b = $a + $b;
}
Sum ();
Echo $b;

The above program will output "3". By declaring $a and $b as global variables within the function, the variables are referenced globally. There is no limit to the number of global variables that a function can manipulate.
Another notable area of scope is the static variable. A static variable exists in a local function, but its value is not lost when the program leaves the function. Consider the following example:

Function Test () {
$a = 0;
echo $a;
$a + +;
}

This function is useless because it assigns the $a to 0 and then "0" each time it is invoked. The $a++ does not have any effect because the variable $a is released after the function call is finished. To make the counting program count effectively without losing the current count result, $a to be known as a static variable:

Function Test () {
static $a = 0;
echo $a;
$a + +;
}

Now, every time you call the test () function, it hits the $a value and adds its value.

Static variables are essential when using recursive functions. Recursive functions are calls to their own functions. You must be careful when writing recursive functions because the number of cycles is indeterminate. You must ensure that there are sufficient conditions to end the recursive process. Here is a simple recursive function count to 10:

Function Test () {
static $count = 0;
$count + +;
Echo $count;
if ($count < 10) {
Test ();
}
｝

(ii) Dynamic variables

Sometimes it is easier to use variable names. That is, a variable name that can be dynamically assigned and used. An assignment statement for a generic variable such as:

$a = "Hello";

A dynamic variable refers to the value of the variable as the name of a new variable. In the above example, hello, you can use double $ as the variable name. Cases:

$ $a = "world";

At this point, two variables are defined and stored in the PHP symbol tree: $a content is "Hello", $hello content is "world". Therefore, the statement: echo "$a ${$a}"; The display result is identical to: echo "$a $hello";

(c) PHP external variables

1. HTML form (get and post)

When a form is submitted to PHP3 script, PHP automatically gets the variables in the form. For example:

<form action= "foo.php Tutorial 3" method= "POST" >
Name: <input type= "text" name= "name" ><br>
<input type= "Submit" >
</form>

When "submit" is pressed, PHP3 automatically generates the variable: $name, which contains all the content that the user entered.

2, IMAGE SUBMIT variable name

When submitting a form, you can use the following tag to replace the standard submit button with a map:

<input type=image src= "Image.gif" name= "sub" >

When the user clicks on the graph, two additional variables sub_x and sub_y are sent to the server along with the form. It contains the coordinates that the user clicks on the diagram. An experienced person may notice that the name the browser actually sent contains a period instead of an underscore, but PHP automatically converts the period to an underscore.

3. HTTP Cookies

PHP supports HTTP cookies. Cookies store data in the client browser to keep in touch with the user or authenticate the user. You can use the Setcookie () function to set up cookies. Cookies are part of the HTTP request header, so you must call the Setcookie () function before any output data is returned to the user's browser. It is similar to the limit of the Header () function. Any cookies returned by the client will be automatically converted to standard PHP variables, just like the data for Get and post methods.

If you want to set multiple values in a cookie, add the name of the cookie to [], for example:

Setcookie ("mycookie[]", "testing", Time () +3600);

Note: New cookies will overwrite cookies already in your browser with the same name, unless they have different paths or domains.

4. Environment variable

PHP automatically converts an environment variable to a normal variable.

Echo $HOME; /* Shows the home environment variable, if set. */

Although information from get,post and cookie structures is automatically converted to PHP variables, it is best to explicitly read them from environment variables to ensure that the correct values are obtained. You can use the getenv () function for this purpose. You can also set variables by using the putenv () function.

Variable type conversions
Explicit type declarations are not required (and not supported) in PHP when a variable is defined, and the type of a variable depends on the type of its value. That is, if you assign a string value to the variable Var, var becomes a string variable. If you assign an integer value to Var, it becomes an integer variable.

An example of a PHP automatic type conversion is the addition operator ' + '. If any of the operands are double, all operands are computed by the double type, and the result is double. Otherwise, all operands are computed by the integer type and the result is an integer. Note: The type of the operand itself does not change, and the type transformation is done only in the calculation

$foo = "0"; $foo is a string (ASCII 48)
$foo + +; $foo is the string "1" (ASCII 49)
$foo + 1; $foo is now an integer (2)
$foo = $foo + 1.3; $foo's now a double (3.3)
$foo = 5 + "Little piggies"; $foo is a double (15)
$foo = 5 + "Small Pigs"; $foo is an integer (15)

To change the type of a variable, you can also use the Settype () function.

1. Force type Conversion

Mandatory type conversions in PHP are the same as in C: write the desired type name in parentheses before the variable that needs to cast the type.

$foo = 10; $foo is an integer
$bar = (double) $foo; $bar is a double
The allowed casts are:
(int), (integer)-Cast to Integer
(real), (double), (float)-cast to double
(string)-cast to String
(array)-Cast to array
(object)-Cast to Object

Note: Parentheses can contain tabs or spaces, and the following function is computed:

$foo = (int) $bar;
$foo = (int) $bar;

2. String conversion

When a string is evaluated as a numeric type, the value and type of the result are determined in the following manner.

If the string contains any '. ', ' e ', and ' e ' characters, it is evaluated as a double type. Otherwise, it is evaluated as an integer type.
The value is calculated from the beginning of the string. If the string is a valid number, the value is used, otherwise the value is 0. A valid number is a symbol bit (optional) followed by one or several digits (which can also contain a decimal point) followed by an optional exponent. Index is an ' e ' or ' e ' followed by one or several digits.

$foo = 1 + "10.5"; $foo is a double (11.5)
$foo = 1 + " -1.3e3"; $foo is a double (-1299)
$foo = 1 + "bob-1.3e3"; $foo is a double (1)
$foo = 1 + "BOB3"; $foo is an integer (1)
$foo = 1 + "Small Pigs"; $foo is an integer (11)
$foo = 1 + "Little piggies"; $foo is a double (11); The string contains ' E '