File: variables.html

package info (click to toggle)
php3 3%3A3.0.18-0potato1.1
links: PTS
area: main
in suites: potato
size: 17,736 kB
ctags: 11,198
sloc: ansic: 108,120; sh: 2,512; php: 2,024; yacc: 1,887; makefile: 1,038; perl: 537; pascal: 238; awk: 90; cpp: 28; sql: 11
file content (993 lines) | stat: -rw-r--r-- 19,035 bytes
parent folder | download | duplicates (3)
<HTML
><HEAD
><TITLE
>Variables</TITLE
><META
NAME="GENERATOR"
CONTENT="Modular DocBook HTML Stylesheet Version 1.41"><LINK
REL="HOME"
TITLE="PHP3 Manual"
HREF="manual.html"><LINK
REL="UP"
TITLE="Syntax and grammar"
HREF="lang-syntax.html"><LINK
REL="PREVIOUS"
TITLE="Types"
HREF="types.html"><LINK
REL="NEXT"
TITLE="Constants"
HREF="constants.html"></HEAD
><BODY
BGCOLOR="#FFFFFF"
TEXT="#000000"
LINK="#0000FF"
VLINK="#840084"
ALINK="#0000FF"
><DIV
CLASS="NAVHEADER"
><TABLE
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TH
COLSPAN="3"
ALIGN="center"
>PHP3 Manual</TH
></TR
><TR
><TD
WIDTH="10%"
ALIGN="left"
VALIGN="bottom"
><A
HREF="types.html"
>Prev</A
></TD
><TD
WIDTH="80%"
ALIGN="center"
VALIGN="bottom"
>Chapter 5. Syntax and grammar</TD
><TD
WIDTH="10%"
ALIGN="right"
VALIGN="bottom"
><A
HREF="constants.html"
>Next</A
></TD
></TR
></TABLE
><HR
ALIGN="LEFT"
WIDTH="100%"></DIV
><DIV
CLASS="SECT1"
><H1
CLASS="SECT1"
><A
NAME="VARIABLES"
>Variables</A
></H1
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="VARIABLES.SCOPE"
>Variable scope</A
></H2
><P
>     The scope of a variable is the context within which it is defined.
     For the most part all PHP variables only have a single scope.
     However, within user-defined functions a local function scope is
     introduced.  Any variable used inside a function is by default
     limited to the local function scope.  For example:
    
    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
> 
$a = 1; /* global scope */ 

Function Test () { 
    echo $a; /* reference to local scope variable */ 
} 

Test ();
     </PRE
><P
></P
></DIV
><P
>     This script will not produce any output because the echo statement
     refers to a local version of the $a variable, and it has not been
     assigned a value within this scope.  You may notice that this is a
     little bit different from the C language in that global variables
     in C are automatically available to functions unless specifically
     overridden by a local definition.  This can cause some problems in
     that people may inadvertently change a global variable.  In PHP
     global variables must be declared global inside a function if they
     are going to be used in that function.  An example:

    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>$a = 1;
$b = 2;

Function Sum () {
    global $a, $b;

    $b = $a + $b;
} 

Sum ();
echo $b;
     </PRE
><P
></P
></DIV
><P
>     The above script will output &quot;3&quot;.  By declaring $a and
     $b global within the function, all references to either variable
     will refer to the global version.  There is no limit to the number
     of global variables that can be manipulated by a function.

    </P
><P
>     A second way to access variables from the global scope is to use
     the special PHP-defined $GLOBALS array.  The previous example can
     be rewritten as:

    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>$a = 1;
$b = 2;

Function Sum () {
    $GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
} 

Sum ();
echo $b;
     </PRE
><P
></P
></DIV
><P
>     The $GLOBALS array is an associative array with the name of the
     global variable being the key and the contents of that variable
     being the value of the array element.

    </P
><P
>     Another important feature of variable scoping is the
     <I
CLASS="EMPHASIS"
>static</I
> variable.  A static variable exists
     only in a local function scope, but it does not lose its value
     when program execution leaves this scope.  Consider the following
     example:

    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>Function Test () {
    $a = 0;
    echo $a;
    $a++;
}
     </PRE
><P
></P
></DIV
><P
>     This function is quite useless since every time it is called it
     sets $a to 0 and prints &quot;0&quot;.  The $a++ which increments
     the variable serves no purpose since as soon as the function exits
     the $a variable disappears.  To make a useful counting function
     which will not lose track of the current count, the $a variable is
     declared static:

    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>Function Test () {
    static $a = 0;
    echo $a;
    $a++;
}
     </PRE
><P
></P
></DIV
><P
>     Now, every time the Test() function is called it will print the
     value of $a and increment it.

    </P
><P
>     Static variables are also essential when functions are called
     recursively.  A recursive function is one which calls itself.
     Care must be taken when writing a recursive function because it is
     possible to make it recurse indefinitely.  You must make sure you
     have an adequate way of terminating the recursion.  The following
     simple function recursively counts to 10:

    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>Function Test () {
    static $count = 0;

    $count++;
    echo $count;
    if ($count &#60; 10) {
        Test ();
    }
    $count--;
}
     </PRE
><P
></P
></DIV
></DIV
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="VARIABLES.VARIABLE"
>Variable variables</A
></H2
><P
>     Sometimes it is convenient to be able to have variable variable
     names.  That is, a variable name which can be set and used
     dynamically.  A normal variable is set with a statement such as:

    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>$a = "hello";
     </PRE
><P
></P
></DIV
><P
>     A variable variable takes the value of a variable and treats that as the
     name of a variable.  In the above example, <I
CLASS="EMPHASIS"
>hello</I
>, can
     be used as the name of a variable by using two dollar signs. ie.

    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>$$a = "world";
     </PRE
><P
></P
></DIV
><P
>     At this point two variables have been defined and stored in the
     PHP symbol tree: $a with contents "hello" and $hello with contents
     "world".  Therefore, this statement:

    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>echo "$a ${$a}";
     </PRE
><P
></P
></DIV
><P
>     produces the exact same output as:

    </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>echo "$a $hello";
     </PRE
><P
></P
></DIV
><P
>     ie. they both produce: <I
CLASS="EMPHASIS"
>hello world</I
>.

    </P
><P
>     In order to use variable variables with arrays, you have to
     resolve an ambiguity problem.  That is, if you write $$a[1] then
     the parser needs to know if you meant to use $a[1] as a variable,
     or if you wanted $$a as the variable and then the [1] index from
     that variable.  The syntax for resolving this ambiguity is:
     ${$a[1]} for the first case and ${$a}[1] for the second.

   </P
></DIV
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="VARIABLES.EXTERNAL"
>Variables from outside PHP</A
></H2
><DIV
CLASS="SECT3"
><H3
CLASS="SECT3"
><A
NAME="VARIABLES.EXTERNAL.FORM"
>HTML Forms (GET and POST)</A
></H3
><P
>      When a form is submitted to a PHP script, any variables from that
      form will be automatically made available to the script by
      PHP. For instance, consider the following form:

     </P
><P
>      <TABLE
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
CLASS="EXAMPLE"
><TR
><TD
><DIV
CLASS="EXAMPLE"
><P
><B
>Example 5-2. Simple form variable</B
></P
><PRE
CLASS="PROGRAMLISTING"
>&lt;form action="foo.php3" method="post"&#62;
    Name: &lt;input type="text" name="name"&#62;&lt;br&#62;
    &lt;input type="submit"&#62;
&lt;/form&#62;
       </PRE
></DIV
></TD
></TR
></TABLE
>

     </P
><P
>      When submitted, PHP will create the variable
      <TT
CLASS="COMPUTEROUTPUT"
>$name</TT
>, which will will contain
      whatever what entered into the <I
CLASS="EMPHASIS"
>Name:</I
> field
      on the form.

     </P
><P
>      PHP also understands arrays in the context of form variables, but
      only in one dimension. You may, for example, group related
      variables together, or use this feature to retrieve values from a
      multiple select input:

     </P
><P
>     <TABLE
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
CLASS="EXAMPLE"
><TR
><TD
><DIV
CLASS="EXAMPLE"
><P
><B
>Example 5-3. More complex form variables</B
></P
><PRE
CLASS="PROGRAMLISTING"
>&lt;form action="array.html" method="post"&#62;
    Name: &lt;input type="text" name="personal[name]"&#62;&lt;br&#62;
    Email: &lt;input type="text" name="personal[email]"&#62;&lt;br&#62;
    Beer: &lt;br&#62;
    &lt;select multiple name="beer[]"&#62;
        &lt;option value="warthog"&#62;Warthog
        &lt;option value="guinness"&#62;Guinness
        &lt;/select&#62;
    &lt;input type="submit"&#62;
&lt;/form&#62;
       </PRE
></DIV
></TD
></TR
></TABLE
>

      </P
><P
>       If PHP's track_vars feature is turned on, either by the <A
HREF="configuration.html#INI.TRACK-VARS"
>track_vars</A
> configuration setting
       or the <TT
CLASS="COMPUTEROUTPUT"
>&lt;?php_track_vars?&gt;</TT
>
       directive, then variables submitted via the POST or GET methods
       will also be found in the global associative arrays
       $HTTP_POST_VARS and $HTTP_GET_VARS as appropriate.

     </P
><DIV
CLASS="SECT4"
><H4
CLASS="SECT4"
><A
NAME="AEN1831"
>IMAGE SUBMIT variable names</A
></H4
><P
>       When submitting a form, it is possible to use an image instead
       of the standard submit button with a tag like:

      </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>&lt;input type=image src="image.gif" name="sub"&#62;
       </PRE
><P
></P
></DIV
><P
>       When the user clicks somewhere on the image, the accompanying
       form will be transmitted to the server with two additional
       variables, sub_x and sub_y. These contain the coordinates of
       the user click within the image.  The experienced may note that
       the actual variable names sent by the browser contains a period
       rather than an underscore, but PHP converts the period to an
       underscore automatically.

    </P
></DIV
></DIV
><DIV
CLASS="SECT3"
><H3
CLASS="SECT3"
><A
NAME="VARIABLES.EXTERNAL.COOKIES"
>HTTP Cookies</A
></H3
><P
>      PHP transparently supports HTTP cookies as defined by <A
HREF="http://www.netscape.com/newsref/std/cookie_spec.html"
TARGET="_top"
>Netscape's Spec</A
>.  Cookies are a
      mechanism for storing data in the remote browser and thus
      tracking or identifying return users.  You can set cookies using
      the <A
HREF="function.setcookie.html"
><B
CLASS="FUNCTION"
>SetCookie()</B
></A
> function.  Cookies are part
      of the HTTP header, so the SetCookie function must be called
      before any output is sent to the browser.  This is the same
      restriction as for the <A
HREF="function.header.html"
><B
CLASS="FUNCTION"
>Header()</B
></A
> function.
      Any cookies sent to you from the client will automatically be
      turned into a PHP variable just like GET and POST method data.

     </P
><P
>      If you wish to assign multiple values to a single cookie, just
      add <I
CLASS="EMPHASIS"
>[]</I
> to the cookie name.  For example:

     </P
><DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>SetCookie ("MyCookie[]", "Testing", time()+3600);
      </PRE
><P
></P
></DIV
><P
>      Note that a cookie will replace a previous cookie by the same
      name in your browser unless the path or domain is different.  So,
      for a shopping cart application you may want to keep a counter
      and pass this along.  i.e.

     </P
><TABLE
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
CLASS="EXAMPLE"
><TR
><TD
><DIV
CLASS="EXAMPLE"
><P
><B
>Example 5-4. SetCookie Example</B
></P
><PRE
CLASS="PROGRAMLISTING"
>$Count++;
SetCookie ("Count", $Count, time()+3600);
SetCookie ("Cart[$Count]", $item, time()+3600);
      </PRE
></DIV
></TD
></TR
></TABLE
></DIV
><DIV
CLASS="SECT3"
><H3
CLASS="SECT3"
><A
NAME="VARIABLES.EXTERNAL.ENVIRONMENT"
>Environment variables</A
></H3
><P
>      PHP automatically makes environment variables available as normal
      PHP variables.
     
     <DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>echo $HOME;  /* Shows the HOME environment variable, if set. */
      </PRE
><P
></P
></DIV
>

     </P
><P
>      Since information coming in via GET, POST and Cookie mechanisms
      also automatically create PHP variables, it is sometimes best to
      explicitly read a variable from the environment in order to make
      sure that you are getting the right version.  The
      <A
HREF="function.getenv.html"
><B
CLASS="FUNCTION"
>getenv()</B
></A
> function can be used for this.  You
      can also set an environment variable with the
      <A
HREF="function.putenv.html"
><B
CLASS="FUNCTION"
>putenv()</B
></A
> function.

   </P
></DIV
></DIV
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="VARIABLES.TYPE-JUGGLING"
>Type juggling</A
></H2
><P
>     PHP does not require (or support) explicit type definition in
     variable declaration; a variable's type is determined by the
     context in which that variable is used. That is to say, if you
     assign a string value to variable <TT
CLASS="PARAMETER"
><I
>var</I
></TT
>,
     <TT
CLASS="PARAMETER"
><I
>var</I
></TT
> becomes a string. If you then assign
     an integer value to <TT
CLASS="PARAMETER"
><I
>var</I
></TT
>, it becomes an
     integer.

    </P
><P
>     An example of PHP's automatic type conversion is the addition
     operator '+'. If any of the operands is a double, then all
     operands are evaluated as doubles, and the result will be a
     double. Otherwise, the operands will be interpreted as integers,
     and the result will also be an integer. Note that this does NOT
     change the types of the operands themselves; the only change is
     in how the operands are evaluated.

    <DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>$foo = "0";  // $foo is string (ASCII 48)
$foo++;      // $foo is the string "1" (ASCII 49)
$foo += 1;   // $foo is now an integer (2)
$foo = $foo + 1.3;  // $foo is now a double (3.3)
$foo = 5 + "10 Little Piggies"; // $foo is integer (15)
$foo = 5 + "10 Small Pigs";     // $foo is integer (15)
     </PRE
><P
></P
></DIV
>

    </P
><P
>     If the last two examples above seem odd, see <A
HREF="variables.html#LANG-SYNTAX.STRINGCONV"
>String conversion</A
>.  

    </P
><P
>     If you wish to force a variable to be evaluated as a certain
     type, see the section on <A
HREF="variables.html#LANG-SYNTAX.TYPECASTING"
>Type casting</A
>. If you
     wish to change the type of a variable, see
     <A
HREF="function.settype.html"
><B
CLASS="FUNCTION"
>settype()</B
></A
>.

    </P
><DIV
CLASS="SECT3"
><H3
CLASS="SECT3"
><A
NAME="AEN1873"
>Determining variable types</A
></H3
><P
>      Because PHP determines the types of variables and converts them
      (generally) as needed, it is not always obvious what type a given
      variable is at any one time.  PHP includes several functions
      which find out what type a variable is. They are
      <A
HREF="function.gettype.html"
><B
CLASS="FUNCTION"
>gettype()</B
></A
>, <A
HREF="function.is-long.html"
><B
CLASS="FUNCTION"
>is_long()</B
></A
>,
      <A
HREF="function.is-double.html"
><B
CLASS="FUNCTION"
>is_double()</B
></A
>, <A
HREF="function.is-string.html"
><B
CLASS="FUNCTION"
>is_string()</B
></A
>,
      <A
HREF="function.is-array.html"
><B
CLASS="FUNCTION"
>is_array()</B
></A
>, and
      <A
HREF="function.is-object.html"
><B
CLASS="FUNCTION"
>is_object()</B
></A
>.
     
    </P
></DIV
><DIV
CLASS="SECT3"
><H3
CLASS="SECT3"
><A
NAME="LANG-SYNTAX.TYPECASTING"
>Type casting</A
></H3
><P
>      Type casting in PHP works much as it does in C: the name of the
      desired type is written in parentheses before the variable which
      is to be cast.

     <DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>$foo = 10;   // $foo is an integer
$bar = (double) $foo;   // $bar is a double
      </PRE
><P
></P
></DIV
>
    
     </P
><P
>      The casts allowed are:
      <P
></P
><UL
><LI
><P
>(int), (integer) - cast to integer
       </P
></LI
><LI
><P
>(real), (double), (float) - cast to double
       </P
></LI
><LI
><P
>(string) - cast to string
       </P
></LI
><LI
><P
>(array) - cast to array
       </P
></LI
><LI
><P
>(object) - cast to object
      </P
></LI
></UL
>

     </P
><P
>      Note that tabs and spaces are allowed inside the parentheses, so
      the following are functionally equivalent:

     <DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>$foo = (int) $bar;
$foo = ( int ) $bar;
      </PRE
><P
></P
></DIV
>

    </P
></DIV
><DIV
CLASS="SECT3"
><H3
CLASS="SECT3"
><A
NAME="LANG-SYNTAX.STRINGCONV"
>String conversion</A
></H3
><P
>      When a string is evaluated as a numeric value, the resulting
      value and type are determined as follows.

     </P
><P
>      The string will evaluate as a double if it contains any of the
      characters '.', 'e', or 'E'. Otherwise, it will evaluate as an
      integer.
     
     </P
><P
>      The value is given by the initial portion of the string. If the
      string starts with valid numeric data, this will be the value
      used. Otherwise, the value will be 0 (zero). Valid numeric data
      is an optional sign, followed by one or more digits (optionally
      containing a decimal point), followed by an optional
      exponent. The exponent is an 'e' or 'E' followed by one or more
      digits.

     <DIV
CLASS="INFORMALEXAMPLE"
><P
></P
><PRE
CLASS="PROGRAMLISTING"
>$foo = 1 + "10.5";      // $foo is double (11.5)
$foo = 1 + "-1.3e3";    // $foo is double (-1299)
$foo = 1 + "bob-1.3e3"; // $foo is integer (1)
$foo = 1 + "bob3";      // $foo is integer (1)
$foo = 1 + "10 Small Pigs";     // $foo is integer (11)
$foo = 1 + "10 Little Piggies"; // $foo is integer (11); 
$foo = "10.0 pigs " + 1;        // $foo is int (11)
$foo = "10.0 pigs " + 1.0;      // $foo is double (11)     
      </PRE
><P
></P
></DIV
>

     </P
><P
>      The type of the variable depends on the second not on the first
      expression, when the first expression is a string.

     </P
><P
>      For more information on this conversion, see the Unix manual
      page for strtod(3).
  </P
></DIV
></DIV
></DIV
><DIV
CLASS="NAVFOOTER"
><HR
ALIGN="LEFT"
WIDTH="100%"><TABLE
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
><A
HREF="types.html"
>Prev</A
></TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="manual.html"
>Home</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
><A
HREF="constants.html"
>Next</A
></TD
></TR
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
>Types</TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="lang-syntax.html"
>Up</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
>Constants</TD
></TR
></TABLE
></DIV
></BODY
></HTML
>