 |
информационных технологий» 3 глава
|
|
|
|
У цикла foreach имеется и другая форма записи, которую следует применять, когда нас не интересует значение ключа очередного элемента. Выглядит она так:
foreach (массив as $value)
команды;
В этом случае доступно лишь значение очередного элемента массива, но не его ключ. Такой цикл применяется для работы с массивами-списками.
Цикл foreach оперирует не исходным массивом, а его копией. Это означает, что любые изменения, которые вносятся в массив, не могут быть «видны» из тела цикла. Что позволяет, например, в качестве массива использовать не только переменную, но и результат работы какой-нибудь функции, возвращающей массив (в этом случае функция будет вызвана всего один раз – до начала цикла, а затем работа будет производиться с копией возвращенного значения).
4.3 Инструкции включения
Инструкция require. Эта инструкция позволяет разбить текст программы на несколько файлов:
require имя_файла;
При запуске (именно при запуске, а не при исполнении!) программы интерпретатор заменит инструкцию на содержимое файла имя_файла (этот файл может также содержать сценарий на РНР, обрамленный, как обычно, тэгами <? и?>). Причем сделает он это только один раз (вотличие от include): а именно, непосредственно перед запуском программы. Эта инструкция используется например, для включения в вывод сценария «шапок» с HTML-кодом.
<?
require "header.htm";
... работает сценарий и выводит само тело документа
require "footer.htm";
?>
Инструкция include. Эта инструкция практически идентична require, за исключением того, что включаемый файл вставляется тело сценария не перед его выполнением, а прямо во время.
Пусть у нас есть 10 текстовых файлов с именами file0.php, file1.php и так далее до file9.php, содержимое которых просто десятичные цифры 0, 1... 9 (по одной цифре в каждом файле). Запустим такую программу:
|
|
|
for($i=0; $i<10; $i++)
{
include "fiie$i.php";
}
В результате получим вывод, состоящий из 10 цифр: «0123456789». Каждый из файлов был включен по одному разу прямо во время выполнения цикла!
Фигурные скобки вокруг include не являются необязательными. Если их убрать то будет выдано сообщение об ошибке (или программа начнет неправильно работать). Это происходит потому, что include не является на самом деле оператором в привычном нам смысле этого слова. Каждый раз, когда интерпретатор встречает инструкцию include, он просто заменяет ее на содержимое файла, указанного в параметре. Если в этом файле несколько команд, то в цикле выполнится только первая из них, а остальные будут запущены уже после окончания цикла. Поэтому необходимо всегда обрамлять инструкцию include фигурными скобками, если размещаете ее внутри какой-либо конструкции.
Трансляция и проблемы с include. Перед исполнением РНР транслирует программу во внутреннее представление. Это означает, что в памяти создается как бы «полуфабрикат», из которого исключены все комментарии, лишние пробелы, некоторые имена переменных и т.д. Впоследствии это внутреннее представление интерпретируется (выполняется). Однако в программе могут встретиться такие места для интерпретатора, которые РНР не сможет оттранслировать заранее. В этом случае он их пропускает, чтобы в момент, когда управление дойдет до определенной точки, опять запустить транслятор.
Одним из таких мест и является инструкция include. Как только управление программы доходит до нее, РНР вынужден приостановиться и ждать, пока транслятор не оттранслирует код включаемого файла. А это достаточно отрицательно сказывается на быстродействии программы. Поэтому, если вы пишете большой и сложный сценарий, применяйте инструкциюrequire вместо include, где только можно.
|
|
|
При использовании include РНР не сможет определить во время компиляции, какие файлы нужно подключить в программу, поэтому в исполняемый файл их код не войдет. Если определенный файл нужно присоединить ровно один раз и в точно определенное место, то лучше воспользоваться require, в противном случае более удачным выбором будет include.
Инструкции однократного включения. В больших и непростых сценариях инструкции include и require применяются очень и очень часто. Поэтому становится довольно сложно контролировать, как бы случайно не включить один и тот же файл несколько раз. Для этого используются инструкции include_once и require_once.
Инструкция require_once работает точно так же, как и require, но за одним важным исключением. Если она видит, что затребованный файл уже был ранее включен, то она ничего не делает. Такой метод работы требует от РНР хранения полных имен всех подсоединенных файлов где-то в недрах интерпретатора. Инструкция include_once работает совершенно аналогично, но включает файл во время исполнения программы, а не во время трансляции.
Замечание. В РНР существует внутренняя таблица, которая хранит полные имена всех включенных файлов. Проверка этой таблицы осуществляется инструкциями include_once и require_once. Однако добавление имени включенного файла производят также и функции require и include. Поэтому, если какой-то файл был востребован, например, по команде require, а затем делается попытка подключить его же, но с использованием require_once, то последняя инструкция просто проигнорируется.
Тема 5 Ассоциативные массивы
5.1 Списки и ассоциативные массивы
5.2 Операции над массивами
5.3 Списки и строки
5.4 Сериализация
5.1 Списки и ассоциативные массивы
Особенности ассоциативных массивов:
1. Все массивы PHP являются ассоциативными (в частности, списки – тоже).
2. Ассоциативные массивы в РНР являются направленными, т.е. в них существует определенный (и предсказуемый) порядок элементов, не зависящий от реализации, а значит, есть первый и последний элементы, и для каждого элемента можно определить следующий за ним.
3. Операция [] всегда добавляет элемент в конец массива, присваивая ему при этом такой числовой индекс, который бы не конфликтовал с уже имеющимися массиве (выбирается номер, превосходящий все имеющиеся цифровые ключи в массиве).
|
|
|
4. Операция $Array[ключ]=значение добавляет элемент в конец массива, за исключением тех случаев, когда ключ уже присутствует в массиве.
5. Для изменения порядка следования элементов в ассоциативном массиве, не изменяя их ключей, можно воспользоваться функциями сортировки, или создать новый пустой массив и заполнить его в нужном порядке, пройдясь по элементам исходного массива.
5.2 Операции над массивами
Над массивами можно выполнять следующие операции:
Инициализация массива.
$NamesList[0]="Dmitry";
$NamesList[l]="Helen";
$NamesList [2]="Sergey";
Печать элементов массива. Количество элементов в массиве легко можно определить функцией count() или ее синонимом sizeof():
for($i=0; $i<count($NamesList); $i++)
echo $NamesList[$i]."<br>";
Добавление элементов в массив (создание массива «на лету»). Автомассивы. Для добавления элемента в конец массива можно не задавать номер элемента массива.
$NamesList[]="Dmitry";
$NamesList[]="Helen";
$NamesList[]="Sergey";
В этом случае РНР сам начнет (если переменная $NamesList не существует) нумерацию с нуля и каждый раз будет прибавлять к счетчику по единичке, создавая список.
Ассоциативный массив часто называется просто хэш.
Добавление элементов в ассоциативный массив осуществляется аналогично, только вместо цифровых ключей нужно указывать строковые. При этом следует помнить, что в строковых ключах буквы нижнего и верхнего регистров считаются различными. Ключом может быть абсолютно любая строка, содержащая пробелы, символы перевода строки, нулевые символы и т.д., т.е. никаких ограничений на ключи не накладывается.
Пример. Пусть необходимо написать сценарий, который работает, как записная книжка: по фамилии абонента выдает его имя. Можно организовать базу данных этой книжки в виде ассоциативного массива с ключами – фамилиями и соответствующими им значениями имен людей:
$Names["Koteroff"]="Dmitry";
$Names["Ivanov"]="Ivan";
$Names["Petrov"]="Peter";
Имя любого абонента можно распечатать командой:
echo $Names["Ivanov"];
$f="Koteroff";
echo $Names[$f];
Инструкция list(). Пусть есть некоторый массив-список $List с тремя элементами: имя человека, его фамилия и возраст. Нужно присвоить переменным $name, $surname и $age эти величины. Это можно сделать следующим образом:
|
|
|
$name=$List[0];
$surname=$List[1];
$age=$List[2];
Однако лучше воспользоваться инструкцией list():
list($name, $surname, $age)=$List;
Если в массиве не хватит элементов, чтобы их заполнить, им присвоятся неопределенные значения. Если нужны только второй и третий элемент массива $List, нужно пропустить первый параметр в инструкции list():
list(,$surname,$age)=$List;
Можно пропускать любое число элементов, как слева или справа, так и посередине списка. Главное – не забыть проставить нужное количество запятых.
Инструкция аrrау() и многомерные массивы. Пусть необходимо написать программу, которая по фамилии некоторого человека из группы будет выдавать его имя. Данные хранятся в ассоциативном массиве:
$Names["Ivanov"]="Dmitry";
$Names ["Petrova"]="Helen";
Теперь можно написать:
echo $Names["Petrova"]; // выведет Helen
echo $Names["Oshibkov"]; // ошибка: в массиве нет такого
// элемента!
То есть, таким образом нельзя создать пустой массив.
Второй способ создания массивов – это использование оператора array().
//создает пустой массив $Names
$Names=array();
//создает такой же массив, как в предыдущем примере с именами
$Names=array ("Ivanov"=>"Dmitry",
"Petrova"=>"Helen")
//создает список с именами (нумерация 0,1,2)
$NamesList=array("Dmitry","Helen","Sergey");
Создание двумерных массивов. Если кроме имени о человеке известен также его возраст, то можно инициализировать массив $Names следующим образом:
$Names["Ivanov"]=array("name"=>"Dmitry","age"=>25);
$Names["Petrova"]=array("name"=>"Helen","age"=>23);
или так:
$Names=аrraу(
"Ivanov"=>array("name"=>"Dmitry","age"=>25),
"Petrova"=>array("name"=>"Helen","age"=>23));
Получить нужный элемента массиве можно следующим образом:
echo $Names["Ivanov"]["age"]; // напечатает "25"
echo $Names["Petrova"]["bad"]; // ошибка: нет такого
// элемента "bad"
Ассоциативные массивы в РНР удобно использовать как некие структуры, хранящие данные. Это похоже на конструкцию struct в Си (или record в Паскале). Это единственный возможный способ организации структур, но он очень гибок.
Доступ по ключу.
//выводит элемент массива $Аrr с ключом anykey
echo $Arr ["anykey"];
//так используются двумерные массивы
echo $Arr ["first"]["second"];
echo $Arr[5];
Величина $Arr[ключ] является полноценным «левым значением», т. е. может стоять в левой части оператора присваивания, от нее можно брать ссылку с помощью оператора &, например:
//присваиваем элементу массива 100
$Arr["anykey"]=array(100,200);
//$ref – синоним элемента массива
|
|
|
$ref=&$Arr["first"]["second"];
$Arr[]="for add"; // добавляем новый элемент
Функция соunt() – определяет число элементов массива:
$num=count($Names); // $num – число элементов в массиве
Слияние массивов, т.е. создание массива, содержащего как элементы одного, так и другого массива. Реализуется при помощи оператора +. Например:
$а=аrrау("а"=>"аа", "b"=>"bb");
$b=array("c"=>"cc", "d"=>"dd");
$c=$a+$b;
В результате в $с окажется ассоциативный массив, содержащий все 4 элемента:
array("a"=>"aa","b"=>"bb","c"=>"cc","d"=>"dd"),
причем именно в указанном порядке.
Направленность массивов заставляет оператор + стать некоммутативным, т. е. $а+$b не равно $b+$а, если $а и $b массивы.
Так как списки являются тоже ассоциативными массивами, оператор + будет работать с ними неправильно! При слиянии списков:
$а=аrrау(10,20,30);
$b=array(100,200);
$c=$a+$b;
в $с будет array(10,20,30)!
Потому что при конкатенации массивов с одинаковыми элементами (то есть, элементами с одинаковыми ключами) в результирующем массиве останется только один элемент с таким же ключом – тот, который был в первом массиве, и на том же самом месте.
При слиянии ассоциативных массивов
$а=аrraу("а"=>10, "b"=>20);
$b=array("b"=>"new?");
$a+=$b;
оператор += не обновит элементы $а при помощи элементов $b. В результате этих операций значение $а не изменится.
Обновить элементы в массиве $а можно с помощью цикла:
foreach ($b as $k=>$v) $a[$k]=$v;
Цепочка
$z=$a+$b+$c+...
эквивалентна
$z=$a; $z+=$b; $z+=$c;...и т. д.
Оператор += для массивов добавляет в свой левый операнд элементы, перечисленные в правом операнде-массиве, если они еще не содержатся в массиве слева.
В массиве не может быть двух элементов с одинаковыми ключами, потому что все операции, применимые к массивам, всегда контролируют, чтобы этого не произошло!
Косвенный перебор элементов массива. Используется для перебора всех элементов массива.
Если массив – список:
//Пусть $Namеs – список имен. Распечатаем их в столбик
for($i=0; $i<count ($Names); $i++)
echo $Names[$i]."\n";
Переменную можно помещать в строку:
for ($i=0; $i<count($Names); $i++)
echo "$Names[$i]\n";
Можно помещать массивы в строки, заключив их в фигурные скобки вместе с символом $:
$Names=array(array('name'=>'Вася','age'=>20),
array('name'=>'Билл','аgе'=>40));
for ($i=0; $i<count($Names); $i++)
echo "{$Names[$i]['age']}\n";
Пусть массив $Names – ассоциативный: его ключи – имена людей, а значения, сопоставленные ключам – возраст этих людей. Для перебора такого массива можно воспользоваться следующей конструкцией:
for(Reset($Names);($k=key($Names));Next($Names))
echo "Возраст $k – {$Names[$k]} лет\n";
Кроме того, что массивы являются направленными, в них есть еще и такое понятие, как текущий элемент. Функция Reset() устанавливает этот элемент на первую позицию в массиве. Функция key() возвращает ключ, который имеет текущий элемент (если он указывает на конец массива, возвращается пустая строка, что позволяет использовать вызов key() в контексте второго выражения for), а функция Next() перемещает текущий элемент на одну позицию вперед.
Функции Reset() и Next() возвращают следующие значения:
– функция Reset() возвращает значение первого элемента массива (или пустую строку, если массив пуст);
– функция Next() возвращает значение элемента, следующего за текущим (или пустую строку, если такого элемента нет).
Если необходим перебор элементов массива с конца, то можно воспользоваться следующей конструкцией:
for(End($Names);($k=key($Names));Prev($Names))
echo "Возраст $k – {$Names[$k]} лет\n";
Функция End() устанавливает позицию текущего элемента в конец массива, a Prev() передвигает ее на один элемент назад.
Функция current() возвращает не ключ, а величину текущего элемента (если он не указывает на конец массива).
Основное достоинство косвенного перебора – «читабельность» и ясность кода, а также то, что массив можно перебрать как в одну, так и в другую сторону.
Недостатки косвенного перебора:
1 Вложенные циклы. Нельзя одновременно перебирать массив в двух вложенных циклах или функциях. Так как второй вложенный for «испортит» положение текущего элемента у первого for'a.
2 Нулевой ключ. Если в массиве встретится ключ 0:
for(Reset($Names);($k=key($Names));Next($Names))
echo "Возраст $k – {$Names[$k]} лет\n";
то в этом случае выражение ($k=key ($Names)), будет равно нулю и цикл оборвется.
Прямой перебор массива. В косвенном переборе сначала вычисляется очередной ключ, а затем по нему косвенно находится значение элемента массива, при прямом переборе на каждом «витке» цикла одновременно получается и ключ, и значение текущего элемента.
Классический перебор. Пусть массив $Names хранит связь имен людей и их возрастов. Перебрать этот массив при помощи прямого перебора можно следующим образом:
for(Reset($Names);list($k,$v)=each($Names);
/*пусто*/)
echo "Возраст $k – $v\n";
В начале заголовка цикла используется функция Reset(). Дальше переменным $k и $v присваивается результат работы функции each(). Третье условие цикла просто отсутствует.
Функция each() во-первых, возвращает список, нулевой элемент которого хранит величину ключа текущего элемента массива $Names, а первый – значение текущего элемента. Во-вторых, она продвигает указатель текущего элемента к следующей позиции. Если следующего элемента в массиве нет, то функция возвращает не список, a false. Поэтому она и размещена в условии цикла for и не указан третий блок операторов в цикле for: он просто не нужен, ведь указатель на текущий элемент и так смещается функцией each ().
Перебор в стиле РНР. Прямой перебор массивов можно осуществить с помощью функции foreach:
foreach($Names as $k=>$v)
echo "Возраст $k – $v\n";
Этот способ перебора работает с максимально возможной скоростью – даже быстрее, чем перебор списка при помощи for и числового счетчика.
5.3 Списки и строки
Функция explode() используется для разбиения строки на более мелкие части (эти части разделяются в строке каким-то специфическим символом типа |). Формат задания функции:
list explode (string $token, string $Str
[, int $limit])
Она получает строку, заданную в ее втором аргументе, и пытается найти в ней подстроки, равные первому аргументу. Затем по месту вхождения этих подстрок строка «разрезается» на части, помещаемые в массив-список, который и возвращается. Если задан параметр $limit, то учитываются только первые ($limit-1) участков «разреза». Таким образом, возвращается список из не более чем $limit элементов.
$st="4597219361|Иванов|Иван|40|[email protected]|Текст, содержащий (|)";
$A=explode("|", $st, 6);
// Мы знаем, что там только 6 полей!
//Теперь $А[0] ="Иванов",... $А[5]= "Текст, содержащий (|)!"
// распределили по переменным
list ($Surname,$Name,$Age,$Email,$Tel)=$A;
Cтрокой разбиения может быть не только один символ, но и небольшая строка.
Функция implode()и ее синоним join() используются для слияния нескольких небольших строк в одну большую, вставляя между ними разделитель:
string implode (string $glue, list $List)
или
string join(string $glue, list $List).
Они берут ассоциативный массив (обычно это список) $List, заданный в ее первом параметре, и «склеивают» его значения при помощи «строки-клея» $glue во втором параметре.
Вместо списка во втором аргументе можно передавать любой ассоциативный массив – в этом случае будут рассматриваться только его значения.
5.4 Сериализация
С помощью функций implode() и explode() можно просто сохранить массив, например, в файле, а затем его оттуда считать и быстро восстановить. Однако этот способ имеет ряд существенных недостатков: во-первых, таким образом можно сохранять только массивы-списки (потому что ключи в любом случае теряются), а во-вторых, ничего не выйдет с многомерными массивами. Пусть нам все-таки нужно сохранить какой-то массив (причем неизвестно заранее, сколько у него измерений) в файле, чтобы потом, при следующем запуске сценария, его аккуратно загрузить и продолжить работу.
Для упаковки массива в строку (ведь в файлы можно писать только строки), и для восстановления строки в массив в исходном виде используются функции Serialize() и Unserialize().
Функция Serialize() возвращает строку, являющуюся упакованным эквивалентом некоего объекта $obj, переданного во втором параметре.
string Serialize (mixed $0bj)
При этом совершенно не важно, что это за объект: массив, целое число.
Пример:
$A=array ("а"=>"аа", "b"=>"bb",
"c" = >array ("х"=>"хх"));
$st=Serialize($A);
echo $st;
// выведется что-то типа нечто:
//а:2:(s:1:"а";s:2:"аа";s:1:"b";s:2:"bb";s:1:"с";а:1:(s:1:"х";s:2:"хх";))
Функция Unserialize(), наоборот, принимает в лице своего параметра $st строку, ранее созданную при помощи Serialize(), и возвращает целиком объект, который был упакован.
mixed Unserialize (string $st)
Например:
$a=array(l,2,3);
$s=Serialize($a);
$a= "bogus";
echo count ($a); // выводит 1
$a=Unserialize ($s);
echo count($a); // выводит 3
Сериализовать можно не только массивы, но и вообще что угодно. Однако в большинстве случаев все-таки используются массивы. Механизм сериализации часто применяется также и для того, чтобы сохранить какой-то объект в базе данных, и тогда без сериализации практически не обойтись.
Тема 6 Работа с массивами
6.1 Сортировка массивов
6.2 Функции для работы с массивами
6.1 Сортировка массивов
Сортировка массива по значениям (asort()/arsort()).
Функция assort() сортирует массив, указанный в ее параметре в алфавитном (если это строки) или в возрастающем (для чисел) порядке. При этом сохраняются связи между ключами и соответствующими им значениями. Пример:
$A=array("a"=>"Zero","b"=>"Weapon","c"=>"Alpha",
"d"=>"Processor");
asort($A);
foreach($A as $k=>$v) echo "$k=>$v ";
// выводит «c=>Alpha d=>Processor b=>Weapon a=>Zero»
Функция arsort() упорядочивает массив по убыванию.
Сортировка по ключам (ksort()/krsort()).
Функция ksort() сортирует массив по ключам (в порядке возрастания). Пример:
$A=array("d"=>"Zero","c"=>"Weapon","b"=>"Alpha","a"=>"Processor");
ksort($A);
for (Reset($A); list ($k, $v) =each ($A);) echo"$k=>$v";
// выводит "a=>Processor b=>Alpha c=>Weapon d=>Zero"
Функция для сортировки по ключам в обратном порядке – krsort().
Сортировка по ключам при помощи функции uksort().
Используется при сортировке по более сложному критерию, чем просто по алфавиту. Например, пусть в $Files хранится список имен файлов и подкаталогов в текущем каталоге. Необходимо вывести этот список не только в лексикографическом порядке, но также и чтобы все каталоги предшествовали файлам. В этом случае можно воспользоваться функцией uksort(), написав предварительно функцию сравнения с двумя параметрами.
Пример. Сортировка с помощью пользовательской функции
// Эта функция должна сравнивать значения $f1 и $f2 и возвращать:
// -1, если $fl<$f2,
// 0, если $fl==$f2
// 1, если $fl>$f2
function FCmp($f1,$f2)
{
// Каталог всегда предшествует файлу
if (is_dir($fl) &&!is_dir($f2)) return -1;
// Файл всегда идет после каталога
if (!is_dir($fl) && is_dir($f2)) return 1;
// Иначе сравниваем лексикографически
if($f1<$f2) return -1; elseif ($fl>$f2) return 1; else return 0;
}
// Пусть $Files содержит массив с ключами — именами файлов
// в текущем каталоге. Отсортируем его.
uksort($Files,"FCmp");
// передаем функцию сортировки "по ссылке"
Cвязи между ключами и значениями функцией uksort() сохраняются.
Сортировка по значениям при помощи функции uasort().
Функция uasort() аналогична uksort(), с той разницей, что пользовательской функции сортировки передаются не ключи, а очередные значения из массива. При этом также сохраняются связи в парах ключ=> значение.
Переворачивание массива array_reverce()
Функция array_reverse() возвращает массив, элементы которого следуют в обратном порядке относительно массива, переданного в параметре. При этом связи между ключами и значениями сохраняются. Например, вместо того, чтобы ранжировать массив в обратном порядке при помощи arsort(), можно отсортировать его в прямом порядке, а затем перевернуть:
$A=array ("a"=>"Zero", "b"=>"Weapon", "c"=>"Alpha",
"d"=>"Processor");
asort ($A);
$A=array_reverse($A);
Сортировка списка sort()/rsort()
Эти две функции предназначены для сортировки списков (под списками понимаются массивы, ключи которых начинаются с 0 и не имеют пропусков). Функция sort() сортирует список по значениям в порядке возрастания, a rsort() – в порядке убывания. Пример:
$A=array ("One", "Two", "Three", "Four");
sort ($A);
for($i=0; $i<count($A); $i++) echo "$i:$A[$i] ";
// выводит «0: Four 1: Two 2: Three 3:One»
Любой ассоциативный массив воспринимается этими функциями как список. То есть после упорядочивания последовательность ключей превращается в 0,1,2,..., а значения нужным образом перераспределяются. Cвязи между парами ключ=>значение не сохраняются, более того – ключи просто пропадают, поэтому сортировать что-либо, отличное от списка, нецелесообразно.
Сортировка списка при помощи функции usort().
Эта функция является «гибридом» функций uasort() и sort(). От sort() она отличается тем, что критерий сравнения обеспечивается пользовательской функцией. А от uasort() – тем, что она не сохраняет связей между ключами и значениями, а потому пригодна только для сортировки списков. Пример:
function FCmp($a,$b)
{ return strcmp ($a, $b); }
$A=array("One", "Two", "Three", "Four");
usort($A);
for ($i=0; $i<count ($A); $i++) echo "$i:$A[$i]";
// выводит «0:Four 1:One 2:Three 3:Two»
Функция strcmp(), возвращает –1, если $а<$b, 0, если они равны, и 1, если $а>$b. Приведенный здесь пример полностью эквивалентен простому вызову sort().
Перемешивание списка shuffle().
Функция shuffle() «перемешивает» список, переданный ей первым параметром, так, чтобы его значения распределялись случайным образом. При этом, во-первых, изменяется сам массив, а во-вторых, ассоциативные массивы воспринимаются как списки. Пример:
$А=аrrау(10,20,30,40,50);
shuffle($A);
foreach($A as $v) echo "$v ";
Приведенный фрагмент выводит числа 10, 20, 30, 40 и 50 в случайном порядке. Функция shuffle() использует стандартный генератор случайных чисел, который перед работой необходимо инициализировать при помощи вызова srand(), иначе при повторном вызове программы результат не измениться.
6.2 Функции для работы с массивами
Ключи и значения.
· array array_flip(array $Arr)
Функция меняет местами его ключи и значения. Исходный массив $Arr не изменяется, а результирующий массив просто возвращается. Если в массиве присутствовали несколько элементов с одинаковыми значениями, учитываться будет только последний из них:
|
|
|
