Лучшее руководство по оператор Scala в 2024 году. В этом руководстве вы можете изучить Арифметические операторы,Операторы отношения,Логические операторы,Битовые операторы,Операторы присваивания,Оператор Внеочередные,
Оператор является символом, используемым для компилятора для выполнения заданного математических и логических операций.
Scala, богатые встроенные операторы, в том числе следующих типов:
Арифметические операторы
Операторы отношения
Логические операторы
Битовые операторы
Операторы присваивания
Далее мы расскажем вам больше, чем применение различных операторов.
В следующей таблице перечислены поддержка арифметических операторов Scala.
Переменная предполагается как 10, В 20:
операторы | описание | примеров |
---|---|---|
+ | плюс | Результатом операции + B 30 |
- | минус | A - результат операции B -10 |
* | Умножение знак | A * B результат операции 200 |
/ | Знак деления | B / A, результат операции 2 |
% | остаток | B% результат вычисления А 0 |
object Test { def main(args: Array[String]) { var a = 10; var b = 20; var c = 25; var d = 25; println("a + b = " + (a + b) ); println("a - b = " + (a - b) ); println("a * b = " + (a * b) ); println("b / a = " + (b / a) ); println("b % a = " + (b % a) ); println("c % a = " + (c % a) ); } }
Реализация указанного выше кода, выход:
$ scalac Test.scala $ scala Test a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5
В следующей таблице перечислены Scala поддерживают операторы отношений.
Переменная предполагается как 10, В 20:
операторы | описание | примеров |
---|---|---|
== | равных | (A == B) результат операции является ложным |
! = | Не равно | (A! = B) результат операции верно |
> | Более | (A> B) Результат Операция является ложным |
< | Менее | (A <B) результат операции верно |
> = | Больше или равно | (A> = B) результат операции является ложным |
<= | Меньше или равно | (A <= B) результат операции верно |
object Test { def main(args: Array[String]) { var a = 10; var b = 20; println("a == b = " + (a == b) ); println("a != b = " + (a != b) ); println("a > b = " + (a > b) ); println("a < b = " + (a < b) ); println("b >= a = " + (b >= a) ); println("b <= a = " + (b <= a) ); } }
Реализация указанного выше кода, выход:
$ scalac Test.scala $ scala Test a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
В следующей таблице перечислены Scala поддерживает логические операторы.
Переменная, как предполагается, 1, B = 0:
операторы | описание | примеров |
---|---|---|
&& | Логика и | (A && B) результат операции является ложным |
|| | Логическое иЛИ | (A || B) результат операции верно |
! | Логическое НЕ | ! (A && B) результат операции верно |
object Test { def main(args: Array[String]) { var a = true; var b = false; println("a && b = " + (a&&b) ); println("a || b = " + (a||b) ); println("!(a && b) = " + !(a && b) ); } }
Реализация указанного выше кода, выход:
$ scalac Test.scala $ scala Test a && b = false a || b = true !(a && b) = true
Битовые операторы битов, используемых для работы, ~, &, |, ^ были сведены на нет, а бит, или битом и, побитовое исключающее ИЛИ операции со следующими примерами таблицы:
р | Q | р & д | р | д | р ^ д |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Если A = 60 и B = 13, две переменные, соответствующие двоичном виде:
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Правило Scala Побитовая следующим образом:
операторы | описание | примеров |
---|---|---|
& | Побитовое И оператор | (A & B) выход 12, бинарная информация: 0000 1100 |
| | Побитовое ИЛИ оператор | (A | B) выход 61, бинарная информация: 00111101 |
^ | Побитовое исключающее ИЛИ оператор | (А ^ б) выход 49, бинарная информация: 00110001 |
~ | Битовые операторы | (~ A) -61 выход, бинарная информация: 1100 0011 в символическом виде дополнительного кода двоичного числа. |
<< | Левый оператор мобильной связи | а << 2 выхода 240 Binary интерпретация: 11110000 |
>> | Правые Операторы мобильной связи | A >> 2 выход 15, бинарная информация: 0000 1111 |
>>> | Сдвиг вправо без знака | A >>> 2 выходы 15 двоичная Объяснение: 0000 1111 |
object Test { def main(args: Array[String]) { var a = 60; /* 60 = 0011 1100 */ var b = 13; /* 13 = 0000 1101 */ var c = 0; c = a & b; /* 12 = 0000 1100 */ println("a & b = " + c ); c = a | b; /* 61 = 0011 1101 */ println("a | b = " + c ); c = a ^ b; /* 49 = 0011 0001 */ println("a ^ b = " + c ); c = ~a; /* -61 = 1100 0011 */ println("~a = " + c ); c = a << 2; /* 240 = 1111 0000 */ println("a << 2 = " + c ); c = a >> 2; /* 215 = 1111 */ println("a >> 2 = " + c ); c = a >>> 2; /* 215 = 0000 1111 */ println("a >>> 2 = " + c ); } }
Реализация указанного выше кода, выход:
$ scalac Test.scala $ scala Test a & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a << 2 = 240 a >> 2 = 15 a >>> 2 = 15
Ниже перечислены оператор Scala язык Назначение: поддержка
операторы | описание | примеров |
---|---|---|
= | Простой оператор присваивания, определяет правый операнд, назначенный левого операнда. | С результатом = А + В А + Б операция назначается C |
+ = | Добавление после присваивания, левая и правая стороны операнда прежде, чем добавить назначен левого операнда. | С + = А соответствует C = C + A |
- = | После присвоения вычитанием, левый и правый операнды по обе стороны левого операнда после вычитания назначен. | C - = A соответствует C = C - A |
* = | Тогда, умножая назначение, левые и правые части операндов умножаются перед тем назначением на левый операнд. | С * = А соответствует C = C * A |
/ = | Разделенные после присваивания, левая и правая стороны разделительного операнда после присваивания левого операнда. | С / = А эквивалентно С = С / А |
% = | Remainder после присваивания, левая и правая части остатка операнда после присваивания левого операнда. | С% = А эквивалентно C = C% A |
<< = | Побитовая оставил после присвоения | C << = 2 соответствует C = C << 2 |
>> = | Побитовая сразу после присвоения | C >> = 2 эквивалентно C = C >> 2 |
& = | Побитовое назначение после операции | С & = 2 эквивалентно С = С & 2 |
^ = | Побитовое исключающее ИЛИ оператора, а затем назначен | C ^ = 2 эквивалентно C = C ^ 2 |
| = | Побитовое ИЛИ назначение после | C | = 2 соответствует C = C | 2 |
object Test { def main(args: Array[String]) { var a = 10; var b = 20; var c = 0; c = a + b; println("c = a + b = " + c ); c += a ; println("c += a = " + c ); c -= a ; println("c -= a = " + c ); c *= a ; println("c *= a = " + c ); a = 10; c = 15; c /= a ; println("c /= a = " + c ); a = 10; c = 15; c %= a ; println("c %= a = " + c ); c <<= 2 ; println("c <<= 2 = " + c ); c >>= 2 ; println("c >>= 2 = " + c ); c >>= 2 ; println("c >>= a = " + c ); c &= a ; println("c &= 2 = " + c ); c ^= a ; println("c ^= a = " + c ); c |= a ; println("c |= a = " + c ); } }
Реализация указанного выше кода, выход:
$ scalac Test.scala $ scala Test c = a + b = 30 c += a = 40 c -= a = 30 c *= a = 300 c /= a = 1 c %= a = 5 c <<= 2 = 20 c >>= 2 = 5 c >>= a = 1 c &= 2 = 0 c ^= a = 10 c |= a = 10
В выражении может содержать множество различных операторов, связывающих с различными типами данных объектов данных, так как выражение имеет разнообразные операции, различный порядок операций может иметь разные результаты даже ошибочными ошибки в работе, так как, когда когда выражение, содержащее различные операции, в соответствии с определенном порядке должны быть объединены, чтобы обеспечить рациональность и правильность результатов, уникальность работы.
Приоритет в порядке убывания сверху вниз, верхний имеет самый высокий приоритет, оператор запятая имеет самый низкий приоритет.
Тот же уровень приоритета, в соответствии с порядком связывания расчета. Большинство операций, вычисляются слева направо, только три приоритеты справа налево комбинации, они являются унарные операторы, операторы, условные операторы присваивания.
Основные приоритеты должны помнить:
Тип оператора | операторы | Связывание направления |
---|---|---|
оценка Expression | () []. Expr ++ expr-- | Слева направо |
Унарный оператор | * & + -! ~ ++ Expr --expr * /% + - >> << <> <=> = ==! = | Справа налево |
Битовые операторы | & ^ | && || | Слева направо |
троичный оператор | ?: | Справа налево |
Операторы присваивания | = + = - = * = / =% = >> = << = & = ^ = | = | Справа налево |
запятая | , | Слева направо |