Операции

Список операций для плеера версии 5.8.0 в порядке возрастания приоритета:

• OR
• AND
• NO
• =, <, >, !, <>, <=, >=, =<, => (операции сравнения)
• OBJ, LOC
• & (конкатенация)
• +, - (сложение, вычитание)
• MOD
• *, / (умножение, деление)
• - (унарный минус)
• ([выр]) - выражения в скобках

Операции записанные на одной строке имеют одинаковый приоритет и выполняются по порядку слева направо, если присутствуют на одном уровне в выражении.

Операции в скобках имеют приоритет перед другими операциями.

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

Верным считается числовое выражение, значение которого отлично от 0. При значении 0 выражение считается ложным. Для значения "верно" настоятельно рекомендуется использовать 1 для совместимости с логическими операциями и функциями, возвращающими логические значения.

5.7.0

В более старых версиях плееров порядок приоритета был иной.

• &
• OR
• AND
• OBJ, LOC, NO
• =, <, >, !, <>, <=, >=, =<, =>
• +, -
• MOD
• *, /
• +, - (унарные)

Некоторые особенности операций сравнения:

• Операции сравнения возвращают 1 (верно) или 0 (неверно) в зависимости от результата сравнения.

• При сравнении чисел всё просто:

  • из двух положительных чисел положительное число большее по модулю будет считаться большим;
  • отрицательное число всегда меньше не отрицательного (положительное и нуль);
  • положительное число всегда больше не положительного (отрицательное и нуль);
  • из двух отрицательных чисел отрицательное число большее по модулю будет считаться меньшим.

• При сравнении строк происходит посимвольное сравнение слева направо:

  • большим считается символ, который в таблице символов стоит позже. Можно опираться на алфавитную последовательность символов, чтобы понять, какая строка окажется большей. Тогда символ 'z' будет больше символа 'a'. Примеры:

  'z' > 'a' & ! вернёт 1
  'z' > 'az' & ! вернёт 1
  'akz' > 'akk' & ! вернёт 1
  • при сравнении любой непустой строки с пустой строкой пустая строка будет считаться меньшей:

  ' ' > '' & ! вернёт 1
  'a' > '' & ! вернёт 1
  'z' > '' & ! вернёт 1
  'akzakz' > 'akzak' & ! вернёт 1
  Можно считать,

  что отсутствующие символы в строке — это пустые символы (пустые строки), которые при сравнении с любым другим символом оказываются меньшим.

  • при сравнении строки с числом, плеер попытается преобразовать оба значения к числу. Если это удастся, будут сравниваться числа. Если не удастся — число будет преобразовано в строку, и будут сравниваться строки.

  'zzz' > 123 & ! вернёт 1
  '123' > 92 & ! вернёт 1
  '123' > '92' & ! вернёт 0

• При сравнении кортежей происходит поэлементное сравнение слева направо:

  • большим будет считаться тот кортеж, элемент которого оказался большим:

  [1, 2, 3] > [1, 2, 2] & ! вернёт 1
  [2, 2, 3] > [1, 2, 3] & ! вернёт 1
  • при сравнении любого непустого кортежа с пустым кортежем, пустой кортеж будет считаться меньшим:

  [1] > [] & ! вернёт 1
  [''] > [] & ! вернёт 1
  [0] > [] & ! вернёт 1
  [1, 2] > [1] & ! вернёт 1
  [1, 2] < [9] & ! вернёт 1
  Можно считать,

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

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

  [8] < 9 & ! вернёт 1
  [9, 8] > 9 & ! вернёт 1
  [0, 0] > 9 & ! вернёт 0
  
  [8, 9] > '8,9' & ! вернёт 0
  ['a', 'z'] < 'az' & ! вернёт 1
  ['a', 'z'] > 'a' & ! вернёт 1
  (['az'] = "az") & ! вернёт 1

Рекомендуем:

Не проводить сравнения значений разных типов, чтобы это не приводило к путанице.

* (умножение)

* — арифметическая операция "УМНОЖЕНИЕ". Перемножает два числа. Общая запись:

[#выражение 1] * [#выражение 2]

, где [#выражение 1] и [#выражение 2] — два любых числовых значения, или выражения. Результатом работы операции является произведение двух чисел.

Примеры:

2 * 2 & ! вернёт 4
4 * 2 & ! вернёт 8
17 * 5 & ! вернёт 85
37 * 100 & ! вернёт 3700

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

[%кортеж] * [#число]

В данном случае каждый элемент кортежа будет умножен на указанное число. Примеры:

%tuple = [4, 10, 16]
%a = %tuple * 2
! %a будет равно [8, 20, 32]

[4, 10] * 'b' & ! ошибка о несоответствии типов данных

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

*pl [2, 3] * [4, 5]
! [2 * [4,5], 3 * [4,5]]
! [[8,10],[12,15]]

В этом случае каждый элемент первого кортежа умножается на второй кортеж. Это и даёт нам в результате новый кортеж из двух кортежей.

*= (умножение-присвоение)

*= — операция "УМНОЖЕНИЕ-ПРИСВОЕНИЕ". Сочетает в себе операции присвоения и умножения. Умножает значение указанной переменной на определённое число и возвращает результат той же переменной. Общая запись:

ИМЯ_МАССИВА *= [#выражение 1]

, где ИМЯ_МАССИВА — это название переменной (без кавычек), или название массива с указанием ячейки, а [#выражение 1] — любое числовое значение или выражение.

Аналогично конструкции:

ИМЯ_МАССИВА = ИМЯ_МАССИВА*[#выражение 1]

Пример:

! мы заменяем две операции: присвоения и умножение
warrior = warrior * 2
! на умножение-присвоение (действие аналогично)
warrior *= 2

Если значением переменной ИМЯ_МАССИВА является кортеж, каждый элемент кортежа будет умножен на указанное число, а полученный таким образом кортеж присвоится переменной. Пример:

%tuple = [4, 10, 16]
%tuple *= 2
! %tuple будет равно [8, 20, 32]

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

%tuple = [2, 3]
%tuple *= [4, 5]
! %tuple будет равно [[8,10],[12,15]]

Обратите внимание.

Умножение-присвоение с кортежем вызовет ошибку несоответствия типов данных, если тип переменной не является кортежем:

number = 4
number *= [4,5] & ! ошибка о несоответствии типов данных
! так ошибки не будет, но в переменной окажется пустой кортеж:
%number *= [4,5]

+ (сложение)

+ — арифметическая операция "СЛОЖЕНИЕ". Суммирует два числа. Общая запись:

[выражение 1]+[выражение 2]

, где [выражение 1] и [выражение 2] — два любых значения, или выражения. Результатом работы операции является сумма двух значений.

Примеры:

2+2 & ! вернёт 4
4+2 & ! вернёт 6
17+5 & ! вернёт 22
37+100 & ! вернёт 137

При "суммировании" строковых значений производится конкатенация, то есть "склеивание" строк:

! на экран будет выведена строка "2627"
"26"+"27"

Если значения "прибавляются" к кортежу, происходит суммирование каждого элемента кортежа с указанным значением:

%tuple = [4, 10, 16]
%a = %tuple + 2
! %a будет равно [6, 12, 18]

Если складываются два кортежа, к значениям каждого элемента первого кортежа прибавляется второй кортеж:

[4, 10] + ['b', 'x']
! [4 + ['b', 'x'], 10 + ['b', 'x']]
! [['4b','4x'], ['10b','10x']]

+= (сложение-присвоение)

+=, (инкремент) — операция "ИНКРЕМЕНТ", сочетающая в себе операции присвоения и сложения. Прибавляет к текущему значению переменной указанное значение. Общая запись:

ИМЯ_МАССИВА += [выражение 1]

, где ИМЯ_МАССИВА — это название переменной (без кавычек), или название массива с указанием ячейки, а [выражение 1] — любое значение или выражение.

Аналогично конструкции:

ИМЯ_МАССИВА = ИМЯ_МАССИВА + [выражение 1]

Пример:

! мы заменяем две операции: присвоения и сложения
warrior = warrior + 15
! на инкремент (действие аналогично)
warrior += 15

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

$text += " (может быть тут что-то написано)"

Если значением переменной ИМЯ_МАССИВА является кортеж, каждый элемент кортежа будет суммирован с указанным значением, а полученный таким образом кортеж присвоится переменной. Пример:

%tuple = [4, 10, 16]
%tuple += 2
! %tuple будет равно [6, 12, 18]

Можно выполнить сложение-присвоение с другим кортежем:

%tuple = [2, 3]
%tuple += [4, 5]
! %tuple будет равно [[6,7],[7,8]]

Обратите внимание.

Сложение-присвоение с кортежем вызовет ошибку несоответствия типов данных, если тип переменной не является кортежем:

number = 4
number += [4,5] & ! ошибка о несоответствии типов данных
! так ошибки не будет, но в переменной окажется пустой кортеж:
%number += [4,5]

Примечание

Инкремент — во многих языках программирования это операция, которая выполняет увеличение переменной. Чаще всего под инкрементом подразумевается увеличение переменной на 1.

- (вычитание)

- — арифметическая операция "ВЫЧИТАНИЕ". Вычитает одно число из другого. Общая запись:

[#выражение 1] - [#выражение 2]

, где [#выражение 1] и [#выражение 2] — два числовых значения, или выражения. Результатом работы операции является разность двух значений.

Примеры:

2 - 2 & ! вернёт 0
4 - 2 & ! вернёт 2
17 - 5 & ! вернёт 12
37 - 100 & ! вернёт -63

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

[%кортеж] - [#число]

В данном случае из каждого элемента кортежа будет вычтено указанное число. Примеры:

%tuple = [4, 10, 16]
%a = %tuple - 2
! %a будет равно [2, 8, 14]

[4, 10] - 'b' & ! ошибка о несоответствии типов данных

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

*pl [2, 3] - [4, 5]
! [2 - [4,5], 3 - [4,5]]
! [2  + ([4,5] * -1), 3 + ([4,5] * -1)]
! [[-4, -5] + 2, [-4,-5] + 3]
! [[-2,-3],[-1,-2]]

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

-= (вычитание-присвоение)

-=, (декремент) — операция "ДЕКРЕМЕНТ", сочетающая в себе операции присвоения и вычитания. Вычитает из текущего значения переменной указанное значение. Общая запись:

ИМЯ_МАССИВА -= [#выражение 1]

, где ИМЯ_МАССИВА — это название переменной (без кавычек), или название массива с указанием ячейки, а [#выражение 1] — любое числовое значение или выражение.

Аналогично конструкции:

ИМЯ_МАССИВА = ИМЯ_МАССИВА - [#выражение 1]

Пример:

! мы заменяем две операции: присвоения и вычитания
warrior = warrior - 15
! на декремент (действие аналогично)
warrior -= 15

Если значением переменной ИМЯ_МАССИВА является кортеж, из каждого элемента кортежа будет вычитаться указанное число, а полученный таким образом кортеж присвоится переменной. Пример:

%tuple = [4, 10, 16]
%tuple -= 2
! %tuple будет равно [2, 8, 14]

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

%tuple = [2, 3]
%tuple -= [4, 5]
! %tuple будет равно [[-2,-3],[-1,-2]]

Обратите внимание.

Вычитание-присвоение с кортежем вызовет ошибку несоответствия типов данных, если тип переменной не является кортежем:

number = 4
number -= [4,5] & ! ошибка о несоответствии типов данных
! так ошибки не будет, но в переменной окажется пустой кортеж:
%number -= [4,5]

Примечание

Декремент — во многих языках программирования это операция, которая выполняет уменьшение переменной. Чаще всего под декрементом подразумевается уменьшение переменной на 1.

- (унарный минус)

унарный - — унарная операции. Общая запись:

-[#выражение]

, где [#выражение] — любое числовое значение или выражение. Результатом работы этой операций является то же самое значение, только с противоположным знаком.

Примеры:

-2 & ! вернёт -2
-(3+6) & ! вернёт -9
-(-27) & ! вернёт 27

Унарный минус можно использовать перед кортежем, содержащим только числовые значения. Это выражение вернёт новый кортеж, в котором знак каждого элемента будет изменён на противоположный:

- [2, 3, -1, -17, 5]
! [-2, -3, 1, 17, -5]

5.7.0

В более ранних версиях плеера существовала операция "унарный плюс":

+(6+7)

По сути, она ничего не делала, поэтому было решено от неё отказаться.

/ (деление)

/ — арифметическая операция "ДЕЛЕНИЕ". Общая запись:

[#выражение 1] / [#выражение 2]

, где [#выражение 1] и [#выражение 2] — два любых числовых значения, или выражения. Значение [#выражение 2] не должно быть равным нулю. Результатом работы операции является частное от деления двух чисел.

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

Примеры:

2 / 2 & ! вернёт 1
4 / 2 & ! вернёт 2
17 / 5 & ! вернёт 3
37 / 100 & ! вернёт 0

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

[%кортеж] / [#число]

В данном случае каждый элемент кортежа будет разделён на указанное число. Примеры:

%tuple = [4, 10, 16]
%a = %tuple / 2
! %a будет равно [2, 5, 8]

[4, 10] / 'b' & ! ошибка о несоответствии типов данных

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

*pl [30, 60] / [2, 6]
! [30 / [2,6], 60 / [2,6]]
! [[15,5],[30,10]]

В этом случае каждый элемент первого кортежа "делится" на второй кортеж. Это даёт нам в результате новый кортеж из двух кортежей.

/= (деление-присвоение)

/= — операция "ДЕЛЕНИЕ-ПРИСВОЕНИЕ". Сочетает в себе операции присвоения и деления. Делит значение указанной переменной на определённое число и возвращает результат той же переменной. Общая запись:

ИМЯ_МАССИВА /= [#выражение 1]

, где ИМЯ_МАССИВА — это название переменной (без кавычек), или название массива с указанием ячейки, а [#выражение 1] — любое числовое значение или выражение.

Аналогично конструкции:

ИМЯ_МАССИВА = ИМЯ_МАССИВА / [#выражение 1]

Пример:

! мы заменяем две операции: присвоения и деления
warrior = warrior / 2
! на деление-присвоение (действие аналогично)
warrior /= 2

Если значением переменной ИМЯ_МАССИВА является кортеж, каждый элемент кортежа будет разделён на указанное число, а полученный таким образом кортеж присвоится переменной. Пример:

%tuple = [4, 10, 16]
%tuple /= 2
! %tuple будет равно [2, 5, 8]

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

%tuple = [10, 30]
%tuple /= [5, 2]
! %tuple будет равно [[2,5],[6,15]]

Обратите внимание.

Деление-присвоение с кортежем вызовет ошибку несоответствия типов данных, если тип переменной не является кортежем:

number = 4
number /= [4,5] & ! ошибка о несоответствии типов данных
! так ошибки не будет, но в переменной окажется пустой кортеж:
%number /= [4,5]

< (меньше)

< — операция сравнения "МЕНЬШЕ". Общая запись:

[выражение_1] < [выражение_2]

Если значение выражения [выражение_1] меньше значения выражения [выражение_2] операция вернёт 1, в противном случае вернёт 0. Иными словами: верно, если первое меньше второго.

Примеры:

! 2 меньше 4 — вернёт 1
2 < 4
! 5 не меньше 5 — вернёт 0
5 < 5
! 7 не меньше 3 — вернёт 0
7 < 3

Сравнивать можно текстовые значения:

"a" < "z"      & ! верно
"z" < "zz"     & ! верно
"aaaaaa" < "z" & ! верно

И можно сравнивать кортежи:

[1, 2, 3] < [1, 2, 9] & ! верно
[1, 2, 3] < [2, 2, 3] & ! верно
[1, 2] < [1, 2, 3] & ! верно

<= (меньше либо равно)

<= — операция сравнения "МЕНЬШЕ ЛИБО РАВНО". Общая запись:

[выражение_1] <= [выражение_2]

Если значение выражения [выражение_1] меньше либо равно значению выражения [выражение_2] операция вернёт 1, в противном случае вернёт 0. Иными словами: верно, если первое меньше второго, либо равно ему.

Примеры:

! 2 меньше 4 — вернёт 1
2 <= 4
! 5 равно 5 — вернёт 1
5 <= 5
! 7 не меньше трёх и не равно ему
7 <= 3 & ! вернёт 0

Аналогично "=<" и конструкциям:

([выражение_1] < [выражение_2]) or ([выражение_1] = [выражение_2])

no [выражение_1] > [выражение_2]

Сравнивать можно и текстовые значения:

"a" <= "z"    & ! верно
"z" <= "zz"    & ! верно
"aaaaaa" <= "z" & ! верно
"z" <= "z" & ! верно

И кортежи:

[1, 2, 3] <= [1, 2, 9] & ! верно
[1, 2, 3] <= [2, 2, 3] & ! верно
[1, 2] <= [1, 2, 3] & ! верно
[1, 2, 3] <= [1, 2, 3] & ! верно

<> (не равно)

<> — операция сравнения "НЕ РАВНО". Общая запись:

[выражение_1] <> [выражение_2]

Если значение выражения [выражение_1] не равно значению выражения [выражение_2] операция вернёт 1, в противном случае вернёт 0. Иными словами: верно, если выражения не равны.

Аналогично "!", или конструкции:

no [выражение_1] = [выражение_2]

Примеры:

! 2 не равно 4 — вернёт 1
2 <> 4
! 5 равно 5 — вернёт 0
5 <> 5

Можно сравнивать и строковые значения:

"abc" <> "def" & ! вернёт 1
"abc" <> "abc" & ! вернёт 0

Можно сравнивать кортежи:

[1, 2, 3] <> [4, 6, 7] & ! вернёт 1
[1, 2, 3] <> [1, 2, 3] & ! вернёт 0

= (равно)

= — операция сравнения "РАВНО". Общая запись:

[выражение_1] = [выражение_2]

Если значение выражения [выражение_1] равно значению выражения [выражение_2] операция вернёт 1, в противном случае вернёт 0. Иными словами: верно, если выражения равны.

Аналогично конструкции:

no [выражение_1] <> [выражение_2]

Примеры:

! 2 не равно 4 — вернёт 0
(2 = 4)
! 5 равно 5 — вернёт 1
(5 = 5)

Можно сравнивать и строковые значения:

("abc" = "def") & ! вернёт 0
("abc" = "abc") & ! вернёт 1

Можно сравнивать кортежи:

([1, 2, 3] = [4, 6, 7]) & ! вернёт 0
([1, 2, 3] = [1, 2, 3]) & ! вернёт 1

Внимание!

Не путайте с операцией присвоения.

= (присвоение)

= — операция присвоения. Общая запись:

ИМЯ_МАССИВА = [значение]

, где ИМЯ_МАССИВА — название переменной (не в кавычках), или название массива с указанием ячейки (не в кавычках), [значение] — любое значение или выражение.

Примеры:

! переменной BOX присваиваем значение 13
BOX = 13
! переменной $text присваиваем значение "Строка текста"
$text = "Строка текста"
! нулевой ячейке массива day присваивается значение 365
day[0] = 365
! переменной tuple присваивается кортеж [1, 'unit', 3]:
%tuple = [1, 'unit', 3]

Имена строковых переменных/массивов должны начинаться с символа $.

Имена переменных/массивов, содержащих кортежи должны начинаться с символа %.

Внимание!

Операцию присвоения не следует путать с операцией сравнения "РАВНО", хотя они очень похожи:

! операция присвоения
alukard = 1000
! операция сравнения
(alukard = 1000)

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

"abc" = "abc"

синтаксически ошибочна. Плеер выдаст ошибку: недопустимое название переменной/массива. Так как в этом случае он не понимает, что это операция сравнения.

Если перед операцией сравнения явно стоит оператор, скобки можно не писать:

if alukard = 150: *pl "Не хватает сил"
*pl "abc" = "abc"

Множественное присвоение

Множественное присвоение позволяет одной командой = присвоить значения сразу нескольким переменным или ячейкам массива. Общая запись:

ИМЯ_МАССИВА_1, ИМЯ_МАССИВА_2, ... , ИМЯ_МАССИВА_N = [ЗНАЧЕНИЕ_1], [ЗНАЧЕНИЕ_2], ... , [ЗНАЧЕНИЕ_N]

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

Важно помнить!

Слева от знака равенства должно быть столько же переменных, сколько справа значений. Число переменных, и число присваиваемых значений — должны совпадать.

При распаковке кортежей это правило не соблюдается.

Примеры:

яблоки_в_кармане, яблоки_в_лукошке, яблоки_у_Лёшки = 58, 11, 19
$строка_1, $строка_2 = 'Ехал Грека Через Реку', 'Видит Грека В Реке Рак'
$name, count = 'Старый меч', 2

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

! три переменные = три значения
red, green, blue = rand(0,255), rand(0,255), rand(0,255)
! две переменные = два значения
яблоки_в_кармане, яблоки_в_лукошке = яблоки_у_Лёшки, яблоки_на_дереве+15

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

! присваиваем пременным x и y значения 12 и 99
x, y = 12, 99
! меняем местами значения. Теперь в x находится число 99, а в y — 12
x, y = y, x

Распаковка кортежей

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

! %unit = [187, 94, 'steel', [0, 2]]
рост, вес, $материал, %координаты = %unit

Как видите, здесь у нас слева четыре имени переменной, а справа только одно имя переменной-кортежа. Такое присвоение называется распаковкой — значения извлекаются из кортежа и помещаются в указанные переменные.

Точно так же распаковывается кортеж, даже не помещённый в переменную:

рост, вес, $материал, %координаты = [187, 94, 'steel', [0, 2]]

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

рост, вес, $материал, %координаты = 187, 94, 'steel', [0, 2]

Cледует подчеркнуть, что множественное присвоение — это по сути распаковка кортежей.

Поскольку, если переменных слева от знака равенства будет больше, чем значений в кортеже, в "лишние" переменные запишутся значения по умолчанию для этих переменных, то и при множественном присвоении произойдёт то же самое.

r, g, b, a = [255, 188, 19]
! r = 255, g = 188, b = 19, a = 0
raz, dva, tri, chetyre = 137, 61
! raz = 137, dva = 61, tri = 0, chetyre = 0

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

Несоответствие типов данных

coords = 23, 34
age, weight, material = 27, 94, 'steel', 'biorobot'

Если тип последней из перечисленных переменных будет кортеж, такое присвоение ошибку не вызовет:

age, weight, %type = 27, 94, 'steel', 'biorobot'
! age = 27, weight = 94, %type = ['steel', 'biorobot']

=< (равно либо меньше)

Внимание!

Данная запись, хотя и допустима в QSP, к использованию не рекомендуется. Используйте "<= (меньше либо равно)" вместо этого.

=< — операция сравнения "РАВНО ЛИБО МЕНЬШЕ". Общая запись:

[выражение_1] =< [выражение_2]

Если значение выражения [выражение_1] меньше либо равно значению выражения [выражение_2] операция вернёт 1, в противном случае вернёт 0. Иными словами: верно, если первое меньше второго, либо равно ему.

Примеры:

! 2 меньше 4 — вернёт 1
2 =< 4
! 5 равно 5 — вернёт 1
5 =< 5
! 7 не меньше трёх и не равно ему
7 =< 3 & ! вернёт 0

Аналогично "<=" и конструкциям:

([выражение_1] < [выражение_2]) or ([выражение_1] = [выражение_2])

no [выражение_1] > [выражение_2]

=> (равно или больше)

=> — операция сравнения "РАВНО ИЛИ БОЛЬШЕ". Общая запись:

Внимание!

Данная запись, хотя и допустима в QSP, к использованию не рекомендуется. Используйте ">= (больше либо равно)" вместо этого.

[выражение_1] => [выражение_2]

Если значение выражения [выражение_1] больше либо равно значению выражения [выражение_2] операция вернёт 1, в противном случае вернёт 0. Иными словами: верно, если первое больше второго, либо равно ему.

Примеры:

! 2 не меньше и не равно 4 — вернёт 0
2 => 4
! 5 равно 5 — вернёт 1
5 => 5
! 7 больше 3
7 => 3 & ! вернёт 1

Аналогично ">=" и конструкциям:

([выражение_1] > [выражение_2]) or ([выражение_1] = [выражение_2])
no [выражение_1] < [выражение_2]

> (больше)

> — операция сравнения "БОЛЬШЕ". Общая запись:

[выражение_1] > [выражение_2]

Если значение выражения [выражение_1] больше значения выражения [выражение_2] операция вернёт 1, в противном случае вернёт 0. Иными словами: верно, если первое больше второго.

Примеры:

! 2 не больше 4 — вернёт 0
2 > 4
! 5 не больше 5 — вернёт 0
5 > 5
! 7 больше 3 — вернёт 1
7 > 3

Сравнивать можно и текстовые значения, при этом символы сравниваются поочерёдно, и большим считается символ, стоящий ближе к концу алфавита.

"z" > "a"         & ! верно
"zz" > "z"     & ! верно
"z" > "aaaaaa" & ! верно

И можно сравнивать кортежи:

[1, 2, 9] > [1, 2, 3] & ! верно
[1, 2, 3] > [2, 2, 3] & ! неверно
[1, 2, 3] > [1, 2] & ! верно

>= (больше либо равно)

>= — операция сравнения "БОЛЬШЕ ЛИБО РАВНО". Общая запись:

[выражение_1] >= [выражение_2]

Если значение выражения [выражение_1] больше либо равно значению выражения [выражение_2] операция вернёт 1, в противном случае вернёт 0. Иными словами: верно, если первое больше второго, либо равно ему.

Примеры:

! 2 не меньше и не равно 4 — вернёт 0
2 >= 4
! 5 равно 5 — вернёт 1
5 >= 5
! 7 больше 3
7 >= 3 & ! вернёт 1

Аналогично "=>" и конструкциям:

([выражение_1] > [выражение_2]) or ([выражение_1] = [выражение_2])
no [выражение_1] < [выражение_2]

Сравнивать можно и текстовые значения, при этом символы сравниваются поочерёдно, и большим считается символ, стоящий ближе к концу алфавита.

"z" >= "a"    & ! верно
"zz" >= "z"    & ! верно
"z" >= "aaaaaa" & ! верно
"z" >= "z" & ! верно

И кортежи:

[1, 2, 9] >= [1, 2, 3] & ! верно
[1, 2, 3] >= [2, 2, 3] & ! не верно
[1, 2] >= [1, 2, 3] & ! не верно
[1, 2, 3] >= [1, 2, 3] & ! верно

! (не равно)

Внимание!

Не путайте с оператором комментария.

Для улучшения читаемости кода рекомендуем использовать <>.

! — операция сравнения "НЕ РАВНО". Общая запись:

[выражение_1]![выражение_2]

Если значение выражения [выражение_1] не равно значению выражения [выражение_2] операция вернёт 1, в противном случае вернёт 0. Иными словами: верно, если выражения не равны.

Аналогично "<>", или конструкции:

no [выражение_1] = [выражение_2]

Примеры:

! 2 не равно 4 — вернёт 1
2 ! 4
! 5 равно 5 — вернёт 0
5 ! 5

& (конкатенация)

& — конкатенация, операция объединения строковых выражений или кортежей. Общая запись:

([$выражение 1] & [$выражение 2])
([%выражение 1] & [%выражение 2])

внимание!

Конкатенацию всегда нужно заключать в скобки!

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

Примеры:

*pl ('привет, ' & 'Мир!')
! на экране увидим строку 'привет, Мир!'
*pl ([1, 2, 3] & [4, 5, 6])
! на экране увидим кортеж [1, 2, 3, 4, 5, 6]

внимание!

Не путайте с символом перечисления команд:

! в данном случае на экран будут
! последовательно выведены строки "26" и "27"
"26" & "27"
! а здесь на экран будет выведена строка "2627"
("26" & "27")

подсказка

Не рекомендуется использовать данную операцию для объединения строк, поскольку строки можно объединять через +:

! на экран будет выведена строка "2627"
"26"+"27"

Такая запись создаёт меньше путаницы при чтении кода и работает аналогичным образом.

Склеить два кортежа в один при помощи операции + не получится:

[2, 5] + [3, 7]
! на экране будет кортеж: [[5,9],[8,12]]

AND

AND — логическое "И". Общая запись:

[#выражение 1] AND [#выражение 2]

Всё данное выражение будет верным, если верны выражения [#выражение 1] и [#выражение 2].

Примеры:

! обе части выражения верны, значит и всё выражение верно
(2 = 2) and (3 <> 2) & ! выражение вернёт 1 (правда)
! одна часть выражения не верна, значит всё выражение неверно
(2 <> 2) and (3 <> 2) & ! выражение вернёт 0 (ложь)
! обе части выражения не верны, значит и всё выражение не верно
(2 <> 2) and (3 = 2) & ! выражение вернёт 0 (ложь)

5.7.0

В старых версиях плеера операция была побитовой.

LOC

LOC — операция проверяет наличие локации и возвращает 1, если локация есть, и — 0, если локации нет. Общая запись:

LOC([$локация])

, где [$локация] — название локации, наличие которой необходимо проверить в игре. Выражение верно, если локация существует в игре.

Примеры:

! проверяет, есть ли в игре локация "начало"
loc("начало") & ! если локация есть, возвращает 1

! если локация "улица" не добавлена в игру
if loc("улица") = 0:
    act "Выйти на улицу": *pl "Я не могу выйти на улицу, дверь не отпирается."
end

MOD

MOD — операция вычисляет остаток от деления двух чисел. Общая запись:

[#выражение 1] MOD [#выражение 2]

, где [#выражение 1] — делимое, [#выражение 2] — делитель.

Примеры:

! 4 делится на 2 нацело
4 mod 2 & ! возвращает 0
! 5 не делится на 2 нацело
5 mod 2 & ! возвращает 1
! 13 не делится на 10 нацело
13 mod 10 & ! возвращает 3

Остаток от деления отрицательного числа будет отрицательным числом.

NO

NO — операция отрицания. Общая запись:

NO [#выражение]

Если [#выражение] верно, то всё выражение неверно, и наоборот. Иными словами, возвращает 0, если значение выражения отлично от нуля, и возвращает 1, если значение выражения равно 0.

Пример:

! 4 равно 4 это верно, значит всё выражение неверно
no (4 = 4) & ! вернёт 0 (ложь)
! можно читать как вопрос: четыре не равно четырём? Нет — ложь.

! то, что 5 равно 3, — неверно, значит всё выражение верно
no (5 = 3) & ! вернёт 1 (правда)
! можно читать как вопрос: пять не равно трём? Да — правда.

5.7.0

В старых версиях плеера операция была побитовой.

OBJ

OBJ — операция проверяет наличие предмета в инвентаре и возвращает 1, если предмет есть, и — 0, если предмета нет. Общая запись:

OBJ([$название])

, где [$название] — название предмета, наличие которого необходимо проверить в окне предметов. Выражение верно, если предмет добавлен в окно предметов.

Примеры:

! проверяет, добавлен ли в окно предметов предмет "Отвёртка"
obj("Отвёртка") & ! если предмет есть, возвращает 1

! в зависимости от наличия того или иного предмета
! выводится то или иное действие
if obj("Полный кувшин") = 1:
    act "Опустошить кувшин":
        delobj "Полный кувшин"
        addobj "Пустой квушин"
        goto $curloc
    end
elseif obj("Пустой кувшин") = 1:
    act "Наполнить кувшин":
        addobj "Полный кувшин"
        delobj "Пустой квушин"
        goto $curloc
    end
end

OR

OR — логическое "ИЛИ". Общая запись:

[#выражение 1] OR [#выражение 2]

Всё данное выражение будет верным, если хотя бы одно из выражений [#выражение 1] и [#выражение 2] верно.

Примеры:

! обе части выражения верны, значит и всё выражение верно
(2 = 2) or (3 <> 2) & ! выражение вернёт 1 (правда)
! одна часть выражения верна, значит всё выражение верно
(2 <> 2) or (3 <> 2) & ! выражение вернёт 1 (правда)
! обе части выражения не верны, значит и всё выражение не верно
(2 <> 2) or (3 = 2) & ! выражение вернёт 0 (ложь)

5.7.0

В старых версиях плеера операция была побитовой.