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

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

В данном разделе описываются все возможности языка, которые имеет РНР версии 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]; // 1-й символ строки - 'Т' $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)

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

 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: //(это. тем не менее - 3-й элемент) # аналог примера выше: $с = аггау( "нулевой " => " АБВ ". "первый" '> 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»

Повод наличия 2-х схожих вариантов для операторов 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 исполняется 1-й, тот, что равняется 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++) ;

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

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

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

foreach

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

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

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

При первом прохождении цикла foreach курсор массива механически сбрасывается для указания на 1-й элемент массива; таким образом, не требуется вызывать функцию 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: } } }?>

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

В 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.