Question

我刚刚开始学习Scala中的高阶函数，我无法理解输出是如何在这里来的，根据文档https://docs.scala-lang.org/tour/higher-order-functions.html高阶函数是一个函数，它可以将函数作为参数或返回一个函数。所以我的问题是，

如果我的b = a（b已分配到a我的计划的multiplyBy2功能正文，那么为什么f(a)是50（检查第1行），之后是预期25（检查第2行）。
如果我在第3行中没有提到f:Int=>Any而不是f:Int，那么为什么会抛出错误

我对工作流感到困惑，我试图多次理解。如果有人通过描述该程序的整个工作流程来帮助我，我将非常感激。感谢。

 package function    
    object HigherOrderFunction 
    {

   def main(args: Array[String]):Unit = 
   {  
       functionExample(25, multiplyBy2)                  
   }  



   def functionExample(a:Int, f:Int=>Any):Unit = //Line 3
   {  
        println(f(a))          //Line 1                         
        println(a)             //Line 2
   }  



   def multiplyBy2(b:Int):Int = 
   {
        println(b) // Assigned a = b, So, a is 25 Now
        b*2       
       // println(b) // Type Mismatch: Int, Required: Unit
   }  
}

输出

25
50
25

Answer 1

要理解上面的代码流程，让我们逐步使用每种方法。

就像你已经定义了函数，其中functionExample是一个更高阶函数，因为它接受一个函数作为参数。

scala> def functionExample(a:Int, f:Int=>Any):Unit = //Line 3
     |    {  
     |         println(f(a))          //Line 1                         
     |         println(a)             //Line 2
     |    }  
functionExample: (a: Int, f: Int => Any)Unit

scala> def multiplyBy2(b:Int):Int = 
     |    {
     |         println(b) // Assigned a = b, So, a is 25 Now
     |         b*2       
     |        // println(b) // Type Mismatch: Int, Required: Unit
     |    }  
multiplyBy2: (b: Int)Int

在此之后我们尝试调用：

scala> functionExample(25, multiplyBy2)      
25
50
25

1）首先调用functionExample使a = 25并使用multiplyBy2绑定函数，multiplyBy2采用参数类型int并返回Any（可以通过声明f：Int =＆gt; Any）看到

2）第一个println用于f（a），它被转换为multiplyBy2（25）。

3）在multiplyBy2函数内部，我们首先打印收到的参数，即25。

所以第一个输出值是25。

4）接下来，multiplyBy2函数返回b * 2，这使得它为25 * 2 = 50，这是f（a）返回的值，并且由于示例代码中的Line1而打印。

5）最后，在Line2中，我们打印我们在functionExample中收到的参数。所以它打印25。

因此输出结果为：

25
50
25

Answer 2

在这里，您将获得一些步骤。很容易摆脱困惑。

评论行中的步骤

package function

    object HigherOrderFunction 
{

   def main(args: Array[String]):Unit = 
   {  
       functionExample(25, multiplyBy2) // Passing a function as parameter  
   }  



   def functionExample(a:Int, f:Int=>Int):Unit = 
   {  
        println(f(a))  // STEP-2: Here f=multiplyBy2, So multiplyBy2=25*2, which is 50          // Calling that function
        println(a)     // STEP-3: Here Simply first Argument is printed out 25

   }  



   def multiplyBy2(b:Int):Int = 
   {

       println(b)     // STEP-1: Here b=a, So the value of b is 25    
       b*2
   }  
}

Answer 3

结果很正常，首先你的a = 25，然后你在println(f(a))中应用f（a），所以你打印25然后你返回* 2 = 50.那么你println(f(a))即50，最后你打印a = 25，因为当你调用multiplyBy2时它从未改变过，它不会改变参数的值。

对于第二个问题，它只是函数的签名，因为f:Int（f是参数值）但是f:Int=>Any（f是参数函数）。

你可以把你的功能写成 def functionExample(a:Int)(f:Int=>Int):Unit = //Line 3 {enter code here`enter code here println(f(a)) //Line 1 println(a) `enter code here`//Line 2 }

Answer 4

您可以使用其实现替换函数来推理它：

第1步：

declare
     json_data2 json;
  json_data json := json('{   "foo": "bar",   "list": [     {"key": "value1"},     {"key": "value2"}   ] }');
  list_value json_list;
begin
  list_value := pljson_ext.get_json_list(json_data, 'list');

  dbms_output.put_line('Count = '||list_value.count);

  for i in 1 .. list_value.count
  loop
     -- json_data2 := json(list_value.get(i));
json(list_value.get(i)).get('key').print;
     -- dbms_output.put_line('key = ' || json_data2.get('key')); -- "key = value"
     -- json_data2.get('key').print;
  end loop;
end;
/

第2步：

object HigherOrderFunction 
{
   def main(args: Array[String]):Unit = 
   {  
       println(multiplyBy2(25))   //Line 1                         
       println(25)                //Line 2
   }  
   def multiplyBy2(b:Int):Int = 
   {
        println(b) // Assigned a = b, So, a is 25 Now
        b*2
   }  
}

我希望现在很清楚为什么你看到25 50 25打印出来了:)）

Scala中高阶函数的工作流程

4 个答案: