当前位置： 正文

Scala中的函数和方法基础

03-19 Scala 310

本文概述

有兴趣了解更多有关Scala的信息吗？参加srcmini的Scala入门课程。

Scala是一种函数式编程语言, 其中既包含作为一流值和方法的函数, 又具有相似性和相异性。函数和方法都是可重用代码的一部分, 也可用于将重复的代码存储在一个地方, 这使函数可以执行特定的特定任务。它们还使代码更易于调试和修改。

但是, 函数是一个在变量中初始化的对象, 但是方法以’def’关键字开头, 后跟方法名称, 参数列表, 带有返回值的方法主体。

你将学习以下主题：

  1. 方法声明和定义
  2. 方法调用
  3. 具有命名参数的方法
  4. 默认参数值
  5. 可变长度参数
  6. 递归函数
  7. 匿名函数

方法声明和定义

Scala中方法声明和定义的语法如下：

def 'method_name' ('parameters':'return_type_parameters') : ('return_type_of_method') = {
    'method_body'
     return 'value'
}

Scala中的方法从以下部分开始：

  1. ‘def’：用于声明方法的关键字。
  2. ” method_name”：是你的方法的名称, 小写驼峰。
  3. ‘parameters’：是方法参数, 可能没有参数, 也可能没有一个参数, 但是当一个以上参数时, 用逗号分隔。
  4. ‘return_type_of_parameters’：需要根据’parameters_list’的数据类型进行匹配并且是强制性的
  5. ‘return_type_of_method’：是可选的, 但是默认情况下, 返回’Unit’, 但是可以使用’return’关键字返回该值。
  6. 赋值符号(‘=’)：是可选的, 如果使用它将分配返回值, 而不使用它会使方法不返回任何内容。
  7. ‘method_body’：是括在花括号'{}’中的代码块, 由所需的逻辑或某些任务或操作组成。
  8. return：是用于返回所需值并终止程序的关键字, 但在Scala中很少使用。

方法调用

Scala中方法调用的语法如下：

    method_name(arguments)

可以通过” method_name”快速完成”方法”调用, ” method_name”是要与参数一起调用的相应方法的名称。

具有命名参数的方法

具有命名实参的方法将允许在方法调用期间将实参传递到方法的参数, 其中, 每个实参都与方法参数一一对应。你将在下面看到通过函数声明和定义传递参数以及实际方法调用的示例：

object calculateResult {
      def funSub(x:Int, y:Int) : Int =
   {

       var diff:Int = 0
       diff = x - y

       // return value
       return diff
   }
   def main(args: Array[String]) {

      // Function call
      println("Difference of the value is: " + funSub(8, 6));
      println("Difference of the value is " + funSub(y=6, x=8));
   }
}

上面的程序给出的输出为：

值的差异是：2

值的差异是：2

上面的程序包含一个对象” calculateResult”, 并且在其内部包含一个名为” funSub”的方法, 其参数x和y的返回类型均为” Int”, 该方法的总体返回类型为” Int”。紧随其后的是分配语句以分配返回值。花括号指示方法主体的开始, 其中变量” diff”以初始值0初始化。在主方法中完成的方法调用” funSub(8, 6)”将8与” x”和6匹配到” y”, 然后执行减法运算, 并返回” diff”的值并最终将其打印出来。类似地, ” funSub(x = 8, y = 6)”在方法调用过程中将6与” y”匹配, 将8与” x”与方法中的参数匹配, 其中顺序与执行类似操作无关, 返回结果将被打印出来。

默认参数值

你可以通过相应值的初始化为方法参数指定默认值, 并且可以通过不传递参数来将方法调用留空。

object calculateResult {
      def funSub(x:Int=9, y:Int=6) : Int =
   {

       var diff:Int = 0
       diff = x - y

       // return value
       return diff
   }
   def main(args: Array[String]) {

      // Function call
    print( "The final value is: " + funSub() );

   }
}

上面的程序给出的输出为：

最终值为：3

你可以看到上面的程序包含定义为” calculateResult”的对象, 并且内部有一个名为” funSub”的方法, 该方法的参数为x和y, 两者的返回类型均为” Int”, 并且该方法的总体返回类型为” Int’, 然后是赋值语句, 它将分配返回值。大括号表示方法主体的开始, 其中变量’diff’的初始值为0初始化。Method调用是在main方法内部进行的, 其中’funSub()’调用并将x初始化为9, y到6, 然后执行该操作, 使值’diff’返回并打印。

可变长度参数

可变长度参数是采用任意数量可变参数的参数, 并且可以由用户或客户端传递。方法中的最后一个参数使用’*’声明, 需要重复。

object variableArgument {
    def main(args: Array[String]) {
       printAll("Scala", "is", "great")
    }

    def printAll(strings: String*) {
        var i : Int = 0;

      for( value <- strings ){
         println(value);
         i = i + 1;
      }
    }
}

上面的程序给出的输出为：

斯卡拉

is

大

你可以看到上面的程序包含一个带有’printAll’方法的对象’variableArgument’, 其中可变长度参数’String *’在结尾定义, 并且在方法调用期间可以传递字符串列表。传递的字符串列表被循环并显示为主要函数内的输出。

递归函数

递归是函数编程中使用的一种技术, 通过反复将其分解为较小的子问题来解决该问题, 这类似于原始问题。解决了较小的问题, 并将其解决方案应用于原始问题的解决方案。因此, 这就是所谓的分而治之或减少与征服问题, 这使代码变得简洁明了。在编写递归函数时, 必须严格考虑这两点。他们是：

  • 基本情况：函数中可能有多个基本情况需要找出, 否则可能导致无限递归。它需要一种解决方案, 即无需递归即可实现的简单输出或解决方案形式。
  • 递归情况：应用递归功能的情况, 即进行递归调用。问题的主要症结在于, 在每个递归调用中, 大小都需要减小, 即问题需要分成较小的子问题, 直到达到基本情况为止。最后, 将解决方案组合起来以解决主要问题, 这称为分治法。

任何给定数字的阶乘是n！它可以用数学方式表示为：

n！ = n。(n-1)。(n-2)… 3.2.1

同样, 你可以将(n-1)。(n-2)… 3.2.1设为(n-1)！因此, 任何给定数的阶乘始终为n。 (n-1)！

现在, 你可以在下面看到解决问题的递归方法。

object factorialDemo {
   def main(args: Array[String]) {
      for (i <- 1 to 5)
         println( "Factorial of " + i + ": = " + factorial(i) )
   }

   def factorial(n: Int): Int = {  
      if (n <= 1)
         return 1  
      else    
      return n * factorial(n - 1)
   }
}

上面的程序给出的输出为：

1：1的阶乘

2的阶乘= 2

3的阶乘：= 6

4阶乘：= 24

5阶乘：= 120

你可以在上面看到其中有一个名为” factorialDemo”的对象, 内部有一个” main”函数, 该函数包含一个循环, 该循环重复五次, 还包含对” factorial”的函数调用, 其中递归函数进行递归调用, 即n至5次。当n小于或等于1时, 它在基本情况下停止, 并返回结果并打印。

匿名函数

匿名函数是那些没有名称的轻量级函数定义, 在Scala中被称为函数文字。

匿名函数示例的语法如下：

匿名函数的第一个语法和示例是：

语法如下：

('first_variable':'data_type', 'second_variable':'data_type') => "certain_expression"

例子：

(var1:String:var2:String) => var1 + var2

OR

匿名函数的第二种语法和示例是：

语法如下：

 (_:'data_type')operator(_'data_type')

例子：

 (_:String)+(_:String)

第一种语法显示” =>”之后的表达式求值为特定值, 而” =>”之前的变量列表用于求值表达式。

上面的第二种语法像占位符一样工作, 在该占位符中, 它只接受一次值作为”通配符”, 然后在其中进行操作。

你将在下面看到一个匿名函数示例：

 object anonymousDemo  
{
    def main(args: Array[String])  
    {


        var function1 = (var1:Int, var2:Int) => var1 + var2
        var function2 = (_:Int) + (_:Int)

        // function call
        println(function1(5, 5))
        println(function2(7, 3))
    }
}

Initializing Scala interpreter ...



Spark Web UI available at http://DESKTOP-03TH7J0:4040
SparkContext available as 'sc' (version = 2.4.3, master = local[*], app id = local-1566986265958)
SparkSession available as 'spark'




<console>:10: error: unbound placeholder parameter

        var function2 = {_:Int} + {_:Int}

                         ^

<console>:10: error: unbound placeholder parameter

        var function2 = {_:Int} + {_:Int}

                                   ^

上面的程序给出的输出为：

10

10

你可以在上方看到名为” anonymousDemo”的对象, 其” main”函数包含两个匿名函数。它们在语法上有所不同, 但可以产生相同的结果, 其中”功能” 1通过从调用函数时获取参数来进行评估-传递值5和5, 结果输出显示为10, 而”功能2″也称为传递7和3, 并在其中接收一次值, 该值接受任何有效的”整数”。根据你的情况, 执行加法运算并输出结果。

总结

恭喜, 你已阅读完本教程。

Scala中有许多高级主题, 例如高阶函数, 嵌套函数, currying函数等。

参考：

SCALA基础知识之旅

Scala |功能–基础

Scala-功能

Scala中的匿名函数

查看srcmini的Scala入门课程。

微信公众号
手机浏览(小程序)
0
分享到：

猜你喜欢

Scala与Java：为什么要学习Scala？
Scala

03-20 488
Scala中的运算符用法
Scala

03-20 500
Scala final关键字用法示例
Scala

03-20 500
Scala HashSet用法详解
Scala

03-20 482
Scala中的列表用法
Scala

03-20 440
Scala的简单程序示例
Scala

03-20 464
没有账号？ 忘记密码？