Pengendali skala
Operator ialah simbol yang memberitahu pengkompil untuk melaksanakan operasi matematik dan logik tertentu.
Scala mempunyai set pengendali terbina dalam yang kaya, termasuk jenis berikut:
Pengendali aritmetik
Pengendali perhubungan
Pengendali logik
Pengendali bitwise
Pengendali tugasan
Seterusnya kami akan memperkenalkan aplikasi operator di atas secara terperinci.
Pengendali aritmetik
Jadual berikut menyenaraikan pengendali aritmetik yang disokong oleh Scala.
Anggap pembolehubah A ialah 10 dan B ialah 20:
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加号 | A + B 运算结果为 30 |
| - | 减号 | A - B 运算结果为 -10 |
| * | 乘号 | A * B 运算结果为 200 |
| / | 除号 | B / A 运算结果为 2 |
| % | 取余 | B % A 运算结果为 0 |
Instance
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) );
}
}Laksanakan Kod di atas, hasil output ialah:
$ scalac Test.scala $ scala Test a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5
Pengendali perhubungan
Jadual berikut menyenaraikan pengendali perhubungan yang disokong oleh Scala.
Andaikan pembolehubah A ialah 10 dan B ialah 20:
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 | (A == B) 运算结果为 false |
| != | 不等于 | (A != B) 运算结果为 true |
| > | 大于 | (A > B) 运算结果为 false |
| < | 小于 | (A < B) 运算结果为 true |
| >= | 大于等于 | (A >= B) 运算结果为 false |
| <= | 小于等于 | (A <= B) 运算结果为 true |
Contoh
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) );
}
}Laksanakan kod di atas, hasil output ialah:
$ scalac Test.scala $ scala Test a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
Operator Logik
Jadual berikut menyenaraikan pengendali logik yang disokong oleh Scala.
Anggap pembolehubah A ialah 1 dan B ialah 0:
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 逻辑与 | (A && B) 运算结果为 false |
| || | 逻辑或 | (A || B) 运算结果为 true |
| ! | 逻辑非 | !(A && B) 运算结果为 true |
Instance
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) );
}
}melaksanakan kod di atas, dan hasil output ialah:
$ scalac Test.scala $ scala Test a && b = false a || b = true !(a && b) = true
Pengendali bit
Pengendali bit digunakan untuk beroperasi pada bit binari, ~ ,&,|,^ masing-masing adalah operasi penolakan, bitwise AND, bitwise AND, bitwise AND dan XOR, seperti yang ditunjukkan dalam contoh jadual berikut:
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Jika anda menyatakan A = 60 dan B = 13; Perduaan yang sepadan dengan dua pembolehubah ialah:
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Peraturan operasi bitwise dalam Scala adalah seperti berikut:
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
| >>> | 无符号右移 | A >>>2 输出结果 15, 二进制解释: 0000 1111 |
Instance
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 );
}
}melaksanakan kod di atas, dan hasil output ialah:
$ 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
Operator Tugasan
Berikut menyenaraikan pengendali tugasan yang disokong oleh Scala bahasa:
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算，指定右边操作数赋值给左边的操作数。 | C = A + B 将 A + B 的运算结果赋值给 C |
| += | 相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数。 | C += A 相当于 C = C + A |
| -= | 相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数。 | C -= A 相当于 C = C - A |
| *= | 相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数。 | C *= A 相当于 C = C * A |
| /= | 相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数。 | C /= A 相当于 C = C / A |
| %= | 求余后再赋值，将左右两边的操作数求余后再赋值给左边的操作数。 | C %= A is equivalent to C = C % A |
| <<= | 按位左移后再赋值 | C <<= 2 相当于 C = C << 2 |
| >>= | 按位右移后再赋值 | C >>= 2 相当于 C = C >> 2 |
| &= | 按位与运算后赋值 | C &= 2 相当于 C = C & 2 |
| ^= | 按位异或运算符后再赋值 | C ^= 2 相当于 C = C ^ 2 |
| |= | 按位或运算后再赋值 | C |= 2 相当于 C = C | 2 |
Instance
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 );
}
}melaksanakan kod di atas, dan hasil output ialah:
$ 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
Keutamaan operator
mungkin mengandungi berbilang perbezaan dalam satu ungkapan Objek data bagi jenis data yang berbeza yang disambungkan oleh pengendali kerana ungkapan mempunyai berbilang operasi, perintah operasi yang berbeza mungkin menghasilkan hasil yang berbeza atau ralat operasi yang salah, kerana apabila ungkapan mengandungi berbilang operasi, ia mestilah Hanya dengan menggabungkan dalam susunan tertentu boleh rasional operasi dan ketepatan dan keunikan keputusan dipastikan.
Keutamaan berkurangan dari atas ke bawah, dengan yang teratas mempunyai keutamaan tertinggi dan pengendali koma mempunyai keutamaan paling rendah.
Dalam keutamaan yang sama, pengiraan adalah berdasarkan susunan gabungan. Kebanyakan operasi dikira dari kiri ke kanan, dan hanya tiga tahap keutamaan digabungkan dari kanan ke kiri Ia adalah operator unary, operator bersyarat dan pengendali tugasan.
Keutamaan asas perlu diingat:
Penunjuk adalah optimum, dan operasi bermata adalah lebih baik daripada operasi binokular. Seperti tanda tambah dan tolak.
Mula-mula darab dan bahagi (modulo), kemudian tambah dan tolak.
Operasi aritmetik dahulu, kemudian operasi anjakan, dan akhirnya operasi bit. Sila beri perhatian khusus kepada: 1 << 3 + 2 & 7 adalah bersamaan dengan (1 << (3 + 2))&7
Pengiraan terakhir bagi logik operasi
| Jenis pengendali | Operator | Menggabungkan arah | th>|||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Kendalian ungkapan | () [] /tr>< tr> | Pengendali unary |
| Kanan ke kiri | |||||||||||||||||||||
| Pengendali bitwise | <🎜>&<🎜><🎜>^<🎜> <🎜 >|<🎜><🎜>&&<🎜><🎜>||<🎜> | Kiri ke kanan | |||||||||||||||||||||||
| Pengendali Ternary | ?: | Kanan ke kiri | |||||||||||||||||||||||
| Pengendali tugasan | = += -= *= /= %= >>= <<= &= ^= |= | Kanan ke kiri | |||||||||||||||||||||||
| , | Kiri ke kanan |
