scala-传名函数和传值函数

Scala的解释器在解析函数参数(function arguments)时有两种方式：先计算参数表达式的值(reduce the arguments)，再应用到函数内部；或者是将未计算的参数表达式直接应用到函数内部。前者叫做传值调用（call-by-value），后者叫做传名调用（call-by-name）。

传值函数和传名函数

object Add {  
  def addByName(a: Int, b: => Int) = a + b   
  def addByValue(a: Int, b: Int) = a + b   
}

传名函数和传值函数在编译器中区别: 

  addByName(2, 2 + 2)  
->2 + (2 + 2)  
->2 + 4  
->6  
  
  addByValue(2, 2 + 2)  
->addByValue(2, 4)  
->2 + 4  
->6  

可以看出，在进入函数内部前，传值调用方式就已经将参数表达式的值计算完毕，而传名调用是在函数内部进行参数表达式的值计算的。

这就造成了一种现象，每次使用传名调用时，解释器都会计算一次表达式的值。对于有副作用(side-effect)的参数来说，这无疑造成了两种调用方式结果的不同。

因此, 在实际的使用中: 

传值调用在进入函数体之前就对参数表达式进行了计算，这避免了函数内部多次使用参数时重复计算其值，在一定程度上提高了效率。

但是传名调用的一个优势在于，如果参数在函数体内部没有被使用到，那么它就不用计算参数表达式的值了。在这种情况下，传名调用的效率会高一点。

package com.doggie  
  
object WhyAlwaysMe {  
  var flag: Boolean = true  
  def useOrNotUse(x: Int, y: => Int) = {  
    flag match{  
      case true => x  
      case false => x + y  
    }  
  }  
  def main(args: Array[String]) =   
  {  
    println(useOrNotUse(1, 2))  
    flag = false  
    println(useOrNotUse(1, 2))  

=> Unit 与 () =>Unit的区别

简单来说, => Unit是 传名函数, 只传入了一个表达式, 在调用时才会去执行, 使用 code调用

() => 是传值函数, 传入的计算后的值, 使用 code() 调用

package main.scala

/**
  * Created by wenbronk on 2017/9/12.
  */
object TestScala {

  def main(args: Array[String]): Unit = {
//    println( addInt(3, 5))
//    println(time())
    delayTime({
      println("2222");
      time()
    })
    delayTime2({
      println("333");
      time
    })
  }

  def delayTime2(t: () => Long): Unit = {
    println("执行...")
    println( t() )
    println("jiesu..")
  }

  def delayTime(t: => Long): Unit = {
    println("执行开始")
    println(t)
    println("执行结束")
  }

  def time() = {
    println("获取时间内, 单位为 纳秒")
    System.nanoTime()
  }

}

执行结果: 

http://blog.csdn.net/asongoficeandfire/article/details/21889375

http://www.aboutyun.com/thread-10864-1-3.html

http://scalagroup.group.iteye.com/group/topic/26303