На главную страницу
Форум txt.version   




Статья :: Синтаксис языка и операторы

Синтаксис языка и операторы

Синтаксис языка и операторы

В данном разделе описываются все возможности языка, которые имеет РНР версии 4.0.6. Представленная информация ориентирована на уровень знании читателя, имеющего навыки программирования. Изложенный материал позволяет в предельно короткий срок изучить все возможности языка, в дальнейшем книга может использоваться в качестве справочного пособия.

Теги, маркирующие РНР-сценарий

Сценариям Р?1Р обычно присваивают расширения .php, .phtml, .php3 (для версии 3). Фактически это html-страницы, внутрь которых внедрен PHP-код, ограниченный одной из четырех пар тегов.

Рекомендуется использовать теги <?РНР и ?>. Сокращенной формой является пара <? и ?>; для того, чтобы се использовать, необходимо в файле конфигурации php.ini установить параметр short_open_tag=0rr или перекомпилировать РНР с параметром — enable-short-tags. Эта форма ограничителей может конфликтовать с синтаксисом XHTML. Ограничители в стиле html <script language="php"> и </script> используются для того, чтобы html-редакторы (например, FrontPage) могли адекватно интерпретировать PHP-код и отличать его от html (для HomeSite это не актуально — он способен воспринимать все четыре формы ограничителей). ASP-ограничители <% и%> можно использовать, если в файле конфигурации php.ini установить параметр asp_tags = On, при этом становится возможным использование функции упрощенного вывода значения переменной <%=$value!%> (ее также можно использовать с сокращенной формой тегов, например <?=$value?>).

Разделение инструкций

Каждая инструкция РНР (подобно языкам С и Perl) должна завершаться точкой с запятой. Например:

<?php echo "Это ": echo " Пример!"; ?>

Если инструкция одна, этого не требуется. Например:

<?php echo "Это Пример! " ?>

Комментарии

PHP поддерживает три стиля комментариев: С, C++ и Unix.

<?php 

echo "Привет!".
// Однострочный комментарий C++ стиля /* Это много- /* Вложенные комментарии недопустимы */ строчный комментарий */ echo "Еще привет!".
# Коментарий в стиле Unix-оболочек ?>

Типы данных

РНР поддерживает пять основных типов данных1: целые числа, дробные числа, строки, массивы и объекты. В документации РНР не указано, но имеется также логический тип (boolean): TRUE, FALSE; и специальный тип NULL для пустых2 (либо неинициализированных значений). Обычно тип переменной не указывается, а автоматически определяется интерпретатором во время исполнения. Можно принудительно задать тип переменной.

Целые числа

Целые числа указываются следующим образом:

$а = 1234; # десятичное целое 

$а = -123; # отрицательное число $а = 0123; # восьмеричное число
(равно десятичному 83) $а = 0x12; # шестнадцатеричное число
(равно десятичному 18)

Размерность целых чисел зависит от платформы, обычно она составляет 32 бита (+ 2 млн).

Дробные числа

Дробные числа (doubles) могут быть инициализированы следующим образом:

$а = 1 234; $а = 1.2еЗ. // 1.2еЗ == 1200

Размерность дробных чисел зависит от платформы, обычная максимальная точность -1.8е308 или приблизительно 14 десятичных значащих разрядов (64 бита в формате IEEE). В процессе арифметических преобразований неизбежна потеря точности (например, выражение floor((0.1+0.7)*10) возвратит 7 вместо ожидаемых 8, так как фактически ((0.1+0.7)*10)=7,99999999...). Кроме того, невозможно точное сопоставление иррациональных чисел (например, 1/3=0.3333333). Поэтому нельзя доверять точности последней цифры дробных чисел, а также сравнивать их без округления. Если требуется более высокая точность вычислений, обратитесь к функциям GMP или BCMath.

Строки

Строки могут быть обозначены двумя парами ограничителей (одинарные и двойные кавычки). При использовании одинарных кавычек строка воспринимается «как есть»; единственная замена, которая производится в строке, — это трансформация «\\» и «V» соответственно в «\» и «'», выполняемая для того, чтобы можно было использовать эти символы, если они обозначают самих себя.

Использование двойных кавычек позволяет интерпретатору заменить указанную в строке переменную на ее значение, например:

$а=5: echo "а=$а"; // напечатает «а=5»

Чтобы вывести после значения переменной символы без разделения их пробелами, используйте заключение переменной в фигурные скобки.

$п=1: echo "$nst": // такой переменной не существует echo "{$n}st"; // выведет: lst

Для подстановки значений свойств вложенных объектов и многомерных массивов также используйте фигурные скобки или конкатенацию.

echo "{$obj->subobj->prop} {$a[l][2]['fnrsf]} ".

Обратный слеш «\» (так же, как в С и Perl) используется для подстановки специальных символов.

Последовательность Означает
\n' Переход на новую строку (LF или ОхОА в ASCII)
\r Возврат к началу строки (CR или OxOD в ASCII)

\t

Горизонтальная табуляция (НТ или 0x09 в ASCII)

\\

Обратный слеш

\$

Знак доллара

\"

Двойная кавычка

\[0-7]{1,3}

1-3 восьмеричные цифры после слеша заменяются на корреспондирующий данному ASCII-коду символ

\x[0-9A-Fa-f]{l,2)

1-2 шестнадцатеричные цифры после \х заменяются на корреспондирующий данному ASCII-коду символ

Если после слеша стоит иной сиМbол, будет выдано предупреждение (если выдача предупреждений разрешена).

Иной способ обозначения длинных строк — это использование синтаксиса «here doc1 цитирование»: после последовательности <« указывается идентификатор, и все последующие строки, вплоть до того как вновь встретится этот идентификатор (он должен стоять в начальной позиции строки), считаются текстом строки. К идентификатору применяются те же требования, как и к именам переменных (он должен начинаться с буквы или «_» и содержать только алфавитно-цифровые символы или «_»). Цитирование аналогично использованию двойных кавычек, но кавычки здесь обозначают самих себя. Такой синтаксис широко используется в Perl.

 <?php 

$str = <«fndOfSl Пример многострочной строки синтаксиса «heredoc». EndOfSl. /* Пример посложнее с переменными. */ class foo { echo " строка 1 строка 2 var $foo: var $bar: function foo() { // конструктор класса $tms->foo = 'Foo'. $this->t>ar = arrayCBarl1. 'Ваг2'. 'ЕагЗ'): } } $foo = new foot); $name = 'Игорь' : echo «< EndOfS? Мое имя - "Sname".
Значение переменной класса $foo->foo. Еще одно значение другой
переменной класса {$foo->bar[l]}.
Заглавная 'А': \х41 EndOfS2; ->>

Строки можно объединять с помощью оператора конкатенации — точка, например:

echo "Значение а = ". $а "\n" "И т.д.";

Оператор сложения «+» не объединяет строки!

Строку можно использовать как нумерованный массив символов, используя С-подобный синтаксис.

<?php // Примеры работы со строками $str = "This is "; $str = $str . " a string"; // $str = "This is a string" $str .= " with a newline at the end An", // $str = "This is a string with a newline at the end.\n" $niJ!II = 9. $str = "Значение- $num"; // подставляется значение $str = 'Переменная $num'; // значение НЕ подставляется Sstr = 'This is a string '; $first = $str[0]; // первый символ строки - 'Т' $1ast = £str[strlen($str)-l];
// последний символ строки - пробел ?>

Преобразование типа строк

При преобразовании строки в числовое значение результирующая неременная будет иметь тип дробного числа, если строка содержит символы «.», «е», «Е»; в противном случае результирующая пере-\ менная окажется целочисленной. Значение определяется по начальным цифрам строки, а если строка начинается с букв, ее числовое значение будет равно нулю. Правильным строковым представлени-_—s ем числа считается знак («-» или «+», который может отсутствовать у положительных чисел), за которым следует последовательность чисел, среди которых могут встречаться точка и/или буква «е». Незначащий ноль может быть пропущен.

$а = 1 + "10 5"; // $а - дробное (11.5) $а = 1 + "-1.3еЗ": // $а - дробное (-1299) $а = 1 + "-.ЗеЗ"; // $а - дробное (-299) $а = 1 + "1-1.ЗеЗ"; // $а - целое (1) $а = 1 + "тдогЗЗЗ": // $а - целое (1) $а - 1 + "10 Разных Штук "; // $а - целое (11) $а = "10.0 у е. " + 1: // $а - целое (11) $а = "10.0 у.е " + 1.0: // $а - дробное (11)

Как видите, преобразование строк в числа происходит при осуществлении с ними арифметических операций, и если строка — это первый элемент выражения, тип ее преобразования зависит от типа последующих чисел. Если вы хотите проверить примеры, приведенные выше, добавьте строку:

 echo "\$а == $а: тип (" gettype ($а) . ")<br>\n"; 

Массивы

Массивы могут быть и действовать как простые индексированные списки (их называют векторами — в них индексом является число) или как ассоциативные списки (их называют хеш-таблицами — в них индексом служит строковое значение). Как в С и Perl, элементы массива нумеруются, начиная с 0, а не с 1.

Одномерные массивы

Массив можно инициализировать либо простым присваиванием ему новых элементов, либо явно, используя функцию аггауО. При добавлении в массив элемента без указания его индекса он заносится в конец списка.

$a[J = "abc". /, $а[0] = "abc"; $а[1] = "def": $а[0] = "абв"; // заменить уже имеющийся элемент *а[] = "gh"; // $а[2] - "abc"; rf пример инициализации нумерованного массива'
$м = array ("первый", "седьмой". 86. 22): # пример инициализации ассоциативного
массива: $с["нулевой"] = "АБВ": $С["первый"] = 444; $с[99] = 4. // эквивалентно записи $с["99"]= 4: //(это. тем не менее - третий элемент) # аналог примера выше: $с = аггау( "нулевой " => " АБВ ". "первый" '> 444. 99 => 4 ):

Массивы можно затем сортировать. Число элементов массива можно узнать, используя функцию countO. Для поэлементного перебора значений ассоциативного массива используются функции next (), prev() и each().

Многомерные массивы

$а[][0] = $f: I двухмерный $а[1][0] = tf: # двухмерный $а["аа"][2] = $f. # возможно комбинировать $а[3]["бб"] = $f. # скалярные и ассоциативные индексы $а["ааа"][4]["ббб"][0] = $f:# четырехмерный! $а = агтау( "апельсин" => аггау( "цвет" => "оранжевый". "вкус" => "сладкий". ). "лимон"=> аггау( "цвет" => "желтый". "вкус" => "кислый". ) ): echo $а["апельсин"]["вкус"]: # выведет "сладкий"

Для правильной подстановки значений многомерных массивов используйте оператор конкатенации или заключайте имя переменной в фигурные скобки. Иначе функция вывода будет воспринимать как относящиеся к массиву только первые скобки, а последующие — как текст.

      

$а[3]['6бб'] = 'Слово': echo "Ошибочка: $а[3][ббб]": // Выведет «Ошибочка Аггау[ббб]» echo "Работает: " . $а[3][ббб]. // Выведет «Работает: Слово» echo "Работает {$а[3][ббб]}": // Выведет «Работает: Слово»

Объекты

Объекты создаются на основе заранее определенных классов с помощью оператора new:

<?php class foo { function do_foo() { echo "Doing foo ". } } Ibar = new foo. . $bar->do_foo(). ?>

Определение типа

PHP не требует явного указания типа переменной, тип определяется интерпретатором во время выполнения и зависимости от того, как переменная используется (и какие значения ей присваиваются). Обычно такие преобразования интуитивно понятны (например, если одно из слагаемых дробное число, то результат — дробное число). Сами переменные не меняют своего типа, изменяется их восприятие. Тип изменяется только при присваивании или изменении значения.

$foo = "О": // $foo - строка (ASCII 48) $foo++; // $foo - строка "1" (ASCII 49) $foo += 1; // $foo - целое (2) $foo = $foo +1.3: // $foo - дробное (3 3) Sfoo = 5 + "10 Круглых кубиков": // $foo - целое (15)

Что касается автоматических преобразований массивов, то здесь возникают неоднозначности.

$а = 1. // $а - целое число $а[0] = "f": // $a становится массивом

Помните, что строки могут рассматриваться как массивы символов. Как поведет себя следующий код:

$а = "Г; // $а - это строка $а[0] = "f": // станет ли $а массивом или останется строкой?

В некоторых версиях РНР 4 результат этой операции не определен. Ожидается, что проблема будет скоро разрешена.

Большинство функций возвращает значение FALSE при ошибке, а в случае нормального завершения — значение, отличное от FALSE. Для того чтобы можно было отличить значение FALSE от пустой строки или нуля, используйте оператор идентичности (а не равенства, который автоматически преобразует тип).

<? $1=-2: $b=TRUE: // переменная $ZZZ не существует 1f($i) echo"! — TRU£\n". else echo"! != TRUEXn": if($i — TRUE) echo"! — TRUEVn": else echo"! !== TRUEVn": if($b — TRUE) echo"b === TRUE\n"; else echo"b !== TRUE\n"; if($ZZZ === null)echo"ZZZ === null\n"; else echo"ZZZ !== null\n"; ?>

Приведенный сценарий должен вывести

i == TRUE т !== TRUE b === TRUE ZZZ — null

Явное приведение типов

Приведение типов сходно с С-стилем: тип переменной указывается перед исходной переменной.

$foo = 10; // $foo is an integer $foo = (boolean) $foo.
// теперь значение $foo = 1 $bar = (double) $foo: // $bar is a double

Типы обозначаются как: (int), (integer) для целых; (real), (double), (float) для дробей; (string) для строк; (array) для массивов; (object) для объектов. Для логических значений: (bool) или (boolean). Тип также можно изменить функцией settype().

Заметьте, некоторые виды преобразований могут быть курьезными.

При преобразовании скалярного1 массива или строки в массив переменная становится нулевым элементом массива.

$var = 'ciao1: $arr = (array) $var. echo $згг[0]. // выводит 'ciao'

При преобразовании скалярного массива или строки в объект переменная становится свойством объекта с именем scalar:

$var = 'ciao': $obj = (object) $var. echo $obj->scalar: // выводит 'ciao'

Переменные

Переменные помечаются знаком доллара, за которым следует имя переменной (как в Perl). Имена переменных чувствительны к регистру (например, $а и $А — разные переменные); первым символом имени должна быть буква или знак подчеркивания «_», за которым следует любая комбинация буквенно-цифровых символов и/или «_». Буквы могут быть латинскими: a-z, A-Z, или ASCII-символами с кодами от 127 до 255. Заметьте, PHP, в отличие от многих компиляторов (языков), позволяет использовать символы кириллицы в именах переменных.

$var = "Петя": $Var = "Вася"; echo "$var. $Var";
// напечатает "Петя. Вася" $4site = 'not yet':
// Ошибка; имя начинается с цифры $_4site = 'not yet1.
// правильно: начинается с подчеркивания $переменная - 'mansikka',
// правильно: русские буквы разрешены.

РПР 4 позволяет передавать значения переменных не только копированием, но и «по ссылке». Тогда новая переменная будет просто ссылаться на старую и станет ее псевдонимом (alias). Изменения одной из них будут так же отражаться и на другой.

Чтобы связать по ссылке две переменных, перед исходной переменной ставится амперсант «&».

<?php $а = 'Яяя', $b = &$а: // ссылка на $а. $b = "Это $b". // изменяя $b
мы одновременно изменяем $а echo $a // Выведет 'Это Яяя' echo $b. // Выведет 'Это Яяя' ?>

Естественно, что ссылка может указывать только на переменную.

<?php $foo = 25. $bar = &$foo: // Присваивание допускается $bar - &(24 * 7). // Ошибка; ссылка на
неименованное значение function test() { return 25.
// функция возвращает значение, а не ссылку.
} $bar = StestO. // Ошибка: ?>

Предопределенные переменные

Состав предопределенных переменных РНР во многом зависит от серверного ПО и его конфигурации. Не все из них доступны при запуске сценария из командной строки. Чтобы выяснить, какие из переменных доступны, и узнать их значения, воспользуйтесь функцией phpinfo().

Переменные РНР

Эти переменные создаются самим РНР. Переменные SH7TP_*_VARS доступны, только если разрешен параметр конфигурации track_vars (в РНР 4.0.3 он разрешен всегда, вне зависимости от файла конфигурации).

При установке директивы register_globals в файле конфигурации эти переменные становятся глобально доступными (фактически они копируются в массив SGLOBALSC]). Эту установку следует использовать с осторожностью, а лучше вовсе исключить, так как хранение переменных в массивах безопасно, а глобальные эквиваленты могут быть перезаписаны передачей сценарию одноименных параметров (не исключая и злоумышленного варианта подобной операции). В случае невозможности блокирования данной установки удостоверьтесь, что данные, которые вы используете из этих переменных, безопасны.

$argv[]

Массив аргументов, передаваемых сценарию. При запуске сценария iu командной строки этот массив содержит список параметров командной строки, как и в С. При вызове методом GET он содержит строку запроса (то есть то, что следует после имени сценария за знаком вопроса).

$argc

Число аргументов, передаваемых сценарию (и, соответственно, содержащихся в массиве Sargv[]). Равно count(Sargv). Для сценария, запускаемого из командной строки, это число параметров; для PHP-страницы это значение 0 или 1.

$PHP_SEI.F

Файловое имя текущего исполняемого сценария РНР относительно корневого каталога web-сервера (например, «/index.php»). При запуске сценария из командной строки значение недоступно.

$HTTP_COOKIE_VARSn

Ассоциативный массив переменных, посылаемых сценарию через HTTP cookies.

$HTTP_GET_VARS[]

Ассоциативный массив переменных, посылаемых сценарию методом HTTP GET (указываются в строке HTTP запроса).

$HTTP_POST_VARS[]

Ассоциативный массив переменных, посылаемых сценарию методом HTTP POST (передаются от html-форм, скрыто от пользователя).

$HTTP_POST_FILES[]

Ассоциативный массив, содержащих информацию о файлах, загружаемых на web-сервер методом HTTP POST.

$HTTP_ENV_VARS[]

Ассоциативный массив переменных окружения среды, в которой запущен сценарий (например, OS, Path, TEMP, System Root и т. п.).

$HTTP_SERVER_VARS[]

Ассоциативный массив переменных web-сервера. См. ниже.

Переменные web-сервера (Apache) - $HTTP_SERVER_VARS[]

Приведенные переменные создаются web-сервером Apache. Другие серверы имеют сходный набор переменных. Большинство переменных декларировано спецификацией CGI 1.1 (http://hoohoo.ncsa.uiuc. edu/cgi/env.html)

Если сценарий запущен из командной строки, большинство из них недоступно.

GATEWAYJNTERFACE

Версия CGI спецификации, используемой web-сервером; например, «CGI/1.1».

SERVER_NAME

Имя хоста сервера, например «localhost». Если сценарий запускается с виртуального хоста, то используется имя для этого хоста.

SERVER_SOFTVJARE'

Описание серверного ПО, передающееся в заголовках ответов на запрос HTTP (например, «Microsoft-IIS/5.0»).

SERVER_PROTOCOL

Протокол, по которому запрашивается web-страница и ее версия, например «НТТР/1.0».

REQUEST_METHOD

Метод HTTP запроса, которым запрашивается web-страница: «GET», «HEAD», «POST» или «PUT».

QUERY_STRING

Строка параметров запроса. Например, для запроса «http:// localhost\index.php?x=5&s=id» этой строкой будет «x=5&s=d».

DOCUMENT_ROOT

Корневой каталог web-сервера, определяемый его конфигурацией.

НТТР_АССЕРТ

Содержание заголовка Accept: у текущего запроса, если он указан. HTTP_ACCEPT_CHARSET

Содержание заголовка Charset: у текущего запроса, если он указан. Например: «iso-8859-l,*,utf-8».

HTTP_ENCODING

Содержание заголовка Accept-Encoding: у текущего запроса, если он указан. Например: «gzip».

HTTP_ACCEPT_LANGUAGE

Содержание заголовка Accept-Language: у текущего запроса, если он указан. Например: «en».

HTTP_CONNECTION

Содержание заголовка Connection: у текущего запроса, если он указан. Например: «Keep-Alive».

HTTP_HOST

Содержание заголовка Host: у текущего запроса, если он указан. Подобно SERVER NAME.

HTTP_REFERER

Адрес страницы, с которой осуществлен переход на текущую. Значение посылается большинством из браузеров, но не всеми.

I HTTP_USER_AGENT

Содержание заголовка User_Agent: текущего запроса, если он указан. Кодификация тина браузера и клиентского ПО, от которого получен запрос. Например: Mozilla/4.5 [en] (XI1; U; Linux 2.2.9 1586) или MoziIla/4.0 (compatible; MSIE 5.01; Windows NT 5.0). Это значение (оно используется функцией get_browser()) имеет смысл использовать для подгонки функциональности страницы (например, особенностей JavaScript) иод возможности браузера.

REMOTE_AODR

IP адрес клиента, просматривающего текущую страницу. REMOTE_PORT

Порт, используемый клиентом для коммуникации с web-сервером. SCRIPT_FILENAME

Имя сценария, включающее абсолютный путь к нему (по мнению web-сервера).

SERVER_ADMIN

Установка «администратор сервера» конфигурации web-сервера. SERVER_PORT

Порт, используемый web-сервером для коммуникации с клиентом. Определяется конфигурацией web-сервера. Обычно 80, для SSL (безопасных соединений) по умолчанию 443.

SERVER_SIGNATURE

Строка, содержащая версию сервера и имя виртуального хоста, добавляемая к генерируемым страницам, если эта функция используется.

PATHJRANSLATED

Имя сценария, включающее абсолютный путь к нему (указывается расположение сценария в файловой системе, а не в каталогах web-сервера). Сравните со SCRIPT_FILENAME.

SCRIPTJIAME

Путь к текущему сценарию в web-каталогах. REQUESTER I

Строка, которой запрашивается сценарий, например: «/index.html».

Область видимости переменной

Область видимости переменной — это контекст, в котором переменная сохраняет свое значение и это значение доступно. В РНР область видимости ограничена текущим файлом, но распространяется на файлы, присоединяемые директивами include и require.

Переменные, используемые вне функций,
недоступны внутри них. $а = 1. /* глобальная область */ Function Test () { echo $a; /* используется локальная
переменная, которая пуста*/ } Test (). //не напечатает ничего

Это отличает РНР от С, где внешние переменные всегда доступны внутри функций, если только внутри функции не объявляется переменная с именем внешней. Это сделано для того, чтобы внутри функций нельзя было случайно изменить внешние переменные. Если же все-таки требуется доступ к внешним переменным, они должны быть объявлены глобальными внутри функции.

$а = 1:$b = 2. Function Sum () { global $a. $b.//использовать глобальные переменные $b = $а + $b. } Sum (): echo $b; // напечатает «3»

Другой способ доступа к внешним неременным — это обращение к ассоциативному массиву $GLOBALS, в котором содержатся все переменные, используемые вне функций.

$а = 1; $b = 2. Function Sum () { $GLOBALS["b"]
= $GLOBALS["a"] + $GLOBALS["b"]; } Sum (); echo $b; // напечатает «3»

Можно пойти на ухищрения и сделать глобальные переменные доступными для чтения внутри функции с помощью функции extract():

function foo() { extract (SGLOBALS): // ... }

Статические переменные

Статические переменные не уничтожаются после завершения функции и сохраняют свое значение на протяжении всего времени исполнения сценария. Инициализируются они только при первом запуске функции.

Function Test () { static $a = 0: echo $a; $а++; } Test (): // напечатает «О» Test (): // напечатает «1» Test (). // напечатает «2»

Статические переменные также используются при рекурсивных вызовах (то есть когда функция вызывает сама себя). Не забудьте обеспечить контроль за тем, чтобы рекурсивный вызов не привел к бесконечному циклу!

Function Test ()) { static Jcount = 0; $count++; echo $count: if (Scount < 10) Test (): $COUnt--; }

«Переменные» переменные (оператор $)

Иногда требуется иметь изменяемые имена переменных, например в случае, если нужно будет производить стандартные действия над различными переменными, но еще неизвестно, какими именно. Такие переменные перед своим «именем» имеют двойной знак доллара вместо одного, чтобы можно было изменять их значения (то есть значения тех неременных, на которые они указывают). При этом если перед такой переменной стоит одинарный знак доллара, ее значение является именем реальной переменной.

Допустим, $А = "X", а $$А = "value", тогда $Х = "value"'.

$а = "hello". // пня переменной $$а $$а = "world". // Shell о содержит "world" echo "$a ${$a}"; // напечатает hello world echo "$э Shell о": // напечатает hello world

При использовании «переменных» переменных с массивами возникает проблема неопределенности. Что означает $$а[1]? Возможно, вы хотите использовать переменную с именем, содержащимся в $а[1], или $$а как переменную массива, а затем ее элемент [1]. В первом случае мы имеем дело с массивом указателей, а во втором — с указателем на массив. Синтаксис фигурных скобок разрешает эту проблему: ${$а[1]} для первого случая и ${$а}[1] для второго. Для того чтобы правильно интерпретировать действие двойного знака доллара, думайте о первом из них, как об операторе разыменования.

Поскольку РНР интерпретирует код, то возможно даже использовать выражения в именах переменных (в фигурных скобках оператора разыменования):

$var="world": Shello_world = "hi everyone". echo S{"hello_".$var}; // выводит hi everyone

Передача переменных PHP-сценарию

HTML-формы

При вызове PHP-сценария HTML-формой все переменные формы автоматически становятся доступными сценарию. При включенном параметре конфигурации track_vars все эти переменные затем сохраняются в ассоциативных массивах $HTTP_POST_VARS, $HTTP_GET_VARS и/или $HTTP_POST_FILES, в зависимости от метода вызова сценария ($НТТР_ SERVERJ/ARS [REQUEST_METHOD] ).

<form act1on="foo.php" method="post"> Name: <input type="text" name="use>~name">
<br> <mput type="submlt">
</form>

При посылке данных этой формы текст, введенный в поле Name, сохраняется в $HTTP_POST_VARS['username']. При включенной директиве конфигурации register_globa1s на глобальном уровне это значение становится также доступно в переменной Susername.

Данные могут также быть посланы формой и затем распознаны РНР, если они заносятся в массивы. Таким способом возможно группировать связанные переменные или получать данные с мультиселек-тивпых элементов ввода:

      

<form action="array php" method="post"> Name: <input type="text" name="personal[name]"><br> Email: <input type="text" name-"personal[email]"><br> Beer: <br> <select multiple name='"beer[]"> <opt i on va1ue="wa rthog">Wa rthog <option value="guinness">Gumness <option value="stuttgarter">Stuttgarter Schwabenbi-ди /select> <input type="submit"> </form>

Также PHP 4 позволяет использовать в формах многомерные массивы.

Имена переменных кнопки IMAGE SUBMIT

Вместо кнопки submit (отправить) для форм возможно использование картинки:

<input type»image src="image.gif" name="sub">

При щелчке мытью на этом рисунке и отправке данных формы посылаются два дополнительных значения: sub_x и sub_y. Они содержат относительные координаты точки нажатия на рисунок. Знатоки заметят, что браузером на самом деле посылаются переменные, разделенные точкой (sub.x и sub.у), но РНР автоматически преобразует точки в знаки подчеркивания.

HTTP Cookies

РНР незаметно для пользователя поддерживает HTTP cookies, следуя спецификации Netscape (http://www.netscape.com/newsref/std/ cookie_ spec.html). Cookies — это механизм хранения данных на стороне клиента, осуществляемый браузером для того, чтобы сервер мог опознать пользователей, однажды посетивших сайт. Использовать cookies позволяет функция SetCookie(). Cookies передаются в заголовке HTTP, поэтому вызывать функцию SetCookie необходимо до того, как любой текст будет передан браузеру. С тем же ограничением можно использовать функцию Header(). Все cookies, отправляемые серверу клиентом, автоматически становятся PHP-переменными, подобно данным, передаваемым методами GET и POST.

Если требуется назначить одному cookie несколько значений, просто добавьте [] к его имени. Например:

SetCoone ("MyCookief]". "Testing". timeO+3600);

При посылке браузеру cookie с именем уже имеющегося у браузера новый cookie заменит старый, если доменное имя и путь к сценарию у старого и нового cookie совпадают.

Поэтому если требуется не замена значения, а добавление (напри-мер, для корзины покупок в «электронном магазине»), то необходимо передавать значение в новом элементе массива, сопровождающееся автоинкрементируемым значением счетчика. Например:

$Count++. // «Товаров» в «корзине» прибавилось
SetCookie ("Count". SCount. timeO+3600): // Всего «товаров» в «корзине»
SetCookie ("Cart[$Count]", Jitem. time()+3600): // Наименование добавляемого «товара»

Переменные окружения среды

РНР автоматически делает переменные окружения среды доступными для сценария, как обычные переменные РНР.

      

echo $HOME; // напечатать переменную Unix-среды НОМЕ,
если она установлена echo $PATH; // напечатать пути используемые
по ум. в Windows

Так как информация, передаваемая методами GET, POST и в Cookie, также создает переменные на глобальном уровне РНР, и их имена могут конфликтовать между собой, бывает полезно выяснить значение неременных среды явно, используя функцию getenv(). Для установки значений переменной в окружении среды используется функция putenv().

Точки в именах получаемых переменных

Обычно РНР не изменяет имена передаваемых сценарию переменных. Но заметьте, что наличие точки в имени переменной вызовет ошибку при попытке ее использования.

$varname.e>t: /* неправильное имя переменной */

Интерпретатор РНР попытается выполнить операцию конкатенации (оператора точка), что н вызывает ошибку. Поэтому РНР заменяет точку в именах получаемых переменных на знак подчеркивания.

Определение типа переменных

Так как РНР автоматически меняет типы переменных, не всегда известно, какой тип она имеет. Поэтому в РНР имеются функции для определения типа переменных: gettype(), is_long(), is_double(), is_string(), is_array() и is_object().

 

Константы

РНР устанавливает значения нескольких констант и предоставляет механизм установки пользовательских констант во время выполнения. Константы подобны переменным с единственным отличием: их однажды установленные с помощью функции define() значения изменению больше не подвергаются.

Предопределенные константы (доступные всегда):

__FILE_

Имя сценария, интерпретируемого в текущий момент. При использовании в файле, включенном или вызванном родительским сценарием (директивой include или require), хранит имя включаемого, а не родительского файла.

__LINE_

Номер текущей интерпретируемой строки. Для подключаемых сценариев позиция указывается относительно этих файлов. PHPJ/ERSION

Строковое значение, хранящее версию РНР интерпретатора, например: «3.0.8-dev».

PHP_OS

Название операционной системы, в которой исполняется РНР, например: «Linux».

TRUE

Значение «Истинно». Регистр не имеет значения.

FALSE

Значение «Ложно». Регистр не имеет значения.

EJRROR

Обозначает ошибку, отличную от ошибки интерпретатора, вызывающую критический сбой.

E_WARNING

Обозначает условие, когда РНР находит ошибку, но не считает ее критической и это не мешает РНР исполнять сам сценарий. Например, такой некритической ошибкой может быть неправильное регулярное выражение в функции еreg().

E_PARSE

Обозначает ситуацию, когда интерпретатор не может исполнить сценарий из-за грубого нарушения синтаксиса.

EJOTICE

Сообщение о событии, которое может быть или не быть ошибкой. Исполнение сценария продолжается. Например, и индексе ассоциированного массива может использоваться строка без кавычек или в выражении использоваться значение несуществующей неременной.

E_ALL

Обобщение всех Е_* констант (в РНР 4 их число увеличилось). При использовании с функцией error_reportingO сообщает обо всех проблемных моментах, отмеченных РНР.

Константы Е_* обычно используются в функции error_reporting() для установки критического уровня ошибки РНР, то есть уровня ошибки, которая вынуждает РНР прекратить исполнение сценария и выдать сообщение об ошибке.

Помимо этого, дополнительные модули при загрузке определяют собственные константы — см. описание функций соответствующих модулей и библиотек. Поэтому совокупный набор констант зависит от того, с какими библиотеками был скомпилирован РНР и какие модули были загружены.

Определять дополнительные константы позволяет функция def ine(). Не забывайте, что константе может быть присвоено только константное значение (а не выражение-макрос, как в С).

defineC'CONSTANT". "Hello world ").
echo CONSTANT;
// outputs "Hello world " <?php // Пример использования
констант __FILE__ и __LINE__ function report_error($file. $line. $message) { echo "Ошибка произошла в файле $file. в стороке Sline- Smessage ": } report_error (__FILE__.__LINE__. "Где-то здесь ошибка!"); ?>

Выражения

Выражения — это «все то, что имеет значение». Наиболее простые примеры — константы и переменные. Например, запись $а =5 присваивает переменной $а целочисленную константу со значением 5. Теперь $а имеет значение 5, и при следующем присваивании: $b = $а оно воспринимается как $b = 5.

Более сложными выражениями являются функции. Например, мы имеем функцию:

function foo (){ return 5- }

Тогда запись $с = foo() означает то же, что и $с = 5. Функции — это выражения, имеющие возвращаемое ими значение.

Значения, конечно, могут быть и не только числовыми. РНР поддерживает три скалярных типа: целые числа, дробные числа и строки (скаляры, в отличие от массивов и объектов, неделимы). РНР также поддерживает два композитных типа (не скаляры): массивы и объекты. Значения любых типов могут быть присвоены любой переменной или возвращены из функций.

РНР является языком, ориентированным на выражения, в том смысле, что почти «все есть выражение». В приведенном выше примере $а = 5 имеется и третье выражение присваивания «=», объединяющее правое и левое выражение? которое также равно здесь пяти. То есть запись $b = ($а = 5) подобна записи $а = 5: $b = 5;, а так как присваивания обрабатываются справа налево, то можно также написать $b = $а = 5.

Хорошими примерами ориентации на выражения являются также операторы пре- и постинкремента и декремента. Так. выражение $а-<-+ имеет значение $а, а -н-$а имеет значение $а + 1 (по аналогии с С). Операторы «прибавления» (+= и -=) и другие операторы этого типа (*=, /=, Х~, &=, ~= и т. п.), по аналогии с инкрементом/декрементом, также являются выражениями (к примеру, возможна запись: $х = ($а += 3), являющаяся сокращением $а = $а + 3; $х = $а;).

Достаточно распространены выражения сравнения, возвращающие О либо 1 (что соответствует FALSE либо TRUE). Обычно такие выражения используются в управляющих структурах.

Еще одно выражение — структура условной альтернативы (которая существует в С).

Sfirst ? Ssecond . Sthird

Значение этого выражения зависит от значения переменной Sfirst: если оно истинно (не ноль), то используется значение переменной $second, в противном случае — Ithird.

echo ( 3 ? "Яблоко" : "Апельсин"). // напечатает: Яблоко function double($i) { // возвращает
удвоенное значение аргумента return $i*2: } $b * Sa = 5: /* назначить значение 5 переменным $а и $b */ $с " $а++: /* аналогично: $с = $а: $а = $а + 1: */ $е = $d = ++$b: // преинкремент сперев
увеличивает $b на 1 // сейчас $е и $d равны б $f = double($d++): /* присвоить 2*6 =
12 переменной $f */ $g = double(->-+$e):
/* присвоить 2*7 •= 14 переменной
$g */ $h = $g += 10; /* увеличить $g на 10 (равно 24); // затем присвоить (24) $h

Так как РНР имеет бинарный тип (boolean), в условных структурах выражения приводятся к взаимоисключающему значению TRUE либо FALSE следующим образом: всякое численное выражение, не равное нулю, тождественно TRUE, а ноль — FALSE; отрицательные числа также — TRUE; пустая строка и строка «О» — FALSE, все другие строки — TRUE; не скаляры (массивы и объекты) имеют значение TRUE, если содержат хоть один элемент. (Такие же правила использует Perl.)

Операторы

Операторы присваивания

Простейший оператор присваивания «=». Не путайте его с оператором сравнения «=». Присваивание осуществляется копированием значения из левой части выражения в правую. Возможны комбинации при присваивании:

$а = ($b = 4) + 5; // $а теперь равно 9. а $b равно 4.

Комбинированные операции (например, +=, &=, .=) позволяют сократить запись присваивания, объединяя ее с основной операцией, при этом переменная слева используется и как исходное значение, и как место сохранения результата.

$а = 3; $а += 5: // $а = 8. эквивалентна:
$а = $а + 5; $b = "Hello ".
$b .- "There!"; // заносит в $b строку "Hello There!", //эквивалентна $b = $b . "There!":

Поскольку присваивание осуществляется посредством копирования, иногда выгоднее использовать присваивание значения по ссылке: $var = &$othervar;. Присваивание по ссылке фактически меняет указатель в переменной назначения так, что теперь он указывает на место, в котором хранится значение назначаемой переменной, то есть обе переменные теперь ссылаются на одно и то же значение и изменение одной переменной влечет за собой непосредственное изменение другой.

Арифметические операторы

Пример

Название

Результат

$a + $b

Сложение

Сумма $а и $b

$a - $b

Вычитание

Разность между $а и $b

$a*$b

Умножение

Произведение $а и $b

$a/$b

Деление

Частное от деления $а на $b

$a % $b

Остаток

Остаток от целочисленного деления $а на $b

 

Оператор деления «/» возвращает целое значение (то есть выполняет целочисленное деление), если делимое и делитель — целые числа (строки конвертируются в целые числа). Иначе если одно из чисел дробное, то результат будет также-дробным.

Инкремент/Декремент

РНР использует синтаксис С в операторах пре- и постинкремента и декремента.

Пример

Название

Результат

++$а

Преинкремент

Увеличивает $а на единицу, а затем возвращает значение $а

$а++

Постинкремент

Возвращает $а, а затем увеличивает $а на единицу

-$а

Предекремент

Уменьшает $а на единицу, а затем возвращает значение $а

$а-

Постдекрсмент

Возвращает $а, а затем уменьшает $а на единицу

  

<?php echo "<h3>Postincrement</h3>"; $a = 5: echo "Должно равняться 5. "
. $a++ "<br>\n"; echo "Должно равняться 6: " .
$a . "<br>\n"; echo "<h3>Preincrement</h3>". $a = 5: echo "Должно равняться б: "
. ++$a . "<br>\n"; echo "Должно равняться 6: "
. $a . "<br>\n"; / echo "<h3>Postdecrement</h3>": a = 5. echo "Должно равняться 5: " .
$a-- . "<br>\n" echo "Должно равняться 4: " . $a . "<br>\n". echo "<h3>Predecrement</h3>": $a = 5. echo "Должно равняться 4: " .
--$a . "<br>\n" echo "Должно равняться 4: "
. $a . "<br>\n": r

Бинарные операторы

Бинарные операторы изменяют значения отдельных битов в целочисленных переменных.

Пример

Название

Результат

$а & $b

Побитовое И

Побитовое «умножение» (1, если оба бита равны 1)

$а | $b

Побитовое ИЛИ

Побитовое «сложение» (0, если оба бита равны 0)

$а Л $b

Побитовое исключающее ИЛИ

«Различие» (1, если биты различные)

-$а

Инверсия

Меняет 1 на 0, а 0 на 1

$а « Sb

Побитовый сдвиг влево

Эквивалентен умножению на 2 $b раз

$а » $b

Побитовый сдвиг вправо

Эквивалентен делению на 2 $b раз

Схема действия побитовых операций:

Биты

Результат оператора

$а & $b

$а| $b

$ал $b

~$а

0

0

0

0

0

1

0

1

0

1

1

1

1

0

0

1

1

0

1

1

1

1

0

0

Операторы сравнения

Пример

Название

Результат

$а -= $b

Равенство

True, если $а равно $b

$а === $b

Идентичность

True, если $а равно $b, и они одного типа

$а != $b

Неравенство

True, если $а не равно $b

Sa !== $b

Неидентичность

True, если $а не равно $b, или они разного типа

$a<$b

Меньше чем

True, если $а меньше чем $b

$a>$b

Больше чем

True, если $а больше чем $b

$a <= $b

Меньше или равно

True, если $а меньше или равно $b

$a >= $b

Больше или равно

True, если $а больше или равно $b

Другой условный оператор «? :» (тернарный), с синтаксисом:

((exprl) ? (ехрг2) : (ехргЗ))

действует так: это выражение имеет значение, равное ехрг2, если exprl равняется TRUE, в противном случае (если exprl = FALSE) оно равняется ехргЗ.

Логические операторы

Пример

Название

Результат

$а and $b

Логическое И

True, если $а И $b равны TRUE

$а or $b

Логическое ИЛИ

True, если $а ИЛИ $b равно TRUE

$а xor $b

Логическое исключающее ИЛИ

True, если $а и $b имеют разные логические значения

!$а

НЕ

Логическая инверсия

$а && $b

Логическое И

Аналогия «and»

$а || $b

Логическое ИЛИ

Аналогия «or»

Причина наличия двух аналогичных вариантов для операторов and и or — их различный приоритет (см. «Приоритет операторов»).

 

Конкатенация — слияние строк

Имеется два строковых оператора: конкатенация «.», объединяющая строки, и конкатенация с присваиванием «.=», которая позволяет сократить запись $А = $А . $Х; до $А .= $Х;.

$a = 'Hello '; $b = $a "World!" // теперь $b содержит "Hello World!"

Приоритет операторов

Приоритет операторов определяет порядок вычисления значений выражений. Например, выражение 1+5*3 равно 16, а не 18, потому что умножение имеет более высокий приоритет и вычисляется до сложения. Скобки изменяют приоритет операторов, например:

(1+5)* 3 == 18

Ассоциативность

Операторы (в порядке уменьшения приоритета)

левая

 

левая

or

левая

XOr

левая

and

правая

print

левая

= += .= *= /=ж = %= &-, |=&_ __ <<= >> =

левая

V ;

левая

II

левая

&&

левая

!

левая

&

левая

&

не имеет

== != === i==

не имеет

<<->>=

левая

« »

левая

+-.

Ассоциативность

Операторы (в порядке уменьшения приоритета)

левая

* / 0/

/ %

(Ыправая

!-++.- (jnt) (double) (string) (array) (object) @

правая

F

не имеет

new

 

Операторы контроля ошибок

PHP поддерживает один оператор контроля ошибок — «0». Когда он предшествует выражению РНР, любое сообщение об ошибке, которое возникает при выполнении этого выражения, игнорируется. Если параметр track_errors разрешен, всякое сообщение об ошибке сохраняется в глобальной переменной $php_errormsg. Эта переменная перезаписывается каждый раз при возникновении новой ошибки.

<?php /* Умышленная ошибка в SQL (лишняя кавычка): */ $res = @mysql_query ("select name, code from 'namelist") or die ("Query failed er-or was '$php_errormsg'"): ?> См. также функцию error_reporting().

Будьте внимательны: в настоящее время префиксный оператор контроля ошибок «@» блокирует даже сообщение о критических ошибках, прерывающих исполнение сценария. Поэтому при таком варианте выполнение сценария может быть прервано, но сообщение об ошибке выведено не будет.

Оператор запуска внешней программы

В РНР есть оператор «обратная галочка» (backticks): (" ') для запуска внешней программы. Запомните, это не одинарная кавычка! РНР попытается запустить программу (или исполняемый сценарий), как если бы она запускалась из командной оболочки. То, что выдается при этом запуске на консоль вывода, возвращается и может быть сохранено в переменной (и использовано для вывода). Заметьте, сам запуск ничего не выводит, если он завершается успешно.

// выдает список файлов текущего каталога Soutput = "Is -аГ: // в сиаемах Unix Soutput = 'dir'; // в системах Windows echo "<pre>$output</pre>". // распечатать результат запуска команды

См. также функции: system(), passthru(), exec(), popen() и escape-shel Icmd().

If - Управляющие структуры

Любой PHP-сценарий состоит из последовательности команд. Это могут быть присваивания, вызовы функций, циклы, условные структуры и даже пустые команды, которые ничего не делают «:>>. Команды обычно завершаются точкой с запятой и могут быть сгруппированы с помощью фигурных скобок (как в С}. Группа команд в фигурных скобках сама является командой (только без знака «;» в конце).

if

Одна из основных условных конструкций — if, она позволяет исполнить фрагмент кода при определенном условии. Ее синтаксис сходен с синтаксисом в С:

if (условное_выражение) команда;

Как было описано выше, условное выражение проверяется на соответствие значению «истина». Если оно равно TRUE, PHP выполняет следующую команду, иначе — игнорирует ее.

if ($а > $b) print "a is bigger than b";

Часто нужно выполнить группу команд при определенном условии, тогда они группируются с помощью фигурных скобок.

if ($а > $b) { print "a is bigger than b": $b = $a; } Условные структуры могут быть
вложенными.

else

Иногда требуется, чтобы при одном условии выполнялось одно действие, а в противном случае — другое; для этого используется ключевое слово else, расширяющее возможности if.

if ($a > $b) { print "а больше чем b"; }
else { // ($а <*• $b) "N print "а не больше чем b":

Фрагмент else выполняется только в том случае, если условное вы-/ ражение в скобках после if имеет значение FALSE, и другие выражения elseif (если они существуют), также имеют значение FALSE (см. ниже).

elseif

Условная конструкция elseif, как видно из названия, — комбинация if и else. Подобно else, она требует, чтобы основное выражение if равнялось FALSE, но также требует, чтобы се собственное выражение равнялось TRUE.

if ($a > $t» { print "а больше чем b"; }
elseif ($а == №) { print "а равно b". } else { piint "а меньше чем b";

Можно иметь несколько подблоков elseif в одном блоке if. Из нескольких блоков elseif исполняется первый, который равняется TRUE. В PHP elseif можно писать также как else if (двумя словами), и смысл при этом не теряется. Таким образом, elseif-блок исполняется, только если начальное выражение if и любое другое, предшествующее el self-выражение равняются FALSE, а текущее elseif — TRUE.

Альтернативный синтаксис управляющих структур

Для управляющих структур if, while, for, foreach, и switch PHP предоставляет альтернативный синтаксис записи. Изменения выражаются в том, что после условного выражения в круглых скобках ставится двоеточие (:), затем следует фрагмент кода, подлежащий условному выполнению, завершающийся соответственно словами: endif;, endwhile;, endfor;, endforeach; или endswitch;. Использование фигурных скобок (для группировки условного фрагмента кода) при этом не требуется.

<?php if ($а == 5)- ?> A is equal to 5 <?php endif; ?>

В примере html-блок «A is equal to 5» включается в генерируемую страницу при условии, что $а равно 5.

 if ($a == 5): 

print "a equals 5"; print "...".-elseif ($а == 6): print "a equals 6"; print "!!!": else- print "a is neither 5 nor 6": endif:

while

Цикл while — самый простой в PHP, он аналогичен своему тезке в С.

while (expr) statement:

Его смысл — повторять выполнение команды до тех пор, пока выражение истинно (TRUE). Проверка значения происходит каждый раз до выполнения команды. Если условное выражение не изменяется (в команде/блоке), то цикл будет исполняться бесконечно. Если условное выражение изначально ложно (FALSE), условный блок игнорируется и выполняться не будет. Блок условного кода может быть органичен фигурными скобками или двоеточием и словом endwhile;. Следующие два примера приводят к идентичному результату (они печатают числа от \ до 10):

/* пример 1 */ $1 =1: while ($1 <= 10) { print $i++: /* постинкремент */ ) /* пример 2 */ $1 = 1; while ($i <= 10): print $1: $i++: endwhile; do..while

Циклы do. .while сходны с циклами while с тем отличием, что выражение проверяется на истинность не до исполнения блока, а после него. То есть гарантируется, что условный блок будет исполнен минимум один раз.

$1 = 0: do { print $i; // напечатает «О» один раз while ($i>0). // условие не выполняется
($i не больше 0)

Следующий пример демонстрирует сложный (однократный) цикл и использование команды «break;» (ради тренировки попробуйте разобраться, что он делает).

do { if ($i < 5) { print "i is not big enough", break:
// досрочно завершить цикл $i *= $factor. if ($1 < Smimmumjimit) { break: // досрочно завершить цикл print "i is ok", * process i... } while(O);
// 0 блокирует дальнейшее выполнение цикла

for

Циклы for - наиболее сложные в РНР.

for (exprl; expr2; ехргЗ) statement:

Первое выражение exprl выполняется безусловно, один раз, до начала цикла (обычно это инициализация переменной-счетчика цикта) Перед началом каждой итерации цикла на истинность проверяется условие ехрг2, и если оно истинно (TRUE), то цикл выполняется i конце каждой итерации цикла выполняется ехргЗ (часто это инкремент счетчика цикла).

Каждое из выражений может быть пустым (то есть «;»). Если выражение ехрг2 - пустое, то цикл является бесконечным (РПР по умолчанию считает его равным TRUE) и его прерывание возможно только осредством использования внутри его блока команды break. Сравните примеры ниже, все они выводят числа от 1 до 10.

/* Пример 1 - Классический стиль*/ for ($1 = 1; $1 <= 10; $1++) { print $1: } /* Пример 2 */ for ($1 = 1;;$!++) { if ($i > 10) { reak: } print S1: } /* Пример З */ $i = 1; for (:.) { if ($1 > 10) { break. } print $1. $i++; } /* Пример 4 - Модернистский стиль*/ for ($1 - 1. $1 <= 10; print $1. $i++) ;

Наиболее «красивы» первый и последний цикл. Но пустые выражения являются часто очень полезными.

РНР также поддерживает синтаксис ограничения блока цикла двоеточием:

for (exprl: expr2. ехргЗ) statement: : endfor; См. также циклы foreach ниже.

foreach

В РНР 4 включена инструкция foreach, позволяющая осуществлять поэлементно одинаковый набор действий для каждого элемента массива. Конструкция может иметь два варианта синтаксиса:

foreach($naccHB as $значение_элемента) действия; foreach($MaccnB as $key =>
1значение_элемента) действия:

Первая форма цикла перемещается по элементам массива, указанным как $массив. При каждой итерации значение текущего элемента присваивается переменной $значение_элемента, внутренний курсор массива (указатель на текущий элемент массива) смещается на следующий элемент и при следующей итерации мы получаем следующий элемент. Вторая форма делает то же самое, но мы можем дополнительно использовать индексное значение массива в переменной Skey (что полезно при работе с ассоциированными массивами). Если вторая форма цикла работает с одномерным, не ассоциированным массивом, то значения Skey и $значение_элемента будут одинаковы.

При первом прохождении цикла foreach курсор массива автоматически сбрасывается для указания на первый элемент массива; таким образом, не требуется вызывать функцию reset() перед запуском цикла foreach.

Также отметим, что цикл foreach оперирует с копией массива, а не с самим массивом, и поэтому курсор самого массива не изменяется, как в конструкции each.

Следующие примеры функционально идентичны:

// работа с численно индексированным
массивом $агг = array (1. 2. 3. 17): reset ($arr):
while (list(. Svalue) = each ($arr))
{ echo "Value: $value<br>\n"; }
foreach ($arr as $value) {
echo "Value $value<br>\n": }
// Следующие примеры также
функционально идентичны:
$агг = array ( "one" => 1.
"two" => 2.
"three" => 3.
"seventeen" -> 17 ).
reset ($arr). while (list($key. Svalue) = each ($arr)) { echo "Key: Skey; Value: $value<br>\n"; } foreach ($arr as $key => Svalue) { echo "Индекс. Skey: Значение: $value<br>\n": // print "\$a[$key] => Sa[$key] \n" // Можно и так написать }

break

break прерывает выполнение циклов for, while, и структур switch, break имеет необязательный аргумент, определяющий, сколько вложенных циклов необходимо прервать.

$arr = array ('one'. 'two', 'three', 'four', 'stop', 'five'): // массив строк while (list (. $val) = each (Sarr)) { // эквивалент записи: foreach(Sarr as $val) if ($val == 'stop') {// если элемент массива break. /* здесь также можно написать: break 1; */ } echo "$val<br>\n"; } '* Использование необязательного аргумента. */ $i = 0: while (++$i) { snitch ($i) { case 5. echo "At 5<br>\n"; break 1. /* Выйти только из switch */ case 10: echo "At 10; quittihg<br>\n": break 2. /* Выйти из структуры switch и цикла while. */ default: break: }}

continue

continue используется в циклических структурах для того, чтобы избежать выполнения оставшейся части цикла и перейти к следующей итерации, continue, подобно инструкции break; может име'гь числовой аргумент, показывающий, на сколько вложенных циклов должно распространяться се действие.

while (list ($key. $value) = each ($arr)) { if (!($key % 2}) { I! пропустить нечетный элемент continue. обработать_четный_элемент (Svalue); } $1 = 0; while ($i++ < 5) { echo "цикл 1-го уровня <br>\n"; while (1) { echo " цикл 2-го уровня <br>\n"; while (1) { echo " цикл 3-го уровня <br>\n". continue 3: } echo "Эта строка никогда не будет выведена.<br>\n": } echo " .. .Эта тоже --br>\n". } echo "Все завершено.<br>\n":

switch

Конструкция switch эквивааснтна последовательности конструкций if, имеющих одно общее условное выражение. Часто приходится выполнять проверку одной переменной (или выражения) на соответствие различным значениям и соответственно выполнять различные наборы инструкций в каждом случае. Это именно то, для чего предназначена конструкция switch.

Следующие два примера демонстрируют замену нескольких конструкций if на одну switch:

if ($1 — 0) { print "1 равно 0"; } if ($1 == 1) { print "i равно 1": } if ($1 - 2) { print "i равно 2". } switch ($1) { -ase 0: print "i равно О"; break; case 1: print BI равно 1": break; case 2 print "i равно 2"; break. }

В конструкции switch инструкции case проверяются одна за другой, и когда обнаруживается соответствие переменной (выражения) значению, указанному после слова case, исполняются все последующие строки, пока не встретится слово break. Если слово break не указано, выполнение продолжается до конца switch-блока.

switch ($1) { case О orint "i равно О"; Cdse 1: print "i равно 1". case 2: print "i равно 2": }

В этом примере, если $i равно О, РНР выполнит все три инструкции print! Если $i равно 1, будут выполнены две последние команды print, и только если $1 равно 2, вы получите единственное «ожидаемое»;сообщение: i равно 2. Поэтому не забывайте указывать слово break в каждом блоке case.

В конструкции switch условное выражение вычисляется только раз и проверяется на соответствие каждому варианту case. В el seif- конструкциях условие проверяется заново (и выражение вычисляется заново), поэтому switch-конструкции выполняются быстрее, если выражение сложное. Блок case также может быть пустым, тогда РНР просто переходит к следующему case (см. объяснение выше).

switch ($1) { case О case l-case 2: print "i равно 0. или 1. или 2": break: case 3 print "i равно З"; }

Особый случай case — это case по умолчанию — default. Он используется в том случае, когда ни один из вариантов не соответствует условному выражению.

switch ($1) { case С: print "i равно О"; break; case 1: print "i равно 1"; break: case 2 print "i равно 2"; break; default rint "i не равно ни 0, ни 1. ни 2": }

Выражение после слова case может быть любым, способным иметь значение и простой тип, то есть целым либо дробным числом или строкой. Массивы и объекты не могут быть использованы в этом I случае, если только они не могут быть приведены к простому типу.

Для конструкций switch возможен альтернативный синтаксис.

/ switch ($1). // вместо открывающей фигурной скобки case 0: print "1 равно О": break, default: print "i не равно 0. 1 и 2"; endswltch: // вместо завершающей фигурной скобки

Директивы require() и include()

Директивы require() и include() заменяются интерпретатором в ходе выполнения на содержимое файла, указанного в этих директивах (их аналогией является директива С препроцессора include). Если в конфигурации РНР разрешен параметр «URL fopen wrappers» (по умолчанию он разрешен), в этих директивах, наряду с локально доступными файлами можно использовать файлы из сети Интернет путем указания их URL (для Widows эта возможность пока недоступна). См. функцию fopen().

Файл, включаемый данными директивами, считается файлом HTML, поэтому если он содержит код РНР, то должны присутствовать теги-ограничители (например, <? и ?>), чтобы этот код выполнялся. Обычный синтаксис:

require ('header.тс'). // возможна также запись: require "header nnr":

Фактически require() не функция, а специальная конструкция языка. В руководстве по РНР говорится, что «на нее не влияют условные конструкции». Но при проверке на практике выяснилось, что require() функционирует так же, как и include(), то есть на нее влияют условные структуры и в цикле с перечислением имен включаемых файлов она заменяет имена файлов. Директива require() выполняется всегда, вне зависимости от того, выполняется ли код, ею подставляемый. Она не возвращает значение (include() может возвращать значение с помощью команды return).

Директива include() — это «почти» функция. Характерный пример ее применения:

Sfiles = array ('first.inc'. 'second.inc'. 'third.me'); for ($1 = 0: $1 < count($flies); $i++) { include $files[$i]: }

Руководство по РНР требует заключения include() в фигурные скобки в условных конструкциях (но, как я выяснил, в этом нет необходимости).

Включаемые файлы также наследуют все переменные, доступные вы-зываюшему сценарию, с теми значениями, которые они имеют в той строке, где встречается директива включения. Если директива включения встречается в объявлении функций или класса, содержимое включаемого файла ведет себя, как если бы оно находилось вместо директивы включения.

include() также позволяет возвращать значение из включаемого сценария командой return (это завершает выполнение включаемого сценария).

<?php // file test.тс echo "До return <br>\n"; if (11 { return 27: } echo "После return <br>\n": ?> <?php // main file (main.php) Sretval = include ('test.inc'): echo "Возвращенное значение: 'Sretval'<br>\n": >> /I Запуск main.php выведет: // До return <br> // Возвращенное значение. '27'<br>

Если необходимо передать во включаемый сценарий аргументы (как при вызове функций), это можно сделать двумя способами: установкой глобальных переменных и вызовом сценария посредством HTTP-запроса (с передачей параметров в адресе URL). Однако не стоит забывать, что во втором способе надо задавать полный адрес URL (чтобы обращение происходило к web-серверу, а не локальному файлу) и что при этом включаться будет не сам код, а результаты его выполнения; помимо этого, сервер должен быть способен выполнить запрашиваемый сценарий.

require ("file php7varone=l&vartwo=2"): // не работает (это не URL) require ("http://someserver/file.php?varone=l&vartwo=2"); // работает Svarone = 1: Svartwo = 2: require ("file txt"); /* Можно включать локальные файлы с любым расширением */

См. также: readfile() и virtuaH).

 

require_once() и include_once()

Эти директивы аналогичны вышеописанным с тем отличием, что они Ш не допускают повторного включения файла, если его включение уже происходило. Это позволяет избежать возникновения ошибок при множественном включении файлов — например, когда это приводит к ситуации повторного определения функции (что вызывает ошибку в РНР), повторного назначения констант и т. п.

См. также: get_required_files(), get_included_files(), readfile() и virtual().

Пользовательские функции

Пользовательские функции могут быть определены следующим образом:

function foo ($arg_l. $arg_2.....$arg_n) { echo "Example function.\n": return Sretval. // значение, возвращаемое функцией }

Внутри тела функции может присутствовать любой PHP-код и даже определение других функций или классов. В РНР 3 определение функции должно предшествовать первому ее использованию, в РНР 4 это требование отсутствует.

РНР не допускает перегрузку функций (в отличие от C++), то есть если функция однажды определена, ее код нельзя изменить или удалить. Поэтому вторичное (пере)определение функции вызовет

ошибку.

РНР 4 также поддерживает неопределенное число аргументов функции и значение аргументов по умолчанию (см. дальше). Для использования этих возможностей полезны функции:
func_num_args(), func_ get_arg() и func_get_args().

Если вы помните, функциям недоступны глобальные переменные.

Передача функциям аргументов

Информация передается функциям через набор их аргументов, представленных последовательностью значений (переменных, выражений), разделенных запятыми. РНР поддерживает: передачу значений аргументов «по значению» (по умолчанию) и передачу значений по ссылке; значения аргументов по умолчанию и переменное для функции число аргументов. См. также:
func_num_args(), func_get_arg() и func_get_args().

function takes_arra.y($'input) { // в функцию передается массив echo "$input[0] + $input[l] = ". $input[0]+$input[l]: }

Передача значений аргументов по ссылке

По умолчанию в функцию передаются значения аргументов, то есть копии значений выражений и переменных, поэтому изменение значений аргументов имеет смысл только внутри функций и не отражается вовне. Если необходимо изменять сами аргументы, тогда их необходимо передавать по ссылке, так как тогда в функцию передаются не значения, а ссылки переменных. Для этого перед переменной в объявлении функции ставится знак амперсант (&), тогда аргумент всегда будет передаваться в функцию по ссылке:

function add_some_extraWstnng. $x) { Istnng .= "дополним строку \п"; $х += 3. // бессмысленно, т.к. //значение $х потеряется при завершении функции } $str = 'Есть строка - '; $а = 1; add_some_extra($str. $а): echo $str; // напечатает 'Есть строка - дополним строку' echo $a. // значение $а не изменилось

Если вы хотите передать аргумент по ссылке в функцию, которая по умолчанию принимает значения «по значению», то амперсант ставится перед переменной в строке вызова функции:

function foo ($bar) { // функция принимает аргумент «по значению» $bаг = ' и что-то еще'; } $str = 'Это строка. ': foo ($str); // передача аргумента по значению echo Sstr . "\n"; // выведет 'Это строка. ' foo (&$str), // передача аргумента по ссылке echo $str; // выведет ' Это строка, и что-то еще'

Значения аргументов по умолчанию

В определении функции можно использовать синтаксис C++ для задания значений аргументов по умолчанию:

function fee ($type = "Яблоко") { return "Имеем фрукт: $type.\n"; } echo fee О: // выводит «Инеем фрукт: Яблоко» echo fee ("Груша"); // выводит «Имеем фрукт Груша» Значение по умолчанию должно быть константным.

Отметим, что аргументы, имеющие значения но умолчанию, должны стоять (в объявлении функций) после аргументов, их не имеющих.

    

function mm (Staste = "вкусный". $ fruit) { return "Имеем Staste фрукт $ fruit\n"; } echo mm ("Яблоко") // Ошибка смысла!

PHP выдаст следующее:

Warning: Missing argument 2 in call to ram () in Предупреждение: Не указан 2-й аргумент в вызове mmm () /usr/local/etc/httpd/htdocs/php3test/functest.htrnl on' line 41 Имеем Яблоко фрукт:

Интерпретатор пытается присвоить первое значение (из аргументов функции) первому аргументу, а так как для второго аргумента значение не задано (ни по умолчанию, ни явно), ю это вызывает ошибку (хотя и не препятствует дальнейшему выполнению сценария). Сравните со следующим примером:

function mmm2000 (Sfruit. $taste = "вкусный") { return "Имеем Staste фрукг: $ fruit\n". } echo mwn2000 ("Яблоко"); // работает как надо! echo mim2000 ("Яблоко", "кислый"); // явное указание аргумента

РНР выдаст следующее:

Имеем вкусный фрукт: Яблоко Имеем кислый фрукт: Яблоко

Неопределенное число аргументов в функции

РНР 4 поддерживает неопределенное число аргументов в функциях пользователя. Для использования этого имеются функции func_num_ args(), func_get_arg() и func get_args(). При этом не требуется использовать специальный синтаксис и список аргументов может указываться, как в обычных функциях.

Возвращение функциями значений

Значения возвращаются функциями с помощью команды return. Возвращаться может любой тип, включая массивы и объекты.

Пользовательские функции 71 function square ($num) { return $num * $num: } echo square (4); // outputs '16'.

Из функции нельзя возвратить несколько значений одновременно, и если такая необходимость возникает, следует использовать массив.

function snalljiumbers() { return array (0. 1. 2); } list ($zero. $one. $two) = smalljiumbers(), echo "Szero. $one, $two";

Чтобы вернуть из функции ссылку, нужно использовать оператор ссылки (&) перед именем функции при ее объявлении и при присваивании ее значения переменной.

function &returns_reference() { return $someref; } Snewref =&returns_reference();

Помимо возвращения значений команда return выполняет еще одну важную роль. Она прерывает выполнение функции подобно команде break в условных структурах и циклах. Если необходимо просто прервать выполнение функции, не возвращая никакого значения, в*команде return аргумент можно не использовать.

function а О { echo "Эта строка будет выведена": return: echo "Сюда мы не доберемся"; } а О;

Переменные-функции

РНР поддерживает концепцию переменных-функций. Это означает, что если после имени переменной указаны круглые скобки, РНР будет искать функцию с именем, содержащимся в переменной, и при нахождении таковой запустит ее. Эту полезную особенность можно использовать для осуществления обратных вызовов, составления списков функций и многими другими способами.

<?рпр function foot) { echo "Функция foo()<br>\n", } function barf $arg = '' ) { echo "Функция bагО; с аргументом '$arg' ,<br>\n" } Sfunc = 'too'. $func(): // запустит функцию foo(): Sfunc = 'bar'. $func( 'test' ); // запустит функцию bar('test'): ?>

Классы

Класс — это коллекция переменных и функций для работы с ними. Переменные класса объявляются словом van. В функциях класса переменная $this означает: «данный объект этого класса» (экземпляр). Необходимо использовать запись this->что-либо для доступа к любой переменной или функции, имеющейся в этом объекте.

<?рhр class Корзина { var $items: // Переменная
(ассоциативный массив). // используемая для хранения данных о том // что имеется в корзине и в каком количестве // Добавить в корзину предмет $а в количестве $num штук function add_item ($a. $num) { $this->items[$a] += $num: } // Удалить из корзины предмет $а
в количестве $num штук function remove_item ($a. $num) { if ($this->items[$a] > $num) { $this->items[$a] -= $num; return TRUE: } else { // нельзя удалить больше предметов, чем имеется return FALSE: } } }?>

Этот класс состоит из одного ассоциативного массива и двух функций для работы с ним.

В PHP 4 только константа может инициализировать значение переменной в объявлении класса, для присваивания неконстантных значений используйте конструктор класса.

Конструктор класса — эта функция класса, имеющая его имя и запускаемая автоматически при создании экземпляра класса.

Объявление класса — всего лишь его описание. Для того чтобы создать экземпляр класса — объект, необходимо создать переменную и назначить ей класс оператором new.

Scart = new Корзина. $cart->addjitpm("10". 1);

Класс может быть расширением другого класса. При наследовании все переменные и функции родительского класса наследуются дочерним классом. Наследование объявляется словом extends после имени класса. РНР не поддерживает множественное наследование (то есть одновременное наследование от нескольких классов).

class Моя_Корзина extends Корзина { var Sowner; // владелец // конструктор класса function Моя_Корзина (Sname = "Игорь") { $this->owner = $name: } }

Класс Моя_Корзина расширяет класс Корзина добавлением одной переменной и конструктора.

$ncart = new Моя_Корзина; print $ncart->owner; // Кто владелец корзины? $nc = new Моя_Корзина("Вова"), // Бовина корзина print $nc->owner; $ncart->add_item ("10" 1): // (Унаследованная функциональность от класса Корзина)

Будьте осторожны: для дочерних классов конструктор родительско-ю класса не вызывается при создании экземпляра дочернего класса. Если необходимо вызвать конструктор родительского класса, это должно быть сделано явно (подобно вызову обычной функции родительского класса).

Ссылки

В РНР ссылки — это способ доступа к значению переменной под различными именами. Они отличны от указателей в С, хранящих адрес переменной, в РНР это всего лишь псевдонимы какой-либо переменной.

Ссылки РНР позволяют двум переменным указывать на одно значение. Так, запись:

 $а =& $b 

означает, что теперь и $а и $b указывают на одно значение. Причем $а и $b теперь полностью идентичны, то есть не $а указывает на $b или наоборот, а обе они указывают на одно место хранения значения.

Основные варианты использования ссылок: передача аргументов по ссылке и возвращение ссылок из функций, они представлены в главе «Функции».

Тот же синтаксис используется в функциях, возвращающих ссылки и при использовании оператора new.

$bаг =& new fooclassO: $foo =& find_var ($bar).

He забудьте: для использования ссылок на объекты оператор ссылки (&), должен использоваться как в конструкторе для переменной $this, так и при создании объекта (назначении его переменной), иначе вы получите два различных объекта.

В дополнение к тому, что сказано о ссылках в главе «Функции», отметим, что по ссылке кроме переменных могут передаваться объекты, созданные оператором new (например, foo(new foobarO), и ссылки, возвращаемые другими функциями.

Удаление ссылочной связи производится использованием функции unset().

Ja = 1; $b =& $а; // создание ссылочной связи inset ($a); // удаление ссылочной связи // при этом $b продолжает оставаться переменной со значением 1

Ссылки можно рассматривать как аналогии жестких файловых связей в системе Unix, тогда действие unseto — аналог команды unlink.

Синтаксис языка и операторы

страницы в данном разделе 
 Синтаксис языка и операторы   


Разделы
Околокомпьютерная литература (375)
Программирование (102)
Программы (75)
ОС и Сети (49)
Интернет (29)
Аппаратное обеспечение (16)
Базы данных (6)

Содержание сайта (выборка)
Apache
Протоколы TCP/IP (принципы, протоколы и архитектура)

PHP, PELR, JSP
PHP
JavaServer Pages (JSP)

Базы данных
Основы mysql
СУБД INFORMIX
СУБД POSTGRES
Основы проектирования реляционных баз данных

HTML, javascript
Спецификация HTML 4.01
Каскадные Таблицы Стилей, Уровень 2
Клиентский JavaScript. Справочник.
JavaScript руководство пользователя
Серверный JavaScript 1.4. Руководство по Использованию.

Паскаль, C, C++, C#
GCC (примеры)
FAQ Валентинa Озеровa DELPHI
C





 
©  programming-lang.com  справочник программиста