Операторы PHP

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

Вы можете ознакомиться со всеми операторами PHP далее.

Арифметические операторы PHP
Помните школьные основы арифметики? Описанные ниже операторы PHP работают таким же образом.

Пример Название Результат
-$a Отрицание Смена знака $a.
$a + $b Сложение Сумма $a и $b.
$a – $b Вычитание Разность $a и $b.
$a * $b Умножение Произведение $a и $b.
$a / $b Деление Частное от деления $a на $b.
$a % $b Деление по модулю Целочисленный остаток от деления $a на $b.
$a ** $b Возведение в степень Результат $a в степени $b. (появилось в PHP 5.6.0)

Операция деления (“/”) всегда возвращает вещественный тип, даже если оба значения были целочисленными (или строками, которые преобразуются в целые числа). В противном случае результат будет дробным.
Операция вычисления остатка от деления “%” работает только с целыми числами, так что применение ее к дробным может привести к нежелательному результату. Остаток $a % $b будет негативным, для негативных значений $a.

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

Логические операторы PHP
Логические операторы предназначены исключительно для работы с логическими выражениями и возвращают false илиtrue.
Приведем таблицу логических операторов PHP

Пример Название Результат
$a and $b Логическое ‘и’ TRUE если и $a, и $b TRUE.
$a or $b Логическое ‘или’ TRUE если или $a, или $b TRUE.
$a xor $b Исключающее ‘или’ TRUE если $a, или $b TRUE, но не оба.
! $a Отрицание TRUE если $a не TRUE.
$a && $b Логическое ‘и’ TRUE если и $a, и $b TRUE.
$a || $b Логическое ‘или’ TRUE если или $a, или $b TRUE.

Смысл двух разных вариантов для операторов “and” и “or” в том, что они работают с различными приоритетами.
Следует заметить, что вычисление логических выражений, содержащих такие операторы, идет всегда слева направо, при этом, если результат уже очевиден (например, false && что-то всегда дает false), то вычисления обрываются, даже если в выражении присутствуют вызовы функций. Например, в операторе $logic = 0&&(time()>100); стандартная функцияtime() никогда не будет вызвана.
Будьте осторожны с логическими операциями — не забывайте про удваивание символа. Обратите внимание, что, например, | и || — два совершенно разных оператора, один из которых может потенциально возвращать любое число, а второй — только false и true.

Операторы инкремента (++) и декремента (–) не работают с логическими переменными.

Строковые операторы PHP
В PHP есть два оператора для работы со строками. Первый – оператор конкатенации (‘.’), который возвращает объединение левого и правого аргумента. Второй – оператор присвоения с конкатенацией, который присоединяет правый аргумент к левому. Приведем конкретный пример:

<?php
$a = “Hello “;
$b = $a . “World!”; // $b содержит строку “Hello World!”
$a = “Hello “;
$a .= “World!”;     // $a содержит строку “Hello World!”
?>

 

Побитовые операторы PHP

Побитовые операции предназначены для работы (установки/снятия/проверки) групп битов в целой переменной. Биты целого числа — это не что иное, как отдельные разряды того же самого числа, записанного в двоичной системе счисления. Например, в двоичной системе число 12 будет выглядеть как 1100, а 2 — как 10, так что выражение 12|2вернет нам число 14 (1110 в двоичной записи). Если переменная не целая, то она вна-
чале округляется, а уж затем к ней применяются перечисленные ниже операторы.
Для представления одного числа используются 32 бита:
*
0000 0000 0000 0000 0000 0000 0000 0000 – это ноль;
*
0000 0000 0000 0000 0000 0000 0000 0001 – это 1;
*
0000 0000 0000 0000 0000 0000 0000 0010 – это 2;
*
0000 0000 0000 0000 0000 0000 0000 0011 – это 3;
*
0000 0000 0000 0000 0000 0000 0000 0100 – это 4;
*
0000 0000 0000 0000 0000 0000 0000 0101 – это 5;
*

*
0000 0000 0000 0000 0000 0000 0000 1111 – это 15;
*

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

Пример Название Результат
$a & $b Побитовое ‘и’ Устанавливаются только те биты, которые установлены и в $a, и в $b.
$a | $b Побитовое ‘или’ Устанавливаются те биты, которые установлены либо в $a, либо в $b.
$a ^ $b Исключающее или Устанавливаются только те биты, которые установлены либо только в $a, либо только в $b
~ $a Отрицание Устанавливаются те биты, которые в $a не установлены, и наоборот.
$a << $b Сдвиг влево Все биты переменной $a сдвигаються на $b позиций влево (каждая позиция подразумевает ‘умножение на 2’)
$a >> $b Сдвиг вправо Все биты переменной $a сдвигаються на $b позиций вправо (каждая позиция подразумевает ‘деление на 2’)

В случае если присутствуют и левый, и правый операнды строки, побитовые операции будут работать с их ASCII-представлениями. Пример:

<?php
echo 12 ^ 9; // Выведет ‘5’
echo “12” ^ “9”; // Отобразит симовол возврата каретки (ascii 8)
                  // (‘1’ (ascii 49)) ^ (‘9’ (ascii 57)) = #8
echo “hallo” ^ “hello”; // Выведет следующие ASCII-значения: #0 #4 #0 #0 #0
                         // ‘a’ ^ ‘e’ = #4
?>

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

Операторы присвоения в PHP
Базовый оператор присвоения обозначается как =. На первый взгляд может показаться, что это оператор “равно”. На самом деле это не так. В действительности, оператор присвоения означает, что левый операнд получает значение правого выражения, (т.е. устанавливается результирующим значением).
Результатом выполнения оператора присвоения является само присвоенное значение. Таким образом, результат выполнения $a = 3 будет равен 3. Это позволяет использовать конструкции вида:

<?php
$a = ($b = 4) + 5; // результат: $a установлена значением 9, переменной $b присвоено 4.
?>


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

<?php
$a = 3;
$a += 5; // устанавливает $a значением 8, аналогично записи: $a = $a + 5;
$b = “Hello “;
$b .= “There!”; // устанавливает $b строкой “Hello There!”,  как и $b = $b . “There!”;
?>

Обратите внимание, что присвоение копирует оригинальную переменную в новую (присвоение по значению), таким образом все последующие изменения одной из переменных на другой никак не отражаются. Начиная с PHP 4, также поддерживается присваивание по ссылке, используя синтаксис $var = &$othervar; ‘Присвоение по ссылке’ означает, что обе переменные указывают на одни и те же данные и никакого копирования не происходит. Подробно о ссылках вы можете узнать здесь.

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

Операторы сравнения, как это видно из их названия, позволяют сравнивать между собой два значения.
Это в своем роде уникальные операции, потому что независимо от типов своих аргументов они всегда возвращают одно из двух: false или true. Операции сравнения позволяют сравнивать два значения между собой и, если условие выполнено, возвращают true, а если нет — false.
В PHP разрешается сравнивать только скалярные переменные. Массивы и объекты в PHP сравнивать нельзя. Их даже нельзя сравнивать на равенство (при помощи оператора ==), но при выполнении такой операции PHP не выдает предупреждения. Так что удивившись как-то раз, почему два совершенно разных массива при сравнении их с помощью== оказываются вдруг одинаковыми, вспомните, что перед сравнением оба операнда преобразуются в слово array, которое потом и сравнивается.
Подробно о сравнении массивов смотрите здесь.
Также вам возможно будет интересно ознакомиться с разделом сравнение типов, в котором приведено большое количество соответствующих примеров.
Операторы сравнения:

Пример Название Результат
$a == $b Равно TRUE если $a равно $b.
$a === $b Тождественно равно TRUE если $a равно $b и имеет тот же тип. (Добавлено в PHP 4)
$a != $b Не равно TRUE если $a не равно $b.
$a <> $b Не равно TRUE если $a не равно $b.
$a !== $b Тождественно не равно TRUE если $a не равно $b или в случае, если они разных типов (Добавлено в PHP 4)
$a < $b Меньше TRUE если $a строго меньше $b.
$a > $b Больше TRUE если $a строго больше $b.
$a <= $b Меньше или равно TRUE если $a is меньше или равно $b.
$a >= $b Больше или равно TRUE если $a больше или равно $b.

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

var_dump(“1” == “01”); // 1 == 1 -> true

switch (“a”) {
case 0:
echo “0”;
break;
case “a”: // Эта ветка никогда не будет достигнута, так как “a” уже сопоставленно с 0
echo “a”;
break;
}
?>
Еще одним условным оператором является тернарный оператор “?”:

<?php
// Пример использования тернарного оператора
$action = (empty($_POST[‘action’])) ? ‘default’ : $_POST[‘action’];
// Приведенный выше код аналогичен следующему блоку с использованием if/else
if (empty($_POST[‘action’])) {
     $action = ‘default’;
} else {
     $action = $_POST[‘action’];
}
?>

Выражение (expr1) ? (expr2) : (expr3) интерпретируется как expr2, если expr1 вычисляется в TRUE, или как expr3 еслиexpr1 вычисляется в FALSE.

Операторы инкремента и декремента в PHP
PHP, аналогично языку Си, поддерживает префиксные и постфиксные операторы инкремента и декремента.

Пример Название Действие
++$a Префиксный инкремент Увеличивает $a на единицу и возвращает значение $a.
$a++ Постфиксный инкремент Возвращает значение $a, а затем увеличивает $a на единицу.
–$a Префиксный декремент Уменьшает $a на единицу и возвращает значение $a.
$a– Постфиксный декремент Возвращает значение $a, а затем уменьшает $a на единицу.

Постфиксные операторы инкремента и декремента
Как и в языке Си, эти операторы увеличивают или уменьшают значение переменной, а в выражении возвращают значение переменной $a до изменения. Например:

$a=10;
$b=$a++;
echo “a=$a, b=$b”; // Выводит a=11, b=10

Как видите, сначала переменной $b присваивалось значение переменной $a, а уж затем был применён инкремент. Впрочем, выражение, значение которого присваивается переменной $b, может быть и сложнее — в любом случае, инкремент $a произойдет только после его вычисления. Такие операции называют постфиксными операциями инкремента.

Префиксные операторы инкремента и декремента

Существуют также операторы инкремента и декремента, которые указываются до, а не после имени переменной. Соответственно, и возвращают они значение переменной уже после изменения. Пример:

$a=10;
$b=–$a;
echo “a=$a, b=$b”; // Выводит a=9, b=9

Операции инкремента и декремента на практике применяются очень часто. Например, они встречаются практически в любом цикле for.

<?php
echo “<h3>Постфиксный инкремент</h3>”;
$a = 5;
echo “Должно быть 5: ” . $a++ . “<br />\n”;
echo “Должно быть 6: ” . $a . “<br />\n”;
echo “<h3>Префиксный инкремент</h3>”;
$a = 5;
echo “Должно быть 6: ” . ++$a . “<br />\n”;
echo “Должно быть 6: ” . $a . “<br />\n”;

Булевы типы не подлежат инкременту и декременту.

Операции с символьными переменными.

$i = ‘W’;
for($n=0; $n<6; $n++) echo ++$i . “\n”; /* Результат работы будет следующий: X Y Z AA AB AC */ ?>

Еще раз напомним, что инкремент или декремент булевых переменных не приводит ни к какому результату.

Операторы эквивалентности PHP

В PHP, начиная с PHP4 есть оператор тождественного сравнения — тройной знак равенства ===,
или оператор проверки на эквивалентность. PHP довольно терпимо относится к тому, что строки неявно преобразуются в числа, и наоборот.
Например, следующий код выведет, что значения переменных равны:

$a=10;
$b=”10″;
if($a==$b) echo “a и b равны”; // Выводит “a и b равны”
И это несмотря на то, что переменная $a представляет собой число, а $b — строку. Теперь рассмотрим несколько другой пример:

$a=0; // ноль
$b=””; // пустая строка
if($a==$b) echo “a и b равны”; // Выводит “a и b равны”

Хотя $a и $b явно не равны даже в обычном понимании этого слова, скрипт заявит, что они совпадают. Почему так происходит? Дело в том, что если один из операндов логического оператора может трактоваться как число, то оба операнда трактуются как числа. При этом пустая строка превращается в 0, который затем и сравнивается с нулем. Неудивительно, что оператор echo срабатывает.
Проблему решает оператор эквивалентности === (тройное равенство). Он не только сравнивает два выражения, но также их типы. Перепишем наш пример с использованием этого оператора:

$a=0; // ноль
$b=””; // пустая строка
if($a===$b) echo “a и b равны”; // Ничего не выводит
Вот теперь ничего выведено не будет. Но возможности оператора эквивалентности идут далеко за пределы сравнения простых переменных. С его помощью можно сравнивать также и массивы, объекты и т. д. Это бывает иногда очень удобно. Вот пример:

$a=array(’a’=>’aaa’);
$b=array(’b’=>’bbb’);
if($a==$b) echo “С использованием == a=b
“;
if($a===$b) echo “С использованием === a=b
“;

Если запустить представленный код, то будет выведено первое сообщение, но не второе.
Произойдет это по той причине, что, как мы уже говорили, операнды-массивы преобразуются в строки array, которые затем и будут сравниваться. Оператор === лишен этого недостатка, поэтому работает верно.
Для оператора === существует и его антипод — оператор !==

Операции с символьными переменными в PHP
PHP следует соглашениям Perl (в отличие от С) касательно выполнения арифметических операций с символьными переменными. Например в Perl ‘Z’+1 будет вычислено как ‘AA’, в то время как в C ‘Z’+1 будет вычислено как ‘[‘ ( ord(‘Z’) == 90, ord(‘[‘) == 91 ). Следует учесть, что к символьным переменным можно применять операцию инкремента, в то время как операцию декремента применять нельзя.

$i = ‘W’;
for($n=0; $n<6; $n++) echo ++$i . “\n”;

/* Результат работы будет следующий: X Y Z AA AB AC */

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

Приоритет операторов определяет, насколько “тесно” связанны между собой два выражения. Например, выражение 1 + 5 * 3 вычисляется как 16, а не 18, поскольку операция умножения (“*”) имеет более высокий приоритет, чем операция сложения (“+”). В случае, если операторы имеют одинаковый приоритет, они будут выполняться слева направо. Круглые скобки могут использоваться для принудительного указания необходимого порядка выполнения операторов. Например, выражение (1 + 5) * 3 вычисляется как 18.
В следующей таблице приведен список операторов, отсортированный по убыванию их приоритетов. Операторы, размещенные в одной строке имеют одинаковый приоритет и порядок их выполнения определяется исходя из ассоциативности.
Операторы с более высоким уровнем приоритета выполняются в первую очередь:

Приоритет
Оператор
Порядок выполнения
13
(постфикс)++ (постфикс)–
слева направо
12
++(префикс) –(префикс)
справа налево
11
* / %
слева направо
10
+ –
слева направо
9
<< >>
слева направо
8
< <= > >=
слева направо
7
== !=
слева направо
6
&
слева направо
5
^
слева направо
4
|
слева направо
3
&&
слева направо
2
||
слева направо
1
= += -= *= /= %= >>= <<== &= ^= |=
справа налево

Пример порядка выполнения операторов (ассоциативность):

<?php
   $a = 3 * 3 % 5; // (3 * 3) % 5 = 4
   $a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2
   $a = 1;
   $b = 2;
   $a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5
?>

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

Операторы исполнения внешних команд в PHP.

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

<?php
$output = `ls -al`;
echo “<pre>$output</pre>”;
?>

Примечание: обратные кавычки недоступны, в случае, если установлен безопасный режим или отключена функция shell_exec().

Операторы для работы с массивами PHP.

Приведем список операторов, работающих с массивами PHP:

Пример Название Результат
$a + $b Объединение Объединение массива $a и массива $b.
$a == $b Равно TRUE в случае, если $a и $b содержат одни и те же элементы.
$a === $b Тождественно равно TRUE в случае, если $a и $b содержат одни и те же элементы в том же самом порядке.
$a != $b Не равно TRUE если массив $a не равен массиву $b.
$a <> $b Не равно TRUE если массив $a не равен массиву $b.
$a !== $b Тождественно не равно TRUE если массив $a не равен тождественно массиву $b.

Оператор + присоединяет правый массив к массиву, размещенному слева НЕ перезаписывая элементы с дублирующимися ключами.

$b = array(“a” => “pear”, “b” => “strawberry”, “c” => “cherry”);

$c = $a + $b; // Объединение $a и $b
echo “Union of \$a and \$b: \n”;
var_dump($c);

$c = $b + $a; // Объединение $b и $a
echo “Union of \$b and \$a: \n”;
var_dump($c);
?>
После своего выполнения скрипт выводит следующее:

Union of $a and $b:
array(3) {
[“a”]=>
string(5) “apple”
[“b”]=>
string(6) “banana”
[“c”]=>
string(6) “cherry”
}
Union of $b and $a:
array(3) {
[“a”]=>
string(4) “pear”
[“b”]=>
string(10) “strawberry”
[“c”]=>
string(6) “cherry”
}
При сравнении элементы массива считаются идентичными, если совпадает и ключ, и соответствующее значение.

var_dump($a === $b); // bool(false)
?>

Операторы управления ошибками PHP.

PHP поддерживает один оператор управления ошибками: знак @. В случае, если он предшествует какому-либо выражению в PHP-коде, любые сообщения об ошибках, генерируемые этим выражением, будут проигнорированы.
В случае, если установлена опция track_errors, все генерируемые сообщения об ошибках будут сохраняться в переменной$php_errormsg. Эта переменная будет перезаписываться при возникновении каждой новой ошибки, поэтому в случае необходимости проверяйте ее сразу же.


Внимание: Оператор @ работает только с выражениями. Есть простое правило: если произвольная языковая конструкция возвращает значение, значит вы можете использовать предшествующий ей оператор @. Например, вы можете использовать @ перед именем переменной, произвольной функцией или вызовом include(), константой и так далее. В то же время вы не можете использовать этот оператор перед определением функции или класса, условными конструкциями, такими как if или foreach.

Внимание: Оператор @ не подавляет вывод ошибок, возникающих на стадии синтаксического разбора скрипта.

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

Операторы классов PHP.

Оператор проверки принадлежности к классу.

 

Оператор instanceof используется для определения того, является ли текущий объект экземпляром указанного класса.
Оператор instanceof был добавлен в PHP5. До этого использовалась функция is_a(), которая на данный момент не рекомендуется к применению, более предпочтительно использовать оператор instanceof.
<?php
class A { }
class B { }
$thing = new A;
if ($thing instanceof A) {
echo ‘A’;
} if ($thing instanceof B) {
echo ‘B’;
}
?>
Поскольку объект $thing является экземпляром класса A, и никак не B, то будет выполнен только первый, опирающийся на класс A, блок:
A

 

Заказать звонок
+
Жду звонка!