Операции
Список операций для плеера версии 5.8.0 в порядке возрастания приоритета:
ORANDNO=,<,>,!,<>,<=,>=,=<,=>(операции сравнения)OBJ,LOC&(конкатенация)+,-(сложение, вычитание)MOD*,/(умножение, деление)-(унарный минус)([выр])- выражения в скобках
Операции записанные на одной строке имеют одинаковый приоритет и выполняются по порядку слева направо, если присутствуют на одном уровне в выражении.
Операции в скобках имеют приоритет перед другими операциями.
Вычисление значений функций имеет приоритет перед всеми операциями.
Верным считается числовое выражение, значение которого отлично от 0. При значении 0 выражение считается ложным. Для значения "верно" настоятельно рекомендуется использовать 1 для совместимости с логическими операциями и функциями, возвращающими логические значения.
В более старых версиях плееров порядок приоритета был иной.
&ORANDOBJ,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]
В более ранних версиях плеера существовала операция "унарный плюс":
+(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 (ложь)
В старых версиях плеера операция была побитовой.
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 (правда)
! можно читать как вопрос: пять не равно трём? Да — правда.
В старых версиях плеера операция была побитовой.
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 (ложь)
В старых версиях плеера операция была побитовой.