cynic Mon Feb 5 04:40:02 2001 EDT
Added files:
/phpdoc/cs/functions array.xml
Log:
should be completely translated
Index: phpdoc/cs/functions/array.xml
+++ phpdoc/cs/functions/array.xml
<reference id="ref.array">
<title>Funkce pro práci s poli</title>
<titleabbrev>Pole</titleabbrev>
<partintro>
<simpara>
Tyto funkce vám umožňují manipulovat a interagovat různými způsoby s poli.
Pole jsou nezbytná pro ukládání a práci se sadami proměnných.
</simpara>
<simpara>
Podporována jsou jednoduchá a vícerozměrná pole; vytvářet se dají uživatelsky
i jako výstup funkce. Existují databázové funkce na plnění polí výsledky
databázových dotazů, a několik dalších funkcí vrací pole.
</simpara>
<para>
Viz také: <function>is_array</function>,
<function>explode</function>,
<function>implode</function>,
<function>split</function> a
<function>join</function>.
</para>
</partintro>
<refentry id="function.array">
<refnamediv>
<refname>array</refname>
<refpurpose>
Vytvořit pole
</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array</function></funcdef>
<paramdef>mixed
<parameter><optional>...</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
Vrací pole argumentů. Argumentům může být přiřazen index pomocí operátoru
<literal>=></literal>.
</para>
<para>
<note>
<para>
<function>array</function> je jazykový konstrukt používaný k reprezentaci
polí, nikoliv běžná funkce.
</para>
</note>
</para>
<para>
Syntaxe "index => hodnota", s čárko jako oddělovačem, definuje indexy a
hodnoty. Index může být řetězec nebo číslo. Pokud se index vynechá,
automaticky se generuje číselný index začínající na 0. Pokud je index
integer, další generovaný index bude nejvyšší celočíselný index + 1. Pozn.:
pokud jsou definovány dva identické indexy, první se přepíše posledním.
</para>
<para>
Následující ukázka demonstruje jak vytvořit dvourozměrné pole, jak určit
klíče v asociativních polích, a jak přeskakovat číselné indexy v normálních
polích.
<example>
<title>Ukázka <function>array</function></title>
<programlisting role="php">
$fruits = array (
"fruits" => array ("a"=>"orange", "b"=>"banana", "c"=>"apple"),
"numbers" => array (1, 2, 3, 4, 5, 6),
"holes" => array ("first", 5 => "second", "third")
);
</programlisting>
</example>
</para>
<para>
<example>
<title>Automatický index a <function>array</function></title>
<programlisting role="php">
$array = array( 1, 1, 1, 1, 1, 8=>1, 4=>1, 19, 3=>13);
print_r($array);
</programlisting>
</example>
výstup bude následující:
<informalexample>
<programlisting>
Array
(
[0] => 1
[1] => 1
[2] => 1
[3] => 13
[4] => 1
[8] => 1
[9] => 19
)
</programlisting>
</informalexample>
Index 3 je definován dvakrát, a podrží si poslední hodnotu 13. Index 4 je
definován po indexu 8 a další generovaný index (hodnota 19) je 9, protože
nejvyšší index byl 8.
</para>
<para>
Tato ukázka vytvoří pole číslované od 1.
<example>
<title>Index začínající 1 s <function>array</function></title>
<programlisting role="php">
$firstquarter = array(1 => 'January', 'February', 'March');
print_r($firstquarter);
</programlisting>
</example>
toto bude výstup:
<informalexample>
<programlisting>
Array
(
[1] => 'January'
[2] => 'February'
[3] => 'March'
)
</programlisting>
</informalexample>
</para>
<para>
Viz také: <function>list</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-count-values">
<refnamediv>
<refname>array_count_values</refname>
<refpurpose>Spočítat všechny hodnoty v poli</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_count_values</function></funcdef>
<paramdef>array <parameter>input</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_count_values</function> vrací pole používající hodnoty z
<parameter>input</parameter> jako klíče a jejich četnosti v
<parameter>input</parameter> jako hodnoty.
</para>
<para>
<example>
<title>Ukázka <function>array_count_values</function></title>
<programlisting role="php">
$array = array (1, "hello", 1, "world", "hello");
array_count_values ($array); // vrací array(1=>2, "hello"=>2, "world"=>1)
</programlisting>
</example>
</para>
</refsect1>
</refentry>
<refentry id="function.array-diff">
<refnamediv>
<refname>array_diff</refname>
<refpurpose>Spočítat rozdíl polí</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_diff</function></funcdef>
<paramdef>array <parameter>array1</parameter></paramdef>
<paramdef>array <parameter>array2</parameter></paramdef>
<paramdef>array
<parameter><optional> ...</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_diff</function> vrací pole obsahující všechny hodnoty z
<parameter>array1</parameter>, které se nevyskytují v žádném z dalších
argumentů. Klíče jsou zachovány.
</para>
<para>
<example>
<title>Ukázka <function>array_diff</function></title>
<programlisting role="php">
$array1 = array ("a" => "green", "red", "blue");
$array2 = array ("b" => "green", "yellow", "red");
$result = array_diff ($array1, $array2);
</programlisting>
</example>
</para>
<para>
<varname>$result</varname> obsahuje <literal>array ("blue");</literal>
</para>
<para>
Viz také: <function>array_intersect</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-flip">
<refnamediv>
<refname>array_flip</refname>
<refpurpose>Prohodit klíče a hodnoty pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_flip</function></funcdef>
<paramdef>array <parameter>trans</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_flip</function> pole s prohozenými klíči a hodnotami.
</para>
<para>
<example>
<title>Ukázka <function>array_flip</function></title>
<programlisting role="php">
$trans = array_flip ($trans);
$original = strtr ($str, $trans);
</programlisting>
</example>
</para>
</refsect1>
</refentry>
<refentry id="function.array-intersect">
<refnamediv>
<refname>array_intersect</refname>
<refpurpose>Spočítat průnik polí</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_intersect</function></funcdef>
<paramdef>array <parameter>array1</parameter></paramdef>
<paramdef>array <parameter>array2</parameter></paramdef>
<paramdef>array
<parameter><optional> ...</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_intersect</function> vrací pole obsahující všechny hodnoty
z <parameter>array1</parameter>, které se vyskytují ve všech argumentech.
Klíče jsou zachovány.
</para>
<para>
<example>
<title>Ukázka <function>array_intersect</function></title>
<programlisting role="php">
$array1 = array ("a" => "green", "red", "blue");
$array2 = array ("b" => "green", "yellow", "red");
$result = array_intersect ($array1, $array2);
</programlisting>
</example>
</para>
<para>
<varname>$result</varname> obsahuje <literal>array ("a" => "green",
"red");</literal>
</para>
<para>
Viz také: <function>array_diff</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-keys">
<refnamediv>
<refname>array_keys</refname>
<refpurpose>Vrátit všechny klíče pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_keys</function></funcdef>
<paramdef>array <parameter>input</parameter></paramdef>
<paramdef>mixed
<parameter>
<optional>search_value</optional>
</parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_keys</function> vrací klíče, numerické i textové, z pole
<parameter>input</parameter>.
</para>
<para>
Pokud je přítomen volitelný argument <parameter>search_value</parameter>,
vrací pouze klíče této hodnoty. Jinak vrací všechny klíče z pole
<parameter>input</parameter>.
</para>
<para>
<example>
<title>Ukázka <function>array_keys</function></title>
<programlisting role="php">
$array = array (0 => 100, "color" => "red");
array_keys ($array); // vrací array (0, "color")
$array = array ("blue", "red", "green", "blue", "blue");
array_keys ($array, "blue"); // vrací array (0, 3, 4)
$array = array ("color" => array("blue", "red", "green"), "size" =>
array("small", "medium", "large"));
array_keys ($array); // vrací array ("color", "size")
</programlisting>
</example>
</para>
<note>
<para>
Tato funkce byla přidána v PHP 4, dále je uvedena implementace pro ty, kteří
stále používají PHP 3.
<example>
<title>
Implementace <function>array_keys</function> pro uživatele PHP 3
</title>
<programlisting role="php">
function array_keys ($arr, $term="") {
$t = array();
while (list($k,$v) = each($arr)) {
if ($term && $v != $term)
continue;
$t[] = $k;
}
return $t;
}
</programlisting>
</example>
</para>
</note>
<para>
Viz také: <function>array_values</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-merge">
<refnamediv>
<refname>array_merge</refname>
<refpurpose>Sloučit dvě nebo více polí</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_merge</function></funcdef>
<paramdef>array <parameter>array1</parameter></paramdef>
<paramdef>array <parameter>array2</parameter></paramdef>
<paramdef>array
<parameter><optional>...</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_merge</function> sloučí prvky dvou nebo více polí dohromady
tak, že hodnoty každého pole se připojí na konec předchozího. Vrací výsledné
pole.
</para>
<para>
Pokud mají vstupní pole stejný textový klíč, pozdější hodnota přepíše
dřívější hodnotu. Pokud ale mají stejný číselný klíč, pozdější hodnota tu
púvodní nepřepíše, ale připojí se k ní.
</para>
<para>
<example>
<title>Ukázka <function>array_merge</function></title>
<programlisting role="php">
$array1 = array ("color" => "red", 2, 4);
$array2 = array ("a", "b", "color" => "green", "shape" => "trapezoid", 4);
array_merge ($array1, $array2);
</programlisting>
</example>
</para>
<para>
Výsledné pole bude <literal>array("color" => "green", 2, 4,
"a", "b", "shape" => "trapezoid", 4)</literal>.
</para>
<para>
Viz také: <function>array_merge_recursive</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-merge-recursive">
<refnamediv>
<refname>array_merge_recursive</refname>
<refpurpose>Rekurzivně sloučit dvě nebo více polí</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_merge_recursive</function></funcdef>
<paramdef>array <parameter>array1</parameter></paramdef>
<paramdef>array <parameter>array2</parameter></paramdef>
<paramdef>array
<parameter><optional>...</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_merge_recursive</function> sloučí prvky dvou nebo více
polí tak, že hodnoty pole se připojí na konec předchozího pole. Vrací
výsledné pole.
</para>
<para>
Pokud obsahují vstupní pole stejný textový klíč, hodnoty těchto klíčů se
rekurzivně sloučí do pole tak, že pokud je jedna z hodnot sama pole, tato
funkce ji také sloučí s odpovídající položkou z dalšího pole. Pokud ale
tato pole mají stejný číselný klíč, pozdější hodnota nepřepíše tu dřívější,
ale připojí se.
</para>
<para>
<example>
<title>Ukázka <function>array_merge_recursive</function></title>
<programlisting role="php">
$ar1 = array ("color" => array ("favorite" => "red"), 5);
$ar2 = array (10, "color" => array ("favorite" => "green", "blue"));
$result = array_merge_recursive ($ar1, $ar2);
</programlisting>
</example>
</para>
<para>
Výsledné pole bude <literal>array ("color" => array
("favorite" => array ("red", "green"), "blue"), 5, 10)</literal>.
</para>
<para>
Viz také: <function>array_merge</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-multisort">
<refnamediv>
<refname>array_multisort</refname>
<refpurpose>Třídit více polí, nebo vícerozměrné pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>bool <function>array_multisort</function></funcdef>
<paramdef>array <parameter>ar1</parameter></paramdef>
<paramdef>mixed
<parameter><optional>arg</optional></parameter>
</paramdef>
<paramdef>mixed
<parameter><optional>...</optional></parameter>
</paramdef>
<paramdef>array
<parameter><optional>...</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_multisort</function> se dá využít k třídění několika
polí najednou nebo k třídění vícerozměrného pole XXX according by one of
more dimensions. Při třídění udržuje asociace klíčů.
</para>
<para>
Vstupní pole jsou manipulována jako sloupce tabulky, která se má třídit
podle řádků - připomíná to funkcionalitu SQL klauzule ORDER BY. První pole
je to, podle kterého se bude třídit. Řádky (hodnoty) v tomto poli that
compare the same are sorted by the next input array, and so on.
</para>
<para>
Struktura argumentů této funkce je trochu neobvyklá, ale pružná. První
argument musí být pole. Každý další argument může být buď pole nebo jeden
z příznak z následujících seznamů:
</para>
<para>
Příznaky směru třídění:
<itemizedlist>
<listitem>
<simpara>SORT_ASC - třídit vzestupně</simpara>
</listitem>
<listitem>
<simpara>SORT_DESC - třídit sestupně</simpara>
</listitem>
</itemizedlist>
</para>
<para>
Příznaky typu třídění:
<itemizedlist>
<listitem>
<simpara>SORT_REGULAR - porovnávat položky normálně</simpara>
</listitem>
<listitem>
<simpara>SORT_NUMERIC - porovnávat položky číselně</simpara>
</listitem>
<listitem>
<simpara>SORT_STRING - porovnávat položky jako řetězce</simpara>
</listitem>
</itemizedlist>
</para>
<para>
Po každém poli můžete specifikovat jeden příznak každého typu. Příznaky
třídění specifikované po každém poli platí pouze pro toto pole - pro další
pole se resetují na defaultní SORT_ASC a SORT_REGULAR.
</para>
<para>
Při úspěchu vrací <literal>true</literal>, při selhání
<literal>false</literal>.
</para>
<para>
<example>
<title>Třídění více polí</title>
<programlisting role="php">
$ar1 = array ("10", 100, 100, "a");
$ar2 = array (1, 3, "2", 1);
array_multisort ($ar1, $ar2);
</programlisting>
</example>
</para>
<para>
V této ukázce bude po setřídění první pole obsahovat 10, "a", 100, 100.
Druhé pole bude obsahovat 1, 1, 2, "3". Položky druhého pole odpovídající
identickým položkám v prvním poli (100 a 100) byly také setříděny.
</para>
<para>
<example>
<title>Třídění vícerozměrného pole</title>
<programlisting role="php">
$ar = array (array ("10", 100, 100, "a"), array (1, 3, "2", 1));
array_multisort ($ar[0], SORT_ASC, SORT_STRING,
$ar[1], SORT_NUMERIC, SORT_DESC);
</programlisting>
</example>
</para>
<para>
V této ukázce bude po setřídění první pole obsahovat 10, 100, 100, "a"
(bylo tříděno vzestupně jako řetězce) a druhé pole bude obsahovat 1, 3,
"2", 1 (tříděno jako čísla, sestupně).
</para>
</refsect1>
</refentry>
<refentry id="function.array-pad">
<refnamediv>
<refname>array_pad</refname>
<refpurpose>Doplnit pole hodnotou na určenou délku</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_pad</function></funcdef>
<paramdef>array <parameter>input</parameter></paramdef>
<paramdef>int <parameter>pad_size</parameter></paramdef>
<paramdef>mixed <parameter>pad_value</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_pad</function> vrací kopii pole
<parameter>input</parameter> doplněnou na velikost
<parameter>pad_size</parameter> hodnotou
<parameter>pad_value</parameter>. Pokud je
<parameter>pad_size</parameter> kladná, pole je doplněno zprava, pokud je
negativní, zleva. Pokud je absolutní hodnota <parameter>pad_size</parameter>
menší nebo rovna velikosti <parameter>input</parameter>, k doplnění nedojde.
</para>
<para>
<example>
<title>Ukázka <function>array_pad</function></title>
<programlisting role="php">
$input = array (12, 10, 9);
$result = array_pad ($input, 5, 0);
// výsledek je array (12, 10, 9, 0, 0)
$result = array_pad ($input, -7, -1);
// výsledek je array (-1, -1, -1, -1, 12, 10, 9)
$result = array_pad ($input, 2, "noop");
// nedoplněno
</programlisting>
</example>
</para>
</refsect1>
</refentry>
<refentry id="function.array-pop">
<refnamediv>
<refname>array_pop</refname>
<refpurpose>Odstranit prvek z konce pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>array_pop</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_pop</function> odstraní a vrátí poslední hodnotu pole
<parameter>array</parameter>, čímž ho zkrátí o jeden prvek.
</para>
<para>
<example>
<title>Ukázka <function>Array_pop</function></title>
<programlisting role="php">
$stack = array ("orange", "apple", "raspberry");
$fruit = array_pop ($stack);
</programlisting>
</example>
</para>
<para>
<varname>$stack</varname> má teď pouze dva prvky:
"orange" a "apple", a <varname>$fruit</varname> obsahuje "raspberry".
</para>
<para>
Viz také: <function>array_push</function>,
<function>array_shift</function> a
<function>array_unshift</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-push">
<refnamediv>
<refname>array_push</refname>
<refpurpose>Přidat jeden nebo více prvků na konec pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>int <function>array_push</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
<paramdef>mixed
<parameter><optional>...</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_push</function> připojuje předané proměnné na konec
<parameter>array</parameter>. Délka <parameter>array</parameter> se zvětšuje
o počet přidaných proměnných. Účinek je stejný jako:
<programlisting role="php">
$array[] = $var;
</programlisting>
opakované pro každou <parameter>var</parameter>.
</para>
<para>
Vrací nový počet prvků v poli.
</para>
<para>
<example>
<title>Ukázka <function>array_push</function></title>
<programlisting role="php">
$stack = array (1, 2);
array_push ($stack, "+", 3);
</programlisting>
</example>
</para>
<para>
Výsledkem této ukázky by byl <varname>$stack</varname> obsahující 4
prvky: 1, 2, "+" a 3.
</para>
<para>
Viz také: <function>array_pop</function>,
<function>array_shift</function> a
<function>array_unshift</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-rand">
<refnamediv>
<refname>array_rand</refname>
<refpurpose>Vybrat náhodně jeden nebo více prvků pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>array_rand</function></funcdef>
<paramdef>array <parameter>input</parameter></paramdef>
<paramdef>int
<parameter><optional>num_req</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_rand</function> je poměrně užitečná, když chcete z pole
vybrat náhodně jednu nebo více hodnot. Přijímá pole
<parameter>input</parameter> a volitelný argument
<parameter>num_req</parameter>, který určuje, kolik položek chcete. Jeho
defaultní hodnota je 1.
</para>
<para>
Pokud vybíráte pouze jednu položku, <function>array_rand</function>
vrací klíč náhodné položky. Jinak vrací pole klíčů náhodně vybraných položek.
Takto můžete vybírat náhodně hodnoty i klíče.
</para>
<para>
Nezapomeňte inicializovat generátor náhodných čísel pomocí
<function>srand</function>.
</para>
<para>
<example>
<title>Ukázka <function>array_rand</function></title>
<programlisting role="php">
srand ((double) microtime() * 10000000);
$input = array ("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
$rand_keys = array_rand ($input, 2);
print $input[$rand_keys[0]]."\n";
print $input[$rand_keys[1]]."\n";
</programlisting>
</example>
</para>
</refsect1>
</refentry>
<refentry id="function.array-reverse">
<refnamediv>
<refname>array_reverse</refname>
<refpurpose>Vrátit pole s prvky v opačném pořadí</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_reverse</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>bool
<parameter><optional>preserve_keys</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_reverse</function> takes input
<parameter>array</parameter> and returns a new array with the
order of the elements reversed, preserving the keys if
<parameter>preserve_keys</parameter> is true.
</para>
<para>
<example>
<title><function>Array_reverse</function> example</title>
<programlisting role="php">
$input = array ("php", 4.0, array ("green", "red"));
$result = array_reverse ($input);
$result_keyed = array_reverse ($input, true);
</programlisting>
</example>
</para>
<para>
<varname>$result</varname> teď obsahuje <literal>array (array ("green",
"red"), 4.0, "php")</literal>. Ale <varname>$result2[0]</varname> je stále
<literal>"php"</literal>.
</para>
<note>
<para>
Druhý argument byl přidán v PHP 4.0.3.
</para>
</note>
</refsect1>
</refentry>
<refentry id="function.array-shift">
<refnamediv>
<refname>array_shift</refname>
<refpurpose>Odstranit prvek ze začátku pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>array_shift</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_shift</function> vrací první položku
<parameter>array</parameter> a odstraní ji, čímž zkrátí
<parameter>array</parameter> o jeden prvek a ostatní posune dolů.
</para>
<para>
<example>
<title>Ukázka <function>array_shift</function></title>
<programlisting role="php">
$args = array ("-v", "-f");
$opt = array_shift ($args);
</programlisting>
</example>
</para>
<para>
<varname>$args</varname> teď má jeden prvek: "-f" a <varname>$opt</varname>
je "-v".
</para>
<para>
Viz také: <function>array_unshift</function>,
<function>array_push</function> a
<function>array_pop</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-slice">
<refnamediv>
<refname>array_slice</refname>
<refpurpose>Vytáhnout část pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_slice</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>int <parameter>offset</parameter></paramdef>
<paramdef>int
<parameter>
<optional>length</optional>
</parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_slice</function> vrací sekvenci prvků
<parameter>array</parameter> určených argumenty
<parameter>offset</parameter> a <parameter>length</parameter>.
</para>
<para>
Pokud je <parameter>offset</parameter> kladný, tato sekvence začne
<parameter>offset</parameter> položek od začátku
<parameter>array</parameter>. Pokud je <parameter>offset</parameter>
záporný, tato sekvence začne tolik položek od konce
<parameter>array</parameter>.
</para>
<para>
Pokud je <parameter>length</parameter> kladná, tato sekvence bude obsahovat
tolik prvků. Pokud je <parameter>length</parameter> záporná, tato sekvence
skončí tolik prvků od konce <parameter>array</parameter>. Pokud
<parameter>length</parameter> vynecháte, tato sekvence bude obsahovat
všechny prvky <parameter>array</parameter> od <parameter>offset</parameter>
do konce.
</para>
<para>
<example>
<title>Ukázka <function>array_slice</function></title>
<programlisting role="php">
$input = array ("a", "b", "c", "d", "e");
$output = array_slice ($input, 2); // returns "c", "d", and "e"
$output = array_slice ($input, 2, -1); // returns "c", "d"
$output = array_slice ($input, -2, 1); // returns "d"
$output = array_slice ($input, 0, 3); // returns "a", "b", and "c"
</programlisting>
</example>
</para>
<para>
Viz také: <function>array_splice</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-splice">
<refnamediv>
<refname>array_splice</refname>
<refpurpose>Odstranit část pole a nahradit ji něčím jiným</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_splice</function></funcdef>
<paramdef>array <parameter>input</parameter></paramdef>
<paramdef>int <parameter>offset</parameter></paramdef>
<paramdef>int
<parameter><optional>length</optional></parameter>
</paramdef>
<paramdef>array
<parameter>
<optional>replacement</optional>
</parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_splice</function> odstraňuje prvky pole
<parameter>input</parameter> určené argumenty <parameter>offset</parameter>
a <parameter>length</parameter>, a případně je nahrazuje prvky volitelného
argumentu (pole) <parameter>replacement</parameter>.
</para>
<para>
Pokud je <parameter>offset</parameter> kladný, tato odstraněná část začne
<parameter>offset</parameter> položek od začátku
<parameter>array</parameter>. Pokud je <parameter>offset</parameter>
záporný, začne tolik položek od konce <parameter>array</parameter>.
</para>
<para>
Pokud vynecháte <parameter>length</parameter>,
<function>array_splice</function> odstraní všechno od
<parameter>offset</parameter> do konce pole. Pokud je
<parameter>length</parameter> kladná, odstraní se právě tolik prvků. Pokud
je <parameter>length</parameter> záporná, konec odstraněné části bude
právě tolik prvků od konce pole. Tip: k odstranění všech prvků od
<parameter>offset</parameter> do konce pole při současně určeném argumentu
<parameter>replacement</parameter> použijte jako
<parameter>length</parameter> <literal>count($input)</literal>.
</para>
<para>
Pokud zadáte <parameter>replacement</parameter> pole, odstraněné prvky se
nahradí prvky tohoto pole. Pokud argumenty <parameter>offset</parameter> a
<parameter>length</parameter> definovány tak, že se nic neodstraní, prvky
pole <parameter>replacement</parameter> se vloží na místo určené argumentem
<parameter>offset</parameter>. Tip: pokud je <parameter>replacement</parameter>
jen jedna hodnota, není nutno ji umisťovat do <literal>array()</literal>,
ledaže chcete, aby tato položka byla opravdu pole.
</para>
<para>
Následující volání jsou ekvivalentní:
<programlisting>
array_push ($input, $x, $y) array_splice ($input, count ($input), 0,
array ($x, $y))
array_pop ($input) array_splice ($input, -1)
array_shift ($input) array_splice ($input, 0, 1)
array_unshift ($input, $x, $y) array_splice ($input, 0, 0, array ($x, $y))
$a[$x] = $y array_splice ($input, $x, 1, $y)
</programlisting>
</para>
<para>
Vrací pole odstraněných prvků.
</para>
<para>
<example>
<title>Ukázky <function>array_splice</function></title>
<programlisting role="php">
$input = array ("red", "green", "blue", "yellow");
array_splice ($input, 2); // $input is now array ("red", "green")
array_splice ($input, 1, -1); // $input is now array ("red", "yellow")
array_splice ($input, 1, count($input), "orange");
// $input is now array ("red", "orange")
array_splice ($input, -1, 1, array("black", "maroon"));
// $input is now array ("red", "green",
// "blue", "black", "maroon")
</programlisting>
</example>
</para>
<para>
Viz také: <function>array_slice</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-unique">
<refnamediv>
<refname>array_unique</refname>
<refpurpose>Odstranit z pole duplicitní hodnoty</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_unique</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_unique</function> přijímá pole <parameter>array</parameter>
a vrací nové pole bez duplicitních hodnot. Klíče jsou zachovány.
</para>
<para>
<example>
<title>Ukázka <function>array_unique</function></title>
<programlisting role="php">
$input = array ("a" => "green", "red", "b" => "green", "blue", "red");
$result = array_unique ($input);
</programlisting>
</example>
</para>
<para>
<varname>$result</varname> teď obsahuje <literal>array ("a" =>
"green", "red", "blue");</literal>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-unshift">
<refnamediv>
<refname>array_unshift</refname>
<refpurpose>Připojit jeden nebo více prvků na začátek pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>int <function>array_unshift</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
<paramdef>mixed
<parameter>
<optional>...</optional>
</parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_unshift</function> připojí předané prvky na začátek
<parameter>array</parameter>. Všechny prvky jsou přidány jako celek, čili
přidané prvky si zachovávají pořadí.
</para>
<para>
vrací nový počet prvků v <parameter>array</parameter>.
</para>
<para>
<example>
<title>Ukázka <function>array_unshift</function></title>
<programlisting role="php">
$queue = array ("p1", "p3");
array_unshift ($queue, "p4", "p5", "p6");
</programlisting>
</example>
</para>
<para>
<varname>$queue</varname> bude mít 5 prvků: "p4", "p5", "p6", "p1" a "p3".
</para>
<para>
Viz také: <function>array_shift</function>,
<function>array_push</function> a
<function>array_pop</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.array-values">
<refnamediv>
<refname>array_values</refname>
<refpurpose>Vrátit všechny hodnoty v poli</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>array_values</function></funcdef>
<paramdef>array <parameter>input</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>array_values</function> vrací všechny hodnoty pole
<parameter>input</parameter>.
</para>
<para>
<example>
<title>Ukázka <function>array_values</function></title>
<programlisting role="php">
$array = array ("size" => "XL", "color" => "gold");
array_values ($array); // vrátí array ("XL", "gold")
</programlisting>
</example>
</para>
<note>
<para>
Tato funkce byla přidána v PHP 4, následuje implementace pro ty, kdo stále
používají PHP 3.
<example>
<title>
Implementace <function>array_values</function> pro uživatele PHP 3
</title>
<programlisting role="php">
function array_values ($arr) {
$t = array();
while (list($k, $v) = each ($arr)) {
$t[] = $v;
return $t;
}
}
</programlisting>
</example>
</para>
</note>
</refsect1>
</refentry>
<refentry id="function.array-walk">
<refnamediv>
<refname>array_walk</refname>
<refpurpose>Použít uživatelskou funkci na všechny prvky pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>int <function>array_walk</function></funcdef>
<paramdef>array <parameter>arr</parameter></paramdef>
<paramdef>string <parameter>func</parameter></paramdef>
<paramdef>mixed <parameter>userdata</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<simpara>
Aplikuje funkci <parameter>func</parameter> na všechny prvky pole
<parameter>arr</parameter>. Funkci <parameter>func</parameter> se jako první
argument předá hodnota a jako druhý klíč. Pokud je přítomen argument
<parameter>userdata</parameter>, bude uživatelské funkci předán jako
třetí argument.
</simpara>
<simpara>
Pokud <parameter>func</parameter> vyžaduje více než dva nebo tři argumenty
(v závislosti na <parameter>userdata</parameter>), pro každé volání
<parameter>func</parameter> z <function>array_walk</function> se vygeneruje
varování. Tato varování se dají potlačit přidáním znaku '@' před
volání <function>array_walk</function> nebo pomocí
<function>error_reporting</function>.
</simpara>
<note>
<para>
Pokud <parameter>func</parameter> potřebuje pracovat přímo s daným polem,
první argument <parameter>func</parameter> se musí předávat odkazem.
Všechny změny těchto hodnot se pak promítnou přímo
v <parameter>arr</parameter>.
</para>
</note>
<note>
<para>
Druhý a třetí argument <parameter>func</parameter> byly přidány v PHP 4.0.
</para>
<para>
V PHP 4 je třeba volat podle potřeby <function>reset</function>, protože
<function>array_walk</function> sama vstupní pole neresetuje.
</para>
</note>
<para>
<example>
<title>Ukázka <function>array_walk</function></title>
<programlisting role="php">
$fruits = array ("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
function test_alter (&$item1, $key, $prefix) {
$item1 = "$prefix: $item1";
}
function test_print ($item2, $key) {
echo "$key. $item2<br>\n";
}
array_walk ($fruits, 'test_print');
reset ($fruits);
array_walk ($fruits, 'test_alter', 'fruit');
reset ($fruits);
array_walk ($fruits, 'test_print');
</programlisting>
</example>
</para>
<simpara>
Viz také: <function>each</function> a
<function>list</function>.
</simpara>
</refsect1>
</refentry>
<refentry id="function.arsort">
<refnamediv>
<refname>arsort</refname>
<refpurpose>Třídit pole sestupně se zachováním klíčů
</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>arsort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>int
<parameter><optional>sort_flags</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>arsort</function> třídí pole tak, že indexy pole si zachovávají
korelace s prvky, se kterými jsou asociovány. Toto je užitečné hlavně při
třídění asociativních polí, kde je pořadí prvků signifikantní.
<example>
<title>Ukázka <function>Arsort</function></title>
<programlisting role="php">
$fruits = array ("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
arsort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
echo "$key = $val\n";
}
</programlisting>
</example>
</para>
<para>
Tato ukázka zobrazí:
</para>
<para>
<informalexample>
<programlisting>
fruits[a] = orange
fruits[d] = lemon
fruits[b] = banana
fruits[c] = apple
</programlisting>
</informalexample>
</para>
<para>
Ovoce bylo sestupně setříděno podle abecedy, a indexy asociované s
jednotlivými prvky byly zachovány.
</para>
<para>
Chování třídění můžete upravit pomocí volitelného argumentu
<parameter>sort_flags</parameter>, detaily viz <function>sort</function>.
</para>
<para>
Viz také: <function>asort</function>,
<function>rsort</function>,
<function>ksort</function> a
<function>sort</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.asort">
<refnamediv>
<refname>asort</refname>
<refpurpose>Třídit pole se zachováním indexů</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>asort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>int <parameter><optional>sort_flags</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>asort</function> třídí pole tak, že si indexy zachovají corelace
s prvky, se kterými jsou spojeny. To je užitečné hlavně při třídění
asociativních polí, u kterých je pořadí prvků signifikantní.
<example>
<title>Ukázka <function>Asort</function></title>
<programlisting role="php">
$fruits = array ("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
asort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
echo "$key = $val\n";
}
</programlisting>
</example>
</para>
<para>
Tato ukázka zobrazí:
</para>
<para>
<informalexample>
<programlisting>
fruits[c] = apple
fruits[b] = banana
fruits[d] = lemon
fruits[a] = orange
</programlisting>
</informalexample>
</para>
<para>
Ovoce bylo setříděno podle abecedy a indexy spojené s jednotlivými
prvky byly zachovány.
</para>
<para>
Chování třídění můžete upravit pomocí volitelného argumentu
<parameter>sort_flags</parameter>, detaily viz <function>sort</function>.
</para>
<para>
Viz také: <function>arsort</function>,
<function>rsort</function>,
<function>ksort</function> a
<function>sort</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.compact">
<refnamediv>
<refname>compact</refname>
<refpurpose>Vytvořit pole obsahující proměnné a jejich hodnoty</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>compact</function></funcdef>
<paramdef>mixed <parameter>varname</parameter></paramdef>
<paramdef>mixed
<parameter><optional>...</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>compact</function> přijímá proměnný počet argumentů. Každý
argument může být buď řetězec obsahující název proměnné nebo pole názvů
proměnných. Toto pole může také obsahovat pole názvů proměnnýchů;
<function>compact</function> je rekurzivně zpracuje.
</para>
<para>
Pro každý z řetězců <function>compact</function> vyhledá v aktivní symbolové
tabulce proměnnou tohoto jména a přidá ji do výsledného pole tak, že název
této proměnné se stane klíčem a obsah této proměnné hodnotou tohoto klíče.
Stručně řečeno, dělá pravý opak toho, co <function>extract</function>.
Vrací pole obsahující všechny tyto proměnné.
</para>
<para>
Řetězce, které neobsahují názvy platných proměnných se přeskočí.
</para>
<para>
<example>
<title>Ukázka <function>compact</function></title>
<programlisting role="php">
$city = "San Francisco";
$state = "CA";
$event = "SIGGRAPH";
$location_vars = array ("city", "state");
$result = compact ("event", "nothing_here", $location_vars);
</programlisting>
<para>
<varname>$result</varname> bude <literal>array ("event"
=> "SIGGRAPH", "city" => "San Francisco", "state" => "CA")</literal>.
</para>
</example>
</para>
<para>
Viz také: <function>extract</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.count">
<refnamediv>
<refname>count</refname>
<refpurpose>Spočítat prvky v proměnné</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>int <function>count</function></funcdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Vrací počet prvků v <parameter>var</parameter>, která je typicky pole
(jelikož všechno ostatní má jeden prvek).
</para>
<para>
Vrací <literal>1</literal>, pokud <parameter>var</parameter> není pole.
</para>
<para>
Vrací <literal>0</literal>, pokud <parameter>var</parameter> není
inicializována.
<warning>
<para>
<function>count</function> vrací <literal>0</literal> pro proměnné,
které nejsou inicializovány, ale vrací také <literal>0</literal> pro
proměnné, které obsahují prázdné pole. Pokud potřebujete zjistit, jestli
dotyčná proměnná existuje, použijte <function>isset</function>.
</para>
</warning>
</para>
<para>
<example>
<title>Ukázka <function>count</function></title>
<programlisting role="php">
$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
$result = count ($a);
//$result == 3
</programlisting>
</example>
</para>
<para>
Viz také: <function>sizeof</function>,
<function>isset</function> a
<function>is_array</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.current">
<refnamediv>
<refname>current</refname>
<refpurpose>Vrátit současný prvek pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>current</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Každé pole má vnitřní ukazatel na jeho "současny" prvek, který se
inicializuje na první prvek vložený do tohoto pole.
</para>
<para>
<function>current</function> vrací prvek, na který tento interní ukazatel
právě ukazuje. Nijak tento ukazatel nemění. Pokud teto vnitřní ukazatel
ukazuje za konec seznamu prvků, <function>current</function> returns
<literal>false</literal>.
<warning>
<para>
Pokud toto pole obsahuje prázdné prvky (0 nebo "", prázdný řetězec), tato
funkce pro tyto prvky také vrátí <literal>false</literal>. Je proto
nemožné určit pomocí <function>current</function>, jestli jste opravdu na
konci pole.
To properly traverse an array that may contain empty elements, use the
<function>each</function> function.
</para>
</warning>
</para>
<para>
Viz také: <function>end</function>,
<function>next</function>,
<function>prev</function> a
<function>reset</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.each">
<refnamediv>
<refname>each</refname>
<refpurpose>
Vrací další klíč/hodnota pár z pole
</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>each</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Vrací současný klíč/hodnota pár z pole <parameter>array</parameter> a posune
interní ukazatel pole. Tento pár se vrací jako pole čtyř prvků s klíči
<emphasis>0</emphasis>, <emphasis>1</emphasis>,
<emphasis>key</emphasis> a
<emphasis>value</emphasis>. Prvky <emphasis>0</emphasis> a
<emphasis>key</emphasis> obsahují název klíče tohoto prvku pole a
<emphasis>1</emphasis> a <emphasis>value</emphasis> obsahují hodnotu.
</para>
<para>
Pokud interní ukazatel pole ukazuje za konec tohoto pole,
<function>each</function> vrací <literal>false</literal>.
</para>
<para>
<example>
<title>Ukázky <function>each</function></title>
<programlisting role="php">
$foo = array ("bob", "fred", "jussi", "jouni", "egon", "marliese");
$bar = each ($foo);
</programlisting>
<para>
<varname>$bar</varname> teď obsahuje následující klíč/hodnota páry:
<itemizedlist spacing="compact">
<listitem><simpara>0 => 0</simpara></listitem>
<listitem><simpara>1 => 'bob'</simpara></listitem>
<listitem><simpara>key => 0</simpara></listitem>
<listitem><simpara>value => 'bob'</simpara></listitem>
</itemizedlist>
<programlisting role="php">
$foo = array ("Robert" => "Bob", "Seppo" => "Sepi");
$bar = each ($foo);
</programlisting>
</para>
<para>
<varname>$bar</varname> teď obsahuje následující klíč/hodnota páry:
<itemizedlist spacing="compact">
<listitem><simpara>0 => 'Robert'</simpara></listitem>
<listitem><simpara>1 => 'Bob'</simpara></listitem>
<listitem><simpara>key => 'Robert'</simpara></listitem>
<listitem><simpara>value => 'Bob'</simpara></listitem>
</itemizedlist>
</para>
</example>
</para>
<para>
<function>each</function> se většinou používa s
<function>list</function> k průchodu polem, např.
<varname>$HTTP_POST_VARS</varname>:
<example>
<title>
Průchod <varname>$HTTP_POST_VARS</varname> pomocí
<function>each</function>
</title>
<programlisting role="php">
echo "Hodnoty odeslané metodou POST:<br>";
reset ($HTTP_POST_VARS);
while (list ($key, $val) = each ($HTTP_POST_VARS)) {
echo "$key => $val<br>";
}
</programlisting>
</example>
</para>
<para>
Poté, co proběhne <function>each</function>, se interní ukazatel pole posune
na další prvek pole nebo zůstane na posledním prvku pole, pokud dojde na
konec.
</para>
<para>
Viz také: <function>key</function>,
<function>list</function>,
<function>current</function>,
<function>reset</function>,
<function>next</function> a
<function>prev</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.end">
<refnamediv>
<refname>end</refname>
<refpurpose>
Nastavit vnitřní ukazatel pole na jeho poslední prvek
</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>end</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>end</function> posune vnitřní ukazatel pole
<parameter>array</parameter> na jeho poslední prvek a vrací tento prvek.
</para>
<para>
Viz také: <function>current</function>,
<function>each</function>,
<function>end</function>,
<function>next</function> a
<function>reset</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.extract">
<refnamediv>
<refname>extract</refname>
<refpurpose>Importovat proměnné z pole do symbolové tabulky</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>int <function>extract</function></funcdef>
<paramdef>array <parameter>var_array</parameter></paramdef>
<paramdef>int
<parameter><optional>extract_type</optional></parameter>
</paramdef>
<paramdef>string
<parameter><optional>prefix</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
Tato funkce se používá k importu proměnných z pole do aktivní symbolové
tabulky. Přijímá pole <parameter>var_array</parameter>; z klíčů vytváří
názvy proměnných a z hodnot hodnoty těchto proměnných. Vytváří jednu
proměnnou z každého klíč/hodnota páru (s ohledem na argumenty
<parameter>extract_type</parameter> a <parameter>prefix</parameter>).
</para>
<note>
<para>
Od PHP 4.0.5 tato funkce vrací počet extrahovaných proměnných.
</para>
</note>
<para>
<function>extract</function> ověřuje, jestli všechny klíče tvoří platné
názvy proměnných, a také jestli nekolidují s proměnnými existujícími v
aktivní symbolové tabulce. Způsob, jakým se nakládá s neplatnými/numerickými
klíči a kolizemi závisí na <parameter>extract_type</parameter>. Ten může
mít jednu z následujících hodnot.
<variablelist>
<varlistentry>
<term>EXTR_OVERWRITE</term>
<listitem>
<simpara>
Pokud existuje kolize, přepsat existující proměnnou.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term>EXTR_SKIP</term>
<listitem>
<simpara>
Pokud existuje kolize, nepřepsat existující proměnnou.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term>EXTR_PREFIX_SAME</term>
<listitem>
<simpara>
Pokud existuje kolize, předřadit před název nové proměnné
<parameter>prefix</parameter>.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term>EXTR_PREFIX_ALL</term>
<listitem>
<simpara>
Opatřit prefixem <parameter>prefix</parameter> všechny názvy proměnných.
Od PHP 4.0.5 toto zahrnuje i číselné indexy.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term>EXTR_PREFIX_INVALID</term>
<listitem>
<simpara>
Prefixem <parameter>prefix</parameter> opatřit pouze neplatné/číselné
názvy proměnných. Tento příznak byl přidán v PHP 4.0.5.
</simpara>
</listitem>
</varlistentry>
</variablelist>
</para>
<para>
Defaultní <parameter>extract_type</parameter> je EXTR_OVERWRITE.
</para>
<para>
Pozn.: <parameter>prefix</parameter> se vyžaduje pouze pokud je
<parameter>extract_type</parameter> EXTR_PREFIX_SAME, EXTR_PREFIX_ALL nebo
EXTR_PREFIX_INVALID. Pokud výsledný název (vč. prefixu) není platný název
proměnné, nenaimportuje se do symbolové tabulky.
</para>
<para>
<function>extract</function> vrací počet proměnných úspěšně naimportovaných
do symbolové tabulky.
</para>
<para>
Možné využití <function>extract</function> je import proměnných do
symbolové tabulky z asociativního pole vráceného
<function>wddx_deserialize</function>.
</para>
<para>
<example>
<title>Ukázka <function>Extract</function></title>
<programlisting role="php">
<?php
/* Předpokládejme, že $var_array je pole vrácené
z wddx_deserialize */
$size = "large";
$var_array = array ("color" => "blue",
"size" => "medium",
"shape" => "sphere");
extract ($var_array, EXTR_PREFIX_SAME, "wddx");
print "$color, $size, $shape, $wddx_size\n";
?>
</programlisting>
</example>
</para>
<para>
Výše uvedená ukázka vytiskne:
<programlisting>
blue, large, sphere, medium
</programlisting>
</para>
<para>
<varname>$size</varname> se nepřepsala, protože bylo specifikováno
EXTR_PREFIX_SAME, tudíž se vytvořila proměnná <varname>$wddx_size</varname>.
Pokud by bylo zadáno EXTR_SKIP, nevytvořila by se ani
<varname>$wddx_size</varname>.
EXTR_OVERWRITE by způsobilo přepsání hodnoty <varname>$size</varname> na
"medium", a EXTR_PREFIX_ALL by vytvořilo nové proměnné pojmenované
<varname>$wddx_color</varname>,
<varname>$wddx_size</varname> a
<varname>$wddx_shape</varname>.
</para>
<para>
U PHP verzí nižších než 4.0.5 musíte použít asociativní pole.
</para>
<para>
Viz také: <function>compact</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.in-array">
<refnamediv>
<refname>in_array</refname>
<refpurpose>Vrátit <literal>true</literal>, pokud v poli existuje daná
hodnota</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>bool in_array</funcdef>
<paramdef>mixed <parameter>needle</parameter></paramdef>
<paramdef>array <parameter>haystack</parameter></paramdef>
<paramdef>bool <parameter>strict</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Hledá v <parameter>haystack</parameter> <parameter>needle</parameter>
a pokud ji najde, vrací <literal>true</literal>, jinak
<literal>false</literal>.
</para>
<para>
Pokud je třetí argument <parameter>strict</parameter> <literal>true</literal>,
<function>in_array</function> také kontroluje typ <parameter>needle</parameter>
v <parameter>haystack</parameter>.
</para>
<para>
<example>
<title>Ukázka <function>in_array</function></title>
<programlisting role="php">
$os = array ("Mac", "NT", "Irix", "Linux");
if (in_array ("Irix", $os)){
print "Got Irix";
}
</programlisting>
</example>
</para>
<para>
<example>
<title>Ukázka <function>in_array</function> s argumentem
<parameter>strict</parameter></title>
<programlisting role="php">
<?php
$a = array('1.10', 12.4, 1.13);
if (in_array('12.4', $a, true))
echo "'12.4' found with strict check\n";
if (in_array(1.13, $a, true))
echo "1.13 found with strict check\n";
?>
// Výstup bude:
1.13 found with strict check
</programlisting>
</example>
</para>
</refsect1>
</refentry>
<refentry id="function.key">
<refnamediv>
<refname>key</refname>
<refpurpose>Fetch a key from an associative array</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>key</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>key</function> vrací index současného prvku pole.
</para>
<para>
Viz také: <function>current</function> a
<function>next</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.krsort">
<refnamediv>
<refname>krsort</refname>
<refpurpose>Třídit pole sestupně podle klíčů</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>int <function>krsort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>int
<parameter><optional>sort_flags</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
Třídí pole sestupně podle klíčů se zachování asociací indexů. To je
užitečné hlavně při práci s asociativními poli.
<example>
<title><function>Krsort</function> example</title>
<programlisting role="php">
$fruits = array ("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
krsort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
echo "$key -> $val\n";
}
</programlisting>
</example>
</para>
<para>
Tato ukázka vytiskne:
</para>
<para>
<informalexample>
<programlisting>
fruits[d] = lemon
fruits[c] = apple
fruits[b] = banana
fruits[a] = orange
</programlisting>
</informalexample>
</para>
<para>
Vlastnosti třídění lze upravit pomocí volitelného argumentu
<parameter>sort_flags</parameter>, detaily viz <function>sort</function>.
</para>
<simpara>
Viz také: <function>asort</function>,
<function>arsort</function>,
<function>ksort</function>,
<function>sort</function>,
<function>natsort</function> a
<function>rsort</function>.
</simpara>
</refsect1>
</refentry>
<refentry id="function.ksort">
<refnamediv>
<refname>ksort</refname>
<refpurpose>Třídit pole podle klíčů</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>int <function>ksort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>int
<parameter><optional>sort_flags</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
Třídí pole podle klíčů se zachování asociací indexů. To je
užitečné hlavně při práci s asociativními poli.
<example>
<title><function>Ksort</function> example</title>
<programlisting role="php">
$fruits = array ("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
ksort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
echo "$key -> $val\n";
}
</programlisting>
</example>
</para>
<para>
Tato ukázka vytiskne:
</para>
<para>
<informalexample>
<programlisting>
fruits[a] = orange
fruits[b] = banana
fruits[c] = apple
fruits[d] = lemon
</programlisting>
</informalexample>
</para>
<para>
Vlastnosti třídění lze upravit pomocí volitelného argumentu
<parameter>sort_flags</parameter>, detaily viz <function>sort</function>.
</para>
<simpara>
Viz také: <function>asort</function>,
<function>arsort</function>,
<function>sort</function>,
<function>natsort</function> a
<function>rsort</function>.
</simpara>
<note>
<para>
Druhý argument byl přidán v PHP 4.
</para>
</note>
</refsect1>
</refentry>
<refentry id="function.list">
<refnamediv>
<refname>list</refname>
<refpurpose>Přiřadit hodnoty přoměnným jako kdyby byly polem</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>list</function></funcdef>
<varargs/>
</funcprototype>
</funcsynopsis>
<para>
Stejně jako <function>array</function>, <function>list</function> vlastně
není funkce, ale jazykový konstrukt. Používá se k přiřazení hodnot více
proměnným v jedné operaci.
<example>
<title>Ukázka <function>list</function></title>
<programlisting role="php">
<table>
<tr>
<th>Employee name</th>
<th>Salary</th>
</tr>
<?php
$result = mysql ($conn, "SELECT id, name, salary FROM employees");
while (list ($id, $name, $salary) = mysql_fetch_row ($result)) {
print (" <tr>\n".
" <td><a href=\"info.php3?id=$id\">$name</a></td>\n".
" <td>$salary</td>\n".
" </tr>\n");
}
?>
</table>
</programlisting>
</example>
</para>
<para>
Viz také: <function>each</function> a
<function>array</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.natsort">
<refnamediv>
<refname>natsort</refname>
<refpurpose>
Třídit pole s využitím algoritmu "přirozeného třídění"
</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>natsort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Tato funkce implementuje srovnávací algoritmus který třídí alfanumerické
řetězce stejným způsobem jako člověk, toto se popisuje jako "přirozené
třídění". Ukázka rozdílu mězi tímto algoritmem a běžnými počítačovými
algoritmy pro řazení řetězců (např. <function>sort</function>):
</para>
<para>
<example>
<title>Ukázka <function>natsort</function></title>
<programlisting role="php">
$array1 = $array2 = array ("img12.png","img10.png","img2.png","img1.png");
sort($array1);
echo "Standardní třídění\n";
print_r($array1);
natsort($array2);
echo "\nPřirozené třídění\n";
print_r($array2);
</programlisting>
</example>
</para>
<para>
Výše uvedený kód vygeneruje následující výstup:
</para>
<para>
<informalexample>
<programlisting>
Standardní třídění
Array
(
[0] => img1.png
[1] => img10.png
[2] => img12.png
[3] => img2.png
)
Přirozené třídění
Array
(
[3] => img1.png
[2] => img2.png
[1] => img10.png
[0] => img12.png
)
</programlisting>
</informalexample>
Více informací viz stránka Martina Poola <ulink
url="&url.strnatcmp;">Natural Order String Comparison</ulink>.
</para>
<para>
Viz také: <function>natcasesort</function>,
<function>strnatcmp</function> a
<function>strnatcasecmp</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.natcasesort">
<refnamediv>
<refname>natcasesort</refname>
<refpurpose>
Třídit pole s využitím algoritmu "přirozeného třídění" (case-insensitive)
</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>natcasesort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Tato funkce implementuje srovnávací algoritmus který třídí alfanumerické
řetězce stejným způsobem jako člověk, toto se popisuje jako "přirozené
třídění".
</para>
<para>
<function>natcasesort</function> je case-insensitive verze
<function>natsort</function>. Ukázka rozdílu mezi tímto algoritmem
a běžným počítačovým tříděním řetězců viz <function>natsort</function>.
</para>
<para>
Více informací viz stránka Martina Poola <ulink
url="&url.strnatcmp;">Natural Order String Comparison</ulink>.
</para>
<para>
Viz také: <function>sort</function>,
<function>natsort</function>,
<function>strnatcmp</function> and
<function>strnatcasecmp</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.next">
<refnamediv>
<refname>next</refname>
<refpurpose>Posunout interní ukazatel pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>next</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Vrací další prvek pole nebo <literal>false</literal>, pokud prvky došly.
</para>
<para>
<function>next</function> se chová jako <function>current</function>, s jedním
rozdílem: posouvá interní ukazatel pole o jeden prvek a vrací prvek, na který
tento ukazatel ukazuje po posunu. To znamená, že vrací další prvek pole
a posouvá interní ukazatel o jeden. Pokud by ukazatel po psunu ukazoval
mimo pole, <function>next</function> vrací <literal>false</literal>.
<warning>
<para>
Pokud toto pole obsahuje prázdné prvky, nebo prvky, jejichž index je 0,
tato funkce vrátí <literal>false</literal> i pro tyto prvky. Ke správnému
průchodu polem, které může obsahovat prázdné prvky nebo prvky s indexem 0
použijte <function>each</function>.
</para>
</warning>
</para>
<para>
Viz také:
<function>current</function>,
<function>end</function>,
<function>prev</function> a
<function>reset</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.pos">
<refnamediv>
<refname>pos</refname>
<refpurpose>Získat současný prvek pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>pos</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<simpara>
Toto je alias k <function>current</function>.
</simpara>
<para>
Viz také: <function>end</function>,
<function>next</function>,
<function>prev</function> a
<function>reset</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.prev">
<refnamediv>
<refname>prev</refname>
<refpurpose>Rewind interní ukazatel pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>prev</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Vrací prvek pole před tím prvkem, na který ukazuje interní ukazatel pole,
nebo <literal>false</literal>, pokud prvky došly.
<warning>
<para>
Pokud toto pole obsahuje prázdné prvky, tato funkce vrátí
<literal>false</literal> i pro tyto prvky. Ke správnému průchodu polem,
které může obsahovat prázdné prvky použijte <function>each</function>.
</para>
</warning>
</para>
<para>
<function>prev</function> se chová stejně jako <function>next</function>,
ale posouvá interní ukazatel pole o jedno místo zpátky místo dopředu.
</para>
<para>
Viz také: <function>current</function>,
<function>end</function>,
<function>next</function> a
<function>reset</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.range">
<refnamediv>
<refname>range</refname>
<refpurpose>Vytvořit pole obsahující rozsah integerů</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>range</function></funcdef>
<paramdef>int <parameter>low</parameter></paramdef>
<paramdef>int <parameter>high</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>range</function> vrací pole integerů od
<parameter>low</parameter> po <parameter>high</parameter> včetně.
</para>
<para>
Ukázka použití viz <function>shuffle</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.reset">
<refnamediv>
<refname>reset</refname>
<refpurpose>Nastavit interní ukazatel pole na jeho první prvek</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>reset</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>reset</function> přetočí interní ukazatel pole
<parameter>array</parameter> na jeho první prvek.
</para>
<para>
<function>reset</function> vrací hodnotu prvního prvku pole.
</para>
<para>
Viz také: <function>current</function>,
<function>each</function>,
<function>next</function> a
<function>prev</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.rsort">
<refnamediv>
<refname>rsort</refname>
<refpurpose>Třídit pole sestupně</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>rsort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>int
<parameter><optional>sort_flags</optional></parameter>
</paramdef>
</funcprototype>
</funcsynopsis>
<para>
Tato funkce sestupně třídí pole.
<example>
<title>Ukázka <function>rsort</function></title>
<programlisting role="php">
$fruits = array ("lemon", "orange", "banana", "apple");
rsort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
echo "$key -> $val\n";
}
</programlisting>
</example>
</para>
<para>
Tato ukázka zobrazí:
</para>
<para>
<informalexample>
<programlisting>
fruits[0] = orange
fruits[1] = lemon
fruits[2] = banana
fruits[3] = apple
</programlisting>
</informalexample>
</para>
<para>
Ovoce bylo setříděno podle abecedy sestupně.
</para>
<para>
Vlastnosti třídění lze upravit pomocí volitelného argumentu
<parameter>sort_flags</parameter>, detaily viz <function>sort</function>.
</para>
<para>
Viz také: <function>arsort</function>,
<function>asort</function>,
<function>ksort</function>,
<function>sort</function> a
<function>usort</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.shuffle">
<refnamediv>
<refname>shuffle</refname>
<refpurpose>Zamíchat pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>shuffle</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>shuffle</function> zamíchá (náhodně změní pořadí prvků) pole.
Musíte inicializovat generátor náhodných čísel pomocí
<function>srand</function>.
<example>
<title>Ukázka <function>shuffle</function></title>
<programlisting role="php">
$numbers = range (1,20);
srand ((double)microtime()*1000000);
shuffle ($numbers);
while (list (, $number) = each ($numbers)) {
echo "$number ";
}
</programlisting>
</example>
</para>
<para>
Viz také: <function>arsort</function>,
<function>asort</function>,
<function>ksort</function>,
<function>rsort</function>,
<function>sort</function> a
<function>usort</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.sizeof">
<refnamediv>
<refname>sizeof</refname>
<refpurpose>Zjistit počet prvků v poli</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>int <function>sizeof</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Vrací počet prvků v poli.
</para>
<para>
Viz také: <function>count</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.sort">
<refnamediv>
<refname>sort</refname>
<refpurpose>Třídit pole</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>sort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>int <parameter><optional>sort_flags</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<function>sort</function> třídí pole. Prvky se uspořádají od nejmenšího
k největšímu.
<example>
<title>Ukázka <function>sort</function></title>
<programlisting role="php">
<?php
$fruits = array ("lemon", "orange", "banana", "apple");
sort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
echo "fruits[".$key."] = ".$val;
}
?>
</programlisting>
</example>
</para>
<para>
Tato ukázka zobrazí:
</para>
<para>
<informalexample>
<programlisting>
fruits[0] = apple
fruits[1] = banana
fruits[2] = lemon
fruits[3] = orange
</programlisting>
</informalexample>
</para>
<para>
Ovoce bylo seřazeno podle abecedy.
</para>
<para>
Vlastnosti třídění lze upravit pomocí volitelného argumentu
<parameter>sort_flags</parameter>, který může nabývat těchto hodnot:
</para>
<para>
Typy třídění:
<itemizedlist>
<listitem>
<simpara>SORT_REGULAR - normální porovnávání</simpara>
</listitem>
<listitem>
<simpara>SORT_NUMERIC - numerické porovnávání</simpara>
</listitem>
<listitem>
<simpara>SORT_STRING - textové porovnávání</simpara>
</listitem>
</itemizedlist>
</para>
<para>
Viz také: <function>arsort</function>,
<function>asort</function>,
<function>ksort</function>,
<function>natsort</function>,
<function>natcasesort</function>,
<function>rsort</function>,
<function>usort</function>,
<function>array_multisort</function> a
<function>uksort</function>.
</para>
<note>
<para>
Druhý argument byl přidán v PHP 4.
</para>
</note>
</refsect1>
</refentry>
<refentry id="function.uasort">
<refnamediv>
<refname>uasort</refname>
<refpurpose>
Třídit pole pomocí uživatelsky definované porovnávací funkce se zachováním
klíčů
</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>uasort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>function <parameter>cmp_function</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Tato funkce třídí pole tak, že si indexy uchovávají spojení s hodnotami.
To je užitečné hlavně při třídění asociativních polí, kde je důležité
pořadí prvků. Srovnávací funkce je uživatelsky definována.
</para>
<note>
<para>
Ukázky uživatelsky definovaných porovnávacích funkcí viz
<function>usort</function> a <function>uksort</function>.
</para>
</note>
<para>
Viz také: <function>usort</function>,
<function>uksort</function>,
<function>sort</function>,
<function>asort</function>,
<function>arsort</function>,
<function>ksort</function> a
<function>rsort</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.uksort">
<refnamediv>
<refname>uksort</refname>
<refpurpose>
Třídit pole podle klíčů pomocí uživatelsky definovane porovnávací funkce
</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>uksort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>function <parameter>cmp_function</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Tato funkce třídí pole podle klíčů pomocí uživatelsky definované
porovnávací funkce. Pokud potřebujete třídit pole podle komplikovanějších
kritérií, měli byste použít tuto funkci.
</para>
<para>
<example>
<title>Ukázka <function>uksort</function></title>
<programlisting role="php">
function cmp ($a, $b) {
if ($a == $b) return 0;
return ($a > $b) ? -1 : 1;
}
$a = array (4 => "four", 3 => "three", 20 => "twenty", 10 => "ten");
uksort ($a, "cmp");
while (list ($key, $value) = each ($a)) {
echo "$key: $value\n";
}
</programlisting>
</example>
</para>
<para>
Tato ukázka zobrazí:
</para>
<para>
<informalexample>
<programlisting>
20: twenty
10: ten
4: four
3: three
</programlisting>
</informalexample>
</para>
<para>
Viz také: <function>usort</function>,
<function>uasort</function>,
<function>sort</function>,
<function>asort</function>,
<function>arsort</function>,
<function>ksort</function>,
<function>natsort</function> a
<function>rsort</function>.
</para>
</refsect1>
</refentry>
<refentry id="function.usort">
<refnamediv>
<refname>usort</refname>
<refpurpose>
Třídit pole podle hodnot pomocí uživatelsky definované porovnávací funkce
</refpurpose>
</refnamediv>
<refsect1>
<title>Popis</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>usort</function></funcdef>
<paramdef>array <parameter>array</parameter></paramdef>
<paramdef>string <parameter>cmp_function</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Tato funkce třídí pole podle hodnot pomocí uživatelsky definované
porovnávací funkce. Pokud potřebujete třídit pole podle komplikovanějších
kritérií, měli byste použít tuto funkci.
</para>
<para>
Porovnávací funkce musí vrace integer menší než 0, 0, a větší než 0, pokud
je první argument menší než, stejný, nebo větší než druhý argument. Pokud
jsou dvě porovnávané hodnoty stejné, jejich pořadí v tříděném poli je
nedefinováno.
</para>
<para>
<example>
<title>Ukázka <function>usort</function></title>
<programlisting role="php">
function cmp ($a, $b) {
if ($a == $b) return 0;
return ($a > $b) ? -1 : 1;
}
$a = array (3, 2, 5, 6, 1);
usort ($a, "cmp");
while (list ($key, $value) = each ($a)) {
echo "$key: $value\n";
}
</programlisting>
</example>
</para>
<para>
Tato ukázka zobrazí:
</para>
<para>
<informalexample>
<programlisting>
0: 6
1: 5
2: 3
3: 2
4: 1
</programlisting>
</informalexample>
</para>
<note>
<para>
V tomto jednoduchém případě by pochopitelně bylo vhodnější použít
<function>rsort</function>.
</para>
</note>
<para>
<example>
<title>
Ukázka <function>usort</function> s vícerozměrným polem
</title>
<programlisting role="php">
function cmp ($a, $b) {
return strcmp($a["fruit"],$b["fruit"]);
}
$fruits[0]["fruit"] = "lemons";
$fruits[1]["fruit"] = "apples";
$fruits[2]["fruit"] = "grapes";
usort($fruits, "cmp");
while (list ($key, $value) = each ($fruits)) {
echo "\$fruits[$key]: " . $value["fruit"] . "\n";
}
</programlisting>
</example>
</para>
<para>
Při třídění vícerozměrného pole $a a $b obsahují reference na první index
pole.
</para>
<para>
Tato ukázka zobrazí:
</para>
<para>
<informalexample>
<programlisting>
$fruits[0]: apples
$fruits[1]: grapes
$fruits[2]: lemons
</programlisting>
</informalexample>
</para>
<para>
<warning>
<para>
Použitá quicksort funkce v některých C knihovnách (např. na systémech
Solaris) může způsobit zhroucení PHP, pokud porovnávací funkce nevrací
konsistentní hodnoty.
</para>
</warning>
</para>
<para>
Viz také: <function>uasort</function>,
<function>uksort</function>,
<function>sort</function>,
<function>asort</function>,
<function>arsort</function>,
<function>ksort</function>,
<function>natsort</function> a
<function>rsort</function>.
</para>
</refsect1>
</refentry>
</reference>
<!-- 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
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->
