案例类（或与此相关的对象）上的 Scala 方法（def）中的 val 是否仅计算一次？

Question

As per this example will the calculation for someValue be ran only once for each instance of the class?

case class MyThing {

  def myMethod {
    val someValue = 19 * 27
    someValue
  }

}

Would the same rules apply to an object

object MyObject {

  def myMethod {
    val someValue = 19 * 27
    someValue
  }

}

If you have an immutable case class (and of course objects are immutable by virtue of being a single instance) then there is no sense in re-running calculations that have been ran, even if they use values in the class itself (I'm thinking of custom hashCode calculations for example).

Is the compiler smart enough to handle that or would it be better to place the val outside of the def? (Making it lazy so it only gets called when needed...)

Answer 1

The literal is inlined at compile time:

scala> object O { def f = 19*27 }
defined object O

scala> :javap -c O
Compiled from "<console>"
public class O$ {

  public int f();
    Code:
       0: sipush        513
       3: ireturn

  <snip>
}

Generally, the Scala compiler doesn't optimize such cases when there are no literals involved:

scala> object O { def f = g*h; def g = 19; def h = 27 }
defined object O

scala> :javap -c O
Compiled from "<console>"
public class O$ {

  public int f();
    Code:
       0: aload_0
       1: invokevirtual #17                 // Method g:()I
       4: aload_0
       5: invokevirtual #20                 // Method h:()I
       8: imul
       9: ireturn

  public int g();
    Code:
       0: bipush        19
       2: ireturn

  public int h();
    Code:
       0: bipush        27
       2: ireturn

  <snip>
}

When you write def , then you mean def , ie every time you call the method everything in it is evaluated. Anything that should be cached needs to be done manually on your side.

In the above example however, it is very likely that the JVM itself will inline g and h , with the result that the first and the second example will be optimized to the same machine code.

Answer 2

Simply put: No.

val is only evaluated once.

def is evaluated every time.

That is the difference between those keywords in the Scala language.

As myMethod has no parameters and is not affected by side-effects, it should be changed to val or as you say lazy val so it is only ran when needed.

It is more productive to program with intent rather than rely on compiler optimisation.