Руководство по РНР 3.0 - Описание языка
Глава 6. Элементы языка
Любой скрипт PHP состоит из
последовательности операторов.
Оператор может быть присваиванием,
вызовом функции, циклом, условным
выражением или пустым выражением
(ничего не делающим). Операторы
обычно заканчиваются точкой с
запятой. Также операторы могут быть
объединены в группу заключением
группы операторов в фигурные
скобки. Группа операторов также
является оператором. В этой части
описаны различные типы операторов.
PHP определяет несколько констант
и предоставляет механизм для
определения Ваших констант.
Константы похожи на переменные, но
они имеют слегка изменЈнный
синтаксис.
ПредопределЈнные константы - это
__FILE__ and __LINE__, которые соответствуют
имени файла и номеру строки,
которая выполняется в настоящий
момент.
Пример 6-1. Использование
__FILE__ и __LINE__<?php
function report_error($file, $line, $message) {
echo "An error occured in $file on line $line: $message.";
}
report_error(__FILE__,__LINE__, "Something went wrong!");
?>
|
Вы можете определить
дополнительные константы с помощью
функций define() и undefine() .
Пример 6-2. Описание
констант<?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // outputs "Hello world."
undefine ("CONSTANT");
?>
|
Выражения - это краеугольный
камень PHP. В PHP почти всЈ является
выражениями. Простейший и наиболее
точный способ определить выражение
- это "что-то, имеющее
значение".
Простейший пример, приходящий на
ум это константы и переменные.
Когда вы печатаете "$a = 5", вы
присваиваете значение '5'
переменной $a. '5', очевидно, имеет
значение 5, иными словами'5' это
выражение со значением5 (в данном
случае'5' это целочисленная
константа).
После этого присваивания вы
считаете значением $a 5, также, если
вы напишете $b = $a, вы будете ожидать
того же как, если бы вы написали $b = 5.
Другими словами, $a это также
выражение со значением 5. Если всЈ
написано правильно, то именно так
оно и случиться.
Несколько более сложные примеры
выражений - это функции. К примеру,
подумайте на следующей функцией :
function foo () {
return 5;
}
Подразумевая, что вы знакомы с
концепциями функции (если нет,
взгляните на часть, посвящЈнную
функциям), вы считаете, что $c = foo()
это практически то же самое, что
написать $c = 5 и вы правы.
Функции - это выражения с тем
значением, которое они возвращают.
Так как foo() возвращает 5, значение
выражение 'foo()' - 5. Обычно функции
подсчитывают возвращаемое
значение,а не возвращают
постоянное значение.
Конечно, значения в PHP не обязаны
быть целыми и зачастую они не
являются таковыми. PHP поддерживает 3
скалярных типа значений : целое,
число с плавающей точкой и строки (
скалярные выражения вы не можете
"разбить" на более маленькие
части, как, к примеру, массивы). PHP
поддерживает 2 составных
(нескалярных) типа : массивы и
объекты. Каждое из таких значений
может быть присвоено переменной
или возвращено функцией.
Итак, пользователи PHP/FI 2 не должны почувствовать каких-то перемен. PHP это
язык, ориентированный на выражения, практически всЈ является выражениями.Обратимся
к примеру, с которым мы уже разобрались, '$a = 5'. Легко заметить, что тут задействованы
два значения - значение целой константы 5 и значение $a, которое также становиться
равным 5.На самом деле здесь присутствует ещЈ одно значение, значение самого
присваивания. Само присваивание становиться равным присваиваемому значению,
в данном случае - 5.На практике это означает, что '$a = 5', не обращая внимания
на то, что оно равно выражению со значением 5. То есть, запись типа '$b = ($a
= 5)' похожа на запись'$a = 5; $b = 5;' (точка с запятой отмечает конец выражения).
Так как присваивания рассматриваются справа налево, вы также можете написать
'$b = $a = 5'.
Другой хороший пример направления выражения это прежварительное и последующее
увеличение и уменьшение. Рользователи PHP/FI 2 и многих других языков могут
быть знакомы с записями variable++ and variable--. Это операторы увеличения
и уменьшения. В PHP/FI 2, оператор '$a++' не имеет значения(не является выражением),
поэтому вы не можете его присвоить или использовать как-либо иначе. PHP расширяет
возможность увеличения/уменьшения делая его выражением, как и в C. В PHP, подобно
C, есть 2 типа инкремента - предварительный и последующий. И предыдущий и последующий
инкремент увеличивает значение переменной и воздействие на переменную идентично.Разница
в значении выражения инкремента. Предыдущее увеличение, которое записывается
как '++$variable', приравнивается увеличенной переменной (PHP увеличивает переменную
до того, как прочитать еЈ значение). Post-increment, which is written '$variable++'
evaluates to the original value of $variable, before it was incremented (PHP
increments the variable after reading its value, thus the name 'post-increment').
Очень распространЈнный тип выражений это выражения сравнения. Эти выражения
имеют значение 0 или 1 (означает ложь или истину соответственно). PHP поддерживает
> (больше, чем), >= ( больше или равно), = (равно), < (меньше,чем)
и <= (меньше или равно). Эти выражения в основном используются внутри условий,
например оператора IF.
Последний пример выражений, с которыми мы разберЈмся, это совмещЈнные выражения
оператор-присваивание. Вы уже знаете, что для того, чтобы увеличить значение
$a на еденицу, вы можете написать '$a++' или '++$a'. Но если следует увеличить
значение больше, чем на еденицу, к примеру - на 3? Вы можете написать '$a++'
несколько раз, но это не очень удобно и эффективно. Намного больше распространено
написание '$a = $a + 3'. '$a + 3' вычисляется, как значение $a плюс 3, а затем
присваивается переменной $a, в результате чего значение $a увеличивается на
3. В PHP, также как и в ряде других языков типа C, вы можете записать это короче,
что со временем бывает проще и быстрее также и для понимания. Добавление 3 к
текущему значению $a может быть записано как '$a+=3'. Это значит следующее :
'возьми значение $a, добавь к нему 3 и присвой это обратно $a. Кроме того, что
это быстрее и понятнее, такой тип выражений быстрее исполняется. Значение '$a+=3'
как и значение обычного присваивания это присвоенное значение. Заметьте, что
оно не равно 3, а является общим значением $a и 3. Любой бинарный (имеющий 2
операнда - прим. пер.) оператор может быть записан таким методом, например :
'$a-=5' (вычесть 5 из значения $a), '$b*=7' (умножиить значение $a на 7) и так
далее.
Есть ещЈ такое выражение, которое может показаться незнакомым, если вы не встречались
с ним в других языках - условный оператор с тремя операндами :
$first ? $second : $third
Если значение первого выражения истинно (не равно 0), то испольняется второе
выражение и это является результатом данного условного выражения. Иначе исполняется
третий оператор.
Этот пример должен помочь Вам лучше понять предварительное и последующее увеличение
и вообще выражения ?
function double($i) /* функция удваивания переменной */
{
return $i*2;
}
$b = $a = 5; /* присваиваем значения переменым $a и $b */
$c = $a++; /* последующее увеличение, присваиваем $c начальное
значение $a (5)*/
$e = $d = ++$b; /* предварительное увеличение, присваиваем
$d и $e увеличенное значение$b (6) */
/* тут и $d и$e равны6 */
$f = double($d++); /* присвоить удвоенное значение $d до его
увеличения, то есть 2*6 = 12, переменной $f*/
$g = double(++$e); /* присвоить удвоенное значение $e после
его увеличения, то есть 2*7 = 14, переменной g */
$h = $g += 10; /* сначала увеличить значение $g на 10, что
даЈт в результате 24, а затем присвоить это значение переменной $h, что также
даЈт 24 */
В начале главы мы сказали, что объясним различные типы операторов и, как и
было обещано выражения могут быть операторами. Впрочем, не каждое выражения
является оператором. В данном случае оператор имеет форму 'выражение' ';', то
есть выражение, за которым следует точка с запятой. В '$b=$a=5;' $a=5 это правильное
выражение, но само по себе оно не является оператором. А вот '$b=$a=5;' является
правильным оператором.
ЕщЈ одна вещь, которую нужно упомянуть - это логические значения выражений.
Во многих случаях, в основном в условных операторах и операторах циклов, вы
не заинтересованы в конкретных значениях выражений, а только являются ли их
значения TRUE или FALSE (в PHP нет специального типа boolean). Логические значения
вычисляются примерно так же, как я в языке Perl. Любое не нулевое целое значение
- это TRUE, ноль - это FALSE. Обратите внимание на то, что отрицательные значения
- это не ноль и поэтому они считаются равными TRUE. Пустая строка и строка '0'
это FALSE; все остальные строки - TRUE. И насчЈт составных типов (массивы и
объекты) - если значение такого типа не содержит элементов, то оно считается
равным FALSE; иначе подразумевается TRUE.
PHP предоставляет полную и мощную реализацию выражений и подробное еЈ описание
выходит за пределы этого руководства. ПриведЈнные выше примеры показали вам,
что такое выражения и как вы можете построить реальные выражения. В остальной
части руководства мы будем писать 'expr' для обозначения любого правильного
выражения PHP.
Структура IF это одна из важнейших возможностей многих языков, включая PHP.
Она позволяет организовать выполнение фрагментов кода по условию. Возможности
PHP по использованию выражения IF похожи на C:
if (expr) statement
Как объяснялось в части про выражения, вычисляется логический результат "expr"
. Если expr равно TRUE, то PHP выполнит "statement", а если FALSE
- проигнорирует.
Следующий пример выведет фразу 'a is bigger than b' если $a больше $b:
if ($a > $b)
print "a is bigger than b";
Зачастую Вам требуется исполнить больше чем одно выражение по условию. Конечно,
не надо окружать каждое выражение конструкцией IF. Вместо этого вы можете сгруппировать
несколько выражений в блок выражений. К примеру, слежующий код не только выведет
фразу, но и присвоит значение $a переменной $b:
if ($a > $b) { print "a is bigger than b"; $b = $a; }
Выражение IF может иметь неограниченную степень вложенности в другие выражения
IF, что позволяет Вам эффективно использовать выполнение по условию различных
частей программы.
Зачастую Вам требуется исполнить одно выражение, если соблюдается какое-либо
условие и другое выражение в противном случае. Вот для этого применияется ELSE.
ELSE расширяет возможности IF по части обработки вариантов выражения, когда
оно равно FALSE. Данный пример выведет фразу 'a is bigger than b' если $a больше
$b, и 'a is NOT bigger than b' в противном случае:
if ($a > $b) {
print "a is bigger than b";
} else {
print "a is NOT bigger than b";
}
Выражение ELSE выполняется только если выражение IF равно FALSE, а если есть
конструкции ELSEIF - то если и они также равны FALSE (см. ниже).
ELSEIF, как и следует из его названия, является комбинацией IF и ELSE. ELSEIF
как и ELSE позволяет выполнить выражение, если значение IF равно FALSE, но в
отличие от ELSE оно выполнится только если выражение ELSEIF равно TRUE.К примеру,
следующий код выведет 'a is bigger than b' если$a>$b, 'a is equal to b' если
$a==$b, и 'a is smaller than b' если$a<$b:
if ($a > $b) {
print "a is bigger than b";
} elseif ($a == $b) {
print "a is equal to b";
} else {
print "a is smaller than b";
}
Внутри одного выражения IF может быть несколько ELSEIF. Первое выражение ELSEIF
(если таковые есть), которое будет равно TRUE, будет выполнено. В PHP3 вы можете
написать 'else if' (два слова), что будет значить то же самое, что и 'elseif'
(одно слово).
Выражение ELSEIF будет выполнено только если выражение IF и все предыдущие
ELSEIF равно FALSE, а данный ELSEIF равен TRUE.
PHP3 предлагает иной путь для группирования операторов с оператором IF. Наиболее
часто это используется когда вы внедряете блоки HTML внутрь оператора IF, но
вообще может использоваться где угодно. Вместо использования фигурных скобок
за "IF(выражение)" должно следовать двоеточие, одно или несколько
выражений и завершающий ENDIF. Рассмотрите слежующий пример :
<?php if ($a==5): ?> A = 5 <?php endif; ?>
В этом примере блок "A = 5" внедрЈн внутрь выражения IF, используемого
альтернативным способом. Блок HTML будет виден только если $a равно 5.statement
written in the alternative syntax.
Этот альтернативный синтаксис применим и к ELSE и ELSEIF (expr) .Вот пример
подобной структуры :
if ($a == 5):
print "a equals 5";
print "...";
elseif ($a == 6):
print "a equals 6";
print "!!!";
else:
print "a is neither 5 nor 6";
endif;
Цикл WHILE - простейший тип цикла в PHP3. Он действует как и его аналог в C.
Основная форма оператора WHILE :
WHILE(expr) statement
Смысл оператора WHILE прост. Он предписывает PHP выполнять вложенный(е) оператор(ы)
до тех пор пока expr равно TRUE. Значение выражения проверяется каждый раз при
начале цикла, так что если значение выражения изменится внутри цикла, то он
не прервЈтся до конца текущей итерации (выполнение всего блока вложенных операторов
- это одна итерация). Иногда, если значение expr равно FALSE с самого начала,
цикл не выполняется ни разу.
Как и в IF, вы можете сгруппировать несколько операторов внутри фигурных скобок
или использовать альтернативный синтаксис :
WHILE(expr): выражения ... ENDWHILE;
Следующие примеры идентичны - оба выводят номера с 1 по 10:
/* example 1 */
$i = 1;
while ($i <= 10) {
print $i++; }
/* example 2 */
$i = 1;
while ($i <= 10):
print $i;
$i++;
endwhile;
Цикл DO..WHILE очень похож на WHILE за исключением того, что значение логического
выражения проверяется не до, а после окончания итерации. Основное отличие в
том, что DO..WHILE гарантировано выполнится хотя бы один раз, что в случае WHILE
не обязательно.
Для циклов DO..WHILE существует только один вид синтаксиса:
$i = 0;
do {
print $i;
} while ($i>0);
Этот цикл выполнится один раз, так как после окончания итерации будет проверено
значение логического выражения, а оно равно FALSE ($i не больше 0), и выполнение
цикла завершится.
Опытные программисты на C может быть знакомы с иным использованием DO..WHILE,
позволяющем прекратить исполнение блока операторов в середине путЈм внедрения
его в цикл DO..WHILE(0) и использования оператора BREAK. Следующий код демонстрирует
такую возможность :
do {
if ($i < 5) {
print "i is not big enough";
break;
}
$i *= $factor;
if ($i < $minimum_limit) {
break;
}
print "i is ok";
...process i...
} while(0);
Не беспокойтесь, если вы не совсем поняли это. Вы можете программировать весьма
мощные скрипты и без этой возможности.
Циклы FOR - наиболее мощные циклы в PHP. Они работают подобно их аналогам в
C. Синтаксис цикла FOR :
FOR (expr1; expr2; expr3) statement
Первое выражение (expr1) безусловно вычисляется(выполняется) в начале цикла.
В начале каждой итерации вычисляется expr2. Если оно равно TRUE, то цикл продолжается
и выполняются вложенный(е) оператор(ы). Если оно равно FALSE, то цикл заканчивается.
В конце каждой итерации вычисляется(исполняется) expr3.
Каждое из этих выражений может быть пустым. Если expr2 пусто, то цикл продолжается
бесконечно (PHP по умолчанию считает его равным TRUE, как и С). Это не так бесполезно,
как могло бы показаться, так как зачастую вам требуется закончить выполнение
цикла используя оператор BREAK в сочетании с логическим условием вместо использования
логического выражения в FOR.
Рассмотрим следующие примеры. Все они выводят номера с 1 по 10 :
/* пример 1 */
for ($i = 1; $i <= 10; $i++) {
print $i;
}
/* пример 2 */
for ($i = 1;;$i++) {
if ($i > 10) {
break;
}
print $i;
}
/* пример 3 */
$i = 1;
for (;;) {
if ($i > 10) {
break;
}
print $i;
$i++;
}
/* пример 4 */
for ($i = 1; $i <= 10; print $i, $i++) ;
Конечно, первый вариант кажется лучшим (или четвЈртый), но оказывавется возможность
использования пустых выражений в цикле FOR зачастую оказывается полезной.
PHP также поддерживает альтернативный синтаксис FOR :
FOR (expr1; expr2; expr3): выражение; ...; endfor;
Другие языки используют оператор foreach для того, чтобы обрабатывает массивы
или списки. PHP использует для этого оператор while и функции list() и each() . Для примера смотрите документацию по
этим функциям.
VREAK прерывает выполнение текущего цикла.
$i = 0;
while ($i < 10) {
if ($arr[$i] == "stop") {
break;
}
$i++;
}
CONTINUE переходит на начало ближайшего цикла.
while (list($key,$value) = each($arr)) {
if ($key % 2) { // skip even members
continue;
}
do_something_odd ($value);
}
Оператор SWITCH похож на группу операторов IF с одинаковым выражением. Во многих
случаях вам нужно сравнить переменную (или выражение) со многими различными
значениями и выполнить различные фрагменты кода в зависимости от того, чему
будет равно значение выражения. Это как раз то, для чего предназначается оператор
SWITCH.
Следующие 2 примера это 2 разлчиных пути для достижения одной вещи, но один
использует серию операторов IF, а другой - оператор SWITCH.
/* пример 1 */
if ($i == 0) {
print "i equals 0";
}
if ($i == 1) {
print "i equals 1";
}
if ($i == 2) {
print "i equals 2";
}
/* пример 2 */
switch ($i) {
case 0:
print "i equals 0";
break;
case 1:
print "i equals 1";
break;
case 2:
print "i equals 2";
break;
}
Важно понять как работает оператор SWITCH чтобы избежать ошибок. SWITCH выполняет
последовательно оператор за оператором. В начале код не исполняется. Только
когда встречается оператор CASE с подходящим значением, PHP начинает выполнять
программу. PHP продолжает выполнять операторы до конца блока SWITCH или пока
не встретит оператор BREAK. Если вы не напишете BREAK в конце цикла операторов,
то PHP продолжит выполнять операторы и следующего SWITCH'а. К примеру :
/* пример 3 */
switch ($i) {
case 0:
print "i equals 0";
case 1:
print "i equals 1";
case 2:
print "i equals 2";
}
В этом случае, если $i равно 0, то PHP выполнит все операторы print! Если $i
равно 1, то PHP выполнит последние два print. И только если $i равно 2, вы получите
ожидаемый результат и выведено будет только 'i equals 2'. Так что важно не забывать
ставить BREAK (разве что в некоторых случаях вы специально не захотите их ставить
для достижения определЈнной цели).
Специальный случай - это 'default case'. Этот оператор соответствует всем значениям,
которые не удовлетворяют другим case'ам. К примеру :
/* example 4 */
switch ($i) {
case 0:
print "i equals 0";
break;
case 1:
print "i equals 1";
break;
case 2:
print "i equals 2";
break;
default:
print "i is not equal to 0, 1 or 2";
}
Другой заслуживающий упоминания факт - это то, что выражения в CASE могут быть
любого скалярного типа, то есть целые числа или числа с плавающей запятой, а
так же строки. Массивы и объекты не будут ошибкой, но в данном случае они не
имеют значимости.
Оператор REQUIRE заменяет себя содержимым указанного файла, похоже на то,как
в препроцессоре C работает #include.
Это означает, что вы не можете поместить require() внутрь цикла и ожидать,
что он включит содержимое дугого файла несколько раз в процессе каждой итерации.
Для это используйте INCLUDE.
require ('header.inc');
Оператор INCLUDE вставляет и выполняет содержимое указанного файла.
Это случается каждый раз, когда встречается оператор INCLUDE, так что вы можете
включить этот оператор внутрь цикла, чтобы включить несколько файлов :
$files = array ('first.inc', 'second.inc', 'third.inc');
for ($i = 0; $i < count($files); $i++) {
include($files[$i]);
}
include() отличается от require() тем, что оператор include выполняется
каждый раз при его встрече, а require() заменяется на содержимое указанного
файла безотносительно будет ли выполнено его содержимое или нет
Так как include() это специальный оператор,
требуется заключать его в фигурные скобки при использовании внутри условного
оператора.
/* Это неправильно и не будет работать, как хотелось бы. */
if ($condition)
include($file);
else
include($other);
/* А вот это - верно. */
if ($condition) {
include($file);
} else {
include($other);
}
Когда файл исполняется, парсер пребывает в "режиме HTML", то есть
будет выводить содержимое файла, пока не встретит первый стартовый тег PHP (<?).
Также смотрите readfile(), virtual().
Функция может быть объявлена следующим образом:
function foo ($arg_1, $arg_2, ..., $arg_n) {
echo "Example function.\n";
return $retval;
}
Внутри функции может быть любой верный код PHP3, даже объявление другой функции
или класса .
Функции должны быть определены перед тем, как на них ссылаться.
Результаты возвращаются через необязательный оператор return. Возвращаемый
результат может быть любого типа, включая списки и объекты.
function my_sqrt ($num) {
return $num * $num;
}
echo my_sqrt (4); // outputs '16'.
Множественные результаты не могут быть возврашены в качестве результата, но
вы можете реализовать это путЈм возврата списка :
function foo() {
return array (0, 1, 2);
}
list ($zero, $one, $two) = foo();
Информация может быть передана функции через список аргументов, которые являются
разделЈнным запятыми списком переменных и/или констант.
PHP3 поддерживает передачу аргументов по значению (по умолчанию), по ссылке, и
значения по умолчанию. Списки аргументов переменной длины не поддерживаются,
но того же можно достичь, передавая массивы.
function takes_array($input) {
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
По умолчанию, аргменты функции передаются по значению. Если вы хотите в функции
модифицировать аргументы, то можете передать их по ссылке.
Если вы хотите, чтобы аргумент всегда передавался по ссылке, то следует поставить
амперсенд (&) перед именем аргумента в объявлении функции :
function foo( &$bar ) {
$bar .= ' and something extra.';
}
$str = 'This is a string, ';
foo ($str);
echo $str; // выведет : 'This is a string, and something extra.'
Если вы хотите передать аргумент по ссылке в случае, когда по умолчанию такого
не делается, то добавьте амперсенд перед именем аргумента в вызове функции :
function foo ($bar) {
$bar .= ' and something extra.';
}
$str = 'This is a string, ';
foo ($str);
echo $str; // выведет 'This is a string, '
foo (&$str);
echo $str; // выведет 'This is a string, and something extra.'
Функции могут определять значения по умолчанию для скалярных аргументов в стиле
C++ как показано :
function makecoffee ($type = "cappucino") {
echo "Making a cup of $type.\n";
}
echo makecoffee ();
echo makecoffee ("espresso");
Этот пример выведет следующее :
Making a cup of cappucino.
Making a cup of espresso.
Значение по умолчанию должно быть константой, а не переменной или, к примеру,
членом класса.
Учтите, что когда вы объявляете аргументы по умолчанию, они должны быть справа
от всех "неумолчальных" аргументов, в противном случае это не будет
работать, как задумано. К примеру :
function makeyogurt ($type = "acidophilus", $flavour) {
return "Making a bowl of $type $flavour.\n";
}
echo makeyogurt ("raspberry"); // не будет работать, как ожидалось
Этот пример выведет следующее :
Warning: Missing argument 2 in call to makeyogurt() in
/usr/local/etc/httpd/htdocs/php3test/functest.htm on line 41
Making a bowl of raspberry .
А теперь сравните с этим :
function makeyogurt ($flavour, $type = "acidophilus") {
return "Making a bowl of $type $flavour.\n";
}
echo makeyogurt ("raspberry"); // а вот это работает
И выводит следующее :
Making a bowl of acidophilus raspberry.
Оператор OLD_FUNCTION позволяет вам определяить функцию использую синтаксис
PHP/FI2 (за исключением того, что вы должны заменить 'function' на 'old_function').
Это свойство только для совместимости и должно использоваться лишь конверторами
PHP/FI2 -> PHP3.
Описанные таким образом функции не могут быть вызваны из служебного кода PHP.
Это к тому же значит, что вы не можете использовать их в функциях типа usort(),
array_walk() и register_shutdown_function().
Вы можете обойти это путЈм введения специальной функции в терминах PHP3, которая
будет вызывать OLD_FUNCTION.
CLASS
Класс - это набор переменных и функций, работающих с этими переменными. Класс
определяется следующим образом :
<?php
class Cart {
var $items; // Количество вещей в корзине покупателя
// Добавить $num наименований типа $artnr в корзину
function add_item ($artnr, $num) {
$this->items[$artnr] += $num;
}
// Убрать $num наименований $artnr из корзины
function remove_item ($artnr, $num) {
if ($this->items[$artnr] > $num) {
$this->items[$artnr] -= $num;
return true;
} else {
return false;
}
}
}
?>
Это определения класса Cart, который состоит связного списка наименований товаров
в корзине и двух функций для добавления и удаления вещей из корзины.
Классы это типы, то есть, заготовки для реальных переменных. Вы должны создавать
переменные желаемого типа, используя оператор new :
$cart = new Cart;
$cart->add_item("10", 1);
Таким образом, мы создали объект $cart класса Cart. Функция add_item() этого
объекта вызывается для добавления 1 товара номер 10 к корзине.
Классы могут быть расширениями других классов. Расширенный класс обладает всеми
переменными и функциями базового класса и тем, что вы определите при расширении
класса. Это делается используя ключевое слово extends :
class Named_Cart extends Cart {
var $owner;
function set_owner ($name) {
$this->owner = $name;
}
}
Это определяет класс Named_Cart, который имеет все переменные и функции класса
Cart плюс дополнительную переменную $owner и дополнительную функцию set_owner().
Вы можете создать поименованую корзину обычным образом и установить или получить
владельца корзины. Также вы можете использовать и нормальные функции корзины
в поименованой корзине :
$ncart = new Named_Cart; // Создать корзину
$ncart->set_owner ("kris"); // Указать владельца
print $ncart->owner; // Распечатать имя владельца корзины
$ncart->add_item ("10", 1); // (унаследовано из обычной корзины)
Внутри функций класса переменная $this означает сам объект. Вы должны использовать
$this->нечто для доступа к переменной или функции с именем 'нечто' внутри
объекта.
Конструкторы это функции в классе, которые автоматически вызываются, когда
вы создаЈте новую переменную данного класса. Функция становится классом, когда
она имеет такое же имя, как и сам класс.
class Auto_Cart extends Cart {
function Auto_Cart () {
$this->add_item ("10", 1);
}
}
Мы определили класс Auto_Cart который является тем же классом Cart плюс имеет
конструктор, который инициализирует корзину при создании, наполняя еЈ одним
товаром типа "10". Конструкторы также могут иметь аргументы, и эти
аргументы могут быть необязательными, что делает конструктор более полезным
:
class Constructor_Cart {
function Constructor_Cart ($item = "10", $num = 1) {
$this->add_item ($item, $num);
}
}
// Покупаем вся одно и то же :
$default_cart = new Constructor_Cart;
// А тут что-то новое :
$different_cart = new Constructor_Cart ("20", 17);
Содержание
FLASH
