Php логическое или. Условные операторы. Все логические операторы в PHP

PHP поддерживает стандартные логические операторы AND и && , OR и || , ! (не) и XOR . Логические операторы позволяют сравнивать результаты работы двух операндов (значения или выражения) с целью определения факта возвращения одним из них или обоими значения true или false и выбора соответствующего продолжения выполнения сценария в зависимости от возвращенного значения. Как и операторы сравнения, логические операторы возвращают одно логическое значение - true либо false , в зависимости от значений находящихся по обе стороны от оператора.

Логическое ИЛИ (OR и ||)

Оператор логическое ИЛИ обозначается как OR или || . Он выполняет операцию «логическое ИЛИ» над двумя операндами. Если один или оба операнда имеют истинное значение, он возвращает true . Если оба операнда имеют ложные значения, он возвращает false . У вас вероятно возник вопрос, зачем же сделали два варианта одного оператора? Смысл двух разных вариантов оператора «логическое ИЛИ» в том, что они работают с различными приоритетами.

Сначала разберем как работает оператор || . И так, если один или оба его операнда имеют истинное значение, он возвращает true . Если оба операнда возвращают ложные значения, он вернет false .

Оператор OR работает также как и оператор || за одним исключением, если оператор OR используется с присваиванием, то сначала он вычислит и вернет значение левого операнда, в остальном он работает точно также как и оператор || , т.е. если один или оба его операнда имеют истинное значение, он возвращает true . Если оба операнда возвращают ложные значения, он вернёт false .

Чтобы стало понятнее, как они работают, приведем следующий пример:

1 // Сначала переменной присваивается значение false, а затем вычисляется второй операнд // Действие приоритета: ($var2 = false) or true $var2 = false or true; echo $var2; // false не выводится // ($var3 = 0) or 3 $var3 = 0 or 3; echo "
$var3"; // => 0 ?>

Любые операторы сравнения и логические можно комбинировать в более сложные конструкции:

Стоит упомянуть еще об одном важном моменте, касательно обоих операторов OR и || . Оператор «логическое ИЛИ» начинает свои вычисления со своего левого операнда, если он возвращает true , то правый операнд вычисляться не будет. Это позволяет экономить время исполнения, но нужно внимательно следить за тем, чтобы код, от которого может зависеть корректная работа программы, не был помещен в правый операнд.

Логическое И (AND и &&)

Оператор логическое И обозначается как AND или && . Он выполняет операцию «логическое И» над двумя операндами. Он возвращает true тогда и только тогда, когда оба операнда имеют значение true . Если один или оба операнда возвращают значение false , оператор возвращает false . Смысл двух разных вариантов записи оператора «логическое И» такой же как и у двух предыдущих операторов, а именно в том, что они работают с различными приоритетами.

Сначала разберем как работает оператор && . И так, если оба его операнда имеют истинное значение, он возвращает true . Если хотя бы один или оба его операнда возвращают значение false , он тоже вернет false .

Оператор AND работает также как и оператор && за одним исключением, если оператор AND используется с присваиванием, то сначала он вычислит и вернёт значение левого операнда, в остальном он работает точно также как и оператор && . Если хотя бы один из его операндов возвращает значение false , он тоже вернет false , также если оба операнда возвращают ложные значения, он возвращает false .

Для понимания рассмотрим теперь, как это работает на практике:

$bar3"; // => 9 ?>

Исключающее ИЛИ (XOR)

Оператор исключающее ИЛИ обозначается как XOR . Он возвращает значение true , если один и только один из операндов имеет значение true . Если оба операнда имеют значение true , оператор вернет значение false .

Так как приоритет оператора XOR такой же как и у операторов AND и OR (ниже чем у оператора присваивания), и он используется в выражении с присваиванием, то сначала он вычисляет и возвращает значение левого операнда.

6 $a1 = 19 xor 5 > 6; var_dump($a1); // => 19 var_dump(true xor true); // false var_dump((2 < 3) xor (5 != 5)); // true ?>

Логическое НЕ (!)

Оператор логическое НЕ , его также называют отрицание обозначается знаком! . Он является унарным оператором, помещаемым перед одиночным операндом. Оператор «логическое НЕ» используется для инверсии логического значения своего операнда и всегда возвращает true или false .

Если потребуется инвертировать значение выражения, например a && b , необходимо будет использовать круглые скобки: !(a && b) . Также с помощью оператора! можно преобразовать любое значение x в его логический эквивалент, дважды применив оператор: !!x .

Итак, мы уже умеем выполнять код, соответствующий определённому условию. Но до этого момента условие могло быть только одно. А что если код должен выполняться при соблюдении сразу нескольких условий?

Для решения этой задачи существуют логические операторы:

= 5 && $price <= 10) echo "Это число находится между 5 и 10"; ?>

Оператор && , который ещё называется логическое И , приводит значения слева и справа к булеву типу, а затем и сам возвращает булево значение: true если слева и справа true , либо false если одно из условий false .

Другими словами, если и одно, и другое условие истинно, то и оператор && возвращает истину. Что и отражает название оператора.

Оператор || или логическое ИЛИ возвращает истину, когда истинно хотя бы одно из двух условий:

5 || 1 > 2) echo "Условие выполнено."; ?>

В коде выше команда echo будет выполнена, поскольку одно из условий истинно.

Все логические операторы в PHP

Между операторами && и and , а также между || и or есть небольшое различие - порядок выполнения.

Как вы знаете, умножение имеет больший приоритет, чем сложение. Так вот, операторы and и or имеют приоритет ниже, чем оператор присваивания = . Результат можно увидеть в следующем примере:

Странно, да? Поскольку у = приоритет выше, PHP воспримет код так:

($var = true) and false;

Т.е. сначала он присваивает переменной $var значение true , а затем происходит операция true and false , которая не имеет смысла, поскольку не влияет на значение переменной.

Ниже расположена таблица с приоритетами операторов. С некоторыми из них вы уже встречались. Чем выше оператор в таблице - тем выше его приоритет.

• ++ -- ~ (int) (float) (string) (array) (object) (bool) @
• * / %
• + - .
• < <= > >=
• == != === !== <> <=>
• ? : (тернарный оператор)
• = += -= *= **= /= .= %= &= |= ^= <<= >>=

Теперь мы можем определить, что приоритет операторов сравнения (==, != и т.д.) выше, чем у логических операторов. Эта информация пригодится нам для выполнения задачи.

PHP поддерживает следующие стандартные логические операторы : "AND" и "&&" (логическое И), "OR" и "||" (логическое ИЛИ), "!" (логическое НЕ) и "XOR" (исключающее ИЛИ). Все они используются в логических выражениях для определения того или иного хода выполнения программы в зависимости от возвращаемого выражением результата и относятся к бинарным операторам, за исключением оператора "!" , который является унарным. При использовании логических операторов их операнды преобразуются к булевому типу данных (), а результат зависит от приведенных логических значений операндов и вида логического оператора (см. таблицу №1).

Таблица №1. Логические операторы

Разница между операторами "AND" и "&&" , а также "OR" и "||" заключается в том, что операторы "AND" , "OR" и "XOR" имеют более низкий приоритет, который даже ниже, чем у операторов присваивания (см. таблицу операторов PHP ).

Важно понимать, как интерпретатор обрабатывает логические выражения. Если в выражении с оператором "||" первый (левый) операнд будет иметь значение true или в выражении с оператором "&&" первый операнд будет иметь значение false , то второй (правый) операнд уже вычисляться не будет. Это связано с тем, что конечный результат в таких случаях уже не изменится (см. таблицу №1), а следовательно отпадает и необходимость тратить время на обработку кода второго операнда. Однако при этом нужно быть внимательным и не помещать в правый операнд код, от которого может зависеть правильная работа программы.

Использование логических операторов показано в примере №2.

false $a=0||false; //Теперь $a==true, т.к. 5->true и 8->true $a=5&&8; //Теперь $a==false, т.к. "0"->false $a="0"&&8; //Теперь $a==true $a=!false; //Теперь $a==false, т.к. 5->true $a=!5; /* Функция foo() не будет вызываться из-за шунтов */ $a=(false&&foo()); $b=(true||foo()); $c=(false and foo()); $d=(true or foo()); /* Отличие "||" от "or" и "&&" от "and" */ //Действует как ($a=(false||true)) $a=false||true; //Действует как (($a=false) or true) $a=false or true; //Действует как ($a=(false&&true)) $a=false&&true; //Действует как (($a=false) and true) $a=false and true; //Теперь $a==5, действует как (($a=5) xor 0) $a=5 xor 0; //Теперь $a==5, действует как (($a=5) and 0) $a=5 and 0; //Теперь $a==5, действует как (($a=5) or 0) $a=5 or 0; //Теперь $a==true, действует как ($a=(5||0)) $a=5||0; //Теперь $a==false, действует как ($a=(5&&0)) $a=5&&0; //Теперь $a==true, действует как ($a=(5 xor 6)) $a=(5 xor 6); ?>

Пример №2. Использование логических операторов

>> I have read a few of these responses and quite honestly didn"t find one that explained the differences between the "||" and "OR" operators.

The difference is explained in the link to on operator precedence.

The "||" operators are evaluated before assignment ("="), whereas the "or" operators are evaluated after the assignment. In your second example you are telling PHP to first assign the result of "(choice1 != false ? "hah" : "boo")" to $val, then "or" it against the rest of the statement. Try the example below and you will see what I mean (note the extra brackets to enforce precedence):

define ("choice1" , false );
define ("choice2" , "dog" );
define ("default1" , "other" );
$val = array();

$val [ "Test 1" ] = (choice1 != false ? "hah" : "boo" ) || (choice2 != false ? "hah2" : "boo2" ) || (default1 != false ? "hah3" : "boo3" );
$val [ "Test 1b" ] = ((choice1 != false ? "hah" : "boo" ) || (choice2 != false ? "hah2" : "boo2" ) || (default1 != false ? "hah3" : "boo3" ));
$val [ "Test 2" ] = (choice1 != false ? "hah" : "boo" ) or (choice2 != false ? "hah2" : "boo2" ) or (default1 != false ? "hah3" : "boo3" );
$val [ "Test 2b" ] = ((choice1 != false ? "hah" : "boo" ) or (choice2 != false ? "hah2" : "boo2" ) or (default1 != false ? "hah3" : "boo3" ));

Foreach ($val as $test => $result ) {
print ("$test: " ); var_dump ($result ); print "
\n
\n" ;
}
?>

test at hto dot com

Because the OR shorthand for an if block can produce more
readable code with less typing, it is tempting to produce functions that will return FALSE on failure or some other data type on success. Like mysql_connect, which "Returns a MySQL link identifier on success, or FALSE on failure."

The novice php php developer should avoid creating functions which might produce a FALSE on failure and an integer on success, if there is any chance that the integer might be zero.

blah blah blah ;
$i = give_me_liberty () or die("FATAL DB ERROR!" );
blah blah blah ;
?>

ironmo67 at yahoo dot com

Discovered a somewhat annoying different between PHP and Perl:

if (! some_function ()) return false ;
?>

cannot be rewritten as the prettier:

function some_function (){ return false ; }
some_function () or return false ;
?>

The following will work however:

function some_function (){ return false ; }
some_function () or die();
?>

Can you guess why? Simply, die() is a function and "return" is a statement (like the difference between print() and echo, sort of). This is really to bad because I find the if(!){} version tired and unreadable, but hey, it"s better than if (some_c_function == 0) { do something }.

A lot of the discussion below could have been avoided simply by being clear that &, | and ^ are *not* logical operators. That"s why they"re not listed on this page. They"re operators that act on the binary representations of numbers. They do not take logical values (i.e., "true" or "false") as arguments without first converting them to the numbers 1 and 0 respectively. Nor do they return logical values, but numbers. Sure, you can later treat those numbers as though they were logical values (in which case 0 is cast to "false" and anything else is cast to "true"), but that"s a consequence of PHP"s type casting rules, and nothing to do with the behaviour of the operators.

If you want logical operations, use logical operators; if you want bitwise operations, use bitwise operators ... using one for the other seems like a good way to make things difficult.

kws_ at hotpop dot com

"Just Because You Can, Doesn"t Mean You Should."

I also feel that circumventing short-circuit evaluation and relying on side-effects in conditional expressions is exercising bad style. Writing code that documents itself using clear and straightforward constructs strikes me as a much better practice than using a convoluted and difficult-to-read expression and explaining it with comments (or worse yet, not documenting it at all!) Indeed, source code should be written for the programmer"s eyes more so than the computer"s.

Utilizing the bitwise operators in a logical context could violates the expectations of the reader and may create confusion because bitwise operators imply bit-field operands.

I also feel that assuming that short-circuit evaluation is best for logical constructs IS within the compiler"s "rights", since when logical operators are used for their intended purpose, the assumptions that short-circuiting makes *ARE* logical, and do (once again, when used correctly) optimize evaluation of logical expressions.

It is not my intention to directly flame or insult any individual, but only to discourage the use of poor style and to encourage new (and even some experienced) programmers to write clear and verbose code, and to think about the programmers, rather than the computers that might end up trying to decipher your creations.

In answer to braintreno:

The second example you brought is the correct way to do it! It is not convoluted logic at all, it is what makes your code readable by not relying on obscure side effects!! It is much easier to read than the first one and it is by far easier to maintain.

For the idea to let a CheckThisOrOther() funtion echo information to the user alone, you should be stripped of your coding licence. If i ever had to maintain on of your scripts, I"d have to hate you.

This is not meant as flame bating as it might sound! Source code is not written for computers to execute, but for coders to read! Keep that at heart and your co-workers will thank you for it!

braintrino

Shadedecho"s post to force evaluation of both OR expression is actually exactly what should be done to suppress short-circuit optimization.

There are many occasions that you don"t want the compiler to short-circuit any evaluation, especially when you want to do an and/or situation. The short-circuit evaluation does an OR operation but not an AND/OR operation!!!

For instance, if I want the check the user"s query form to see if the user has missed answering any entry AND/OR if the user had duplicated the same answer for more than one entry, then I need to send the form back to the client informing what I want to be corrected.

Function SomeAnswersAreMissing()
{
...
echo "Oops! You missed answering some questions.";
return TRUE;
}

Function SomeAnswersAreDuplicated()
{
...
echo "Oops! You can answer both the same way.";
return TRUE;
}

If (SomeAnswersAreMissing() || SomeAnswersAreDuplicated())
SendFormAgain();

If I do that, the user will only see the missing answer warning but not the duplicated answer warning, even if both are true. This is not informative to the user because he/she will have to re-submit the form twice before he/she realized everything he/she did wrong, and frustrate the hack out of them. That is not user-friendly.

If (SomeAnswersAreMissing() | SomeAnswersAreDuplicated())
SendFormAgain();

Then both warning messages are sent at the same time, and the user can correct it in one re-send.

Thank shadedecho, I had been looking for a way to override the compiler"s stupid short-circuit optimization. The computer cannot just assume that short-circuiting is the best:(

BTW, of course you can do:

$you_made_a_mistake = false;

If (SomeAnswersAreMissing())

if (SomeAnswersAreDuplicated())
$you_made_a_mistake = true;

If ($you_made_a_mistake)
SendFormAgain();

But that is convoluted logic!!!

hop

Dear Newbie,

(as i don"t see such ideas creeping up in experienced programmers" minds...)

Please don"t pay attantion to shadedecho"s post from 14-Mar-2003 04:02! He is heavily relying on obscure side effects, which is not only very bad programming practice, but also does not achieve the optimization he thinks it is.

The proper way to make this

echo $a;
}

Work like shadedecho wants is (although the example as a whole is rather inapt):

$a .= blah();
$a .= blah2();

If ($a) { echo $a; }

If you read the discussion he links to you will find that he really wanted to get all distinct entries from two different db tables. Even there he is mistaken. The proper way to do this is to process the first table and then process the second table.
This is not only far more readable than the workaround with "|", it is also not the least slower.

shadedecho

It appears (after much frustrating but ultimately helpful searching and discussion on forums like tek-tips) that the
|| and the && are "short-circuited" as has been previously noted BUT the | and & operators (documented by PHP as bitwise operators) behave as their non-short-circuited counter-parts, respectively.

Function blah() {
echo "hello< br>";
return "from blah()< br>";
}

Function blah2() {
echo "world\< br>";
return "from blah2()< br>";
}

If (($a .= blah()) || ($a .= blah2())) {
echo $a;
}

This would result in the following output:

Hello
from blah()

Notice the "world" didn"t get echo"d and the "from blah2()" didn"t get concat"d into the $a variable, because the first assigment to $a was successful, so the "short-circuting" kicks in and the boolean test terminates without evaluating the rest of it.

HOWEVER, if you replace || with just | in that "if" statement, you get the output:

Hello
world
from blah()
from blah2()

Eureka! all parts of the boolean test are evaluated, in expected left-to-right fashion, and following all the normal precendence rules, so far as I can see.

This makes total sense... Using the bitwise operators, what is occurring is the bitwise-level operation on the result of two non-bitwise operations (the assignments). If a non-bitwise operation returns null (in other words, the value being assigned turns out to be null or 0), the bitwise operator would bind to that (or more appropriately, would "see" it) as a "0", otherwise it would see a non-zero (string of bits with at least one "1" in it).

Then a bitwise | is done on the two values, and if either is non-zero (has "1" bits in it) then the result will have those "1" bits in it (non-zero), and the if statement will interpret any non-zero value as true in a boolean test. Likewise, if both operands to the | were null or 0, then the result would be a zero value, which "if" would interpret as false.

The if statement above is doing a bitwise | on (in this case) two non-zero values (with "1"s in it at the bit level), so the | operation returns a non-zero value which is then reinterpreted by the if statement as TRUE!

So, in this special case where you are trying to string together non-short-circuited boolean tests, these operators work on their operands at the bitwise level, and since they are not comparison operators but mathematical operators, they can"t be short-circuited, and the resulting behavior is a non-short-circuited "boolean test".

I know, you must think I am crazy for trying to get around a built-in optimization like this, but I assure you there is a very good reason for it, and if you are interested, you can check out this thread as I have a very long post in there which explains what I was trying to do:

It is the 9th post down, where you will find my description of my database query"ing which i was wanting to optimize.

Which probably isn"t what you want.

This may be of aid to those who like their code to read like english, and might think that the precedence differences of these operators are relatively exotic: they aren"t.

As for me I ran into this problem because there is no symbolic logical XOR (for instance, no ^^) so I had to use XOR, and then figured that in similar places I"d ought to use AND and OR, and then my code broke:)

So now I"ve got to
$a = ($b xor $c);

Jesse Thompson
bend.com

yohgaki at hotmail dot com

In PHP4, "and", "or", "&&", "||" -- all are "short circuit" like in C/C++. In PHP3, I think it was not.

"Short circuit" means language stops evaluation of expression when conditions are determined. (Most language uses short circuit evaluation for logical condition)

$a = true;
$b = false;
if ($a || $b) {
}

This "if" statement only evaluate $a, since $a is true and whole condition must be true. (i.e. if $b is a function instead of value, the function will not be called)

muerte at web-ster dot com

I was hoping to find an operator similar to ||= functions in perl. My first thought would be:

$i = $i or "default"

But or doesn"t work like that. If you want to assign a default value to your variables only if they"re not already assigned you CAN however do:

$i or $i = "default"

The first example does NOT work because the or operator is not overloadable like it is in Perl.

dante at hearme dot com

I wanted to do something like this:

$choice1 = "";
$choice2 = "dog";
$default = "other";
$val = $choice1 || $choice2 || $default;

But then $val1 will only contain 1 or 0. Instead I did this:

$choice1 = "";
$choice2 = "dog";
$default = "other";
$val = $choice1 or $choice2 or $default;

Now $val contained the string "dog". That"s
weird that "or" is different from "||"...and I would
think that the "||" should be smart enough to handle
strings...the way PERL does. Guess not. Maybe it"s
a design choice.

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

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

Логические операции

Логические операции позволяют комбинировать логические значения (называемые также истинностными) для получения новых логических значений. Как показано в таблице ниже, в языке PHP поддерживаются стандартные логические операции (and, or, not и xor), причем первые две имеют альтернативные версии.

Операции && и || должны быть знакомы программистам, работающим с языком C. Операцию! обычно называют not, поскольку она становится отрицанием для того операнда, к которому применяется.

Чтобы проверить, имеют ли оба операнда значение TRUE, следует использовать оператор AND, который можно записать и как двойной амперсанд (&&). Оба оператора, AND и &&, являются логическими, их единственное отличие в том, что оператор && имеет более высокий приоритет, чем оператор AND. То же самое относится к операторам OR и ||. Оператор AND возвращает TRUE, только если оба операнда имеют значение TRUE; в противном случае возвращается значение FALSE.

Чтобы проверить, имеет ли хотя бы один операнд значение TRUE, следует использовать оператор OR, который можно записать и как двойную вертикальную линию (||). Этот оператор возвращает TRUE, если хотя бы один из операндов имеет значение TRUE.

При использовании оператора OR в программе могут появиться трудноуловимые логические ошибки. Если PHP обнаружит, что первый операнд имеет значение TRUE, он не станет вычислять значение второго операнда. Это позволяет экономить время исполнения, но вы должны внимательно следить за тем, чтобы код, от которого зависит корректная работа программы, не был помещен во второй операнд.

Проверить, имеет ли значение TRUE только один из операндов (но не оба сразу), позволяет оператор XOR. Этот оператор возвращает значение TRUE, если один и только один из операндов имеет значение TRUE. Если оба операнда имеют значение TRUE, оператор вернет значение FALSE.

Инвертировать логическое значение можно с помощью оператора NOT, который часто записывается и в виде восклицательного знака (!). Он возвращает значение TRUE, если операнд имеет значение FALSE, и значение FALSE, если операнд имеет значение TRUE.

В таблице ниже приведены некоторые логические выражения и их результаты:

Операции сравнения

В таблице ниже показаны операции сравнения, которые могут применяться либо с числами, либо со строками:

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

Приоритет операций

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

можно переписать как

Инструкция if - else

Инструкция if позволяет исполнить блок кода, если условное выражение в этой инструкции имеет значение TRUE; в противном случае блок кода не исполняется. В качестве условия может применяться любое выражение, включающее проверки на ненулевое значение, равенство, NULL с участием переменных и значений, возвращаемых функциями.

Не важно, какие отдельные условные выражения составляют условное предложение. Если условие истинно, исполняется программный код, заключенный в фигурные скобки ({}). В противном случае PHP игнорирует его и переходит к проверке второго условия, проверяя все условные предложения, которые вы записали, пока не наткнется на инструкцию else , после чего автоматически выполнит этот блок. Инструкция else не является обязательной .

Синтаксис инструкции if:

If (условное выражение) { блок программного кода; }

Если в результате вычисления условного выражения получается значение TRUE, то блок программного кода, расположенный после него, будет исполнен. В следующем примере если переменная $username имеет значение "Admin", будет выведено приветственное сообщение. В противном случае ничего не произойдет:

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

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

Не забывайте закрывать фигурной скобкой блок кода в инструкции if, если вы поставили фигурную скобку в начале блока. В блоке else тоже должны быть открывающая и закрывающая фигурные скобки, как в блоке if.

Все это хорошо, кроме случаев, когда вам требуется проверить несколько условий подряд. Для этого подойдет инструкция elseif . Она позволяет проверять дополнительные условия, пока не будет найдено истинное или достигнут блок else. У каждой инструкции elseif есть собственный блок кода, размещаемый непосредственно после условного выражения инструкции elseif. Инструкция elseif идет после инструкции if и перед инструкцией else, если таковая имеется.

Синтаксис инструкции elseif немного сложнее, но следующий пример поможет вам разобраться в нем:

Здесь проверяется два условия, и, в зависимости от значения переменной $username, выполняются разные действия. И еще есть возможность что-то сделать, если значение переменной отличается от первых двух.

Тернарный оператор?:

Оператор?: – это тернарный (трехместный) оператор, который принимает три операнда. Он работает аналогично инструкции if, но возвращает значение одного из двух выражений. Выражение, которое будет вычисляться, определяется условным выражением. Двоеточие (:) служит разделителем выражений:

(условие) ? вычислить_если_условие_истинно: вычислить_если_условие_ложно;

В примере ниже проверяется значение, и в зависимости от его значения (TRUE или FALSE) возвращаются разные строки:

Вполне очевидно, что приведенный выше оператор эквивалентен следующему оператору:

Инструкция switch

Инструкция switch сравнивает выражение с несколькими значениями. Как правило, в качестве выражения используется переменная, в зависимости от значения которой должен быть исполнен тот или иной блок кода. Например, представим себе переменную $action, которая может иметь значения "ADD" (добавить), "MODIFY" (изменить) и "DELETE" (удалить). Инструкция switch позволяет легко определить блок кода, который должен исполняться для каждого из этих значений.

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

Инструкция switch берет значение, стоящее рядом с ключевым словом switch, и начинает сравнивать его со всеми значениями, стоящими рядом с ключевыми словами case , в порядке их расположения в программе. Если соответствие не найдено, не исполняется ни один из блоков. Как только совпадение обнаружено, выполняется соответствующий блок кода. Расположенные ниже блоки кода также исполняются – до конца инструкции switch или до ключевого слова break . Это удобно для организации процесса, состоящего из нескольких последовательных шагов. Если пользователь уже проделал некоторые шаги, он сможет продолжить процесс с того места, на котором прервался.

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

Выбор по умолчанию

Если значение условного выражения не совпало ни с одним из предложенных в инструкциях case вариантов, инструкция switch и в этом случае позволяет что-то сделать, примерно как инструкция else конструкции if, elseif, else. Для этого нужно последним вариантом в списке выбора сделать инструкцию default :

Кроме обычного, инструкция switch поддерживает альтернативный синтаксис – конструкцию из ключевых слов switch/endswitch , определяющих начало и конец инструкции вместо фигурных скобок:

Прерывание исполнения

Если должен быть исполнен только блок кода, соответствующий определенному значению, то в конце этого блока следует вставить ключевое слово break. Интерпретатор PHP, встретив ключевое слово break, перейдет к исполнению строки, расположенной после закрывающей фигурной скобки инструкции switch (или ключевого слова endswitch). Но если не использовать инструкцию break то проверка продолжается в последующих ветвях case конструкции switch. Ниже показан пример:

Если переменная $action будет иметь значение "ASSEMBLE ORDER", результат работы этого фрагмента будет следующим:

Собрать заказ. Упаковать. Доставить заказчику.

Если предположить, что стадия сборки уже была пройдена, и переменная $action имеет значение "PACKAGE", то будет получен следующий результат:

Упаковать. Доставить заказчику.

Иногда, отсутствие операторов break бывает полезным, как в приведенном примере, где формируются стадии заказа, но в большинстве случаев следует использовать этот оператор.