 |
информационных технологий» 4 глава
|
|
|
|
$A=array("a"=>"aaa", "b"=>"aaa", "c"=>"ccc");
$A=array_flip($A);
// теперь $A===array("aaa"=>"b", "ccc"=>"c");
· list array_keys(array $Arr [,mixed $SearchVal])
Функция возвращает список, содержащий все ключи массива $Arr. Если задан необязательный параметр $SearchVal, то она вернет только те ключи, которым соответствуют значения $SearchVal.
Фактически, эта функция с заданным вторым параметром является обратной по отношению к оператору [] — извлечению значения по его ключу.
· list array_values(array $Arr)
Функция array_values() возвращает список всех значений в ассоциативном массиве $Arr. Такое действие бесполезно для списков, но иногда оправдано для хэшей.
· bool in_array(mixed $val, array $Arr)
Возвращает true, если элемент со значением $val присутствует в массиве $Arr.
· array array_count_values(list $List)
Функция подсчитывает, сколько раз каждое значение встречается в списке $List, и возвращает ассоциативный массив с ключами – элементами списка и значениями – количеством повторов этих элементов. Т.е. функция array_count_values() подсчитывает частоту появления значений в списке $List. Пример:
$List=array(1, "hello", 1, "world", "hello");
array_count_values($array);
// возвращает array(1=>2, "hello"=>2, "world"=>1)
Комплексная замена в строке.
string strtr(string $st, array $Substitutes)
Функция strtr берет строку $st и проводит в ней контекстный поиск и замену: ищутся подстроки – ключи в массиве $Substitutes – и замещаются на соответствующие им значения.
$Subs=array("<name>" => "Larry",
"<time>" => date("d.m.Y"));
$st="Привет, <name>! Сейчас <time>";
echo strtr($st,$Subs);
Функция strtr() начинает поиск с самой длинной подстроки и не проходит по одному и тому же ключу дважды.
Слияние массивов.
array array_merge(array $A1, array $A2,...)
Функция array_merge()сливает массивы, перечисленные в ее аргументах, в один большой массив и возвращает результат. Если в массивах встречаются одинаковые ключи, в результат помещается пара ключ=>значение из того массива, который расположен правее в списке аргументов. Однако это не затрагивает числовые ключи: элементы с такими ключами помещаются в конец результирующего массива в любом случае. Пример, сливающий два списка в один:
|
|
|
$L1=array(10,20,30);
$L2=array(100,200,300);
$L=array_merge($L1,$L2);
// теперь $L===array(10,20,30,100,200,300);
Получение части массива.
array array_slice(array $Arr, int $offset [, int $len])
Функция возвращает часть ассоциативного массива, начиная с пары ключ=>значения со смещением (номером) $offset от начала и длиной $len (если последний параметр не задан, до конца массива). Параметры $offset и $len задаются по точно таким же правилам, как и аналогичные параметры в функции substr(). Параметры могут быть отрицательными (в этом случае отсчет осуществляется от конца массива), и т. д. Примеры:
$input=array("a","b","c","d","e");
$output=array_slice($input,2); // "c", "d", "e"
$output=array_slice($input,2,-1); // "c", "d"
$output=array_slice($input,-2,1); // "d"
$output=array_slice($input,0,3); // "a", "b", "c"
Вставка/удаление элементов.
Для вставки и удаления элементов массива могут использоваться: оператор [] (пустые квадратные скобки) добавляет элемент в конец массива, присваивая ему числовой ключ; оператор Unset() вместе с извлечением по ключу удаляет нужный элемент.
· int array_push(alist &$Arr, mixed $var1 [, mixed $var2, …])
Функция добавляет к списку $Arr элементы $var1, $var2 и т. д. Она присваивает им числовые индексы – точно так же, как это происходит для стандарных [].
array_push($Arr,1000); // вызываем функцию…
$Arr[]=1000; // то же самое, но короче
Функция array_push() воспринимает массив, как стек, и добавляет элементы всегда в его конец. Она возвращает новое число элементов в массиве.
· mixed array_pop(list &$Arr)
Функция array_pop(), в противоположность array_push(), снимает элемент с «вершины» стека (то есть берет последний элемент списка) и возвращает его, удалив после этого его из $Arr. Если список $Arr был пуст, функция возвращает пустую строку.
|
|
|
· int array_unshift(list &$Arr, mixed $var1 [,mixed $var2, …])
Функция похожа на array_push(), но добавляет перечисленные элементы не в конец, а в начало массива. При этом порядок следования $var1, $var2 и т. д. остается тем же, т. е. элементы как бы «вдвигаются» в список слева. Новым элементам списка, как обычно, назначаются числовые индексы, начиная с 0; при этом все ключи старых элементов массива, которые также были числовыми, изменяются (чаще всего они увеличиваются на число вставляемых значений). Функция возвращает новый размер массива. Пример:
$A=array(10,"a"=>20,30);
array_unshift($A,"!","?");
// теперь $A===array(0=>"!", 1=>"?", 2=>10, a=>20, 3=>30)
· mixed array_shift(list &$Arr)
Функция извлекает первый элемент массива $Arr и возвращает его. При извлечении первого элемента корректируются все числовые индексы у всех оставшихся элементов.
· array array_unique(array $Arr)
Функция array_unique() возвращает массив, составленный из всех уникальных значений массива $Arr вместе с их ключами. В результирующий массив помещаются первые встретившиеся пары ключ=>значение:
$input=array("a" => "green", "red", "b" => "green", "blue", "red");
$result=array_unique($input);
// теперь $result===array("a"=>"green", "red", "blue");
· array array_splice(array &$Arr, int $offset [, int $len] [, int $Repl])
Функция возвращает подмассив $Arr, начиная с индекса $offset максимальной длины $len, и заменяет только что указанные элементы на то, что находится в массиве $Repl (или просто удаляет, если $Repl не указан). Параметры $offset и $len могут быть и отрицательными, в этом случае отсчет начинается от конца массива. Пример:
$input=array("red", "green", "blue", "yellow");
array_splice($input,2);
// Теперь $input===array("red", "green")
array_splice($input,1,-1);
// Теперь $input===array("red", "yellow")
array_splice($input,-1,1,array("black","maroon"));
// Теперь $input===array("red", "green", "blue", "black", "maroon")
array_splice($input,1,count($input),"orange");
// Теперь $input===array("red", "orange")
В качестве параметра $Repl можно указать и обычное, строковое значение, а не массив из одного элемента.
Переменные и массивы.
· array compact(mixed $vn1 [, mixed $vn2, …])
Функция compact(), упаковывает в массив переменные из текущего контекста (глобального или контекста функции), заданные своими именами в $vn1, $vn2 и т. д. При этом в массиве образуются пары с ключами, равными содержимому $vnN, и значениями соответствующих переменных. Пример:
|
|
|
$a="Test string";
$b="Some text";
$A=compact("a","b");
// теперь $A===array("a"=>"Test string", "b"=>"Some text")
Параметры функции могут быть не только строками, но и списками строк. В этом случае функция последовательно перебирает все элементы этого списка, и упаковывает те переменные из текущего контекста, имена которых она встретила. Эти списки могут, в свою очередь, также содержать списки строк, и т. д. Пример:
$a="Test";
$b="Text";
$c="CCC";
$d="DDD";
$Lst=array("b",array("c","d"));
$A=compact("a",$Lst);
//теперь $A===array("a"=>"Test","b"=>"Text","c"=>"CCC", "d"=>"DDD")
· void extract(array $Arr [, int $type] [, string $prefix])
Функция получает в параметрах массив $Arr и превращает каждую его пару ключ=>значение в переменную текущего контекста. Параметр $type предписывает, что делать, если в текущем контексте уже существует переменная с таким же именем, как очередной ключ в $Arr. Он может быть равен одной из следующих констант:
EXTR_OVERWRITE – переписывать существующую переменную (по умолчанию);
EXTR_SKIP – не перезаписывать переменную, если она уже существует;
EXTR_PREFIX_SAME – в случае совпадения имен создавать переменную с именем, предваренным префиксом из $prefix.
EXTR_PREFIX_ALL – всегда предварять имена создаваемых переменных префиксом $prefix
Пример:
// Сделать все переменные окружения глобальными
extract($HTTP_ENV_VARS);
// То же самое, но с префиксом E_
extract($HTTP_ENV_VARS, EXTR_PREFIX_ALL, "E_");
echo $E_COMSPEC; // выводит переменную окружения COMSPEC
Параметр $prefix имеет смысл указывать только тогда, применяются режимы EXTR_PREFIX_SAME или EXTR_PREFIX_ALL.
Замечание. Использование extract() и compact() может быть оправдано лишь для небольших массивов, да и то только в шаблонах, а в остальных случаях считается признаком дурного тона.
Создание списка – диапазона чисел.
list range(int $low, int $high)
Функция создает список, заполненный целыми числами от $low до $high включительно.
|
|
|
Тема 7 Функции и области видимости
7.1 Формат определения функции, передача параметров
7.2 Глобальные, локальные, статические переменные
7.3 Рекурсия, вложенные и условно-определяемые функции
7.4 Передача функций по ссылке и возврат функцией ссылки
7.1 Формат определения функции, передача параметров
Формат определения функции:
function имя_функции (арг1[=зн1], арг2[=зн2],... аргN[=знN])
{
операторы_тела_функции;
}
Имя функции должно быть уникальным с точностью до регистра букв. Это означает, что, во-первых, имена MyFunction, myfunction и даже MyFuNcTiOn будут считаться одинаковыми, и, во-вторых, нельзя переопределить уже определенную функцию (стандартную или нет – не важно), но зато можем давать функциям такие же имена, как и переменным в программе (конечно, без знака $ в начале). Список аргументов состоит из нескольких перечисленных через запятую переменных, каждая из которых должна задаваться при вызове функции (если для этой переменной присвоено через знак равенства значение по умолчанию (обозначенное =знM), ее можно будет опустить).
Если у функции не должно быть аргументов, то следует оставить пустые скобки после ее имени, например:
function SimpleFunction()
{... }
В фигурные скобки заключается тело функции. В нем могут быть любые операторы, включая даже операторы определения других функций (однако эти «другие функции» не будут локальными, как в Паскале, а станут далее «видны» для всей программы, но только с того момента, как до их описания дойдет управление). Если функция должна возвращать какое-то значение, что среди них должен встретиться оператор return. Если же она должна отработать без возврата значений, то оператор return можно и не указывать (или указывать без задания возвращаемого значения).
Синтаксис оператора return:
return возвращаемое значение;
В PHP можно использовать return абсолютно для любых объектов (какими бы большими они ни были), причем без заметной потери быстродействия. Пример:
function MySqrt($n)
{ return $n*$n;
}
echo MySqrt(4); // выводит 16
Сразу несколько значений функции возвратить не могут. Однако, если это все же нужно, то можно вернуть ассоциативный массив или список:
function Silly()
{ return array(1,2,3);
}
// присваивает массиву значение array(1,2,3)
$arr=Silly();
// присваивает переменным $a, $b, $c первые значения из списка
list($a,$b,$c)=Silly();
Если функция не возвращает никакого значения, т. е. инструкции return в ней нет, то считается, что функция возвратила значение false.
Вызывать функции нужно только после того, как они будут определены.
В отличие от других языков программирования, функцию можно задавать не только в определенном месте программы, но и прямо среди других операторов:
|
|
|
echo "Программа...";
function GetMaxNum($arr,$max)
{... тело функции...
}
echo "Программа продолжается!";
При таком подходе транслятор, дойдя до определения функции, проверит его корректность и оттранслирует во внутреннее представление, но не будет генерировать код для выполнения, а сразу переключится на следующие за телом функции команды. Только потом, при вызове функции, интерпретатор начнет исполнять ее команды.
Параметры по умолчанию. Часто бывают необходимо, чтобы у функции было много параметров, причем некоторые из них будут задаваться совершенно единообразно. Например, нужна функция сортировки массива. Тогда, кроме очевидного параметра – массива – хотелось бы также задавать и второй параметр, который бы указывал порядок сортировки (в убывающем или в возрастающем порядке). При этом чаще всего придется сортировать в порядке убывания. В этом случае мы можем оформить функцию так:
function MySort(&$Arr, $NeedLoOrder=1)
{... сортируем в зависимости от $NeedLoOrder...
}
Теперь, имея такую функцию, можно написать в программе:
MySort($my_array,0); // сортирует в порядке возрастания
MySort($my_array); // второй аргумент задается по умолчанию!
То есть, можно опустить второй параметр у функции, что будет выглядеть так, как будто его задали равным 1. Значение по умолчанию для какого-то аргумента указывается справа от него через знак равенства. Значения аргументов по умолчанию должны определяться справа налево, причем недопустимо, чтобы после любого из таких аргументов шел обычный «неумолчальный» аргумент. Пример неверного описания функции:
// Ошибка!
function MySort($NeedLoOrder=1, &$Arr)
{
... сортируем в зависимостиот $NeedLoOrder...
}
MySort(,$my_array); // Ошибка!
Передача параметров по ссылке. Рассмотрим механизм передачи аргументов функции. Пусть, например, есть такая программа:
function Test($a)
{ echo "$a\n"; // распечатается значение 10
$a++;
echo "$a\n"; // распечатается значение 11
}
...
$num=10;
Test($num);
echo $num; // распечатается значение 10
Функция Test() не возвращает никакого значения, т. е. является в чистом виде подпрограммой или процедурой. Создается переменная $a, локальная для данной функции, и ей присваивается значение 10 (то, что было в $num). После этого значение 10 выводится на экран, величина $a инкрементируется, и новое значение (11) опять печатается. Так как тело функции закончилось, происходит возврат в вызвавшую программу. При последующем выводе переменной $num будет напечатано 10 (и это несмотря на то, что в переменной $a до возврата из функции было 11!). Это происходит потому, что $a – лишь копия $num, а изменение копии никак не отражается на оригинале.
Если необходимо, чтобы функция имела доступ не к величине, а именно к самой переменной (переданной ей в параметрах), достаточно при передаче аргумента функции перед его именем поставить &.
Пример передачи параметров по ссылке (первый способ):
function Test($a)
{ echo "$a\n";
$a++;
echo "$a\n";
}
$num=10; // $num=10
Test(&$num); // теперь $num=11!
echo $num; // выводит 11!
Такой способ передачи параметров исторически называется «передачей по ссылке», в этом случае аргумент не является копией переменной, а «ссылается» на нее. Передача параметра по ссылке полностью соответствует синтаксису задания ссылочной переменной в PHP.
Чтобы не забывать каждый раз писать & перед переменной, передавая ее функции, существует и другой синтаксис передачи по ссылке: можно символ & перенести прямо в заголовок функции.
Передача параметров по ссылке (второй способ):
function Test(&$a)
{ echo "$a\n";
$a++;
echo "$a\n";
}
....
$num=10; // $num=10
Test($num); // а теперь $num=11!
echo $num; // выводит 11!
В качестве параметров, передаваемых по ссылке, можно задавать только переменные, но не непосредственные значения!
Переменное число параметров. Функция может иметь несколько параметров, заданных по умолчанию. Они перечисляются справа налево, и их всегда фиксированное количество. Пусть необходимо написать функцию, которая принимает один или более параметров (сколько именно – неизвестно на этапе определения функции). Пусть она должна вывести эти параметры «лесенкой» – каждый следующий на новой строке с отступом от предыдущего.
Пример передачи переменного числа параметров функции:
function myecho()
{ for($i=0; $i<func_num_args(); $i++)
{
for($j=0; $j<$i; $j++) echo " ";// выводим отступ
echo func_get_arg($i)."<br>\n"; // выводим элемент
}
}
// отображаем строки «лесенкой»
myecho("Меркурий", "Венера", "Земля", "Марс");
При описании myecho() указаны пустые скобки в качестве списка параметров, словно функция не получает ни одного параметра. На самом деле в PHP при вызове функции можно указывать параметров больше, чем задано в списке аргументов – в этом случае никакие предупреждения не выводятся (но если фактическое число параметров меньше, чем указано в описании, PHP выдаст сообщение об ошибке). «Лишние» параметры как бы игнорируются, в результате пустые скобки в myecho() позволяют в действительности передать ей сколько угодно параметров.
Для того чтобы иметь доступ к «проигнорированным» параметрам, существуют три встроенные в PHP функции:
· int func_num_args()
Возвращает общее число аргументов, переданных функции при вызове.
· mixed func_get_arg(int $num)
Возвращает значение аргумента с номером $num, заданного при вызове функции. Нумерация отсчитывается с нуля.
· list func_get_args()
Возвращает список всех аргументов, указанных при вызове функции.
Пример использования функции func_get_args:
function myecho()
{ foreach(func_get_args() as $v) {
for($j=0; $j<@$i; $j++) echo " ";
echo "$v<br>\n";
@$i++;
}
}
// выводим строки "лесенкой"
myecho("Меркурий", "Венера", "Земля", "Марс");
В программе используется цикл foreach для перебора аргументов, а также оператор отключения ошибок @, чтобы PHP не «ругался» на то, что переменная $i не определена при первом «обороте» цикла.
7.2 Глобальные, локальные, статические переменные
Все переменные, которые объявляются и используются в функции, по умолчанию локальны для этой функции. При этом существует только два способа объявления глобальных переменных: инструкция global или через массив $GLOBALS.
Локальные переменные. Аргументы функции (передаваемые по значению, а не по ссылке) являются временными объектами, которые создаются в момент вызова и исчезают после окончания функции.
Пример локальных переменных (параметров):
$a=100; // Глобальная переменная, равная 100
function Test($a)
{ echo $a; // выводим значение параметра $a
// Этот параметр не имеет к глобальной $a никакого отношения!
$a++; // изменяется только локальная копия значения,
//переданного в $a
}
Test(1); // выводит 1
echo $a; // выводит 100 – глобальная $a не изменилась
Такими же свойствами будут обладать не только аргументы, но и все другие переменные, инициализируемые или используемые внутри функции.
Пример локальных переменных:
function Silly()
{ $i=rand(); // записывает в $i случайное число
echo $i; // выводит его на экран
// Эта $i не имеет к $i никакого отношения!
}
for($i=0; $i!=10; $i++) Silly();
Здесь переменная $i в функции будет не той переменной $i, которая используется в программе для организации цикла. Поэтому цикл и проработает только 10 «витков», напечатав 10 случайных чисел (а не будет крутиться долго и упорно, пока «в рулетке» функции rand() не выпадет 10.
Глобальные переменные. Для задания глобальной переменной нужно до её первого использования объявить ее в теле функции «глобальной».
Пример использование global:
function Silly()
{ global $i;
$i=rand();
echo $i;
}
for($i=0; $i!=10; $i++) Silly();
Теперь переменная $i будет везде едина: что в функции, что во внешнем цикле (для последнего это приведет к немедленному его «зацикливанию», во всяком случае до тех пор, пока rand() не выкинет 10).
Пример использования глобальных переменных внутри функции:
$Monthes[1]="Январь";
$Monthes[1]="Февраль";
...
$Monthes[12]="Декабрь";
...
// Возвращает название месяца по его номеру.
// Нумерация начинается с 1!
function GetMonthName($n)
{ global $Monthes;
return $Monthes[$n];
}
...
echo GetMonthName(2); // выводит «Февраль»
Массив $Monthes, содержащий названия месяцев, довольно объемист. Поэтому описывать его прямо в функции неудобно. В то же время функция GetMonthName() представляет собой довольно преемлемое средство для приведения номера месяца к его словесному эквиваленту. Она имеет единственный параметр: это номер месяца.
Массив $GLOBALS.Есть и второй способ добраться до глобальных переменных. Это – использование встроенного в язык массива $GLOBALS. Он представляет собой хэш, ключи которого есть имена глобальных переменных, а значения – их величины. Этот массив доступен из любого места в программе – в том числе и из тела функции, и его не нужно никак дополнительно объявлять.
Пример использования массива $GLOBAL:
// Возвращает название месяца по его номеру.
// Нумерация начинается с 1!
function GetMonthName($n)
{ return $GLOBALS["Monthes"][$n]; }
Не только переменные, но даже и массивы могут иметь совершенно любую структуру, какой бы сложной она ни была. Например, предположим, что в программе есть ассоциативный массив $A, элементы которого – двумерные массивы чисел. Тогда доступ к какой-нибудь ячейке этого массива с использованием $GLOBALS мог бы выглядеть так:
$GLOBALS["A"][First"][10][20];
То есть получился четырехмерный массив!
Массив $GLOBALS имеет ряд особенностей.
Во-первых, массив $GLOBALS изначально является глобальным для любой функции, а также для самой программы. Вполне допустимо его использовать не только в теле функции, но также и в любом другом месте.
Во-вторых, с этим массивом допустимы не все операции, разрешенные с обычными массивами. Нельзя присвоить этот массив какой-либо переменной целиком, используя оператор =; нельзя передать его функции «по значению» – можно передавать только по ссылке. Остальные операции допустимы. Можно по одному перебрать у массива $GLOBALS все элементы и, например, вывести их значения на экран.
В-третьих, добавление нового элемента в $GLOBALS равнозначно созданию новой глобальной переменной (предваренной символом $ в начале имени, ведь в самом массиве ключи – это имена переменных без символа доллара), а выполнение операции Unset() для него равносильно уничтожению соответствующей переменной.
В массиве $GLOBALS всегда присутствует переменная GLOBALS. Элемент с ключом GLOBALS является не обычным массивом, а лишь ссылкой на $GLOBALS.
Особенность использования инструкция global.
Инструкция global $a говорит о том, что переменная $a является глобальной, т.е., является синонимом глобальной $a. Синоним в терминах PHP – это ссылка, поэтому global создает ссылку.
Пример:
function Test()
{ global $a;
$a=10;
}
Приведенное описание функции Test() полностью эквивалентно следующему описанию:
function Test()
{ $a=&$GLOBALS[’a’];
$a=10;
}
Из второго фрагмента видно, что оператор Unset($a) в теле функции не уничтожит глобальную переменную $a, а лишь «отвяжет» от нее ссылку $a. Точно то же самое происходит и в первом случае.
Пример:
$a=100;
function Test()
{ global $a;
Unset($a);
}
Test();
echo $a; // выводит 100, т. е. настоящая $a не была удалена в Test()!
Для того, чтобы удалить глобальную $a из функции существует только один способ: использовать $GLOBALS['a']:
function Test() { unset($GLOBALS['a']); }
$a=100;
Test();
echo $a; // Ошибка! Переменная $a не определена!
Статические переменные. Статические переменные определяются в теле функции с помощью слова static.
Пример задания статических переменных:
function Silly()
{ static $a=0;
echo $a;
$a++;
}
for($i=0; $i<10; $i++) Silly();
После запуска будет выведена строка 0123456789. Если убрать слово static, то результатом будет строка 0000000000, потому что переменная $a стала локальной, и ей при каждом вызове функции присваивается одно и то же значение – 0.
Конструкция static говорит компилятору о том, что уничтожать указанную переменную для функции между вызовами не надо. В то же время присваивание $a=0 сработает только один раз, а именно – при самом первом обращении к функции.
7.3 Рекурсия, вложенные и условно-определяемые функции
Рекурсия. В PHP поддерживаются рекурсивные вызовы функций, т. е. вызовы функцией самой себя.
Примера функции, рекурсивно вычисляющей факториал числа n.
function Factor($n)
{ if($n<=0) return 1;
else return $n*Factor($n-1);
}
echo Factor(20);
Вложенные функции. Стандарт PHP не поддерживает вложенные функции. Однако он поддерживает нечто, немного похожее на них. Вместо того чтобы, как и у переменных, ограничить область видимости для вложенных функций своими «родителями», PHP делает их доступными для всей остальной части программы, но только с того момента, когда «функция-родитель» была из нее вызвана.
Пример вложенных функций:
function Parent($a)
{ echo $a;
function Child($b)
{ echo $b+1;
return $b*$b;
}
return $a*$a*Child($a);
// фактически возвращает $a*$a*($a+1)*($a+1)
}
// Вызываем функции
Parent(10);
Child(30);
// Если теперь ВМЕСТО этих двух вызовов поставить такие
// же, но только в обратном порядке, то система выдает ошибку!
Нет никаких ограничений на место описания функции – будь то глобальная область видимости программы, либо же тело какой-то другой функции. В то же время понятия «локальная функция» как такового в PHP не существует. Каждая функция добавляется во внутреннюю таблицу функций PHP тогда, когда управление доходит до участка программы, содержащего определение этой функции. При этом, само тело функции пропускается, однако ее имя фиксируется и может далее быть использовано в сценарии для вызова. Если же в процессе выполнения программы PHP никогда не доходит до определения некоторой функции, она не будет «видна», как будто ее и не существует.
Если вызвать функцию Parent() два раза подряд,
Parent(10);
Parent(20);
то последний вызов породит ошибку: функция Child() уже определена. Это произошло потому, что Child() определяется внутри Parent(), и до ее определения управление программы фактически доходит дважды (при первом и втором вызовах Parent()). Поэтому-то интерпретатор и «протестует»: он не может второй раз добавить Child() в таблицу функций.
Условно определяемые функции. Предположим, у нас в программе где-то устанавливается переменная $OS_TYPE в значение win, если сценарий запущен под Windows 9x, и в unix, если под Unix. В отличие от Unix, в Windows нет такого понятия, как владелец файла, а значит, стандартная функция chown() (которая назначает владельца для указанного файла) там просто не имеет смысла. В некоторых версиях PHP для Windows ее может в этой связи вообще не быть. Однако, чтобы улучшить переносимость сценариев с одной платформы на другую (без изменения их кода!) можно написать следующую простую «обертку» для функции chown():
|
|
|
