Scala 运算符（深入浅出）

Scala 运算符：从基础到精通的实用指南

在学习 Scala 的过程中，你可能会发现它不像 Java 那样有大量繁琐的语法符号，但恰恰是这些看似简单的符号，构成了程序逻辑的核心骨架。今天我们就来深入聊聊 Scala 运算符，这不仅是写代码的工具，更是表达逻辑、构建表达式的关键语言。无论你是刚接触 Scala 的初学者，还是已经有一定经验的开发者，这篇内容都会帮你把“运算符”这个看似基础的概念真正吃透。

什么是 Scala 运算符？它和你熟悉的其他语言有何不同？

在大多数编程语言中，运算符是用于执行数学、比较或逻辑操作的符号。比如 + 表示加法，> 表示大于。Scala 也支持这些基本运算符，但它的设计哲学更强调“一切都是表达式”，这意味着运算符不仅是操作工具，更可以是方法调用的一种语法糖。

举个例子，a + b 在 Scala 中其实等价于 a.+(b)。这种设计让开发者可以将自定义类的方法用运算符形式调用，从而写出更自然、更可读的代码。

比如你可以这样定义一个复数类：

class Complex(val real: Double, val imag: Double) {
  // 重载 + 运算符，实现复数加法
  def +(other: Complex): Complex = {
    new Complex(this.real + other.real, this.imag + other.imag)
  }
}

// 使用示例
val c1 = new Complex(3.0, 4.0)
val c2 = new Complex(1.0, 2.0)
val sum = c1 + c2  // 看似是运算符，其实是方法调用
println(sum)       // 输出: Complex(4.0,6.0)

注释：这里 c1 + c2 被编译器自动转换为 c1.+(c2)，体现了 Scala 运算符的“方法化”本质。这种机制让代码更接近数学表达式，阅读起来更直观。

常见的 Scala 运算符分类与使用场景

Scala 运算符大致可以分为以下几类：算术、比较、逻辑、赋值、位运算。下面逐一说明。

算术运算符：基础中的基础

算术运算符是最常用的，包括 +、-、*、/ 和 %（取模）。

val a = 10
val b = 3

val add = a + b       // 13
val sub = a - b       // 7
val mul = a * b       // 30
val div = a / b       // 3（整数除法，结果为整数）
val mod = a % b       // 1（余数）

println(s"加法: $add, 减法: $sub, 乘法: $mul, 除法: $div, 取模: $mod")

注释：在 Scala 中，当操作数为 Int 时，/ 是整数除法，会舍去小数部分。如果希望得到浮点结果，需将其中一个操作数转为 Double，如 a.toDouble / b。

比较运算符：判断条件的“眼睛”

比较运算符用于判断两个值之间的大小或相等关系，返回布尔值（Boolean）。

val x = 5
val y = 10

val isEqual = x == y        // false
val isNotEqual = x != y     // true
val isGreater = x > y       // false
val isLessOrEqual = x <= y  // true

println(s"相等: $isEqual, 不等: $isNotEqual, 大于: $isGreater, 小于等于: $isLessOrEqual")

注释：注意 Scala 使用 == 判断值相等，而 eq 用于判断对象引用是否相同。这与 Java 中 == 比较引用的机制不同，Scala 更倾向于比较“值”。

逻辑运算符：构建复杂条件的关键

逻辑运算符 &&（与）、||（或）、!（非）用于组合多个布尔表达式。

val age = 25
val hasLicense = true
val isStudent = false

// 逻辑组合：必须年满 18 且有驾照，或者是学生
val canDrive = (age >= 18 && hasLicense) || isStudent

println(s"是否可以开车：$canDrive") // 输出: true

注释：&& 和 || 有短路求值特性。例如 a && b，如果 a 为 false，则不会计算 b，这在处理可能抛异常的表达式时非常有用。

运算符优先级与结合性：别让代码“跑偏”

在复杂的表达式中，运算符的优先级和结合性决定了执行顺序。Scala 的优先级规则与大多数语言类似，但有些细节值得注意。

例如，* 的优先级高于 +，所以 a + b * c 等价于 a + (b * c)。

val result = 5 + 3 * 2  // 先算 3*2=6，再 5+6=11
println(result)         // 输出: 11

注释：当不确定优先级时，建议使用括号明确表达式结构，提升可读性。

优先级表格（从高到低）

注释：该表格帮助你快速掌握运算符执行顺序。优先级高的先执行，相同优先级的从左到右结合。

特殊运算符：Scala 的“语法糖”艺术

Scala 的强大之处在于它允许你自定义运算符，甚至使用非标准符号。比如你可以定义一个 ++ 操作符来表示“递增”。

class Counter(var value: Int = 0) {
  def ++: Unit = {
    value += 1
  }
  
  def --: Unit = {
    value -= 1
  }
  
  override def toString: String = s"Counter($value)"
}

val counter = new Counter(5)
counter ++     // 等价于 counter.++:
counter ++     // 再加一次
println(counter) // 输出: Counter(7)

注释：++ 是一个合法的运算符名称，尽管它不是标准的数学符号。Scala 允许使用字母、数字、下划线以及部分特殊字符（如 +, -, *, /, =, !, &, | 等）组合成运算符。但建议避免过于奇怪的命名，以免降低代码可读性。

实战案例：用 Scala 运算符构建一个简单计算器

我们来写一个简单的命令行计算器，支持加减乘除和括号。

object SimpleCalculator {
  def calculate(expr: String): Double = {
    // 简化处理：直接使用 Scala 的表达式求值能力
    // 注意：实际生产中应使用更安全的表达式解析器
    val cleaned = expr.replaceAll("\\s+", "") // 去除空格
    // 由于 Scala 不直接支持动态表达式求值，这里用反射或编译器 API
    // 为演示，我们手动解析简单表达式
    try {
      // 仅支持基本运算，不支持括号嵌套
      val result = eval(cleaned)
      result
    } catch {
      case _: Exception => throw new IllegalArgumentException(s"表达式错误: $expr")
    }
  }

  private def eval(expr: String): Double = {
    // 简化版：支持 +, -, *, /，左结合
    if (expr.matches("""^-?\d+(\.\d+)?""")) return expr.toDouble

    var i = 0
    var result = 0.0
    var op = '+'

    while (i < expr.length) {
      val ch = expr(i)
      if (ch.isDigit || ch == '.') {
        val numStr = extractNumber(expr, i)
        val num = numStr.toDouble
        result = op match {
          case '+' => result + num
          case '-' => result - num
          case '*' => result * num
          case '/' => result / num
        }
        i += numStr.length
      } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
        op = ch
        i += 1
      } else {
        i += 1
      }
    }
    result
  }

  private def extractNumber(expr: String, start: Int): String = {
    var i = start
    while (i < expr.length && (expr(i).isDigit || expr(i) == '.')) i += 1
    expr.substring(start, i)
  }

  def main(args: Array[String]): Unit = {
    val input = "10 + 2 * 3 - 4"
    val result = calculate(input)
    println(s"计算结果: $input = $result") // 输出: 计算结果: 10 + 2 * 3 - 4 = 20.0
  }
}

注释：这个例子展示了如何在不依赖外部库的前提下，利用 Scala 的字符串处理和运算符逻辑构建简易计算器。虽然简化了括号处理，但已体现“运算符”在表达式构建中的核心作用。

总结：掌握 Scala 运算符，就是掌握表达式之美

Scala 运算符不只是符号的集合，它是一套表达逻辑、组织代码的语法体系。从 + 到 ++，从 && 到自定义运算符，每一种用法背后都体现了函数式编程的思想：让代码更简洁、更自然、更像数学公式。

通过本文的学习，你应该已经理解了：

• Scala 运算符本质是方法调用
• 各类运算符的优先级和结合性影响执行顺序
• 可以通过自定义运算符提升代码表达力
• 实际项目中需注意可读性与安全性

掌握这些，你就能写出既高效又优雅的 Scala 代码。别忘了，真正的高手，不是背下所有运算符，而是知道什么时候该用、怎么用得恰到好处。

未来在处理数据流、构建 DSL 或进行函数式编程时，你会越来越体会到：Scala 运算符，是你表达思想的画笔。