CSS Rollover Lists (Horizontal Menu)
1.
|
Make
a basic list using a href property
Example
<div id="navigation">
<ul>
<li><a
href="#">Home</a></li>
<li><a
href="#">Countries</a></li>
<li><a
href="#">People</a></li>
<li><a
href="#">About Us</a></li>
<li><a
href="#">Contact</a></li>
</ul>
</div>
|
Output
·
Home
·
Countries
·
People
·
About Us
·
Contact
|
2.
|
To remove the HTML bullets set the “ list-style-type” to “none”
CSS Code
#navigation ul {
list-style-type: none;
}
|
Output
Home
Countries
People
About Us
Contact
|
3.
|
Remove paddings and margins
CSS Code
#navigation ul {
list-style-type:
none;
padding: 0;
margin: 0;
}
|
Output
Home
Countries
People
About Us
Contact
|
4.
|
In order to get the list items in one line we
use “inline” property for “a” element
CSS Code
#navigation ul {
list-style-type:
none;
padding: 0;
margin: 0;
}
#navigation ul li {
display: inline;
}
|
Output
|
5.
|
Remove the text underline. Navigations do not
have underlines. For this set the “text-decoration”
property of the “a” element as
none.
CSS Code
#navigation ul li {
display: inline;
}
#navigation ul li a {
text-decoration: none;
}
Output
|
|
6.
|
Add padding around list items so that it
looks like they are inside a box.
CSS Code
#navigation ul li {
display: inline;
}
#navigation ul li a
{
text-decoration: none;
padding: .2em 1em;
}
Output
|
|
7.
|
Add background color to the list items. Also change the text
color to make it readable.
CSS Code
#navigation ul li a
{
text-decoration: none;
padding:
.2em 1em;
color: #fff;
background-color: #036;
}
Output
|
|
8.
|
Add rollover color to the lists. Use
“a:hover” to set a second background color, as a rollover state.
CSS Code
#navigation ul li a
{
text-decoration: none;
padding:
.2em 1em;
color: #fff;
background-color: #036;
}
#navigation ul li a:hover
{
color: #fff; background-color: #369; }
Output
|
<code><ul id="nav">
<li>
<a href="#">Home</a>
</li>
<li>
<a href="#">About</a>
<ul>
<li><a href="#">The product</a></li>
<li><a href="#">Meet the team</a></li>
</ul>
</li>
<li>
<a href="#">Services</a>
<ul>
<li><a href="#">Sevice one</a></li>
<li><a href="#">Sevice two</a></li>
<li><a href="#">Sevice three</a></li>
<li><a href="#">Sevice four</a></li>
</ul>
</li>
<li>
<a href="#">Product</a>
<ul>
<li><a href="#">Small product (one)</a></li>
<li><a href="#">Small product (two)</a></li>
<li><a href="#">Small product (three)</a></li>
<li><a href="#">Small product (four)</a></li>
<li><a href="#">Big product (five)</a></li>
<li><a href="#">Big product (six)</a></li>
<li><a href="#">Big product (seven)</a></li>
<li><a href="#">Big product (eight)</a></li>
<li><a href="#">Enourmous product (nine)</a></li>
<li><a href="#">Enourmous product (ten)</a></li>
<li><a href="#">Enourmous product (eleven)</a></li>
</ul>
</li>
<li>
<a href="#">Contact</a>
<ul>
<li><a href="#">Out-of-hours</a></li>
<li><a href="#">Directions</a></li>
</ul>
</li>
</ul></code>
The CSS
This is where the magic happens--we use CSS to transform a series of nested <ul>
s into a smooth, easy to use, neat and self-contained dropdown menu.
<code><span class="code-comment">/* BE SURE TO INCLUDE THE CSS RESET FOUND IN THE DEMO PAGE'S CSS */</span>
<span class="code-comment">/*------------------------------------*\
NAV
\*------------------------------------*/</span>
#nav{
list-style:none;
font-weight:bold;
margin-bottom:10px;
<span class="code-comment">/* Clear floats */</span>
float:left;
width:100%;
<span class="code-comment">/* Bring the nav above everything else--uncomment if needed.
position:relative;
z-index:5;
*/</span>
}
#nav li{
float:left;
margin-right:10px;
position:relative;
}
#nav a{
display:block;
padding:5px;
color:#fff;
background:#333;
text-decoration:none;
}
#nav a:hover{
color:#fff;
background:#6b0c36;
text-decoration:underline;
}
<span class="code-comment">/*--- DROPDOWN ---*/</span>
#nav ul{
background:#fff; <span class="code-comment">/* Adding a background makes the dropdown work properly in IE7+. Make this as close to your page's background as possible (i.e. white page == white background). */</span>
background:rgba(255,255,255,0); <span class="code-comment">/* But! Let's make the background fully transparent where we can, we don't actually want to see it if we can help it... */</span>
list-style:none;
position:absolute;
left:-9999px; <span class="code-comment">/* Hide off-screen when not needed (this is more accessible than display:none;) */</span>
}
#nav ul li{
padding-top:1px; <span class="code-comment">/* Introducing a padding between the li and the a give the illusion spaced items */</span>
float:none;
}
#nav ul a{
white-space:nowrap; <span class="code-comment">/* Stop text wrapping and creating multi-line dropdown items */</span>
}
#nav li:hover ul{ <span class="code-comment">/* Display the dropdown on hover */</span>
left:0; <span class="code-comment">/* Bring back on-screen when needed */</span>
}
#nav li:hover a{ <span class="code-comment">/* These create persistent hover states, meaning the top-most link stays 'hovered' even when your cursor has moved down the list. */</span>
background:#6b0c36;
text-decoration:underline;
}
#nav li:hover ul a{ <span class="code-comment">/* The persistent hover state does however create a global style for links even before they're hovered. Here we undo these effects. */</span>
text-decoration:none;
}
#nav li:hover ul li a:hover{ <span class="code-comment">/* Here we define the most explicit hover states--what happens when you hover each individual link. */</span>
background:#333;
}</code>
filetype: comments.html
<html>
<head>
<title>comment box</title>
</head>
<body>
<form action="sabincomment.php" method="post">
name:<input type="text" id="name" name="name"><br>
comment:<textarea id="comment"name="comment" rows=4 cols=60>your text here</textarea>
<input type="submit" id="submit" name="submit" value="comment">
</form>
http://webstufflearning.blogspot.com/
</body>
</html>
filetype:sabincomment.php
<?
$name=$_POST['name'];
$comment=$_POST['comment'];
$con=mysql_connect("localhost","root","");
mysql_select_db("share",$con);
$sql="INSERT INTO comment(name , comment) VALUES ('".$name."','".$comment."')";
$result=mysql_query($sql);
mysql_close();
if($result){
header('location:http://localhost/comments/display.php');
}
?>
http://webstufflearning.blogspot.com/
filetype:display.php
<html>
<head>
<title>comment box</title>
</head>
<body>
<?
$con=mysql_connect("localhost","root","");
mysql_select_db("share",$con);
$sql="SELECT * from comment";
$result=mysql_query($sql);
mysql_close();
while($row=mysql_fetch_array($result)){
$name=$row['name'];
$comment=$row['comment'];
echo "$name:<br>$comment:";}
?>
http://webstufflearning.blogspot.com/
</body>
</html>
<?php
$text = $_GET['Comments'];
mysql_connect ("localhost", "user", "password") or die ('Error: ' . mysql_error());
mysql_select_db("databasename") or die ('Data error:' . mysql_error());
$query="INSERT INTO KeepData (player_data)VALUES ('$text')";
mysql_query($query) or die ('Error updating database' . mysql_error());
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<textarea id="Comments" name="Comments">
example text
</textarea>
<input type="submit" name="mysubmit" value="Save Post" />
</form>
Chapter 2. PHP
Contents:
Introducing PHPConditions and Branches
Loops
A Working Example
Arrays
Strings
Regular Expressions
Date and Time Functions
Integer and Float Functions
User-Defined Functions
Objects
Common Mistakes
The topics covered in this chapter include:
- PHP basics, including script structure, variables, supported types, constants, expressions, and type conversions
- Condition and branch statements supported by PHP, including if, if...else, and the switch statements
- Looping statements
- Arrays and array library functions
- Strings and string library functions
- Regular expressions
- Date and time functions
- Integer and float functions
- How to write functions, reuse components, and determine the scope and type of variables
- An introduction to PHP object-oriented programming support
- Common mistakes made by programmers new to PHP, and how to solve them
The remainder of the chapter expands on the more advanced features of PHP, presents a reference to selected library functions, and discusses some of the common mistakes that programmers make when learning PHP. This material can be examined briefly, and used later as a reference while reading Chapter 4 to 13 and while programming in PHP. However, programmers new to PHP should consider reading the beginning of the Section 2.5 and Section 2.6 sections to understand the way PHP supports these concepts, as there are important differences from other languages.
We don't attempt to cover every function and every library that are supported by PHP. However, we provide brief descriptions of the supported libraries in Appendix E. In later chapters, we discuss more specialized library functions that support the topics and techniques presented here.
2.1. Introducing PHP
The current version of PHP is PHP4, which we call PHP throughout this book. The current release at the time of writing is 4.0.6.PHP is a recursive acronym that stands for PHP: Hypertext Preprocessor; this is in the naming style of GNU, which stands for GNU's Not Unix and which began this odd trend. The name isn't a particularly good description of what PHP is and what it's commonly used for. PHP is a scripting language that's usually embedded or combined with HTML and has many excellent libraries that provide fast, customized access to DBMSs. It's an ideal tool for developing application logic in the middle tier of a three-tier application.2.1.1. PHP Basics
Example 2-1 shows the first PHP script in this book, the ubiquitous "Hello, world." When requested by a web browser, the script is run on the web server and the resulting HTML document sent back to the browser and rendered as shown in Figure 2-1.Figure 2-1. The rendered output of Example 2-1 shown in the Netscape browser
Example 2-1. The ubiquitous Hello, world in PHP
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" > <html> <head> <title>Hello, world</title> </head> <body bgcolor="#ffffff"> <h1> <?php echo "Hello, world"; ?> </h1> </body> </html>
simply prints the greeting, "Hello, world."<?php echo "Hello, world"; ?>
The PHP script shown in Example 2-1 is rather pointless: we could simply have authored the HTML to include the greeting directly. Because PHP integrates so well with HTML, using PHP to produce static strings is far less complicated and less interesting than using other high-level languages. However, the example does illustrate several features of PHP:
- The begin and end script tags are <?php and ?> or, more simply, just <? and ?>. The longer begin tag style <?php avoids conflicts with other processing instructions that can be used in HTML. We use both styles in this book.
Other begin and end tag styles can also be configured, such as the HTML style that is used with JavaScript or other embedded scripts: <script language="PHP"> and </script>. - Whitespace has no effect, except to aid readability for the developer. For example, the script could have been written succinctly as <?php echo "Hello, world";?> with the same effect. Any mix of spaces, tabs, carriage returns, and so on in separating statements is allowed.
- A PHP script is a series of statements, each terminated with a semicolon. Our simple example has only one statement: echo "Hello, world";.
- A PHP script can be anywhere in a file and interleaved with any HTML fragment. While Example 2-1 contains only one script, there can be any number of PHP scripts in a file.
- When a PHP script is run, the entire script including the start and end script tags <?php and ?> is replaced with the output of the script.
TIP: When we present a few lines of code that are sections of larger scripts, we usually omit the start and end tags.The freedom to interleave any number of scripts with HTML is one of the most powerful features of PHP. A short example is shown in Example 2-2; a variable, $outputString="Hello, world", is initialized before the start of the HTML document, and later this string variable is output twice, as part of the <title> and <body> elements. We discuss more about variables and how to use them later in this chapter.
Example 2-2. Embedding three scripts in a single document
<?php $outputString = "Hello, world"; ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" > <html> <head> <title><?php echo $outputString; ?></title> </head> <body bgcolor="#ffffff"> <h1><?php echo $outputString; ?></h1> </body> </html>
2.1.1.1. Creating PHP scripts
A PHP script can be written using plain text[4] and can be created with any text editor, such as joe, vi, nedit, emacs, or pico.[4]While printable characters with the most significant bit are allowed, PHP scripts are usually written using characters from the 7-bit ASCII character set.If you save a PHP script in a file with a .php extension under the directory configured as Apache's document root, Apache executes the script when a request is made for the resource. Following the installation instructions given in Appendix A, the document root is:
Consider what happens when the script shown in Example 2-1 is saved in the file:/usr/local/apache/htdocs/
Apache—when configured with the PHP module—executes the script when requests to the URL http://localhost/example.2-1.php are made, assuming the web browser is running on the same machine as the web server./usr/local/apache/htdocs/example.2-1.php
If directory permissions don't permit creation of files in the document root, it's also possible to work in the user home directories. If the installation instructions in Appendix A have been followed, a directory can be created by a user beneath her home directory and the permissions set so that the directory is readable by the web server:
The example file can then be created with the filename:mkdir ~/public_html chmod a+rx ~/public_html
The file can then be retrieved with the URL http://localhost/~user/example.2-1.php, where user is the user login name.~/public_html/example.2-1.php
2.1.1.2. Comments
Comments can be included in code using familiar styles from other high-level programming languages. This includes the following styles:// This is a one-line comment # This is another one-line comment style /* This is how you can create a multi-line comment */
2.1.1.3. Outputting data with echo and print
The echo statement used in Example 2-1 and Example 2-2 is frequently used and designed to output any type of data. The print statement can be used for the same purpose. Consider some examples:The difference between print and echo is that echo can output more than one argument:echo "Hello, world"; // print works just the same print "Hello, world"; // numbers can be printed too echo 123; // So can the contents of variables echo $outputString;
There is also a shortcut that can output data. The following very short script outputs the value of the variable $temp:echo "Hello, ", "world";
The print and echo statements are also often seen with parentheses:<?=$temp; ?>
Parentheses make no difference to the behavior of print. However, when they are used with echo, only one output parameter can be provided.The echo and print statements can be used for most tasks and can output any combination of static strings, numbers, arrays, and other variable types discussed later in this chapter. We discuss more complex output with printf in Section 2.6 later in this section.echo "hello"; // is the same as echo ("hello");
2.1.1.4. String literals
PHP can create double- and single-quoted string literals. If double quotation marks are needed as part of a string, the easiest approach is to switch to the single-quotation style:Quotation marks can be escaped like this:echo 'This works'; echo "just like this."; // And here are some strings that contain quotes echo "This string has a ': a single quote!"; echo 'This string has a ": a double quote!';
One of the convenient features of PHP is the ability to include the value of a variable in a string literal. PHP parses double-quoted strings and replaces variable names with the variable's value. The following example shows how:echo "This string has a \": a double quote!"; echo 'This string has a \': a single quote!';
To include backslashes and dollar signs in a double-quoted string, the escaped sequences \\ and \$ can be used. The single-quoted string isn't parsed in the same way as a double-quoted string and can print strings such as:$number = 45; $vehicle = "bus"; $message = "This $vehicle holds $number people"; // prints "This bus holds 45 people" echo $message;
We discuss parsing of string literals in more detail in Section 2.6.'a string with a \ and a $'
2.1.2. Variables
Variables in PHP are identified by a dollar sign followed by the variable name. Variables don't need to be declared, and they have no type until they are assigned a value. The following code fragment shows a variable $var assigned the value of an expression, the integer 15. Therefore, $var is defined as being of type integer.Because the variable in this example is used by assigning a value to it, it's implicitly declared. Variables in PHP are simple: when they are used, the type is implicitly defined—or redefined—and the variable implicitly declared.$var = 15;
The variable type can change over the lifetime of the variable. Consider an example:
This fragment is acceptable in PHP. The type of $var changes from integer to string as the variable is reassigned. Letting PHP change the type of a variable as the context changes is very flexible and a little dangerous.$var = 15; $var = "Sarah the Cat";
Variable names are case-sensitive in PHP, so $Variable, $variable, $VAriable, and $VARIABLE are all different variables.
WARNING: One of the most common sources of bugs in PHP is failing to detect that more than one variable has accidentally been created. The flexibility of PHP is a great feature but is also dangerous. We discuss later how to set the error reporting of PHP so that it creates warning messages sensitive to unassigned variables being used.
2.1.3. Types
PHP has four scalar types—boolean, float, integer, and string—and two compound types, array and object.TIP: In this book, and particularly in this chapter, we present function prototypes that specify the types of arguments and return values. There are many functions that allow arguments or return values to be of different types, which we describe as mixed.Variables of a scalar type can contain a single value at any given time. Variables of a compound type—array or object—are made up of multiple scalar values or other compound values. Arrays and objects have their own sections later in this chapter. Other aspects of variables—including global variables and scope—are discussed later, with user-defined functions.Boolean variables are as simple as they get: they can be assigned either true or false. Here are two example assignments of a Boolean variable:
An integer is a whole number, while a float is a number that has an exponent and a fractional part. The number 123.01 is a float, and so is 123.0. The number 123 is an integer. Consider the following two examples:$variable = false; $test = true;
A float can also be represented using an exponential notation:// This is an integer $var1 = 6; // This is a float $var2 = 6.0;
You've already seen examples of strings earlier, when echo( ) and print( ) were introduced, and string literals are covered further in Section 2.6. Consider two example string variables:// This is a float that equals 1120 $var3 = 1.12e3; // This is also a float that equals 0.02 $var4 = 2e-2
$variable = "This is a string"; $test = 'This is also a string';
2.1.4. Constants
Constants associate a name with a simple, scalar value. For example, the Boolean values true and false are constants associated with the values 1 and 0, respectively. It's also common to declare constants in a script. Consider this example constant declaration:Constants aren't preceded by a $ character; they can't be changed once they have been defined; they can be accessed anywhere in a script, regardless of where they are declared; and they can only be simple, scalar values.define("pi", 3.14159); // This outputs 3.14159 echo pi;
Constants are useful because they allow parameters internal to the script to be grouped. When one parameter changes—for example, if you define a new maximum number of lines per web page—you can alter this constant parameter in only one place and not throughout the code.
2.1.5. Expressions, Operators, and Variable Assignment
We've already described simple examples of assignment, in which a variable is assigned the value of an expression using an equals sign. Most numeric assignments and expressions that work in other high-level languages also work in PHP. Here are some examples:There are many mathematical functions available in the math library of PHP for more complex tasks. We introduce some of these in Section 2.9.// Assign a value to a variable $var = 1; // Sum integers to produce an integer $var = 4 + 7; // Subtraction, multiplication, and division // that might have a result that is a float or // an integer, depending on the initial value of $var $var = (($var - 5) * 2) / 3; // These all add 1 to $var $var = $var + 1; $var += 1; $var++; // And these all subtract 1 from $var $var = $var - 1; $var -= 1; $var--; // Double a value $var = $var * 2; $var *= 2; // Halve a value $var = $var / 2; $var /= 2; // These work with float types too $var = 123.45 * 28.2;
String assignments and expressions are similar:
// Assign a string value to a variable $var = "test string"; // Concatenate two strings together // to produce "test string" $var = "test" . " string"; // Add a string to the end of another // to produce "test string" $var = "test"; $var = $var . " string"; // Here is a shortcut to add a string to // the end of another $var .= " test";
2.1.5.1. Expressions
Expressions in PHP are formulated in much the same way as other languages. An expression is formed from literal values (integers, strings, floats, Booleans, arrays, and objects), operators, and function calls that return values. An expression has a value and a type; for example, the expression 4 + 7 has the value 11 and the type integer, and the expression "Kelpie" has the value Kelpie and the type string. PHP automatically converts types when combining values in an expression. For example, the expression 4 + 7.0 contains an integer and a float; in this case, PHP considers the integer as a floating-point number, and the result is a float. The type conversions are largely straightforward; however, there are some traps, which are discussed later in this section.2.1.5.2. Operator precedence
The precedence of operators in an expression is similar to the precedence defined in any other language. Multiplication and division occur before subtraction and addition, and so on. However, reliance on evaluation order leads to unreadable, confusing code. Rather than memorize the rules, we recommend you construct unambiguous expressions with parentheses, because parentheses have the highest precedence in evaluation.For example, in the following fragment $variable is assigned a value of 32 because of the precedence of multiplication over addition:
The result is much clearer if parentheses are used:$variable = 2 + 5 * 6;
$variable = 2 + (5 * 6);
2.1.6. Type Conversion
PHP provides several mechanisms to allow variables of one type to be considered as another type. Variables can be explicitly converted to another type with the following functions:The function settype(mixed variable, string type) can explicitly set the type of variable to type, where type is again one of array, boolean, float, integer, object, or string.string strval(mixed variable) integer intval(mixed variable) float floatval(mixed variable)
PHP supports type-casting in much the same way as C, to allow the type of an expression to be changed. By placing the type name in parentheses in front of a variable, PHP converts the value to the desired type:
(int) $var or (integer) $var | Cast to integer |
(bool) $var or (boolean) $var | Cast to Boolean |
(float) $var, (double) $var or (real) $var | Cast to float |
(string) $var | Cast to string |
(array) $var | Cast to array |
(object) $var | Cast to object |
Table 2-1. Examples of type conversion in PHP using casting operators
Value of $var | (int) $var | (bool) $var | (string) $var | (float) $var |
---|---|---|---|---|
null | 0 | false | "" | 0 |
true | 1 | true | "1" | 1 |
false | 0 | false | "" | 0 |
0 | 0 | false | "0" | 0 |
3.8 | 3 | true | "3.8" | 3.8 |
"0" | 0 | false | "0" | 0 |
"10" | 10 | true | "10" | 10 |
"6 feet" | 6 | true | "6 feet" | 6 |
"foo" | 0 | true | "foo" | 0 |
2.1.6.1. Automatic type conversion
Automatic type conversion occurs when two differently typed variables are combined in an expression or when a variable is passed as an argument to a library function that expects a different type. When a variable of one type is used as if it were another type, PHP automatically converts the variable to a value of the required type. The same rules are used for automatic type conversion as are demonstrated inTable 2-1.Some simple examples show what happens when strings are added to integers and floats and when strings and integers are concatenated:
Not all type conversions are so obvious and can be the cause of hard-to-find bugs:// $var is set as an integer = 115 $var = "100" + 15; // $var is set as a float = 115.0 $var = "100" + 15.0; // $var is set as a string = "39 Steps" $var = 39 . " Steps";
Automatic type conversion can change the type of a variable. Consider the following example:// $var is set as an integer = 39 $var = 39 + " Steps"; // $var is an integer = 42 $var = 40 + "2 blind mice"; // $var is a float, but what does it mean $var = "test" * 4 + 3.14159;
$var = "1"; // $var is a string == "1" $var += 2; // $var is now an integer == 3 $var /= 2; // $var is now a float == 1.5 $var *= 2; // $var is still a float == 3
WARNING: Care must be taken when interpreting non-Boolean values as Boolean. Many library functions in PHP return values of different types: false if a valid result could not be determined, or a valid result. A valid return value of 0, 0.0, "0", an empty string, null, or an empty array is interpreted false when used as a Boolean value.The solution is to test the type of the variable using the functions described in the next section.
2.1.7. Examining Variable Type and Content
Because PHP is flexible with types, it provides the following functions that can check a variable's type:All the functions return a Boolean value of true or false for the variable variable, depending on whether it matches the variable type that forms the name of the function. For example, the following prints 1, that is, true:boolean is_int(mixed variable) boolean is_float(mixed variable) boolean is_bool(mixed variable) boolean is_string(mixed variable) boolean is_array(mixed variable) boolean is_object(mixed variable)
$test = 13.0; echo is_float($test); // prints 1 for true
2.1.7.1. Debugging with print_r( ) and var_dump( )
PHP provides the print_r( ) and var_dump( ) functions, which print the type and value of an expression in a human-readable form:These functions are useful for debugging a script, especially when dealing with arrays or objects. To test the value and type of $variable at some point in the script, the following code can be used:print_r(mixed expression) var_dump(mixed expression [, mixed expression ...])
This prints:$variable = 15; var_dump($variable);
While the var_dump( ) function allows multiple variables to be tested in one call, and provides information about the size of the variable contents, print_r( ) provides a more concise representation of arrays and objects. These functions can be used on variables of any type, and we use them throughout this chapter to help illustrate the results of our examples.int(15)
2.1.7.2. Testing, setting, and unsetting variables
During the running of a PHP script, a variable may be in an unset state or may not yet be defined. PHP provides the isset( ) function and the empty( ) language construct to test the state of variables:isset( ) tests if a variable has been set with a non-null value, while empty( ) tests if a variable has a value. The two are different, as shown by the following code:boolean isset(mixed var) boolean empty(mixed var)
A variable can be explicitly destroyed using unset( ):$var = "test"; // prints: "Variable is Set" if (isset($var)) echo "Variable is Set"; // does not print if (empty($var)) echo "Variable is Empty";
After the call to unset in the following example, $var is no longer defined:unset(mixed var [, mixed var [, ...]])
Another way to test that a variable is empty is to force it to the Boolean type using the (bool) cast operator discussed earlier. The example interprets the $var variable as type Boolean, which is equivalent to testing for !empty($var):$var = "foo"; // Later in the script unset($var); // Does not print if (isset($var)) echo "Variable is Set";
Table 2-2 show the return values for isset($var), empty($var), and (bool)$var when the variable $var is tested. Some of the results may be unexpected: when $var is set to "0", empty( ) returnstrue.$var = "foo"; // Both lines are printed if ((bool)$var) echo "Variable is not Empty"; if (!empty($var)) echo "Variable is not Empty";
Table 2-2. Expression values
State of the variable $var | isset($var) | empty($var) | (bool)$var |
---|---|---|---|
$var = null; | false | true | false |
$var = 0; | true | true | false |
$var = true | true | false | true |
$var = false | true | true | false |
$var = "0"; | true | true | false |
$var = ""; | true | true | false |
$var = "foo"; | true | false | true |
$var = array( ); | true | true | false |
unset $var; | false | true | false |
Copyright © 2003 O'Reilly & Associates. All rights reserved.