Побитовые операторы выполняют низкоуровневые манипуляции с битами в двоичных представлениях чисел. Эти операторы редко используются в программировании на PHP, поэтому если вы не знакомы с двоичным представлением целых чисел, то можете пропустить этот раздел. Побитовые операторы выполняют поразрядные операции булевой алгебры над отдельными битами операндов.
В наличии PHP есть 6 побитовых операторов:
Побитовое И (&)
Оператор & выполняет операцию логическое И над каждым битом своих операндов. Бит результата устанавливается, если соответствующий бит установлен в обоих операндах.
Пример работы оператора «Побитовое И»:
| И | 0011 |
| 0101 | |
| 0001 | |
Тоже самое только на примере PHP:
<?php $x = 3; // .$y; // ...0110 (6) ?>
$y; // ...0110 (6)
?>
Побитовое НЕ (~)
Оператор ~ (побитовое НЕ) представляет собой унарный оператор, указываемый перед своим единственным операндом. Он выполняет инверсию всех битов операнда. Из-за способа представления целых со знаком в PHP применение оператора ~ к значению эквивалентно изменению его знака и вычитанию 1.
Пример работы оператора «Побитовое НЕ»:
| НЕ | |
| 01 | |
| 10 | |
Тоже самое только на примере PHP:
<?php $y = 5; // ...0101 echo ~$y; // ...1010 (-6) ?>
Осталось рассмотреть два оператора — сдвиг влево и сдвиг вправо. Эти операторы можно использовать для быстрого умножения и деления (каждая позиция подразумевает «умножение/деление на 2»).
Сдвиг влево (<<)
Оператор << сдвигает все биты в первом операнде влево на количество позиций, указанное во втором операнде, который должен быть целым числом.
Сдвиг значения влево на одну позицию эквивалентен умножению на 2, на две позиции — умножению на 4 и т.д.
Пример работы оператора «Сдвиг влево»:
<?php $y = 5; // 000000101 // тоже самое что и 5 * 4 echo $y << 2; // 000010100 (20) ?>
Сдвиг вправо (>>)
Оператор >> сдвигает все биты в первом операнде вправо на количество позиций, указанное во втором операнде, который должен быть целым числом. Сдвиг значения вправо на одну позицию эквивалентен делению на 2, на две позиции — делению на 4 и т.д.
Пример работы оператора «Сдвиг вправо»:
<?php $y = 20; // 000010100 // тоже самое что и 20 / 4 echo $y >> 2; // 000000101 (5) ?>
Помимо описанных операторов, в PHP также предусмотрены и сокращенные формы записи побитовых операторов.
| Оператор | Описание | Пример | Сокращенная форма записи |
|---|---|---|---|
| &= | Присваивает левому операнду результат работы Побитового И | $x = $x & $y | $x &= $y |
| |= | Присваивает левому операнду результат работы Побитового ИЛИ | $x = $x | $y | $x |= $y |
| ^= | Присваивает левому операнду результат работы Исключающего ИЛИ | $x = $x ^ $y | $x ^= $y |
| >>= | Присваивает левому операнду результат работы оператора Сдвига вправо | $x = $x >> 6 | $x >>= 6 |
| <<= | Присваивает левому операнду результат работы оператора Сдвига влево | $x = $x << 6 | $x <<= 6 |
С этой темой смотрят:
- Выражения и операторы
- Арифметические операторы
- Операторы сравнения
- Логические операторы
PHP: Побитовые операторы | PHP
Битовые операторы позволяют работать с поразрядным представлением аргументов.
$y
# Каждый шаг означает «умножить на два».
* Каждый шаг означает «поделить на два».
- Что такое бит?
- Байт
- Табличное представление байта
- Побитовый оператор AND
- Пример побитового оператора PHP AND с одним общим битом
- Пример побитового оператора PHP AND с двумя общими битами
- Побитовый оператор OR
- Побитовый оператор XOR
- Пример использования побитового оператора PHP XOR
- Побитовый оператор NOT
- Пример использования побитового оператора PHP NOT после оператора AND
- Пример использования битовой операции PHP NOT перед оператором AND
- Сдвиг битов
- Пример использования побитового оператора сдвига влево
- Еще один пример использования оператора сдвига влево
- Пример использования побитового оператора сдвига вправо
- Еще один пример использования оператора сдвига вправо
- Пример использования оператора сдвиг вправо с превышением значения шага
- Байт
В PHP битовых операциях бит (двоичный разряд) — это базовая единица информации, хранящаяся в вычислительной системе, которая существует в двух возможных состояниях, представленных как ON или OFF.
В компьютерной системе состояние ON рассматривается как состояние 1, а OFF — 0. Эти состояния можно сравнить с двумя состояниями электрического переключателя (ВКЛ и ВЫКЛ) и т.п.
Значения задаются в двоичной системе исчисления. В десятичной системе построение числа основано на 10. Давайте посмотрим, как можно построить десятичное число —
231 = (2 ; 102 ) + (3 ; 101) + (1 ; 100)
= 200 + 30 + 1
= 231
Система двоичных чисел следует той же концепции. Единственное отличие состоит в том, что база равна 2, а не 10. Посмотрим, как двоичное число преобразовать в десятичное —
1011010=(1 x 26)+(0 x 25)+(1 x 24)+(1 x 23)+(0 x 22)+(1 x 21)+(0 x 20)
=(1 x 64) +(0 x 32)+(1 x 16)+(1 x 8)+(0 x 4)+(1 x 2)+(0 x 1)
=64+0+16+8+0+2+0
=90
Таким образом, (1011010)2= (90)10
Байт состоит из последовательности битов. Байт состоит из восьми битов.
Максимальное значение байта составляет 255. Таким образом устанавливается значение места каждого бита.
| 1 байт (8 бит) | ||||||||
| 8-ой | 7-ой | 6-ой | 5-ый | 4-ый | 3-ий | 2-ой | 1-ый | |
| Установленное значение | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
Табличное представление байта, демонстрирующее, как максимальное значение байта в битовой операции с числами составляет 255:
| 1 байт (8 бит) | ||||||||||
| Установленное значение | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | |||
| 27 | 26 | 25 | 24 | 23 | 22 | 21 | 20 | |||
| 128 | 64 | 32 | 16 | 8 | 4 | 1 | = | 255 | ||
Десятичное число 93 может быть представлено в двоичной форме:
| 1 байт (8 бит) | ||||||||||
| Установленное значение | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | |||
| 27 | 26 | 25 | 24 | 23 | 22 | 21 | 20 | |||
| 0 | 64 | 0 | 16 | 8 | 4 | 0 | 1 | = | 93 | |
<?php $x=13; $y=22; echo $x & $y; ?>
Результат примера:
4
Пояснение
Опираясь на приведенные выше таблицы битовых операций, можно сказать, что единственный общий бит находится на третьей позиции с установленным значением 4.
Таким образом, $x & $y = 4:
| 1 байт (8 бит) | ||||||||||
| Установленное значение | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 13 | |
| $y | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | = | 22 |
В приведенной выше таблице для $x (13) установлено значение на первой, третьей и четвертой позиции. Значения позиции равны 1, 4 и 8. А для $y (22) значение установлено на второй, третьей и пятой позициях с соответствующими значениями: 2, 4 и 16.
Единственный бит, который является общим для $x и $y — это третий. Поэтому возвращается 4.
Рассмотрим другой пример оператора &, в котором больше бит.
<?php $x=77; $y=198; echo $x & $y; ?>
Результат примера PHP битовой операции:
68
Пояснение
| 1 байт (8 бит) | ||||||||||
| Place Value | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | = | 77 |
| $y | 1 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | = | 198 |
В приведенной выше таблице значение установлено для $x (77) на первой, третьей, четвертой и седьмой позиции.
Значения позиций равны 1, 4, 8 и 64. Значение для $y (198) установлено на второй, третьей, седьмой и восьмой позициях с соответствующими значениями: 2, 4, 64 и 128.
Из приведенной выше таблицы видно, что общие для $x и $y — это третий и седьмой биты. Таким образом, возвращается 64 + 4 = 68.
Пример побитового оператора PHP OR:
<?php $x=5; $y=11; echo $x | $y; ?>
Результат примера:
15
Пояснение
| 1 байт (8 бит) | ||||||||||
| Place Value | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | = | 5 |
| 0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | = | 11 | |
В приведенной выше таблице битовой операции с числами для $x (5) значение установлено на первой и третьей позициях.
Значения позиций соответственно равны 1 и 4. Для $y (11) значения установлены на первой, второй и четвертой позициях с соответствующим значением: 1, 2 и 8.
Для $x и $y общими являются первый, второй, третий или четвертый бит. Возвращаемое значение представляет собой добавление значений позиций битов, то есть: 8 + 4 + 2 + 1 = 15.
Оператор Xor также выполняет побитовое сравнение двух числовых выражений и в результате устанавливает общий бит. Когда одно и только одно выражение является истинным, тогда он возвращает true.
В приведенной ниже таблице показано, как выполняется операция XOR:
| Выражение 1 | Выражение 2 | Результат |
| False | False | False |
| False | True | True |
| True | False | True |
| True | True | False |
В приведенной ниже таблице показано побитовое сравнение оператора XOR:
| Бит в Выражении 1 | Бит в Выражении 2 | Результат |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 |
<?php $x=12; $y=11; echo $x ^ $y; ?>
Результат примера PHP битовой операции:
7
Пояснение
| 1 байт (8 бит) | ||||||||||
| Значение позиции | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | = | 12 |
| $y | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | = | 11 |
В приведенной выше таблице для $x (12) установлено значение на третьей и четвертой позиции.
Значения позиции равны 4 и 8. А для $y (11) значение задано на первой, второй и четвертой позиции с соответствующими значениями: 1, 2 и 8.
$ x и $ y устанавливают вместе первый, второй, третий или четвертый бит. Но вместе они используют только 4-й бит. Поэтому возвращаемое значение представляет собой добавление места для них. Но не совместно используемый бит: 4 + 2 + 1 = 7.
В приведенной ниже таблице будет показано, как оператор NOT выполняет операции с $x и $y и возвращает true, когда заданный в одном выражении бит не задан в другом выражении.
<?php $x=12; $y=10; echo $x & ~ $y; ?>
Результат примера:
4
Пояснение
| 1 байт (8 бит) | ||||||||||
| Значение позиции | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | = | 12 |
| $y | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | = | 10 |
В приведенной выше таблице для $x (12) значение установлено на третьей и четвертой позициях.
Значения позиции равны 4 и 8. Для $y (10) значение установлено на второй и четвертой позициях с соответствующими значениями 2 и 8.
Для $x и $y заданы биты на первой, второй, третьей и четвертой позициям, но общий для них только четвертый бит. Возвращаемое значение равно 4, так как это единственное значение, заданное для $x, но не заданное для $y.
<?php $x=12; $y=10; echo ~ $x & $y; ?>
Результат примера:
2
Пояснение
В этом случае возвращаемое значение равно 2, потому что бит установлен для $y, но не установлен для $x.
Если a и b — это два числа. Оператор сдвига перемещает бит b на определенное количество позиций. Каждый шаг означает умножение на два (сдвиг влево). Если это сдвиг вправо, тогда каждый шаг означает деление на два.
<?php $x=8; $y=3; echo $x << $y; ?>
Результат примера битовой операции
64
Пояснение
| 1 байт (8 бит) | ||||||||||
| Значение позиции | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | = | 8 |
| Результат | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | = | 64 |
В приведенном выше примере берется значение $x, которое равно 8, и выполняется операция сдвига влево: 8 умножается на 2 три раза.
Таким образом, мы получаем 8 x 2 x 2 x 2 = 64.
<?php $x=12; $y=4; echo $x << $y; ?>
Результат примера:
192
Пояснение
В приведенном выше примере берется значение $x, равное 12, и выполняется операция сдвига влево: умножается на 2 четыре раза. Таким образом, мы получаем 12 x 2 x 2 x 2 x 2 = 192.
| 1 байт (8 бит) | ||||||||||
| Значение позиции | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | = | 12 |
| Результат | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | = | 192 |
<?php $x=8; $y=3; echo $x >> $y; ?>
Результат примера битовой операции с числами:
1
Пояснение
| 1 байт (8 бит) | ||||||||||
| Значение позиции | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | = | 8 |
| Результат | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | = | 1 |
В приведенном выше примере берется значение $x, которое равно 8, и выполняется операция сдвига вправо: 8 делится на 2 три раза.
Таким образом, получаем 8/2 = 4/2 = 2/2 = 1.
<?php $x=96; $y=5; echo $x >> $y; ?>
Результат примера:
3
Пояснение
| 1 байт (8 бит) | ||||||||||
| Значение позиции | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | = | 96 |
| Результат | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | = | 3 |
В приведенном выше примере берется значение $x, равное 96, и выполняется операция сдвига вправо: 96 делится на 2 пять раз. Таким образом, мы получаем 96/2 = 48/2 = 24/2 = 12/2 = 6/2 = 3.
<?php $x=64; $y=7; echo $x >> $y; ?>
Результат примера PHP битовой операции:
0
Пояснение
| 1 байт (8 бит) | ||||||||||
| Значение позиции | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | ||
| $x | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | = | 64 |
| Результат | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | = | 0 |
В приведенном выше примере берется значение $x, равное 64, и выполняется операция сдвига вправо: 64 делится на 2 семь раз.
При делении в определенный момент нам нечего делить. Таким образом, результат равен 0.
Дайте знать, что вы думаете по данной теме в комментариях. За комментарии, отклики, подписки, лайки, дизлайки низкий вам поклон!
Дайте знать, что вы думаете по данной теме статьи в комментариях. Мы крайне благодарны вам за ваши комментарии, подписки, лайки, дизлайки, отклики!
Вадим Дворниковавтор-переводчик статьи «PHP Bitwise operator»
Оператор PHP — Русские Блоги
Оператор PHP
Введение
Символ, который может реализовать определенную арифметическую функцию.
По разным функциям его можно разделить на следующие категории:
1. Арифметический оператор
2. Назначение оператора
3. Строковый оператор
4. Оператор сравнения
5. Увеличение / уменьшение оператора
6. Логические операторы
7. Битовый оператор
8. Контроль ошибок оператора
9. Тринокулярный оператор
Разным операторам соответствуют разные операнды, монокуляр, бинокуляр, тринокуляр.
Когда оператор выполняет операцию, он должен убедиться, что операнды согласованы.
Два, арифметический оператор
Результатом операции деления может быть число с плавающей запятой или целое число.
В операции по модулю, если есть десятичная дробь, десятичная часть будет удалена.
При работе с модулем знак результата зависит от первого числа.
В-третьих, оператор присваивания
Оператор присваивания =
$a = ‘php’
[Мышление]: $ a = ($ b = 4) + 5; Как понять эту строку кода? $ A = 9
Значением выражения операции присваивания является присвоенное значение. Другими словами, значение «$ a = 3» равно 3.
Выражения также являются ценными.
Иногда мы также комбинируем = с другими операциями, чтобы сформировать комбинированное назначение.
$a = $a + 5 => $a += 5;
Четыре, строковые операторы
Есть только один строковый оператор, который является точкой.
Там нет знака плюс,
Обратите внимание, что точки и операторы присваивания вместе образуют присваивания.
Пять, операторы сравнения
Оператор сравнения, сравнивает отношения между двумя операндами и возвращает логическое значение.
Есть два способа написания, начиная с! = И <>
Внимание к детали:
Если вы сравните целое число со строкой, строка будет преобразована в целое число. Если вы сравниваете две числовые строки, они сравниваются как целые числа.
=== и == разница. Например, 0 == false возвращает true, а 0 === false возвращает false
Шесть, увеличивая и уменьшая операторы
++ и-
По разным позициям он делится на передний ++, передний — задний ++, задний —
Разница между передней и задней частью?
Является ли он передним или задним, результат переменной является последовательным.
Порядок различных операций анализируется с помощью выражений.
Предлог ++ $ b — сначала выполнить операцию, а затем получить значение
Затем поместите $ b ++, затем сначала получите значение, а затем выполните операцию.
☞ Обратите внимание на детали
Оператор увеличения / уменьшения не влияет на логические значения. Уменьшение значения NULL не имеет никакого эффекта, но результатом увеличения значения NULL является 1
Семь логических операторов
И: правда, если оба
Или: ложь, если оба ложны или
Нет: если это правда или ложь, если это правда или ложь, это прямо противоположно. !
XOR: xor, если два значения различны, результат равен true, два одинаковы, результат равен false.
Два оператора && и и имеют разные приоритеты.
Операция короткого замыкания:
При выполнении логических операций, если значение всего выражения может быть определено через первый параметр, то последующие операции не будут выполняться.
$ b, $ a >> 2, $ b << 2 ценность.
Все битовые операции отображаются в двоичном виде.
В то же время обратите внимание на двоичное представление исходного кода, инвертированного кода и дополнения.
Оригинальный код:
Преобразовать десятичную в двоичную. Старший бит представляет собой знаковый бит, 0 представляет положительное число, а 1 представляет отрицательное число.
Обратный код:
Для положительных чисел обратный код совпадает с исходным кодом
Для отрицательных чисел знаковый бит остается неизменным, а остальные биты инвертируются.
Дополнительный код:
Для положительных чисел дополнение и исходный код совпадают
Для отрицательных чисел добавьте 1 к основанию обратного.
Когда компьютер выполняет вычисления внизу, он имеет форму дополнения до двух. Почему?
Процесс $ a & $ b $ a | $ b:
Ø Сдвиг вправо: младший бит переполняется, знаковый бит остается неизменным, а старший бит завершается знаковым битом (эквивалентно делению на 2n и затем округлению)
Ø Сдвиг влево: старший бит переполняется, знаковый бит остается неизменным, а младший бит заполняется 0 (эквивалентно умножению на 2n)
Процесс вычисления $ a >> 2 и $ b << 2:
Независимо от того, является он левым или правым, он только изменит размер числа без изменения знака, поэтому бит знака всегда остается неизменным во время операции сдвига.
В реальном программировании бит часто используется для обозначения состояния (или значения).
Девять операторов контроля ошибок
Мы не ожидаем увидеть ошибки, и мы можем использовать оператор контроля ошибок для их маскировки.
Эта операция используется не во всех местах, где могут возникать ошибки. В общем, для ошибок, которые мы не можем контролировать, например, при запросе других ресурсов, ее можно использовать.
☞ Обратите внимание на детали
Оператор @ действителен только для выражений. Его нельзя поместить перед определением функции или класса, а также нельзя использовать в условных структурах, таких как if и foreach.
Десять, три оператора
Из названия можно сказать, что у этого оператора есть три операнда. ?
Из названия можно сказать, что у этого оператора есть три операнда. ? :
Выражение 1? Выражение 2: Выражение 3
Эквивалент простого оператора if .
.. else
Если (выражение 1) {
Выражение 2
} else {
Выражение 3
}
Использование тринокулярного оператора может упростить процедуру.
☞ Обратите внимание на детали
Ø Приоритет оператора определяет, как «жесткие» два выражения связаны.
Ø Операторы в одной строке имеют одинаковый приоритет, а направление их комбинации определяет порядок оценки.
Ø При необходимости вы можете использовать скобки для принудительного изменения приоритета. Может улучшить читаемость кода.
Ø && || и и или
Ø Хотя = имеет более низкий приоритет, чем большинство других операторов, PHP по-прежнему допускает выражения, подобные следующим: если (! $ A = foo ()), в этом случае возвращаемое значение foo () присваивается $ а.
Если при написании кода операция более сложная (больше операторов), вы можете использовать () для изменения приоритета.
Побитовые операторы все еще актуальны в современном PHP?
PHP
- Шаблоны проектированияШаблоны и практикаПроизводительностьПроизводительность и масштабированиеБезопасность
В этой статье мы рассмотрим, что такое побитовые операторы и актуально ли их использование в современную эпоху вычислений.
Пример варианта использования
Здесь перечислены побитовые операторы, но чтобы по-настоящему понять пример, мы сосредоточимся только на одном: побитовом и ( и ). Пример заставил меня щелкнуть. Вот что мы сделаем — погрузимся прямо в пример.
Представьте, что у вас есть веб-сайт, на котором данный пользователь может иметь определенные разрешения. Например, такой журнал, как SitePoint:
- , автор может создавать черновики и редактировать свой профиль.
- редактор может, в дополнение к вышеперечисленному, создавать черновики и готовые сообщения CRUD, а также профили авторов CRUD.
- администратор может, в дополнение к вышеперечисленному, добавить права администратора.
Поскольку у пользователя может быть несколько разрешений, существует несколько способов определения разрешений в базе данных и системе, использующей ее.
Двойное соединение
Добавьте роли, добавьте разрешения, прикрепите разрешения к ролям в таблице соединений, затем создайте другую таблицу соединений и привяжите некоторые роли к некоторым пользователям.
Этот подход создает четыре дополнительные таблицы:
- разрешения
- ролей
- разрешения <-> роли
- ролей<->пользователей
Довольно много накладных расходов. Представьте, что вам нужно регулярно редактировать их или перечислять в приложении в некоторых часто посещаемых списках. Только сильное кеширование спасло бы это приложение от краха при большой нагрузке.
Одно преимущество, однако, состоит в том, что, определяя роли очень хорошо со сложными разрешениями, вам нужно только привязать пользователей к ролям, и все готово — это делает эту таблицу присоединения легкой и быстрой.
Единое объединение
Добавление разрешений, добавление таблицы объединения, прикрепление некоторых разрешений для некоторых пользователей
Этот подход создает две дополнительные таблицы:
- разрешения
- разрешений<->пользователей
Гораздо меньше накладных расходов, чем в предыдущем примере, но у вас гораздо больше записей в таблице соединений, потому что у пользователя может быть МНОГО разрешений (просто CRUD для черновика — это 4 разрешения).
С большим количеством пользователей и большим количеством разрешений эта таблица может быстро стать тяжелой.
The Column Stampede
Добавьте столбец в таблицу пользователей для каждого разрешения, затем сделайте его тип данных tinyint(1) (в основном логическим), чтобы проверять разрешение как «включено» или «выключено».
Установка разрешений для пользователя будет выглядеть примерно так:
UPDATE `users` SET `editProfile` = 1, `deleteProfile` = 0, `createDraft` = 1, `publishDraft` = 0 ... WHERE `id ` = 5
Этот подход не добавляет дополнительных таблиц, но без необходимости расширяет таблицу до гигантских размеров и требует модификации базы данных каждый раз, когда добавляется новое разрешение. Это хороший подход, когда вы знаете, что в обозримом будущем у вас будет максимум два или три разрешения, но не следует использовать их ни для чего другого.
Однако, поскольку список столбцов, если смотреть на него издалека, напоминает двоичное число (1010), этот подход является отличным переходом в другой…
Побитовый подход
Прежде чем мы углубимся в этот подход, ускоренный курс в двоичном формате.
Двоичные числа
Все компьютеры хранят данные в двоичном виде: 0 или 1. Итак, число 14 на самом деле хранится как: 1110. Как так?
Двоичные числа оцениваются справа налево при вычислении их значения, как и действительные числа. Итак, число 1337 означает:
- 1 х 7
- + 3 х 10
- + 3 х 100
- + 1 х 1000
Поскольку каждая цифра в десятичной системе (с основанием 10) умножается на 10. Первая цифра равна 1, следующая — 10, следующая за ней — 100, следующая — 1000 и т. д.
В двоичной системе основание равно 2, поэтому каждая цифра умножается на 2. Таким образом, число 1110 равно:
- 0 x 1
- + 1 х 2
- + 1 х 4
- + 1 х 8
Это 2 + 4 + 8, что равно 14.
Да, преобразовать двоичные числа в десятичные очень просто.
Итак, когда мы смотрим на наши столбцы разрешений до 1010, это можно также рассматривать как число 10, записанное в двоичной форме.
2), что равно равно 4 и т. д. Таким образом, все очень легко запомнить.
Чем это нам поможет?
Побитовый подход
Что ж, глядя на разрешения издалека, мы можем представить состояние всех столбцов сразу одним двоичным числом. Если мы можем представить все столбцы одновременно одним двоичным числом, это означает, что мы также можем представить его одним целым числом при переводе в десятичное число!
Если бы у нас был один столбец разрешений , содержащий значение 14 , мы бы теперь знали, что это на самом деле 1110 , и мы бы знали, что у нас есть три из четырех разрешений! Но какие 3 наши из 4?
Представьте себе следующее сопоставление разрешений:
| ИЗМЕНЕНИЕ РАЗРЕШЕНИЙ | ПРОФИЛЬ СОЗДАТЬ | РЕДАКТИРОВАНИЕ ПРОФИЛЯ | ПРОФИЛЬ УДАЛИТЬ | ЧЕРНОВИК СОЗДАТЬ | РЕДАКТИРОВАНИЕ ПРОЕКТА | ЧЕРНОВИК УДАЛИТЬ | ПУБЛИКАЦИЯ ПРОЕКТА | ЗАВЕРШЕНО РЕДАКТИРОВАНИЕ | ЗАВЕРШЕНО УДАЛЕНИЕ |
|---|---|---|---|---|---|---|---|---|---|
| 512 | 256 | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
Число 14 в двоичном формате равно 1110, но количество нулей слева не имеет значения, поэтому мы можем дополнять его до тех пор, пока не достигнем числа разрешений в таблице: 0000001110.
Это все еще 14, только представитель разрешений из таблицы выше. Для всех целей 0000001110 === 1110.
В соответствии с этим мы видим, что учетная запись с разрешением 14 имеет разрешения: DRAFT_DELETE , DRAFT_PUBLISH и FINISHED_EDIT . Конечно, это не совсем репрезентативная установка разрешений в реальном мире, но это просто пример, на котором мы можем экстраполировать, что если бы у кого-то было 1111111111, у него были бы ВСЕ разрешения (вероятно, пользователь-администратор). В десятичном виде это 1023. Итак, кто-то со значением 1023 в столбец разрешений — это кто-то со всеми разрешениями.
Но как проверить это в нашем коде? Другими словами, как мы можем узнать, установлен ли бит разрешения (1) или нет (0), особенно если число хранится как десятичное, а не двоичное?
Для этого и нужны побитовые операторы, в частности одиночный амперсанд и , также известный как побитовый и .
MySQL поддерживает это так:
SELECT * FROM user WHERE id = 5 AND 512 & разрешения
Это буквально переводится как «выбрать всех пользователей с идентификатором 5, у которых также есть 512 бит разрешений столбца , установленных на 1». Вы можете проверить наличие других битов, просто изменив их значение: 256, 128, 64, 32, 16, 8, 4, 2 или 1. этот разделенный раздел, если вы не хотите знать, как работает этот оператор или подобные операторы, но просто заинтересованы в продолжении примера.
Когда мы говорим И 512 и разрешения , мы ищем, чтобы часть после И была ИСТИНА, потому что именно так работают SQL-запросы — они оценивают условия и возвращают те строки, которые возвращают истину в отношении требований.
Следовательно, 512 и разрешения должны оцениваться как истинные. Мы знаем, что любое ненулевое значение, будь то целое число, логическое значение, говорящее «истина», или непустая строка, на самом деле считается «истиной».
Так что 512 верно. 1 верно. 0 ложно. 128 правда.
512 — целое число с основанием 10, а разрешения — столбец, который может содержать целое число с основанием 10. побитовое и фактически смотрят на сечение этих двух чисел и возвращают биты, которые установлены (1) в обоих из них. Таким образом, если число 512 равно 1000000000, а значение разрешений равно 1023, при преобразовании в двоичное число это будет 1111111111. Их поперечное сечение возвращает 1000000000, поскольку в обоих числах установлен только самый левый бит. Когда мы преобразуем это обратно в десятичное число, получится 512, что считается 9.
-
ивозвращает двоичное число, в котором установлены все биты, установленные в обоих операндах. 9 возвращает двоичное число со всеми установленными битами, установленными в одном из операндов, но не в обоих. -
~просто возвращает обратное — все, что не установлено в исходном операнде, теперь установлено.
9 возвращает двоичное число со всеми установленными битами, установленными в одном из операндов, но не в обоих. Существуют также операторы побитового сдвига: сдвиг влево << и сдвиг вправо >> . Они резко изменяют значения двоичных чисел, буквально перемещая все установленные биты на одно место вправо или влево. Их использование в нашем контексте сомнительно, поэтому мы не будем их здесь рассматривать.
И в PHP мы можем проверить, установлен ли бит следующим образом:
if (1023 & 1) {
}
Но это очень, очень сложно расшифровать — просто смотреть на необработанные числа не очень-то читабельно или понятно. Таким образом, в PHP лучше использовать константы, определяющие разрешения в виде битов и извлекающие целочисленное значение разрешения из столбца. Затем вы получите что-то вроде этого:
if ($user->permissions & \MyNamespace\Role::FINISHED_DELETE) {
//
}
Здесь мы предполагаем, что у нас есть класс \MyNamespace\Role , определенный и загруженный такими константами:
const FINISHED_DELETE = 1; константа FINISHED_EDIT = 2; константа DRAFT_PUBLISH = 8; .
..
константа CHANGE_PERMISSIONS = 512;
Внезапно у вас появился действительно простой способ хранения нескольких разрешений для каждого пользователя без использования дополнительных таблиц и создания ненужных накладных расходов.
Итак, как сохранить это в базе данных при изменении разрешений? Просто суммируйте разрешения и сохраните их как целое число! человек, который может FINISHED_DELETE и FINISHED_EDIT имеет разрешение 1 и 2 в соответствии с приведенными выше константами. Поэтому, чтобы сохранить их разрешения, вы просто суммируете их (1+2=3) и сохраняете 3 в столбце разрешений . нет другого способа получить число 3 с двоичными комбинациями — число 3 не может быть представлено в двоичном виде иначе, чем 0011 — поэтому вы можете быть на 100% уверены, что число 3 всегда означает, что у пользователя есть разрешение 1 и разрешение 2, соответствующие их значениям в константах.
Это кажется слишком простым и практичным, не так ли? В чем подвох?
Предостережения
Есть два основных предостережения:
- Необходимо помнить об использовании степени двойки при расчете следующего битового значения разрешения. Поэтому, если вам нужно добавить новое разрешение, вы не можете просто волей-неволей выбрать 543, если у вас уже есть 512 — это должно быть 1024. Это становится немного сложнее, когда числа становятся больше.
- Поскольку наши компьютеры работают под управлением 64-битных операционных систем на 64-битных процессорах (в большинстве случаев — некоторые даже застряли на 32-битных до сих пор!), это означает, что число может иметь максимум только 64 бита. Это означает, что вы можете хранить только перестановки с максимальным разрешением 64 для данного пользователя. Для небольших и средних сайтов этого вполне достаточно, но на огромных сайтах это может превратиться в проблему. Решение состоит в том, чтобы использовать разные столбцы для разных контекстов разрешений (
draft_permissions,account_permissionsи т. д.). Каждый из этих столбцов может содержать перестановки 64 разрешений сам по себе, чего достаточно даже для самых требовательных веб-сайтов.
Поэтому, если вам нужно добавить новое разрешение, вы не можете просто волей-неволей выбрать 543, если у вас уже есть 512 — это должно быть 1024. Это становится немного сложнее, когда числа становятся больше.Заключение
Битовые операции, безусловно, все еще имеют место в современном программировании.
Хотя может показаться нелогичным использовать что-то такое, казалось бы, сложное (на самом деле это не так — он просто не так знаком, как современные таблицы соединений), этот подход дает много преимуществ, не последним из которых является резкое повышение производительности, как в данных размер (намного меньше информации для хранения в базе данных и последующего извлечения) и скорость (объект пользователя может иметь предварительно выбранное значение разрешения - это просто int - и, таким образом, его можно проверять в любое время).
Представленные здесь пакеты, безусловно, упрощают работу, но только в том случае, если вы еще не знакомы с еще более простыми альтернативами, подобными продемонстрированным выше.
Как вы относитесь к использованию побитовых операторов для проверки разрешений и такому подходу к их хранению? Есть очевидные плюсы/минусы? Дайте нам знать, как вы это делаете и почему!
Поделиться этой статьей
Бруно Скворц
Бруно — разработчик блокчейна и технический преподаватель в Web3 Foundation, фонде, который создает новое поколение свободного интернета для людей.
Он выпускает два информационных бюллетеня, на которые вы должны подписаться, если вы заинтересованы в Web3.0: Dot Leap освещает экосистему и техническое развитие Web3, а NFT Review рассказывает об эволюции экосистемы невзаимозаменяемых токенов (цифровых предметов коллекционирования) внутри этой новой новой сети. . Его текущим страстным проектом является RMRK.app, самая продвинутая система NFT в мире, которая позволяет NFT владеть другими NFT, NFT реагировать на эмоции, NFT управляться демократически, а NFT быть несколькими вещами одновременно.
аутентификацияавторизацияBrunoSOOPHPразрешенияPHP
PHP | Операторы | Codecademy
Операторы используются для выполнения операций над переменными и значениями.
Арифметические операторы
PHP имеет следующие основные арифметические операторы для выполнения общих математических операций:
| Оператор | Имя | Описание |
|---|---|---|
+ | Дополнение | $x + $y возвращает сумму $x и $y |
- | Вычитание | $x - $y возвращает разницу между $x и $y |
* | Умножение | $x * $y возвращает произведение $x и $y |
/ | Подразделение | $x / $y возвращает частное $x и $y |
% | Модуль | $x % $y возвращает целочисленный остаток от $x , разделенный на $y |
** | Возведение в степень | $x ** $y возвращает $x в степени $y |
Оператор деления возвращает число с плавающей запятой, если только его операнды не являются целыми числами, а результатом является целое число, и в этом случае он возвращает целое число.
Операнды по модулю перед вычислением преобразуются в целые числа. Результат по модулю будет иметь тот же знак, что и делимое.
$x = 0;
$х = $х + 4; // $x теперь равно 4
$x = $x - 1; // $x теперь равно 3
$x = $x * 8; // $x теперь 24
$x = $x / 4; // $x теперь 6
$x = $x % 4; // $x теперь 2
$x = $x ** 3; // $x теперь 8
?>
Операторы присваивания
Основной оператор присваивания = берет правый операнд и присваивает его переменной, которая является левым операндом. PHP также имеет ряд дополнительных операторов присваивания, которые являются ярлыками для более длинных выражений.
Арифметические операторы присваивания
Для каждого вышеуказанного арифметического оператора существует оператор присваивания.
| Оператор | Имя | Описание |
|---|---|---|
+= | Дополнительное задание | $a += 3 сокращение от $a = $a + 3 |
-= | Задание на вычитание | $a -= 3 сокращение от $a = $a - 3 |
*= | Назначение умножения | $a *= 3 является сокращением от $a = $a * 3 |
/= | Назначение отдела | $a /= 3 — сокращение от $a = $a / 3 |
%= | Присвоение по модулю | $a %= 3 является сокращением от $a = $a % 3 |
**= | Присвоение возведения в степень | $a **= 3 является сокращением от $a = $a ** 3 |
$x = 0;
$х += 4; // $x теперь равно 4
$x -= 1; // $x теперь равно 3
$x *= 8; // $x теперь равно 24
$x /= 4; // $x теперь 6
$x %= 4; // $x теперь равно 2
$x **= 3; // $x теперь 8
?>
Операторы побитового присваивания
Для каждого побитового оператора существует оператор присваивания (см.
ниже).
| Оператор | Имя | Описание |
|---|---|---|
<<= | Назначение левой смены | $a <<= 3 является сокращением от $a = $a << 3 |
>>= | Назначение правой смены | $a >>= 3 — сокращение от $a = $a >> 3 |
$x = 19;
$х &= 7;
// $x равно 3 : 10011 & 00111 = 00011
1 = 10100$x = 7;
$х <<= 2;
// $x равно 28 : 00111 << 2 = 11100
$x = 19;
$x >>= 2;
// $x равно 4 : 10011 >> 2 = 00100
?>
Побитовые операторы
Побитовые операторы манипулируют отдельными битами целого числа.
| Оператор | Имя | Описание |
|---|---|---|
| 9 | Ксор | Результат имеет установленный бит, только если этот бит установлен только в одном операнде. |
~ | Не | берет один операнд и инвертирует в нем каждый бит. |
<< | Сдвиг влево | $a << $b означает, что биты $a сдвинуты влево на $b пробела. $b нуля вставляются справа, а самые левые биты $b отбрасываются. |
>> | Правый сдвиг | $a >> $b означает, что биты $a сдвинуты вправо на $b пробела. $b копии крайнего левого бита вставляются слева, а крайние правые $b биты отбрасываются. |
$x = 19 & 7;
// $x равно 3 : 10011 & 00111 = 00011
$x = 19 | 7;
// $x равно 23 : 10011 | 00111 = 10111
1 = 10100$x = 7 << 2;
// $x равно 28 : 00111 << 2 = 11100
$x = 19 >> 2;
// $x равно 4 : 10011 >> 2 = 00100
?>
Операторы сравнения
| Имя | Описание | |
|---|---|---|
== | Равно | $x == $y равно true , если $x и $y равны после жонглирования типами. |
=== | Идентичен | $x === $y равно true , если $x и $y равны и имеют один и тот же тип. |
!= | Не равно | $x != $y равно true , если $x и $y не равны после жонглирования типами. |
<> | Не равно | $x <> $y равно true , если $x и $y не равны после жонглирования типами. |
!== | Не идентичный | $x !== $y равно true , если $x и $y не равны или не одного типа. |
< | Меньше | $x < $y равно верно , если $x меньше $y . |
> | Больше, чем | $x > $y равно true , если $x больше $y . |
<= | Меньше или равно | $x <= $y равно true , если $x меньше или равно $y . |
>= | Больше или равно | $x >= $y равно true , если $x больше или равно $y . |
<=> | Космический корабль | $x <=> $y возвращает целое число, большее, меньшее или равное нулю, когда $x больше, меньше или равно $y соответственно. |
$х = 5;
$y = '5';
если ($x == $y):
эхо "равно";
еще:
эхо "не равно";
конец;
// Вывод: равно
echo "
";if ($x === $y):
echo "идентично";
еще:
эхо "не идентичны";
конец;
// Вывод: не идентичный
echo "
";$y = 12;
если ($x > $y):
эхо $x .
иначе:
эхо $x . " не больше " . $у;
конец;
// Вывод: 5 не больше 12
?>
" больше, чем " . $у; Операторы увеличения/уменьшения
| Оператор | Имя | Описание |
|---|---|---|
++$x | Преинкремент | Увеличивает $x на единицу, затем возвращает $x . |
$х++ | Постинкремент | Возвращает $x , затем увеличивает $x на единицу. |
--$x | Предекремент | Уменьшает $x на единицу, затем возвращает $x . |
$х-- | Постдекремент | Возвращает $x , затем уменьшает $x на единицу. |
$х = 6;
эхо "Постинкремент:" .
\n";// Вывод: постинкремент: 6
эхо "После постинкремента:" . $х. "
\n";// Вывод: после постинкремента: 7
эхо "Преинкремент:" . ++$х . "
\n";// Вывод: Преинкремент: 8
echo "После преинкремента:" . $х. "
\n";// Вывод: после преинкремента: 8
echo "Постдекремент:" . $х-- . "
\n";// Вывод: Постдекремент: 8
echo "После постдекремента:" . $х. "
\n";// Вывод: После постдекремента: 7
echo "Преддекремент:" . --$х. "
\n";// Вывод: преддекремент: 6
echo "После преддекремента:" . $х. "
\n";// Вывод: После преддекремента: 6
$х++ . "Логические операторы
| Оператор | Имя | Описание |
|---|---|---|
и | и | x$ и $y является истинным , только если x$ и y$ оба являются истинными . |
или | или | $x или $y равно true , если либо $x , либо $y равно true . |
хор | Ксор | $x или $y равно true только тогда, когда только одно из $x или $y равно true . |
! | Не | !$x равно true , когда $x равно false и false , когда $x равно true . |
&& | и | x$ && $y равно истинно , только если x$ и y$ оба равны верно . |
|| | или | $х || $y равно true , если либо $x , либо $y равно true . |
Хотя и и && и или и || имеют одинаковое значение, но работают с разным приоритетом.
Важно отметить, что && и || имеют более высокий приоритет, чем = , а и и или нет.
$x = ложь || истинный; // $x присваивается значение true ($x = (false || true))
$x = false или true; // $x присваивается значение false (($x = false) или true)
?>
Строковые операторы
| Оператор | Имя | Описание |
|---|---|---|
. | Объединить | Объединяет левый и правый операнды |
.= | Объединить назначение | Объединяет левый и правый операнды и присваивает значение левому операнду. |
$x = 'это' . '&' . 'что';
эхо $x; // Вывод: это&то;
$x .= '!';
эхо $x; // Вывод: это&то!;
?>
Операторы массива
| Оператор | Имя | Описание |
|---|---|---|
+ | Союз | $x + $y возвращает объединение массивов $x и $y . |
+= | Назначение Союза | $x += $y присваивает объединение $x и $y $x. |
== | Равно | $x == $y равно true , если $x и $y состоят из одних и тех же пар ключ/значение. |
=== | Идентичен | $x === $y равно true , если $x и $y имеют одинаковые пары ключ/значение, в том же порядке и одного типа. |
!= | Не равно | $x != $y равно true , если $x и $y не имеют одинаковых пар ключ/значение. |
<> | Не равно | $x <> $y равно true , если $x и $y не имеют одинаковых пар ключ/значение. |
!== | Не идентичный | $x !== $y равно true if $x === $y равно false . |
При использовании + с массивами возвращается массив правого операнда, присоединенного к левому операнду.
В случаях, когда в массивах есть совпадающие ключи, будут использоваться элементы из левого операнда
и совпадающие элементы из правого операнда будут отброшены.
Тип Операторы
| Оператор | Имя | Описание |
|---|---|---|
экземпляр из | Экземпляр | $x instanceof SomeClass возвращает true , если $x является экземпляром класса SomeClass . |
SomeClass может быть именем класса, переменной данного класса или строкой, содержащей имя класса.
anastasionico.uk | Операторы PHP (часть 1)
Итак, в предыдущих частях этой серии вы познакомились с основами PHP,
Вы видели, какие основные конструкции дает вам этот язык,
. Вы уже видели, что существует несколько типов переменных (делятся на простые и составные).
Теперь мы закончили играть и приступаем к делу серьезно!
Вопрос, на который ответит сегодняшний пост в блоге:
"Теперь, когда я знаю, как создавать переменные, как мне вставить их в поток моего кода?" .
Ответ: через операторы,
Операторы PHP позволяют перемещаться по коду, обновлять переменные, вести посетителей вашего веб-приложения в том или ином направлении (за счет использования управляющих структур) .
Существуют различные типы операторов,
некоторые из них вы будете использовать каждый день много раз в день, другие - редко, но как только вы поймете, как они работают, они сделают вас веб-разработчиком. выше среднего, если не топ 10% среди ваших коллег.
Этот пост является частью серии под названием " Основы PHP для опытных разработчиков ".
В этой серии вы изучите основы PHP , но также увидите много небольших советов и функций, которые вы найдете только в книгах и расширенных руководствах .
В зависимости от вашего уровня вы можете просто читать их время от времени или вообще пропускать.
Вам не обязательно учить все, что здесь написано, наизусть!
Просто прочитайте, узнайте, что существуют определенные функции или методы, и вернитесь к этим страницам, когда почувствуете, что готовы к следующему уровню.
Основы PHP для опытных веб-разработчиков (часть 1)
Конструкция и комментарии PHP 7
Как использовать переменные (PHP 7)
Составные переменные в PHP (массивы, объекты и т. д.)
Операторы PHP (часть 1)
PHP Операторы (часть 2)
Условные структуры в PHP
петли в PHP (Учебное пособие)
Также этот пост в блоге делится на несколько основных разделов
Арифметические операторы
Оператор
Тернарный оператор
Оператор NULL Coalescing
Spaceship Operator
Оператор
9105 Последний
9105 Последний 9173 9105 Последний 9173 9105 Последний 9173 9105 Последний 9105 9105 Последний 9105 9105 Последний 9105 9105 Последний 9105 9105.
В PHP существует различных типов операторов .
Они варьируются от арифметических операторов до логических операторов, включая операторы присваивания, операторы ссылок, космические корабли и побитовые операции.
Каждый из них имеет свою четко определенную цель, которую вы увидите прямо сейчас.
Арифметические операторы те же самые, которым ваш учитель учил вас в начальной школе.
Это сложений, вычитаний, делений, умножений, , тогда вы получите в степени , обозначенной символом **, и , модуль , обозначенный символом %.
Существует два типа арифметических операторов, учитывающих два аргумента (которые называются бинарными) , и операторы, учитывающие только один аргумент (они называются унарными) .
В свою очередь,
Унарные операторы делятся на два типа: Префиксные и Постфиксные.
Эти типы меняются в зависимости от того, появляется ли оператор до или после переменной, которую вы хотите изменить.
Если оператор стоит перед переменной (префиксом), то интерпретатор, синтаксический анализатор PHP оценит операцию и вернет измененную переменную.
Если вместо
оператор появляется после переменной (в данном случае Postfix), то интерпретатор вернет переменную, как если бы оператор никогда не выполнялся и только после выполнения запрошенной операции над переменной.
Чтобы понять, что такое логические операторы, подумайте о них так, как если бы они были спряжениями в грамматике.
Цель использования логических операторов в языках программирования, таких как PHP, состоит в том, чтобы выполнять более сложные условия, поскольку они фактически могут соединять разные условия в одно.
Эти новые условия делают операторов более точными и простыми в обращении.
.
Логические операторы обычно используются между двумя условиями,
создают своего рода большее условие, которое будет истинным или ложным в зависимости от связи между логическим оператором и двумя используемыми условиями.
Если используется оператор "и" или && для выполнения основного условия, оба условия должны оцениваться как истинные.
В случае, если это "или" или || оператор между вашим утверждением для, главное условие, которое должно быть оценено как истинное, между первым и вторым условием должно быть оценено как истинное, 9одно из двух условий должно оцениваться как истинное, но не оба.
Оператор "не" самый простой и обозначается символом "!" условие просто переворачивается на текущую ситуацию.
В отличие от другого логического оператора, слово: "не" нельзя использовать в условии , что означает, что единственный способ создать оператор "не" — поставить перед условием символ "!"
Тернарный оператор используется довольно давно.
PHP использует тот же формат, что и C, который представляет собой язык программирования, разработанный Деннисом Ритчи между 1969 и 1973 годами. двоеточие.
Если условие истинно, то во внимание будет приниматься первое выражение, в противном случае во внимание будет приниматься второе выражение.
Посмотрите на тернарные операторы, как если бы они были простыми if-else, но для простых операций, таких как присваивание или эхо даты, или, по крайней мере, здесь, где я нахожу это более полезным.
Вот пример:
эхо (isset($var)) ? "переменная установлена" : "переменная не установлена";
Как видите, синтаксис в примере будет идентичен оператору if-else.
После того, как вы попрактикуетесь, написать эту строку кода будет намного проще.
Существует еще более короткая версия этого утверждения, в которой используется символ ?: .
Эта версия называется Elvis (не спрашивайте почему) и состоит в написании только второго выражения.
В этом случае, если условие истинно и тернарный оператор должен присвоить переменную, она будет оцениваться как 1.
Эта версия не подходит для тестирования, фактически PHP в этом случае выдаст ошибку
$вар = истина; $result = (isset($var)) ?: "переменная не установлена" ; эхо $результат; // $результат будет 1
Вот краткое объяснение тернарного оператора из Википедии.
Существует еще одна версия тернарного оператора (вроде), которая называется нулевым оператором объединения или оператором двойного вопросительного знака.
Вы узнаете его по символу ?? г.
Это позволяет проверить условие с еще более чистым синтаксисом за счет использования двух вопросительных знаков.
Можно присвоить значение переменной, если рассматриваемая переменная была установлена ранее и не равна нулю.
Поскольку оператор объединения нулей не сообщает об ошибках при его использовании, лучше использовать его вместо оператора Элвиса
$результат = $вар ?? "Привет";
: Как вы можете видеть из предыдущего примера, если переменная, представленная в первом выражении, была установлена, то переменная $result примет это значение, в противном случае PHP выдаст значение справа от оператора Null Coalescing, в этом случае строка «Привет».
Эта функция также применима к нескольким операторам объединения Null,
Это может быть цепочка за другой , дающая жизнь ряду условий, как и для одиночного, в синтаксическом анализаторе PHP будет следовать выражениям справа, пока не найдет допустимое значение.
$результат = $вар ?? $var2 ?? "Привет";
Вот один из операторов, предпочитаемых PHP-программистами хотя бы из-за его формы.
Оператор космического корабля используется для анализа и сравнения двух разных значений и чрезвычайно полезен, например, когда данные должны быть упорядочены.
Оператор космического корабля может возвращать три разных значения.
Это -1, 0 и 1.
Эти значения зависят от операндов.
Если операнд слева меньше операнда справа, то оператор космического корабля вернет -1, если два значения равны, он вернет 0, если второй операнд (тот, что справа) больше, чем первый операнд (слева) значение, возвращаемое оператором космического корабля, будет 1.
Оператор космического корабля также работает, если вы хотите работать со строками, на самом деле, он очень полезен для сортировки слов и букв.
Имейте в виду , что с той же буквой буква меньшего формата будет считаться основным , а с заглавной буквой будет считаться второстепенным .
см. примеры ниже.
1 ⇔ 0 // получится 1 1 ⇔ 1 // будет 0 1 ⇔ 2 // получится -1 "переменная" ⇔ "Переменная" // это приведет к 1
Посмотрите официальное руководство, чтобы узнать больше об операторе космического корабля в PHP 9.0003
Побитовые операторы работают с целыми битами.
Они представлены в двоичной форме.
Существует три побитовых оператора:
Первый - это оператор И, который имеет установленный бит, если установлены оба операнда, тогда у нас есть побитовый оператор ИЛИ, который вместо этого будет иметь набор результатов, если один или оба операнда операнды имеют установленный бит.
Наконец,
у нас есть побитовый оператор XOR , который установит бит результата только в том случае, если бит установлен в одном из операндов, а не в обоих
Результатом этой операции является просто значение, которое мы получаем после реализации этих правил.
Я понимаю, что это может показаться очень сложной концепцией.
Чтобы упростить эту концепцию, вы можете думать об этих операциях, как если бы они представляли несколько десятичных чисел.
Вы можете вычислить двоичное представление чисел, просто сравнивая их справа налево, а затем преобразовать в десятичное, когда закончите.
Чтобы сделать концепцию еще более понятной, ниже я проиллюстрирую пример, приведенный автором Эндрю Биком.
Принимая во внимание два числа 50 и 25,
К этим двум числам реализуем оператор Побитовое И.
Как видите,
по правилам показаны в приоритете, в результате получаем значение 16,
При проверке числа выводится результат и целое число.
Теперь я покажу один из самых странных операторов во всем репертуаре PHP.
Вы прочтете о смещении битов!
Сдвиг битов позволяет вам сдвигать битовый шаблон на значение, вы можете сделать это либо с правой, либо с левой стороны.
Чтобы понять, как работает сдвиг битов, представьте число так, как если бы оно отображалось в двоичной форме.
Если ссылка находится справа, то оператор называется "Сдвиг вправо" и бит перемещается с правой стороны,
если вместо этого
мы используем "Сдвиг "Влево" операция добавит ноль в правой части двоичного представления рассматриваемого числа
50 // Результат в двоичном формате 00110010 50 >> 1 // Результат в двоичном формате: 0011001 // Результат десятичного числа 25 50 << 1 // Результат в двоичном формате: 01100100 // Результат десятичного числа 100
В конце концов, у нас есть побитовое , а не оператор .
Это очень просто понять, чтобы найти результат этого побитового оператора, просто найдите двоичное значение числа и инвертируйте 1 в 0 и наоборот.
Вам очень поможет функция base_convert(), которая выводит двоичное представление десятичного числа. от EpicFact Найдите ниже.
г.
Надеюсь, вам понравится
Какая интересная тема, не правда ли?
Лично я считаю, что операторы PHP являются основой каждого языка программирования.
Они незаменимы, и, как вы увидите в следующих главах этой серии (подпишитесь на мой информационный бюллетень, чтобы получать уведомления о публикации), вы будете широко использовать их в структурах управления и других операциях.
Как вы видели, некоторые из них очень просты (я уверен, у вас не было проблем с тем, чтобы понять, как выполнить сложение между двумя переменными), но есть и такие, как оператор "Элвис" или побитовые операции могут создать проблемы даже для опытных программистов,
Тем не менее,
это темы, необходимые на важных экзаменах, таких как сертификат PHP Zend.
Как вы знаете, основная цель этой серии сообщений в блоге, как и других на моем веб-сайте, — дать вам дополнительный толчок, чтобы ваши навыки взлетели до небес, а вместе с ними и ваша карьера.
Как всегда,
, если вам что-то непонятно и вы хотите получить разъяснения по поводу того, что написано в этом посте, не стесняйтесь, присылайте мне электронное письмо или, что еще лучше, воспользуйтесь сообществом на Facebook для помощь. ссылка ниже.
Основы PHP для опытных веб-разработчиков (часть 1)
Конструкция и комментарии PHP 7
Как использовать переменные (PHP 7)
Составные переменные в PHP (массивы, объекты и др.