luk Fri Apr 26 16:35:28 2002 EDT
Added files:
/phpdoc/cs/language variables.xml
Modified files:
/phpdoc/cs/language control-structures.xml
Log:
Index: phpdoc/cs/language/control-structures.xml
diff -u phpdoc/cs/language/control-structures.xml:1.4
phpdoc/cs/language/control-structures.xml:1.5
--- phpdoc/cs/language/control-structures.xml:1.4 Thu Apr 25 17:58:13 2002
+++ phpdoc/cs/language/control-structures.xml Fri Apr 26 16:35:27 2002
@@ -854,27 +854,25 @@
<link linkend="control-structures.declare.ticks">ticks</link>)
</para>
<para>
- The <literal>statement</literal> part of the
- <literal>declare</literal> block will be executed - how
- it is executed and what side-effects occur during execution
- may depend on the directive set in the
- <literal>directive</literal> block.
+ Část <literal>statement</literal> bloku <literal>declare</literal>
+ bude provedena - jak bude provedena a jaké vedlejší efekty nastanou
+ během provádění může záležet na direktivě nastavené v bloku
+ <literal>directive</literal>.
</para>
<sect2 id="control-structures.declare.ticks">
<title>Ticks</title>
- <para>A tick is an event that occurs for every
- <replaceable>N</replaceable> low-level statements executed
- by the parser within the <literal>declare</literal> block.
- The value for <replaceable>N</replaceable> is specified
- using <literal>ticks=<replaceable>N</replaceable></literal>
- within the <literal>declare</literal> blocks's
- <literal>directive</literal> section.
+ <para>Tick je událost, která nastane pro každých
+ <replaceable>N</replaceable> nízkoúrovňových konstruktů provedených
+ parserem uvnitř bloku <literal>declare</literal>. Hodnota
+ <replaceable>N</replaceable> je specifikována pomocí
+ <literal>ticks=<replaceable>N</replaceable></literal> uvnitř sekce
+ <literal>directive</literal> bloku <literal>declare</literal>.
</para>
<para>
- The event(s) that occurs on each tick is specified using the
- <function>register_tick_function</function>. See the example
- below for more details. Note that more than one event can occur
- for each tick.
+ Událost(i), která nastane při každém ticku, se specifikuje pomocí
+ <function>register_tick_function</function>. Více podrobností - viz
+ příklad níže. Uvědomte si, že na každý tick může nastat více než jedna
+ událost.
</para>
<para>
<example>
Index: phpdoc/cs/language/variables.xml
+++ phpdoc/cs/language/variables.xml
<?xml version="1.0" encoding="iso-8859-2"?>
<!-- EN-Revision: 1.45 Maintainer: luk Status: mixed -->
<chapter id="language.variables">
<title>Proměnné</title>
<sect1 id="language.variables.basics">
<title>Základy</title>
<simpara>
Proměnné jsou v PHP reprezentovány znakem dolaru, následovaným názvem
příslušné proměnné. V názvech proměnných se rozlišuje velikost písmen.
</simpara>
<para>
Názvy proměnných jsou podřízeny stejným pravidlům jako jiná návěští
v PHP. Platný název proměnné začíná písmenem nebo podtržítkem,
následovaným libovolným počtem písmen, číslic nebo potržítek. Jako
regulární výraz to lze zapsat takto:
'[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
</para>
<note>
<simpara>
Pro naše účely zde budeme za písmena považovat znaky a-z, A-Z
a ASCII znaky od 127 do 255 (0x7f-0xff).
</simpara>
</note>
<para>
<informalexample>
<programlisting role="php">
<![CDATA[
$var = "Bob";
$Var = "Joe";
echo "$var, $Var"; // vypíše "Bob, Joe"
$4site = 'not yet'; // neplatné; začíná číslicí
$_4site = 'not yet'; // platné; začíná podtržítkem
$täyte = 'mansikka'; // platné; 'ä' je ASCII 228.
]]>
</programlisting>
</informalexample>
</para>
<para>
V PHP 3 mají proměnné vždy přiřazenu hodnotu. To znamená, že když
přiřadíte výraz do proměnné, celá hodnota původního výrazu se
zkopíruje do cílové proměnné. Tedy, například, po přiřazení hodnoty
jedné proměnné do druhé, změna jedné z nich se na druhé neprojeví.
Více informací o tomto způsobu přiřazení viz
<link linkend="language.expressions">Výrazy</link>.
</para>
<para>
PHP nabízí jiný způsob přiřazení hodnot proměnným:
<emphasis>přiřazení odkazu</emphasis>. To znamená, že nová proměnná
jednoduše odkazuje (jinými slovy, "stává se aliasem" nebo "ukazuje na")
na původní proměnnou. Změny na nové proměnné se projeví na té původní
a naopak. To také znamená, že se nic nekopíruje; proto je přiřazení
rychlejší. Avšak toto zrychlení bude zjistitelné pouze v těsných cyklech
nebo při přiřazování velkých polí či objektů.
</para>
<para>
Pro přiřazení odkazu stačí jednoduše před proměnnou, která bude
přiřazována (zdrojová proměnná), předřadit ampersand (&). Například
následující kus kódu vypíše dvakrát 'Jmenuji se Bob':
<informalexample>
<programlisting role="php">
<![CDATA[
<?php
$foo = 'Bob'; // Přiřadí hodnotu 'Bob' do $foo
$bar = &$foo; // Odkaz $foo přes $bar.
$bar = "Jmenuji se $bar"; // Změna $bar...
echo $bar;
echo $foo; // $foo je také změněno.
?>
]]>
</programlisting>
</informalexample>
</para>
<para>
Jednou z důležitých věcí, které je třeba si uvědomit, je to, že přes
odkazy lze přiřazovat pouze pojmenované proměnné.
<informalexample>
<programlisting role="php">
<![CDATA[
<?php
$foo = 25;
$bar = &$foo; // Toto je platné přiřazení.
$bar = &(24 * 7); // Neplatné; odkazuje se nepojmenovaný výraz.
function test()
{
return 25;
}
$bar = &test(); // Neplatné.
?>
]]>
</programlisting>
</informalexample>
</para>
</sect1>
<sect1 id="language.variables.predefined">
<title>Předdefinované proměnné</title>
<simpara>
PHP poskytuje velké množství předdefinovaných proměnných jakémukoli
skriptu, který provádí. Mnoho těchto proměnných, bohužel, nemůže být
plně zdokumentováno, protože závisejí na tom, na kterém serveru skript
běží, na verzi a nastavení serveru a dalších faktorech. Některé z těchto
proměnných nebudou dostupné, když PHP poběží z příkazové řádky. Seznam
proměnných - viz sekce
<link linkend="reserved.variables">Předdefinované proměnné</link>.
</simpara>
<warning>
<simpara>
V PHP 4.2.0 a pozdějších se změnila implicitní sada předdefinovaných
proměnných, které jsou globálně dostupné. Individuální vstupní a
serverové proměnné se <emphasis>implicitně</emphasis> neumísťují do
globálního kontextu; namísto toho jsou v následujících
<link linkend="language.variables.superglobals">superglobálních
polích</link>.
</simpara>
<simpara>
Můžete však stále vynutit staré chování nastavením
<link linkend="ini.register-globals">register_globals</link> v souboru
&php.ini; na 'On'.
</simpara>
<simpara>
Pro více informací a pozadí těchto změn prosím nahlédněte do
<ulink url="&url.php.release4.1.0;">PHP 4.1.0 Release Announcement</ulink>.
</simpara>
</warning>
<simpara>
Od verze 4.1.0 poskytuje PHP sadu předdefinovaných polí, obsahujících
proměnné WWW serveru (pokud to jde), prostředí a uživatelského vstupu.
Tato nová pole mají tu zvláštnost, že jsou automaticky globální -- tedy
např. automaticky dostupné v každém kontextu. Z tohoto důvodu jsou
často známa jako "autoglobální" nebo "superglobální". (V PHP neexistuje
mechanismus pro uživatelskou definici superglobálních proměnných).
Superglobální proměnné jsou vypsány níže; pro seznam jejich obsahů a
další diskusi o předdefinovaných proměnných v PHP a jejich charakteru
však musíte nahlédnout do části
<link linkend="reserved.variables">Předdefinované proměnné</link>.
</simpara>
<variablelist id="language.variables.superglobals">
<title>PHP superglobals (superglobální proměnné)</title>
<varlistentry>
<term><link linkend="reserved.variables.globals">$GLOBALS</link></term>
<listitem>
<simpara>
Obsahuje odkaz na každou proměnnou, která je momentálně dostupná
v globálním kontextu skriptu. Klíči tohoto pole jsou názvy globálních
proměnných.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term><link linkend="reserved.variables.server">$_SERVER</link></term>
<listitem>
<simpara>
Proměnné nastavované WWW serveru nebo jinak přímo spjaté s prováděcím
prostředím aktuálního skriptu. Analogické starému poli
<varname>$HTTP_SERVER_VARS</varname> (které je stále dostupné, ale
zavržené).
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term><link linkend="reserved.variables.get">$_GET</link></term>
<listitem>
<simpara>
Proměnné poskytované skriptu přes HTTP GET. Analogické starému poli
<varname>$HTTP_GET_VARS</varname> (které je stále dostupné, ale
zavržené).
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term><link linkend="reserved.variables.post">$_POST</link></term>
<listitem>
<simpara>
Proměnné poskytované skriptu přes HTTP POST. Analogické starému poli
<varname>$HTTP_POST_VARS</varname> (které je stále dostupné, ale
zavržené).
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term><link linkend="reserved.variables.cookies">$_COOKIE</link></term>
<listitem>
<simpara>
Proměnné poskytované skriptu přes HTTP cookies. Analogické starému poli
<varname>$HTTP_COOKIE_VARS</varname> (které je stále dostupné, ale
zavržené).
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term><link linkend="reserved.variables.files">$_FILES</link></term>
<listitem>
<simpara>
Proměnné poskytované skriptu přes HTTP post uploady souborů. Analogické
uploads. Analogické starému poli
<varname>$HTTP_POST_FILES</varname> (které je stále dostupné, ale
zavržené). Více informací - viz
<link linkend="features.file-upload.post-method">Upload metodou
POST</link>.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term><link linkend="reserved.variables.environment">$_ENV</link></term>
<listitem>
<simpara>Proměnné poskytované skriptu z prostředí. Analogické starému
poli <varname>$HTTP_ENV_VARS</varname> (které je stále dostupné, ale
zavržené).
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term><link linkend="reserved.variables.request">$_REQUEST</link></term>
<listitem>
<simpara>
Proměnné poskytované skriptu přes libovolný vstupní mechanismus a
kterým proto nelze důvěřovat. Pozn.: při běhu z příkazové řádky zde
<emphasis>nebudou</emphasis> přítomny položky <varname>argv</varname>
a <varname>argc</varname>; nacházejí se v poli
<varname>$_SERVER</varname>. Přítomnost a pořadí proměnných v tomto
poli se definuje podle konfigurační direktivy
<link linkend="ini.variables-order">variables_order</link>. Toto pole
nemá přímou analogii ve verzích PHP před 4.1.0.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term><link linkend="reserved.variables.session">$_SESSION</link></term>
<listitem>
<simpara>
Proměnné, které jsou momentálně registrovány v aktuální relaci skriptu.
Analogické starému poli
<varname>$HTTP_SESSION_VARS</varname> (které je stále dostupné, ale
zavržené). Více informací - viz <link
linkend="ref.session">Funkce pro obsluhu sessions</link>.
</simpara>
</listitem>
</varlistentry>
</variablelist>
</sect1>
<sect1 id="language.variables.scope">
<title>Kontext ("scope") proměnné</title>
<simpara>
Kontext proměnné je oblast, ve které je definována. Většina proměnných
v PHP má pouze jediný kontext. Ten zahrnuje i soubory vložené pomocí
"include" nebo "require". Například:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
$a = 1;
include "b.inc";
]]>
</programlisting>
</informalexample>
<simpara>
Zde bude proměnná <varname>$a</varname> dostupná ve vloženém skriptu
<filename>b.inc</filename>. Avšak uvnitř uživatelsky definovaných funkcí
se zakládá jejich lokální kontext. Jakákoli proměnná použitá uvnitř
funkce je implicitně omezena na tento místní kontext. Například:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
$a = 1; /* globální kontext */
function Test()
{
echo $a; /* odkaz na proměnnou v lokálním kontextu */
}
Test();
]]>
</programlisting>
</informalexample>
<simpara>
Tento skript nevyprodukuje žádný výstup, protože konstrukt "echo"
odkazuje na lokální verzi proměnné <varname>$a</varname>, a ta nemá
v tomto kontextu přiřazenu žádnou hodnotu. Můžete si všimnout, že to je
trochu jiné než v jazyce C, kde jsou globální funkce automaticky
dostupné ve funkcích, pokud nejsou specificky zastíněny lokální definicí.
To může způsobit problémy tím, že člověk může nechtěně změnit globální
proměnnou. V PHP musí být globální proměnné deklarovány uvnitř funkce
jako globální, pokud se v ní mají používat. Příklad:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
$a = 1;
$b = 2;
function Sum()
{
global $a, $b;
$b = $a + $b;
}
Sum();
echo $b;
]]>
</programlisting>
</informalexample>
<simpara>
Výše uvedený skript vytiskne "3". Deklarací
<varname>$a</varname> a <varname>$b</varname> ve funkci jako globálních
proměnných se dosáhne toho, že při odkazování na proměnné se pracuje
s jejich globální verzí. Počet globálních proměnných, se kterými lze ve
funkci manipulovat, není omezen.
</simpara>
<simpara>
Druhým způsobem, jak přistupovat k proměnným z globálního kontextu, je
použití speciálního pole <varname>$GLOBALS</varname>, definovaného
v PHP. Předchozí příklad lze přepsat:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
$a = 1;
$b = 2;
function Sum()
{
$GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
}
Sum();
echo $b;
]]>
</programlisting>
</informalexample>
<simpara>
Pole <varname>$GLOBALS</varname> je asociativní pole s názvem globální
proměnné jako klíčem a obsahem příslušné proměnné jako obsahem elementu
pole.
</simpara>
<simpara>
Jinou důležitou vlastností rozlišování kontextů proměnných je možnost
používání <emphasis>static</emphasis> proměnných. Statická proměnná
existuje pouze v lokálním kontextu funkce, ale neztrácí svoji hodnotu,
pokud provádění programu tento kontext opustí. Uvažujme následující
příklad:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
function Test ()
{
$a = 0;
echo $a;
$a++;
}
]]>
</programlisting>
</informalexample>
<simpara>
Tato funkce je poněkud neužitečná, neboť při každém volání nastavuje
<varname>$a</varname> na <literal>0</literal> a tiskne "0".
Konstrukt <varname>$a</varname>++, který inkrementuje proměnnou, nemá
žádný význam, protože při skončení vykonávání funkce se obsah proměnné
<varname>$a</varname> ztrácí. Aby měla funkce skutečný význam čítače a
hodnota se neztrácela, deklaruje se proměnná <varname>$a</varname>
jako statická:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
function Test()
{
static $a = 0;
echo $a;
$a++;
}
]]>
</programlisting>
</informalexample>
<simpara>
Nyní se při každém volání funkce Test() vytiskne hodnota proměnné
<varname>$a</varname> a inkrementuje se.
</simpara>
<simpara>
Static variables also provide one way to deal with recursive
functions. 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, using the static
variable <varname>$count</varname> to know when to stop:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
function Test()
{
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
Test ();
}
$count--;
}
]]>
</programlisting>
</informalexample>
</sect1>
<sect1 id="language.variables.variable">
<title>Variable variables</title>
<simpara>
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:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
$a = "hello";
]]>
</programlisting>
</informalexample>
<simpara>
A variable variable takes the value of a variable and treats that
as the name of a variable. In the above example,
<emphasis>hello</emphasis>, can be used as the name of a variable
by using two dollar signs. i.e.
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
$$a = "world";
]]>
</programlisting>
</informalexample>
<simpara>
At this point two variables have been defined and stored in the
PHP symbol tree: <varname>$a</varname> with contents "hello" and
<varname>$hello</varname> with contents "world". Therefore, this
statement:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
echo "$a ${$a}";
]]>
</programlisting>
</informalexample>
<simpara>
produces the exact same output as:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
echo "$a $hello";
]]>
</programlisting>
</informalexample>
<simpara>
i.e. they both produce: <computeroutput>hello world</computeroutput>.
</simpara>
<simpara>
In order to use variable variables with arrays, you have to
resolve an ambiguity problem. That is, if you write
<varname>$$a[1]</varname> then the parser needs to know if you
meant to use <varname>$a[1]</varname> as a variable, or if you
wanted <varname>$$a</varname> as the variable and then the [1]
index from that variable. The syntax for resolving this ambiguity
is: <varname>${$a[1]}</varname> for the first case and
<varname>${$a}[1]</varname> for the second.
</simpara>
</sect1>
<sect1 id="language.variables.external">
<title>Variables from outside PHP</title>
<sect2 id="language.variables.external.form">
<title>HTML Forms (GET and POST)</title>
<simpara>
When a form is submitted to a PHP script, any variables from that
form will be automatically made available to the script by
PHP. If the <link linkend="ini.track-vars">track_vars</link>
configuration option is turned on, then these variables will be
located in the associative arrays
<varname>$HTTP_POST_VARS</varname>,
<varname>$HTTP_GET_VARS</varname>, and/or
<varname>$HTTP_POST_FILES</varname>, according to the
source of the variable in question.
</simpara>
<para>
For more information on these variables, please read <link
linkend="language.variables.predefined">Predefined
variables</link>.
</para>
<para>
<example>
<title>Simple form variable</title>
<programlisting role="php">
<![CDATA[
<form action="foo.php" method="post">
Name: <input type="text" name="username"><br>
<input type="submit">
</form>
]]>
</programlisting>
</example>
</para>
<para>
When the above form is submitted, the value from the text input
will be available in
<varname>$HTTP_POST_VARS['username']</varname>. If the <link
linkend="ini.register-globals">register_globals</link>
configuration directive is turned on, then the variable will also
be available as <varname>$username</varname> in the global scope.
</para>
<note>
<para>
The <link linkend="ini.magic-quotes-gpc">magic_quotes_gpc</link>
configuration directive affects Get, Post and Cookie values. If
turned on, value (It's "PHP!") will automagically become (It\'s \"PHP!\").
Escaping is needed for DB insertion. Also see
<function>addslashes</function>, <function>stripslashes</function> and
<link linkend="ini.magic-quotes-sybase">magic_quotes_sybase</link>.
</para>
</note>
<simpara>
PHP also understands arrays in the context of form variables
(see the <link linkend="faq.html">related faq</link>). You may,
for example, group related variables together, or use this
feature to retrieve values from a multiple select input:
</simpara>
<para>
<example>
<title>More complex form variables</title>
<programlisting role="php">
<![CDATA[
<form action="array.php" method="post">
Name: <input type="text" name="personal[name]"><br>
Email: <input type="text" name="personal[email]"><br>
Beer: <br>
<select multiple name="beer[]">
<option value="warthog">Warthog
<option value="guinness">Guinness
<option value="stuttgarter">Stuttgarter Schwabenbräu
</select>
<input type="submit">
</form>
]]>
</programlisting>
</example>
</para>
<para>
In PHP 3, the array form variable usage is limited to
single-dimensional arrays. In PHP 4, no such restriction applies.
</para>
<sect3 id="language.variables.external.form.submit">
<title>IMAGE SUBMIT variable names</title>
<simpara>
When submitting a form, it is possible to use an image instead
of the standard submit button with a tag like:</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
<input type="image" src="image.gif" name="sub">
]]>
</programlisting>
</informalexample>
<simpara>
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.
</simpara>
</sect3>
</sect2>
<sect2 id="language.variables.external.cookies">
<title>HTTP Cookies</title>
<simpara>
PHP transparently supports HTTP cookies as defined by <ulink
url="&spec.cookies;">Netscape's Spec</ulink>. Cookies are a
mechanism for storing data in the remote browser and thus
tracking or identifying return users. You can set cookies using
the <function>setcookie</function> 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 <function>header</function> function. Any cookies
sent to you from the client will automatically be turned into a
PHP variable just like GET and POST method data.</simpara>
<simpara>
If you wish to assign multiple values to a single cookie, just
add <emphasis>[]</emphasis> to the cookie name. For
example:
</simpara>
<informalexample>
<programlisting role="php">
<![CDATA[
setcookie("MyCookie[]", "Testing", time()+3600);
]]>
</programlisting>
</informalexample>
<simpara>
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.
</simpara>
<example>
<title>SetCookie Example</title>
<programlisting role="php">
<![CDATA[
$Count++;
setcookie("Count", $Count, time()+3600);
setcookie("Cart[$Count]", $item, time()+3600);
]]>
</programlisting>
</example>
</sect2>
<sect2 id="language.variables.external.environment">
<title>Environment variables</title>
<para>
PHP automatically makes environment variables available as normal
PHP variables.
<informalexample>
<programlisting role="php">
<![CDATA[
echo $HOME; /* Shows the HOME environment variable, if set. */
]]>
</programlisting>
</informalexample>
</para>
<para>
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
<function>getenv</function> function can be used for this. You
can also set an environment variable with the
<function>putenv</function> function.
</para>
</sect2>
<sect2 id="language.variables.external.dot-in-names">
<title>Dots in incoming variable names</title>
<para>
Typically, PHP does not alter the names of variables when they
are passed into a script. However, it should be noted that the
dot (period, full stop) is not a valid character in a PHP
variable name. For the reason, look at it:
<programlisting role="php">
<![CDATA[
$varname.ext; /* invalid variable name */
]]>
</programlisting>
Now, what the parser sees is a variable named
<varname>$varname</varname>, followed by the string concatenation
operator, followed by the barestring (i.e. unquoted string which
doesn't match any known key or reserved words) 'ext'. Obviously,
this doesn't have the intended result.
</para>
<para>
For this reason, it is important to note that PHP will
automatically replace any dots in incoming variable names with
underscores.
</para>
</sect2>
<sect2 id="language.variables.determining-type-of">
<title>Determining variable types</title>
<para>
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
<function>gettype</function>, <function>is_array</function>,
<function>is_float</function>, <function>is_int</function>,
<function>is_object</function>, and
<function>is_string</function>.
</para>
</sect2>
</sect1>
</chapter>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->
