Question

我有一组函数，它们都有一个共同的返回类型，但参数的数量和类型不同，例如：

def find(id: Int): MyVal = {}
def like(part: String, max: Int): MyVal = {}
def first(): MyVal = {}

所有这些都需要通过一个通用的验证程序，我想要做的是将该逻辑封装到一个函数中，然后采用上述任何方法（以及其他具有相同返回类型的方法）另一个论点：

def checkAndEvaluate(token: String, func: () => MyVal): MyVal = {
    validateToken(token) match {
        case Pass => func()
        case Fail => // Do some error handling
    }
}

换句话说，我想传递函数文字，以及它们所需的参数，然后只有让它们从里面接收函数进行评估。验证通过。

在Scala中可以做到这一点，如果可以，那么实现它的首选方法是什么？

Answer 1

您根本不需要使用function，您只需要Scala参数call-by-name：More about call-by-name parameter

一个简短的例子：

scala> def invoke(id: Int): Int = { println("invoked"); 0 }
invoke: (id: Int)Int

scala> def run(x : Int, i: => Int): Int = x match {
     |   case 0 => i
     |   case 1 => -1
     | }
run: (x: Int, i: => Int)Int

scala> run(0, invoke(100))
invoked
res2: Int = 0

scala> run(1, invoke(100))
res3: Int = -1

根据您的代码：

scala> def find(id: Int): Int = 0
find: (id: Int)Int

scala> def like(part: String, max: Int): Int = 1
like: (part: String, max: Int)Int

scala> def first(): Int = 2
first: ()Int

scala> def checkAndEval(token: String, lazyEval : => Int): Int = token.size match {
     |   case 0 => lazyEval
     |   case _ => -1
     | }
checkAndEval: (token: String, lazyEval: => Int)Int

scala> checkAndEval("", like("xxx", 0))
res0: Int = 1

scala> checkAndEval("err", like("xxx", 0))
res1: Int = -1

Answer 2

这在scala中非常容易，这是一个例子：

  checkAndEvaluate("token", () => find(1))
  checkAndEvaluate("token", () => like("like", 1))
  checkAndEvaluate("token", () => first())

如果你打电话给func()，那么在致电{{1}}之前，这些功能都不会被调用。

是否可以推迟使用不同数量/类型的参数评估函数文字？

2 个答案: