Вложенные конструкции if-else

Пример8

<?

$a=2;

$b=2;

$с=7;

$d=7;

$cat="Juli";

$dog="Hard";

if($a == $b or $c == $d);

{

echo "Все Переменные равны";

if($cat!=$dog);

{

echo "<br>В переменной cat и dog содержаться разные имена";

}

}

?>

Если инструкция_1 или инструкция_2 должны состоять из нескольких команд, то они, как всегда, заключаются в фигурные скобки.

Например:

if($a>$b)

{ print "а больше b"; } ; elseif($a==$b) { print "а равно b"; };

else { print "а меньше b"; $c=$a; }

Это не опечатка: допускается писать elseif слитно, вместо else if. Хотя это и не удобочитаемо, конечно предпочтительнее первый вид записи.

Конструкция if-else имеет еще один альтернативный синтаксис:

if (логическое_выражение) :

команды;

elseif(другое_логическое_выражение):

другие_команды;

else:

иначе_команды;

endif

на расположение двоеточия (:) особо обратите внимание! Если его пропустить, будет сгенерировано сообщение об ошибке. И еще: как обычно, блоки elseif и else можно опускать.

Альтенрнативный синтаксис:

<?

if(@$go):?>

Привет,<?=$Name?>!

<?else:?>

<form action=<?=$REQUEST_URI?> method=post>

Ваше имя :<input type=text name=Name><br><br>

<input type=submit name=go value="Отоcлать!">

<?endif?>

Цикл с предусловием while

Эта конструкция также унаследована непосредственно от Си. Ее предназначение — цикличное выполнение команд в теле цикла, включающее предварительную проверку, нужно ли это делать (истинно ли логическое выражение в заголовке). Если не нужно (выражение ложно), то конструкция заканчивает свою работу, иначе выполняет очередную итерацию и начинает все сначала. Выглядит цикл так:

while(логическое_выражение)

инструкция;

где, как обычно, логическое_выражение - логическое выражение, а

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

Пример.

<?

$a=0;

While ($a<10)

{

echo $a;

$a=$a+1;

}

?>

Пример10

<?

$a=0;

While ($a<=10)

{

echo "$a<br>\n";

$a=$a+1;

}

?>

Задание. Посчитать сумму чисел от 1 до 100.

Пример11.

<?

$sum=0;

$i=1;

While ($i<=100)

{

$sum=$sum+$i;

$i++;

}

echo "Cумма всех чисел от 1 до 100 равна -$sum<br>";

?>

Пример12:

$i=1; $p=1;

while($i<32) {

echo $p," ";

$p=$p*2; // можно было бы написать $p*=2

$i=$i+1; // можно было бы написать $i+=1 или даже $i++

}

Данный пример выводит все степени двойки до 31-й включительно.

Как и инструкция if, цикл while имеет альтернативный синтаксис, что упрощает его применение вперемешку с HTML-кодом:

while(логическое_выражение):

команды;

endwhile;

Цикл с постусловием do-while

В отличие от цикла while, этот цикл проверяет значение выражения не до, а после каждого прохода. Таким образом, тело цикла выполняется хотя бы один раз. Выглядит оператор так:

do {

команды;

} while(логическое_выражение);

После очередной итерации проверяется, истинно ли логическое_выражение, и, если это так, управление передается вновь на начало цикла, в противном случае цикл обрывается. Альтернативного синтаксиса для do-while разработчики РНР не предусмотрели (видимо, из-за того, что, в отличие от прикладного программирования, этот цикл довольно редко используется при программировании сценариев).

Пример13.

<?

$sum=0;

$i=1;

do

{

$sum = $sum + $i;

$i++;

}

While ($i <= 1000);

echo "Cумма всех чисел от 1 до 1000 равна - $sum<br>"

?>

Универсальный цикл for

Мы уже с ним встречались, он не зря назван универсальным — ведь с его помощью можно (и нужно) создавать конструкции, которые будут выполнять действия совсем не такие тривиальные, как простая переборка значения счетчика (а именно для этого используется for в Паскале и чаще всего в Си). Формат конструкции такой:

for(инициализирующие_команды; условие_цикла;

команды_после_прохода) тело цикла;

Работает он следующим образом. Как только управление доходит до цикла, первым делом выполняются операторы, включенные в инициализирующие_команды (слева направо). Эти команды перечисляются там, через запятую.

Пример14

<?

for ($i=0, $sum=0; $i<=1000; $i++)

{

$sum=$sum +$i;

}

echo "Сумма всех чисел от 1 до 1000 равна - $sum";

?>

Пример15

for($i=0,$j = 10,$k="Test!; )

Затем начинается итерация. Первым делом проверяется, выполняется ли условие_цикла (как в конструкции while). Если да, то все в порядке, и цикл продолжается. Иначе, осуществляется выход из конструкции. Например:

// прибавляем по одной точке

for($i=0,Sj=0,$k="Test"; $i<10; ) $k.=".";

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

for($i=0,$j=0,$k="Points"; $i<100; $j++, $i+=$j ) $k=$k.".";

<?

for($i=0,$j=0,$k="Points"; $i<100; $j++, $i+=$j)

$k=$k.".";

echo " - $k";

?>

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

Например:

<?

$i=0; $j=0; $k="Points";

while ($i<100)

{

$k.=".";

$j++; $i+=$j;

}

echo"Вывод-$k ";

?>

Попробуйте сказать: сколько точек добавится в конец переменной $k после выполнения цикла?

Как обычно, имеется и альтернативный синтаксис конструкции:

for (инициализирующие_команды; условие_цикла;

команды_после_прохода):

операторы;

endfor;

Инструкции break и continue

Очень часто для того, чтобы упростить логику какого-нибудь сложного цикла, удобно иметь возможность его прервать в ходе очередной итерации (к примеру, при выполнении какого-нибудь особенного условия). Для этого и существует инструкция break, которая осуществляет немедленный выход из цикла. Она может задаваться с одним необязательным параметром — числом, которое указывает, из какого вложенного цикла должен быть произведен выход. По умолчанию используется 1, т. е. выход из текущего цикла, но иногда применяются и другие значения:

<?

for($i=0; $i<10; $i++)

{

if ($i==5) break ;

echo"$i";

}

?>

Как только переменная $i равна 5, цикл останавливается.

В этом примере инструкция break осуществляет выход не только из второго, но и из первого цикла, поскольку указана с параметром 2.

Примечание

Применение такой формы записи break — новинка РНР версии 4. Ни в одном другом языке, который бы использовал подобный синтаксис его нет! Инструкцию break удобно использовать для циклов поисков: как только очередная итерация цикла удовлетворяет поисковому условию, поиск обрывается. Например, вот цикл, который ищет в массиве $А первый нулевой элемент:

<?

$a[0]=0;

$a[1]=1;

for ($i=0;$i<count($a);$i++)

{

if ($a[$i]==1) break;

echo"$i";

}

Предлагается разобрать почему, при сравнение с 0, на экран ничего не выводится.

?>

Стандартная функция count (), которую мы рассмотрим далее, просто возвращает число элементов в массиве $a.

Инструкция continue так же, как и break, работает только "в паре" с циклическими конструкциями. Она немедленно завершает текущую итерацию цикла и переходит к новой (конечно, если выполняется условие цикла для цикла с предусловием). Точно так же, как и для break, для continue можно указать уровень вложенности цикла, который будет продолжен по возврату управления.

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

Например, вот цикл, который обнуляет те элементы массива $A, которые удовлетворяют нескольким условиям:

<?

$a[0]=0;

$a[1]=1;

$a[2]=2;

$a[3]=0;

$a[4]=4;

for ($i=0;$i<count($a);$i++)

{

if ($a[$i]==0) continue;

else

if($a[$i]!=0);//!continue;

$a[$i]=0;

echo"<br>$a[$i]";

}

?>

Замечание

Грамотное использование break и continue— искусство, позволяющее заметно улучшить "читабельность" кода и количество блоков else.

Нетрадиционное использование do-while и break.

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

Листинг 4.2. Модель сценария для обработки формы

…….

$WasError=0; // индикатор ошибки — если не 0, то была ошибка

// Если нажали кнопку Submit (с именем $doSubmit)...

if(@$doSubmit) do

{

// Проверка входных данных

if(неправильное имя пользователя) { $WasError=I; break; }

. . . и т. д.

if(неправильные данные) { $WasError=l; break; }

. . . и т. д.

// Данные в порядке. Обрабатываем их.

выполняем действия;

выводим результат;

завершаем сценарий;

}

while(0);

Выводим форму, через которую пользователь будет запускать этот сценарий, и, возможно, отображаем сообщение об ошибке в случае, если $WasError!=0.

Здесь представлен наиболее обычный способ для организации сценариев-диалогов. Запустив сценарий без параметров, пользователь видит форму с приглашением ввести свое имя, пароль и некоторые другие данные. При нажатии кнопки запускается тот же самый сценарий, который определяет, что была нажата кнопка dosubmit, и первым делом проверяет имя и пароль.

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

Мы видим, что указанный алгоритм можно реализовать наиболее удобно, имея какой-то способ обрывания блока "проверки-и-завершения" и возврата к выводу формы заново. Как раз это и делает конструкция

if(что то) do { ... } while(0);

Очевидно, что тело цикла do-while выполняется в любом случае только один раз (так как выражение в while всегда ложно). Тем не менее, такой "вырожденный" цикл мы можем использовать для быстрого выхода из него посредством break.

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

Цикл for each

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

foreach (массив as $key=>$value)

команды;

Здесь команды циклически выполняются для каждого элемента массива, при этом очередная пара ключ=>значение оказывается в переменных $key и $value.

Рассмотрим пример (листинг 4.3), где покажем, как мы можем отобразить содержимое всех глобальных переменных при помощи foreach:

Листинг 4.3. Вывод всех глобальных переменных

foreach ($GLOBALS as $k=>$v)

echo "<b>$k</b> => <tt>$v</tt><br>\n";

У цикла foreach имеется и другая форма записи, которую следует применять, когда нас не интересует значение ключа очередного элемента. Выглядит она так:

foreach (массив as $value) команды;

В этом случае доступно лишь значение очередного элемента массива, но не его ключ. Это может быть полезно, например, для работы с массивами-списками.

Внимание

Цикл foreach оперирует не с исходным массивом, а его копией. Это означает, что любые изменения, которые вносятся в массив, не могут быть "видны" из тела цикла. Что позволяет, например, в качестве массива использовать не только переменную, но и результат работы какой-нибудь функции, возвращающей массив (в этом случае функция будет вызвана всего один раз — до начала цикла, а затем работа будет производиться с копией возвращенного значения).

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

Конструкция switch-case

Часто вместо нескольких расположенных подряд инструкций if-else целесообразно воспользоваться специальной конструкцией

switch-case:

switch(выражение)

{

case значение1: команды1; [break;]

case значение2: команды2; [break;]

case значение3: команды3; [break;]

[default: команды_по_умолчанию; [break]]

}

Делает она следующее: вычисляет значение выражения (пусть оно равно, например, v), а затем пытается найти строку, начинающуюся с case v:. Если такая строка обнаружена, выполняются команды, расположенные сразу после нее (причем на все последующие операторы case “что-то” внимание не обращается, как будто их нет, а код после них остается без изменения). Если же найти такую строку не удалось, выполняются команды после default (когда они заданы).

Обратите внимание на операторы break (которые условно заключены в

квадратные скобки, чтобы подчеркнуть их необязательность), добавленные после каждой строки команд, кроме последней (для которой можно было бы тоже указать break, что не имело бы смысла). Если бы не они, то при равенстве у=значение1 сработали бы не только команды1, но и все нижележащие.

Вот альтернативный синтаксис для конструкции switch-case:

switch(выражение):

case значение1: команды1; [break;]

………

case значениеN: командыN; [break;]

[default: команды_по_умолчанию; [break]]

endswitch;

ПРИМЕР16

<?

$sposob="Банк";

switch ($sposob)

{

case "Банк":

echo "Чтобы оплатить через Банк.................";

break;

case "Почта":

echo "Чтобы оплатить через Почту.................";

break;

case "Western Union":

echo "Чтобы оплатить через Western Union.................";

break;

default:

echo "<p> Вы не выбрали способ оплаты";

break;

}

?>

Инструкция require

Эта инструкция позволяет нам разбить текст программы на несколько файлов. Ее формат такой:

require имя_файла;

При запуске (именно при запуске, а не при исполнении!) программы интерпретатор просто заменит инструкцию на содержимое файла имя_файла (этот файл может также содержать сценарий на РНР, обрамленный, как обычно, тэгами <? и ?>). Причем сделает он это только один раз (в отличие от include, который рассматривается ниже): а именно, непосредственно перед запуском программы. Это бывает довольно удобно для включения в вывод сценария всяких "шапок" с HTML-кодом. Например (листинги 9.4, 9.5 и 9.6):

Листинг 4.4. Файл header. htm

<html>

<headxtitle>Title! </titlex/head>

<body bgcolor=yellow>

Листинг 4.5. Файл footer.htm

& copy; My company, 1999.

</bodyx/html>

Листинг 4.6. Файл script. php

require "header.htm";

. . . работает сценарий и выводит само тело документа

require "footer.htm";

Безусловно, это лучше, чем включать весь HTML-код в сам сценарий вместе с инструкциями программы. Вам скажет спасибо тот, кто будет пользоваться вашей программой и захочет изменить ее внешний вид. Однако, несмотря на кажущееся удобство, это все же плохая практика. Действительно, наш сценарий разрастается аж до трех файлов! А как было сказано выше, чем меньше файлов использует программа, тем легче с ней будет работать дизайнеру и верстальщику (которые о РНР имеют слабое представление).

Инструкция include

Эта инструкция практически идентична require, за исключением того, что включаемый файл вставляется "в сердце" нашего сценария не перед его выполнением, а прямо во время.

Действительно. Пусть у нас имеется 10 текстовых файлов с именами file0.php, file1.php и так далее до file9.php, содержимое которых просто десятичные цифры 0, 1 ... 9 (по одной цифре в каждом файле). Запустим такую программу:

for($i=0; $i<10; $i++)

{

include "file$i.php";

}

В результате мы получим вывод, состоящий из 10 цифр: "0123456789". Из этого мы можем заключить, что каждый из наших файлов был включен по одному разу прямо во время выполнения цикла! (Попробуйте теперь вместо include подставить require и сравните результат.)

И обратите внимание на, казалось бы, лишние фигурные скобки вокруг include. Попробуйте их убрать. Вы тут же можете получить совершенно сообщение об ошибке (или, еще хуже, программа начнет неправильно работать, а причину разыскать будет нелегко). Так происходит потому, что include не является на самом деле оператором в привычном нам смысле этого слова. Чтобы это понять, представьте, что каждый раз, когда интерпретатор встречает инструкцию include, он просто "в лоб" заменяет ее на содержимое файла, указанного в параметре.

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

ПРИМЕР 17 СДЕЛАТЬ!

Создаём первый файл PHP.

Имя файла Include.php

<?

$a=30;

$b=120;

$c=$a+$b;

echo "Сумма переменных - $c";

?>

Создаём второй файл и переносим в него из файла Include.php инициализации двух переменных $a=30; $b=120; Сохраняем второй файл в той же папке.

Settings.php

<?

$a=30;

$b=120;

?>

Удаляем из файла Include.php инициализации двух переменных $a=30; $b=120; и записываем на их месте include "Settings.php"

Include.php

<?

include "Settings.php"

$c=$a+$b;

echo "Сумма переменных - $c";

?>

Трансляция и проблемы с include

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

Одним из таких "камней" как раз и является инструкция include. Как только управление программы доходит до нее, РНР вынужден приостановиться и ждать, пока транслятор не оттранслирует код включаемого файла. А это очень отрицательно сказывается на быстродействии программы, особенно большой. Поэтому, если вы пишете большой и сложный сценарий, применяйте инструкцию require вместо include, где только можно.

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

Что же оптимальнее — require или include? Если вы точно уверены, что определенный файл нужно присоединить ровно один раз и в точно определенное место, то воспользуйтесь require. В противном случае более удачным выбором будет include.

Инструкции однократного включения

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

Чтобы стало яснее, приведем пример: разработчик Билл написал несколько очень полезных функций для работы с файлами Excel и решил объединить их в библиотеку — файл xllib.php (листинг 4.7):

Листинг 4.7. Библиотека xllib.php

Function LoadXlDocument($filename) { . . ,

Function SaveXlDocument($filename,$doc) {…

Разработчик Вася захотел сделать то же самое для работы с документами Microsoft Word, в результате чего на свет явилась библиотека wlib.php. Так как Word и Excel связаны между собой, Вася использует в своей библиотеке (листинг 4.8) возможности, предоставляемые библиотекой xllib.php - подключает ее командой require:

Листинг 4.8. Библиотека wlib.php

require "wllib.php";

Function LoadWDocument ($filename) ( . . . )

Function SaveWDocument ($filename, $doc) ( . .

Эти две библиотеки настолько популярны в среде Web-программистов, что скоро все стали их внедрять в свои программы. При этом, конечно же, никому нет дела до того, как эти библиотеки на самом деле устроены - все просто подключают их к своим сценариям при помощи require, не задумываясь о возможных последствиях.

Но в один прекрасный день одному неизвестному программисту потребовалось работать и с документами Word, и с документами Excel. Он, не долго думая, подключил к своему сценарию обе эти библиотеки (листинг 4.9):

Листинг 4.9. Подключение библиотек xllib.php и wlib.php

require "wlib.php";

require "xllib.php";

$wd=LoadWDocument ( "document . doc" ) ;

$xd=LoadXl Document ("document . xls") ;

При запуске этого сценария он получил сообщение об ошибке, в котором говорилось, что в файле xiib.php функция LoadXlDoc() определена дважды!..

Если проследить за тем, как транслятор РНР "разворачивает" код листинга 4.9., то нетрудно понять, почему это произошло. Вот как это происходит:

//require "wlib.php";

//require "xllib.php";

Function LoadXl Document ($filename) ( . . . )

Function SaveXIDocument ($filename, $doc) ( . . . )

Function LoadWDocument ($filename) ( . . . )

Function SaveWDocument ($filename,$doc) ( . . . )

//require "xllib.php";

Function LoadXlDocument($filename) { . . . }

Function SaveXIDocument($filename, $doc) ( . . . )

$wd=LoadWDocument("document.doc") ;

$xd=LoadXlDocument("document.xls");

Как видим, файл xllib.php был включен в текст сценария дважды: первый раз косвенно через wiib.php, и второй раз — непосредственно из программы. Поэтому транслятор, дойдя до выделенной строки, обнаружил, что функция LoadxiDocument () определяется второй раз, на что честно и прореагировал. Конечно, разработчик сценария мог бы исследовать исходный текст библиотеки wiib.php и понять, что во второй раз xllib.php включать не нужно. Но это не выход. Действительно, при косвенном подключении файлов третьего и выше уровней вполне могут возникнуть ситуации, когда без модификации кода библиотек будет уже не обойтись. А это недопустимо. Как же быть?

Разработчики РНР предлагают простое решение: инструкции

inciude_once и require_once.

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

Инструкция include_once работает совершенно аналогично, но включает файл во время исполнения программы, а не во время трансляции.

Замечание

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

Постарайтесь вообще отказаться от require и include. Это во многом упростит разбиение большой и сложной программы на относительно независимые модули.

Вызов внешней программы САМОСТОЯТЕЛЬНО!

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

Вот так, например, мы можем в системе Windows узнать содержимое текущего каталога, которое выдает команда dir:

$st=`command.com/c dir`;

echo "<pre>$st</pre>";

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