PHP
операторы

Вступление

замечания

Операторы строк (. И. =)

Есть только два строковых оператора:

• Конкатенация двух строк (точка):

  $a = "a";
  $b = "b";
  $c = $a . $b; // $c => "ab"
  

• Конкатенация назначения (точка =):

  $a = "a";
  $a .= "b"; // $a => "ab"
  

Основное назначение (=)

$a = "some string";

приводит к $a имеющему значение some string .

Результатом выражения присваивания является назначаемое значение. Обратите внимание, что один знак равенства = НЕ для сравнения!

$a = 3;
$b = ($a = 5);

делает следующее:

1. Строка 1 назначает от 3 до $a .
2. Строка 2 присваивает от 5 до $a . Это выражение также дает значение 5 .
3. Строка 2 затем присваивает результат выражения в круглых скобках ( 5 ) равным $b .

Таким образом: как $a и $b теперь имеют значение 5 .

Комбинированное присвоение (+ = и т. Д.)

Комбинированные операторы присваивания являются ярлыком для операции над некоторой переменной и последующим присвоением этой новой переменной этой переменной.

Арифметика:

$a = 1;   // basic assignment
$a += 2; // read as '$a = $a + 2'; $a now is (1 + 2) => 3
$a -= 1; // $a now is (3 - 1) => 2
$a *= 2; // $a now is (2 * 2) => 4
$a /= 2; // $a now is (16 / 2) => 8
$a %= 5; // $a now is (8 % 5) => 3 (modulus or remainder)

// array +
$arrOne = array(1);
$arrTwo = array(2);
$arrOne += $arrTwo;

Обработка нескольких массивов вместе

$a **= 2; // $a now is (4 ** 2) => 16 (4 raised to the power of 2)

Комбинированная конкатенация и назначение строки:

$a = "a";
$a .= "b"; // $a => "ab"

Комбинированные бинарные операторы присваивания:

$a = 0b00101010;  // $a now is 42
$a &= 0b00001111; // $a now is (00101010 & 00001111) => 00001010 (bitwise and)
$a |= 0b00100010; // $a now is (00001010 | 00100010) => 00101010 (bitwise or)
$a ^= 0b10000010; // $a now is (00101010 ^ 10000010) => 10101000 (bitwise xor)
$a >>= 3;         // $a now is (10101000 >> 3) => 00010101 (shift right by 3)
$a <<= 1;         // $a now is (00010101 << 1) => 00101010 (shift left by 1)

Изменение приоритета оператора (с круглыми скобками)

Порядок, в котором операторы оцениваются, определяется приоритетом оператора (см. Также раздел «Примечания»).

В

$a = 2 * 3 + 4;

$a получает значение 10, потому что сначала оценивается 2 * 3 (умножение имеет более высокий приоритет, чем добавление), что дает результат 6 + 4 , который равен 10.

Приоритет может быть изменен с помощью круглых скобок: в

$a = 2 * (3 + 4);

$a получает значение 14, потому что сначала оценивается (3 + 4) .

ассоциация

Левая ассоциация

Если предел двух операторов равен, ассоциативность определяет группировку (см. Также раздел «Примечания»):

$a = 5 * 3 % 2; // $a now is (5 * 3) % 2 => (15 % 2) => 1

* и % имеют одинаковый приоритет и левую ассоциативность. Поскольку умножение происходит сначала (слева), оно сгруппировано.

$a = 5 % 3 * 2; // $a now is (5 % 3) * 2 => (2 * 2) => 4

Теперь оператор модуля встречается первым (слева) и поэтому группируется.

Правильная ассоциация

$a = 1;
$b = 1;
$a = $b += 1;

Оба значения $a и $b теперь имеют значение 2 потому что $b += 1 сгруппировано, а затем результат ( $b равен 2 ) присваивается $a .

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

равенство

Для базового тестирования равенства используется равный оператор == . Для более полных проверок используйте идентичный оператор === .

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

Например, пример ниже будет отображать «a и b равны», но не «a и b идентичны».

$a = 4;
$b = '4';
if ($a == $b) {
    echo 'a and b are equal'; // this will be printed
}
if ($a === $b) {
    echo 'a and b are identical'; // this won't be printed
}

При использовании оператора равенства числовые строки передаются в целые числа.

Сравнение объектов

=== сравнивает два объекта, проверяя, являются ли они точно таким же экземпляром . Это означает, что new stdClass() === new stdClass() разрешает false, даже если они создаются одинаково (и имеют точно такие же значения).

== сравнивает два объекта, рекурсивно проверяя, равны ли они ( глубокие равны ). Это означает, что для $a == $b , если $a и $b :

1. того же класса
2. имеют одинаковые свойства, включая динамические свойства
3. для каждого свойства $property set, $property $a->property == $b->property истинно (следовательно, рекурсивно проверяется).

Другие широко используемые операторы

Они включают:

1. Больше ( > )
2. Lesser Than ( < )
3. Больше или равно ( >= )
4. Меньше или равно ( <= )
5. Не равно ( != )
6. Не одинаково равно ( !== )

1. Greater Than : $a > $b , возвращает true если значение $a больше, чем $b , в противном случае возвращает false.

Пример :

var_dump(5 > 2); // prints bool(true)
var_dump(2 > 7); // prints bool(false)

2. Lesser Than : $a < $b , возвращает true если значение $a меньше значения $b , в противном случае возвращает false.

Пример :

var_dump(5 < 2); // prints bool(false)
var_dump(1 < 10); // prints bool(true)

3. Больше или равно: $a >= $b , возвращает true если значение $a больше или равно $b или равно $b , в противном случае возвращает false .

Пример :

var_dump(2 >= 2); // prints bool(true)
var_dump(6 >= 1); // prints bool(true)
var_dump(1 >= 7); // prints bool(false)

4. Меньше, чем равное : $a <= $b , возвращает значение true если значение $a меньше или равно $b или равно $b , в противном случае возвращает значение false .

Пример :

var_dump(5 <= 5); // prints bool(true)
var_dump(5 <= 8); // prints bool(true)
var_dump(9 <= 1); // prints bool(false)

5/6. Не равный / идентичный: Чтобы перефразировать предыдущий пример равенства, в приведенном ниже примере будет отображаться «a и b не идентичны», но не «a и b не равны».

$a = 4;
$b = '4';
if ($a != $b) {
    echo 'a and b are not equal'; // this won't be printed
}
if ($a !== $b) {
    echo 'a and b are not identical'; // this will be printed
}

Оператор космического корабля (<=>)

PHP 7 представляет новый тип оператора, который может использоваться для сравнения выражений. Этот оператор будет возвращать -1, 0 или 1, если первое выражение меньше, равно или больше второго выражения.

// Integers
print (1 <=> 1); // 0
print (1 <=> 2); // -1
print (2 <=> 1); // 1

// Floats
print (1.5 <=> 1.5); // 0
print (1.5 <=> 2.5); // -1
print (2.5 <=> 1.5); // 1
 
// Strings
print ("a" <=> "a"); // 0
print ("a" <=> "b"); // -1
print ("b" <=> "a"); // 1

Объекты не сопоставимы, и поэтому это приведет к неопределенному поведению.

Этот оператор особенно полезен при написании пользовательской функции сравнения с использованием usort , uasort или uksort . Например, для массива объектов, которые будут отсортированы по их weight свойству, анонимная функция может использовать <=> для возврата значения, ожидаемого функциями сортировки.

usort($list, function($a, $b) { return $a->weight <=> $b->weight; });

В PHP 5 это потребовало бы более сложного выражения.

usort($list, function($a, $b) {
    return $a->weight < $b->weight ? -1 : ($a->weight == $b->weight ? 0 : 1);
});

Оператор Null Coalescing (??)

Null coalescing - новый оператор, введенный в PHP 7. Этот оператор возвращает свой первый операнд, если он установлен, а не NULL . В противном случае он вернет свой второй операнд.

Следующий пример:

$name = $_POST['name'] ?? 'nobody';

эквивалентен обоим:

if (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

а также:

$name = isset($_POST['name']) ? $_POST['name'] : 'nobody'; 

Этот оператор также может быть цепным (с право-ассоциативной семантикой):

$name = $_GET['name'] ?? $_POST['name'] ?? 'nobody';

что эквивалентно:

if (isset($_GET['name'])) {
    $name = $_GET['name'];
} elseif (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

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

$firstName = "John";
$lastName = "Doe";
echo $firstName ?? "Unknown" . " " . $lastName ?? "";

Это будет выводить только John , и если его $ firstName равно null, а $ lastName - Doe он выведет Unknown Doe . Чтобы вывести John Doe , мы должны использовать круглые скобки, подобные этому.

$firstName = "John";
$lastName = "Doe";
echo ($firstName ?? "Unknown") . " " . ($lastName ?? "");

Это выведет John Doe вместо John .

instanceof (оператор типа)

Для проверки того, является ли какой-либо объект определенным классом, оператор (двоичный) instanceof может использоваться с PHP версии 5.

Первым (левым) параметром является объект для тестирования. Если эта переменная не является объектом, instanceof всегда возвращает false . Если используется константное выражение, возникает ошибка.

Второй (правый) параметр - это класс для сравнения. Класс может быть предоставлен как само имя класса, строковая переменная, содержащая имя класса (а не строковая константа!) Или объект этого класса.

class MyClass {
}

$o1 = new MyClass();
$o2 = new MyClass();
$name = 'MyClass';

// in the cases below, $a gets boolean value true
$a = $o1 instanceof MyClass;
$a = $o1 instanceof $name;
$a = $o1 instanceof $o2;

// counter examples:
$b = 'b';
$a = $o1 instanceof 'MyClass'; // parse error: constant not allowed
$a = false instanceof MyClass; // fatal error: constant not allowed
$a = $b instanceof MyClass;    // false ($b is not an object)

instanceof также может использоваться для проверки того, является ли объект некоторого класса, который расширяет другой класс или реализует некоторый интерфейс:

interface MyInterface {
}

class MySuperClass implements MyInterface {
}

class MySubClass extends MySuperClass {
}

$o = new MySubClass();

// in the cases below, $a gets boolean value true    
$a = $o instanceof MySubClass;
$a = $o instanceof MySuperClass;
$a = $o instanceof MyInterface;

( Для того, чтобы проверить , является ли объект не какого - то класса, не оператор ! ) Может быть использован:

class MyClass {
}

class OtherClass {
}

$o = new MyClass();
$a = !$o instanceof OtherClass; // true

Обратите внимание, что круглые скобки вокруг $o instanceof MyClass не нужны, потому что instanceof имеет более высокий приоритет, чем ! , хотя это может сделать код более удобным для чтения с круглыми скобками.

Предостережения

Если класс не существует, вызываемые функции автозагрузки вызываются, чтобы попытаться определить класс (это тема, выходящая за рамки этой части Документации!). В версиях PHP до 5.1.0 оператор instanceof также запускает эти вызовы, тем самым фактически определяя класс (и если класс не может быть определен, произойдет фатальная ошибка). Чтобы этого избежать, используйте строку:

// only PHP versions before 5.1.0!
class MyClass {
}

$o = new MyClass();
$a = $o instanceof OtherClass; // OtherClass is not defined!
// if OtherClass can be defined in a registered autoloader, it is actually
// loaded and $a gets boolean value false ($o is not a OtherClass)
// if OtherClass can not be defined in a registered autoloader, a fatal
// error occurs.

$name = 'YetAnotherClass';
$a = $o instanceof $name; // YetAnotherClass is not defined!
// $a simply gets boolean value false, YetAnotherClass remains undefined.

Начиная с версии PHP 5.1.0, зарегистрированные автозагрузчики больше не вызывают в этих ситуациях.

Старые версии PHP (до 5.0)

В более ранних версиях PHP (до 5.0) функция is_a может использоваться для определения того, какой объект принадлежит некоторому классу. Эта функция устарела в PHP версии 5 и не указана в PHP версии 5.3.0.

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

Тернарный оператор можно рассматривать как оператор inline if . Он состоит из трех частей. operator и два результата. Синтаксис выглядит следующим образом:

$value = <operator> ? <true value> : <false value>

Если operator оценивается как true , значение в первом блоке будет возвращено ( <true value> ), иначе будет возвращено значение во втором блоке ( <false value> ). Поскольку мы устанавливаем значение $value для результата нашего тернарного оператора, он сохраняет возвращаемое значение.

Пример:

$action = empty($_POST['action']) ? 'default' : $_POST['action'];

$action будет содержать строку 'default' если empty($_POST['action']) значение true. В противном случае оно будет содержать значение $_POST['action'] .

Выражение (expr1) ? (expr2) : (expr3) оценивает expr2 если expr1 оценивается как true , а expr3 если expr1 оценивается как false .

Можно исключить среднюю часть тернарного оператора. Expression expr1 ?: expr3 возвращает expr1 если expr1 значение TRUE и expr3 противном случае. ?: часто называют оператором Элвиса .

Это ведет себя как оператор Null Coalescing ?? , за исключением того, что ?? требует, чтобы левый операнд был точно null а ?: пытается разрешить левый операнд в логическое и проверить, разрешает ли он логическое значение false .

Пример:

function setWidth(int $width = 0){
    $_SESSION["width"] = $width ?: getDefaultWidth();
}

В этом примере setWidth принимает параметр ширины или значение по умолчанию 0 для изменения значения сеанса ширины. Если $width равно 0 (если $width не указана), который будет разрешен для boolean false, вместо этого используется значение getDefaultWidth() . Функция getDefaultWidth() не будет вызываться, если $width не разрешалось для boolean false.

Дополнительные сведения о преобразовании переменных в boolean см. В разделе Типы .

Приращение (++) и Decrementing Operators (-)

Переменные могут быть увеличены или уменьшены на 1 с ++ или -- , соответственно. Они могут либо предшествовать, либо преуспеть в переменных и слегка варьироваться семантически, как показано ниже.

$i = 1;
echo $i; // Prints 1

// Pre-increment operator increments $i by one, then returns $i
echo ++$i; // Prints 2

// Pre-decrement operator decrements $i by one, then returns $i
echo --$i; // Prints 1

// Post-increment operator returns $i, then increments $i by one
echo $i++; // Prints 1 (but $i value is now 2)

// Post-decrement operator returns $i, then decrements $i by one
echo $i--; // Prints 2 (but $i value is now 1)

Более подробную информацию об операторах увеличения и уменьшения можно найти в официальной документации .

Оператор выполнения (``)

Оператор выполнения PHP состоит из backticks (``) и используется для запуска команд оболочки. Результат команды будет возвращен и может поэтому храниться в переменной.

// List files
$output = `ls`;
echo "<pre>$output</pre>";

Обратите внимание, что оператор execute и shell_exec() даст тот же результат.

Логические операторы (&& / AND и || / OR)

В PHP существует две версии логических операторов AND и OR.

Заметим, что && и || операторы имеют более высокий приоритет, чем and и / or . См. Таблицу ниже:

Из-за этого безопаснее использовать && и || вместо and и / or .

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

Префикс побитовых операторов

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

// bitwise NOT ~: sets all unset bits and unsets all set bits
printf("%'06b", ~0b110110); // 001001

Операторы битмасс-битмаски

Побитовое И & : бит устанавливается только в том случае, если он установлен в обоих операндах

printf("%'06b", 0b110101 & 0b011001); // 010001

Побитовое ИЛИ | : бит устанавливается, если он установлен в любом или обоих операндах

printf("%'06b", 0b110101 | 0b011001); // 111101

Побитовое XOR ^ : бит устанавливается, если он установлен в один операнд и не установлен в другом операнде, т. Е. Только если этот бит находится в другом состоянии в двух операндах

printf("%'06b", 0b110101 ^ 0b011001); // 101100

Пример использования битмасков

Эти операторы могут использоваться для управления битмашками. Например:

file_put_contents("file.log", LOCK_EX | FILE_APPEND);

Здесь | оператор используется для объединения двух битмасков. Хотя + имеет тот же эффект, | подчеркивает, что вы комбинируете битмаски, а не добавляете два нормальных целых числа.

class Foo{
    const OPTION_A = 1;
    const OPTION_B = 2;
    const OPTION_C = 4;
    const OPTION_A = 8;

    private $options = self::OPTION_A | self::OPTION_C;

    public function toggleOption(int $option){
        $this->options ^= $option;
    }

    public function enable(int $option){
        $this->options |= $option; // enable $option regardless of its original state
    }

    public function disable(int $option){
        $this->options &= ~$option; // disable $option regardless of its original state,
                                    // without affecting other bits
    }

    /** returns whether at least one of the options is enabled */
    public function isOneEnabled(int $options) : bool{
        return $this->options & $option !== 0;
        // Use !== rather than >, because 
        // if $options is about a high bit, we may be handling a negative integer
    }

    /** returns whether all of the options are enabled */
    public function areAllEnabled(int $options) : bool{
        return ($this->options & $options) === $options;
        // note the parentheses; beware the operator precedence
    }
}

Этот пример (при условии, что $option всегда содержит только один бит) использует:

• Оператор ^ удобно переключать битмаски.
• | оператора, чтобы установить бит, пренебрегая его исходным состоянием или другими битами
• оператор ~ для преобразования целого числа с одним битом, установленным в целое число, причем только один бит не задан
• Оператор & отменяет бит, используя эти свойства & :
  • Так как &= с битом набора ничего не сделает ( (1 & 1) === 1 , (0 & 1) === 0 ), то выполнение &= с целым числом с единственным не установленным битом будет только отменять этот бит , не влияя на другие биты.
  • &= с несоответствующим битом будет отменять этот бит ( (1 & 0) === 0 , (0 & 0) === 0 )
• Использование оператора & с другой битовой маской отфильтровывает все остальные биты, не заданные в этой битовой маске.
  • Если на выходе установлены какие-либо биты, это означает, что включена одна из опций.
  • Если на выходе есть все бит битовой маски, это означает, что все параметры в битовой маске включены.

Имейте в виду , что эти операторы сравнения: ( < > <= >= == === != !== <> <=> ) имеют более высокий приоритет , чем эти операторы битовая-битовых масок: ( | ^ & ). Поскольку побитовые результаты часто сравниваются с использованием этих операторов сравнения, это общая ошибка, о которой нужно знать.

Операторы битового сдвига

Побитовый сдвиг влево << : сдвинуть все биты влево (более значимые) на заданное количество шагов и отбросить биты, превышающие размер int

<< $x эквивалентно отключению наивысших битов $x и умножению на $x th мощности 2

printf("%'08b", 0b00001011<< 2); // 00101100

assert(PHP_INT_SIZE === 4); // a 32-bit system
printf("%x, %x", 0x5FFFFFFF << 2, 0x1FFFFFFF << 4); // 7FFFFFFC, FFFFFFFF

Побитовое смещение вправо >> : сбросить самый низкий сдвиг и сдвинуть оставшиеся биты вправо (менее значимые)

>> $x эквивалентно делению на $x th степени 2 и отбрасывать нецелую часть

printf("%x", 0xFFFFFFFF >> 3); // 1FFFFFFF

Пример использования смещения битов:

Быстрое деление на 16 (более высокая производительность, чем /= 16 )

$x >>= 4;

В 32-битных системах это отбрасывает все биты в целое число, устанавливая значение 0. В 64-битных системах это приводит к сбою наиболее значимых 32 бит и сохраняет минимум

$x = $x << 32 >> 32;

Значимые 32 бита, эквивалентные $x & 0xFFFFFFFF

Примечание. В этом примере используется printf("%'06b") . Он выводит значение в 6 двоичных разрядов.

Операторы объектов и классов

Доступ к объектам или классам осуществляется с помощью оператора объекта ( -> ) и оператора класса ( :: .

class MyClass {
    public $a = 1;
    public static $b = 2;
    const C = 3;
    public function d() { return 4; }
    public static function e() { return 5; }
}

$object = new MyClass();
var_dump($object->a);   // int(1)
var_dump($object::$b);  // int(2)
var_dump($object::C);   // int(3)
var_dump(MyClass::$b);  // int(2)
var_dump(MyClass::C);   // int(3)
var_dump($object->d()); // int(4)
var_dump($object::d()); // int(4)
var_dump(MyClass::e()); // int(5)
$classname = "MyClass";
var_dump($classname::e()); // also works! int(5)

Обратите внимание, что после оператора объекта значение $ не должно быть записано ( $object->a вместо $object->$a ). Для оператора класса это не так, и необходимо $ . Для константы, определенной в классе, значение $ никогда не используется.

Также обратите внимание, что var_dump(MyClass::d()); разрешено только в том случае, если функция d() не ссылается на объект:

class MyClass {
    private $a = 1;
    public function d() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump(MyClass::d());   // Error!

Это приводит к ошибке «Неустранимая ошибка PHP: использование $ this, если не в контексте объекта»

Эти операторы оставили ассоциативность, которую можно использовать для «цепочки»:

class MyClass {
    private $a = 1;
    
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    
    public function get() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump($object->add(4)->get());  // int(5)

Эти операторы имеют наивысший приоритет (они даже не упоминаются в руководстве), даже выше этого clone . Таким образом:

class MyClass {
    private $a = 0;
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    public function get() {
        return $this->a;
    }
}

$o1 = new MyClass();
$o2 = clone $o1->add(2);
var_dump($o1->get()); // int(2)
var_dump($o2->get()); // int(2)

Значение $o1 добавляется до того, как объект клонируется!

Обратите внимание, что использование скобок для влияния приоритета не работает в PHP версии 5 и старше (это делается в PHP 7):

// using the class MyClass from the previous code
$o1 = new MyClass();
$o2 = (clone $o1)->add(2);  // Error in PHP 5 and before, fine in PHP 7
var_dump($o1->get()); // int(0) in PHP 7
var_dump($o2->get()); // int(2) in PHP 7