3

Операторы

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

Введение для операторов

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

Оператор    =    (Равно)

Итак, вот его первое использование (Присвоение значения переменной):

LongVariable.l = 1

Второй способ (Сравнение равенства между двумя выражениями, переменными или значениями):

LongVariable.l = 1
If LongVariable = 1
   Debug "Yes, LongVariable does equal 1"
EndIf

Вы в первый раз, увидели команду IF, но не стоит пугаться.  Эта команда позволяет выполняться коду Debug "Yes, LongVariable does equal 1" только при условии если LongVariable.l = 1. Команда Endif  является неотъемлемой к команде IF . Она показывает конец всех действий связанных с условной командой IF . Обязательно попробуйте поменять значение в первой строчке кода ( например так: LongVariable.l=4) и посмотрите результат.

Оператор    +    (Плюс)

Оператор +  используется для  связки(суммирования) строк, а так же для суммирования чисел.Вот пример суммирования чисел:

NumberOne.l = 50
NumberTwo.l = 25
NumberThree.l = NumberOne + NumberTwo
Debug NumberThree

Число, которое будет в окне отладки: 75. То есть мы присвоили значение первой переменной 50, затем присвоили второй переменной 25. А третьей переменной назначили сумму первых двух переменных. А вот еще один способ сложения двух чисел и присвоение переменной NumberOne.l:

NumberOne.l = 50 + 25
Debug NumberOne

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

NumberOne.l = 50
NumberOne + 25
Debug NumberOne

Здесь мы присвоили переменной значение 50, а потом прибавили еще 25. В итоге в окне отладки будет 75.

Теперь пример сложения строк:

StringOne.s = "Mary had a"
StringTwo.s = " little lamb"
StringThree.s = StringOne + StringTwo
Debug StringThree

Мы двум переменным присвоили по строке, а затем объединили в общую строку. Обратите внимание на пробел в строке " little lamb" и попробуйте убрать его и запустить. Понятно теперь зачем нужен пробел? Ну ладно, вот еще один пример:

StringOne.s = "Mary had a" + " little lamb"
Debug StringOne

Если вам надо строковую переменную сложить с каким нибудь текстом, то это можно сделать примерно так:

StringOne.s = "Mary had a"
StringOne + " little lamb"
Debug StringOne

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

Оператор   -   (Mинус)

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

NumberOne.l = 50
NumberTwo.l = 25
NumberThree.l = NumberOne - NumberTwo
Debug NumberThree

 В итоге в переменной NumberThree.l окажется 25 То есть разность двух переменных NumberOne - NumberTwo . А вот еще один пример:

NumberOne.l = 50
NumberOne - 10
Debug NumberOne

Здесь NUMBERONE присваивается значение 50, затем NUMBERONE  уменьшается на 10, используя оператор минус . Новое значение NUMBERONE (40) и будет в окне вывода отладки.

Оператор    *     (Умножение)

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

NumberOne.l = 5
NumberTwo.l = 25
NumberThree.l = NumberOne * NumberTwo
Debug NumberThree

Окно отладки покажет результат 125 , поскольку в этом примере мы умножили NUMBERONE на NumberTwo (5 * 25 = 125). И еще один пример перемножения переменной:

NumberOne.l = 50
NumberOne * 3
Debug NumberOne

Здесь NUMBERONE присваивается значение 50 , затем NUMBERONE умножается на 3, используя оператор умножения. Новое значение NUMBERONE (150) и будет в отладочном окне.

Оператор    /    (Деление)

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

NumberOne.l = 100
NumberTwo.l = 2
NumberThree.l = NumberOne / NumberTwo
Debug NumberThree

Здесь NUMBERONE присваивается значение 100. NumberTwo присваивается значение 2. Затем мы
делим NUMBERONE (100) на NumberTwo (2) и сохраняем результат  в NumberThree. И в отладочном окне мы можем видеть 50
И еще один пример:

NumberOne.l = 50
NumberOne / 5
Debug NumberOne

Здесь NUMBERONE присваивается значение 50 , далее используя оператор деления разделим это значение на 5. В переменной NUMBERONE будет значение 10, о чем и свидетельствует окно отладки.

 Оператор     &    (Битовый AND)

Битовые операторы манипулируют числами на уровне двоичных файлов. Если вы мало знакомы с бинарными данными, вы можете обратиться к главе 13 (пристальный взгляд на числовые типы данных), где дается полное объяснение. Битовые операторы не могут быть использованы с дробными числами или строками.

Как работает:

Битовый оператор & сравнивает два двоичных числа и возращает 1 (TRUE) только в том случае, если у обоих чисел биты равны 1 (TRUE). Во всех других случаях оператор возращает 0 (FALSE) Все же для вас подготовлена таблица из которой все станет более понятно.

В таблице можно увидеть два числа 77 и 117, которые будут обрабатываться оператором &. После обработки оператором &,  конечным результатом будет число 69 . Чтобы объяснить, как это значение достигается, нужно смотреть на каждую колонку битов сверху вниз. Взгляните на крайний правый столбец: этот столбец при обработке оператора &, устанавливается как TRUE (истина), поскольку в строчках обоих чисел для этого столбца стоят единички. Если вы посмотрите на крайний левый столбец, то увидете, что название у него False (ложь), поскольку у чисел в этом столбце значение ноль. Просмотрите внимательно таблицу, а так же прочитайте еще раз внимательно как работает оператор. Теперь можно привести пример использования оператора &

NumberOne.b = 77
NumberTwo.b = 117
NumberThree.b = NumberOne & NumberTwo
Debug NumberThree

В этом маленьком примере двум переменным присваиваются числа, которые будут обрабатываться оператором &, а в переменную NumberThree запишется результат и будет выведен в окно отладки. Значение будет равно 69.   А вот еще один пример:

NumberOne.b = 77
NumberOne & 117
Debug NumberOne

Здесь NUMBERONE присваивается значение 77, и обрабатывается с помощью оператора &  значением 117, а результат сохраняется в  NUMBERONE. И значение сохраненное в NUMBERONE выводится в окно отладки. Далее идет обобщающая таблица работы оператора  &.

Оператор  |  (Битовый OR)

Битовый оператор | сравнивает два двоичных числа и возращает 1 (TRUE) в том случае, если хотя бы у одного из чисел бит равен 1 (TRUE). Во всех других случаях оператор возращает 0 (FALSE) И конечно же для вас подготовлена таблица из которой все станет более понятно:

В таблице можно увидеть два числа 54 и 102, которые будут обрабатываться оператором |. После обработки оператором |,  конечным результатом будет число 118 . Чтобы объяснить, как это значение достигается, нужно смотреть на каждую колонку битов сверху вниз. Взгляните на крайние столбцы: эти столбцы при обработке оператора |, устанавливается как FALSE (Ложь), поскольку в строчках обоих чисел для этого столбца стоят нули. Если вы посмотрите на любые столбцы с названием TRUE, то увидете, что хотя бы в одном строчке столбца есть единичка. Просмотрите внимательно таблицу, а так же прочитайте еще раз внимательно как работает оператор. Теперь можно привести пример использования оператора |

NumberOne.b = 54
NumberTwo.b = 102
NumberThree.b = NumberOne & NumberTwo
Debug NumberThree

В этом маленьком примере двум переменным присваиваются числа, которые будут обрабатываться оператором |, а в переменную NumberThree запишется результат и будет выведен в окно отладки. Значение будет равно 118.   А вот еще один пример:

NumberOne.b = 54
NumberOne | 102
Debug NumberOne

Здесь NUMBERONE присваивается значение 54, и обрабатывается с помощью оператора |  значением 102, а результат сохраняется в  NUMBERONE. И значение сохраненное в NUMBERONE выводится в окно отладки. Далее идет обобщающая таблица работы оператора  |.

Оператор ! (Побитовый XOR)

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

В таблице можно увидеть два числа 38 и 74, которые будут обрабатываться оператором !. После обработки оператором !,  конечным результатом будет число 108 . Чтобы объяснить, как это значение достигается, нужно смотреть на каждую колонку битов сверху вниз. Взгляните на  столбцы в которых сверху  идут одинаковые биты: эти столбцы при обработке оператора !, устанавливается как FALSE (Ложь). Если вы посмотрите на любые столбцы с названием TRUE, то увидете, что биты в этих столбцах разные. Просмотрите внимательно таблицу, а так же прочитайте еще раз внимательно как работает оператор. Теперь можно привести пример использования оператора !

NumberOne.b = 38
NumberTwo.b = 74
NumberThree.b = NumberOne ! NumberTwo
Debug NumberThree

В этом маленьком примере двум переменным присваиваются числа, которые будут обрабатываться оператором !, а в переменную NumberThree запишется результат и будет выведен в окно отладки. Значение будет равно 108.   А вот еще один пример:

NumberOne.b = 38
NumberOne ! 74
Debug NumberOne

Здесь NUMBERONE присваивается значение 38, и обрабатывается с помощью оператора !  значением 74, а результат сохраняется в  NUMBERONE. И значение сохраненное в NUMBERONE выводится в окно отладки. Далее идет обобщающая таблица работы оператора  !.

Оператор ~ (Битовый NOT)

Оператор ~ представляет полное отрицание битов. То есть то что было нулем, станет единицей и наоборот. Вот небольшой пример его применения:

NumberOne.b = 43
NumberTwo.b = ~NumberOne
Debug NumberTwo

Здесь переменной 'NUMBERONE' присваивается значение '43 '. Далее мы создадим переменную' NumberTwo и присвоим ей значение 'NUMBERONE ', но в перевернутом бинарном уровне с использованием оператора ' ~ '. Это значение  (которое должно быть '-44 ')  затем выводится в окно вывода отладки.

Как вы поняли каждый бит инвертируется или говоря проще становится противоположным. Если вы число -44 обработаете опять оператором  ~   то получите число 43.

Оператор << (Сдвиг влево)

Операторы сдвига бит похожи на побитовые операторы тем, что они манипулировать числами в бинарной уровне. Как следует из их названия они сдвигаются все биты влево или вправо в зависимости от используемого оператора. Вот код, демонстрирующий использование '<<' оператора:

NumberOne.b = 50
NumberTwo.b = NumberOne << 1
Debug NumberTwo

В этом примере мы переменной NUMBERONE присваиваем значение 50. Затем мы создаем переменную NumberTwo и присваиваем ей значение NUMBERONE, но обработанное оператором <<. Результат этой операции  100  мы и наблюдаем в окне вывода отладки. Чтобы лучше понимать функции этого оператора, надо взглянуть на таблицу, представленную ниже. Как вы можете видеть результат вычисления имеет просто смещение двоичных битов влево от их исходного положения, в данном случае на одно место. При переключении битов влево создаются нули справа от имеющихся битов, а крайние слева биты будут сдвинуты и будут потеряны навсегда.

Оператор >> (Сдвиг вправо)

 Оператор >> работает точно так же, как оператор <<, но  в противоположном направлении. Вот код демонстрирующий использование этого оператора:

NumberOne.b = 50
NumberTwo.b = NumberOne >> 1
Debug NumberTwo

В этом примере мы назначаем переменной NUMBERONE значение 50. Затем мы создаем переменную NumberTwo и присваиваем ей значение NUMBERONE, но обработанное оператором >>. Результат этой операции  25  мы и наблюдаем в окне вывода отладки.И конечно же посмотрите таблицу:

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

Оператор < (Меньше)

Оператор <  используется при сравнении двух переменных или выражений. Если значение слева меньше чем справа, то этот оператор возвращает "True" (1),
в противном случае он вернет FALSE (0). Вот фрагмент кода, демонстрирующий его использование:

NumberOne.l = 1
NumberTwo.l = 2
If NumberOne < NumberTwo
Debug "1: NumberOne is less than NumberTwo"
Else
Debug "2: NumberTwo is less than NumberOne"
EndIf

Здесь мы проверяем значения двух переменных. Если  NUMBERONE меньше NumberTwo (что конечно же так), то выполнится 1:NumberOne is less than NumberTwo в окне отладки. Если же мы изменим значение 'NUMBERONE' на 3 , вот так:

NumberOne.l = 3
NumberTwo.l = 2
If NumberOne < NumberTwo
Debug "1: NumberOne is less than NumberTwo"
Else
Debug "2: NumberTwo is less than NumberOne"
EndIf

То в окне отладки мы увидим другое предложение 2: NumberTwo is less than NumberOne

Оператор > (Больше)

Оператор >  используется при сравнении двух переменных или выражений. Если значение слева больше чем справа, то этот оператор возвращает "True" (1),
в противном случае он вернет FALSE (0). Вот фрагмент кода, демонстрирующий его использование:

NumberOne.l = 2
NumberTwo.l = 1
If NumberOne > NumberTwo
Debug "1: NumberOne is more than NumberTwo"
Else
Debug "2: NumberTwo is more than NumberOne"
EndIf

Здесь мы проверяем значения двух переменных. Если  NUMBERONE больше NumberTwo (что конечно же так), то выполнится 1:NumberOne is more than NumberTwo в окне отладки. Если же мы изменим значение 'NUMBERONE' на 0 , вот так:

NumberOne.l = 0
NumberTwo.l = 1
If NumberOne > NumberTwo
Debug "1: NumberOne is more than NumberTwo"
Else
Debug "2: NumberTwo is more than NumberOne"
EndIf

То в окне отладки мы увидим другое предложение 2: NumberTwo is more than NumberOne

Оператор <= (Меньше или равно)

Этот оператор используется при сравнении двух переменных или выражений. Если значение слева меньше или равно правому, то этот оператор вернет "True" (1), в противном случае он возвратит "False" (0). Вот фрагмент кода, демонстрирующий его использование:

NumberOne.l = 0
NumberTwo.l = 1
If NumberOne <= NumberTwo
Debug "1: NumberOne is less than or equal to NumberTwo"
Else
Debug "2: NumberOne is NOT less than or equal to NumberTwo"
EndIf

Здесь, как вы сами понимаете, в окне отладки будет 1: NumberOne is less than or equal to NumberTwo  А вот если мы изменим NumberOne и сделаем его к примеру 2 или 3 или больше:

NumberOne.l = 2
NumberTwo.l = 1
If NumberOne <= NumberTwo
Debug "1: NumberOne is less than or equal to NumberTwo"
Else
Debug "2: NumberOne is NOT less than or equal to NumberTwo"
EndIf

То в окошке отладки будет: 2: NumberOne is NOT less than or equal to NumberTwo

Оператор >= (Больше или равно)

Этот оператор используется при сравнении двух переменных или выражений. Если значение слева больше или равно правому, то этот оператор вернет "True" (1), в противном случае он возвратит "False" (0). Вот фрагмент кода, демонстрирующий его использование:

NumberOne.l = 2
NumberTwo.l = 1
If NumberOne >= NumberTwo
Debug "1: NumberOne is more than or equal to NumberTwo"
Else
Debug "2: NumberOne is NOT more than or equal to NumberTwo"
EndIf

Здесь,в окне отладки будет 1: NumberOne is more than or equal to NumberTwo  А вот если мы изменим NumberOne и сделаем его равным 0:

NumberOne.l = 0
NumberTwo.l = 1
If NumberOne >= NumberTwo
Debug "1: NumberOne is more than or equal to NumberTwo"
Else
Debug "2: NumberOne is NOT more than or equal to NumberTwo"
EndIf

То в окне отладки будет 2: NumberOne is NOT more than or equal to NumberTwo

Оператор <> (Не равно)

Этот оператор используется при сравнении двух переменных или выражений. Если значение слева не равно правому, то этот оператор вернет "True" (1), в противном случае он возвратит "False" (0). Вот фрагмент кода, демонстрирующий его использование:

NumberOne.l = 0
NumberTwo.l = 1
If NumberOne <> NumberTwo
Debug "1: NumberOne does not equal NumberTwo"
Else
Debug "2: NumberOne does equal NumberTwo"
EndIf

Здесь,в окне отладки будет: 1: NumberOne does not equal NumberTwo поскольку NumberOne и NumberTwo не равны друг другу, а теперь давайте изменим наш пример так:

NumberOne.l = 1
NumberTwo.l = 1
If NumberOne <> NumberTwo
Debug "1: NumberOne does not equal NumberTwo"
Else
Debug "2: NumberOne does equal NumberTwo"
EndIf

Здесь оператор возратит False а в окне отладки мы увидим: 2: NumberOne does equal NumberTwo

Оператор AND (логическое и)

Логические операторы применяются для объединения сравниваемых логических выражений. Делается это для большего удобства в написании кода. Данный оператор возратит TRUE, только если оба его сравниваемых значения соответствуют запрашиваемой логике.  Посмотрите на этот фрагмент кода:

StringOne.s = "The quick brown fox"
NumberOne.l = 105
If StringOne = "The quick brown fox" And NumberOne = 105
Debug "1: Both expressions evaluate to true (1)"
Else
Debug "2: One or both of the expressions evaluate as false (0)"
EndIf

По моему все просто, но я попробую объяснить как можно проще:

1) первой переменной мы присвоили строку The quick brown fox.

2) второй переменной присоили число 105

3) далее мы спрашиваем: если строка равна StringOne = "The quick brown fox" а так же NumberOne = 105, то оператор вернет True и в окне отладки будет: 1: Both expressions evaluate to true (1)  Но ели бы это было не так то оператор вернет False и в окне мы увидели бы 2: One or both of the expressions evaluate as false (0)

Оператор Not (логическое НЕ)

 
Оператор Not используется для выполнения логического отрицания для выражений или логических значений. Другими словами все, что оценивается как истинно справа  возвращается как ложное и наоборот. См. пример:

One.l = 1
Two.l = 2
If Not One = 5
   Debug "1: One = 5 is evaluated as true (1)"
Else
  Debug "2: One = 5 is evaluated as false (0)"
EndIf
If Not Two = 2
  Debug "1: Two = 2 is evaluated as true (1)"
Else
  Debug "2: Two = 2 is evaluated as false (0)"
EndIf

Двум переменным присваиваются значения. Далее идет условие: If Not One = 5  Давайте прочитаем его более понятно. Мысленно переставим два слова Not и One, и прочитаем:

ЕСЛИ One НЕ РАВНО 5

ТОГДА Debug "1: One = 5 is evaluated as true (1)"

ИНАЧЕ Debug "2: One = 5 is evaluated as false (0)"

С остальными условиями так же.

Оператор Or (логическое или)

Данному оператору нужно хотя бы одно выполняемое условие из двух или более и он вернет TRUE. См пример:

StringOne.s = "The quick brown fox"
NumberOne.l = 105
If StringOne = "The quick brown fox" Or NumberOne = 100
Debug "1: One or more expressions evaluate to true (1)"
Else
Debug "2: Both of the expressions evaluate as false (0)"
EndIf

Здесь сравниваются два условия и поскольку одно из них истинно, этого достаточно для того чтобы оператор возратил True, а в окне отладки высветилась надпись: 1: One or more expressions evaluate to true (1)

Оператор XOr (Логический XOR)

Оператор 'XOR' используется для проверки сразу двух выражений. Посмотрите на этот кусок кода:

StringOne.s = "The quick brown fox"
NumberOne.l = 105
If StringOne = "The quick brown fox" XOr NumberOne = 105
  Debug "1: Only one expression is true (1)"
Else
  Debug "2: The expressions are either both true (1) or both false (0)"
EndIf

Если только одно из выражений является True, то результат справедлив. Если оба выражения являются либо True либо False, то оператор Xor возвращает  false. Для того чтобы разобраться в этом примере, вам надо запустить этот код и поизменять значения переменных.

Оператор % (Остаток)

Этот оператор делит два числа и возращает остаток от деления. Вот пример:

NumberOne.l = 20 % 8
Debug NumberOne

Если 20 разделить на 8, то остаток будет 4

Оператор () (Скобки)

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

NumberOne.l = 2 * 5 + 3
Debug NumberOne

В данном случае будет 13, а теперь другой пример:

NumberOne.l = 2 * (5 + 3)
Debug NumberOne

А теперь мне кажется вам должно быть понятно, что результат 16

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

Приоритет операторов это термин, который означает порядок, в котором будут выполняться действия во время компиляции, а так же при выполнении программы. Посмотрите на таблицу, самый высокий приоритет у оператора под номером 1, а самый низкий у номера 8. Отсюда думается мне все понятно:

В этом примере:

Debug 3 + 10 * 2

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

Debug (3 + 10) * 2

Результатом будет 26

Примечания по выражениям

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

Правила вычисления выражений

Краткий справочник по операторам