scala 函数中嵌套函数_Scala中的VarArgs函数和@varargs批注

scala 函数中嵌套函数

In this post, we are going to discuss about Functions with Var-Args (Variable Number Of Arguments) concept in Scala.

在本文中，我们将讨论Scala中具有Var-Args（可变参数个数）概念的函数。

介绍 (Introduction)

Var-Args Functions(Methods) means taking Variable Number of Arguments. As a Java Developer, We have already tasted usage of Var-Args methods in Java-based Applications.

Var-Args函数（方法）意味着采用可变数量的参数。 作为Java开发人员，我们已经尝试过在基于Java的应用程序中使用Var-Args方法。

Like Java, Scala also supports “Variable Number Of Arguments” to Functions(Methods). Scala follows same rules like Java’s Var-Args Methods with some syntax changes. We will discuss these details in next section.

与Java一样，Scala也支持对函数（方法）使用“可变数量的参数”。 Scala遵循与Java的Var-Args方法相同的规则，但语法有所变化。 我们将在下一节中讨论这些细节。

Like myself, if someone is moving from Java to Scala, it is always better to compare both Java and Scala Languages features and syntax to learn them easily.

和我一样，如果有人从Java迁移到Scala，最好比较一下Java语言和Scala语言的功能和语法，以轻松学习它们。

Java中带有VarArgs的方法 (Methods With VarArgs in Java)

Java 5 has introduced Var-Args Parameters feature. It uses the following syntax:

Java 5引入了Var-Args参数功能。 它使用以下语法：

Method-Return-Type Method-Name(Argument2-Type Argument2Name ...)

Java uses 3 dots “…” notation to declare the Var-Args parameters. We can use this 3 dots notation either before Argument name or after Argument name.

Java使用3点“…”符号来声明Var-Args参数。 我们可以在Argument名称之前或Argument名称之后使用这3个点符号。

Java Example:-

Java示例：-

public class MyVarArgsClass{
      public static void main(String args...){ }
  }

Here we have declared standard main() method by using Var-Args parameter. Internally, JVM converts these Var-Args parameter to array only.

在这里，我们使用Var-Args参数声明了标准的main（）方法。 在内部，JVM将这些Var-Args参数仅转换为数组。

Scala中带有VarArgs的函数 (Functions With VarArgs in Scala)

Scala also follows similar kind of syntax to define Var-Args parameter. But it uses * to define Var-Args parameter.

Scala还遵循类似的语法来定义Var-Args参数。 但是它使用*定义Var-Args参数。

Scala’s Var-Args Functions Syntax:-

Scala的Var-Args函数语法：

def Method-Name(Argument1Name : Type, Argument2Name : Type*)

Scala Example:-

Scala示例：-

def display(str: String*) {
    str.map(println)
  }

Here “str” is a Var-Args parameter to display function.

此处的“ str”是要显示功能的Var-Args参数。

Scala的Var-Args函数规则 (Scala’s Var-Args Functions Rules)

Like Java, Scala’s Var-Args Functions follows these Rules in evaluating and resolving Var-Args Parameters.

与Java一样，Scala的Var-Args函数在评估和解析Var-Args参数时遵循以下规则。

• The Var-Args Parameter is defined by using * (Star symbol).
  Var-Args参数是通过使用*（星号）定义的。
• The Var-Args Parameter must be the last parameter in the Parameter List.
  Var-Args参数必须是参数列表中的最后一个参数。
• Because of the above condition, each Function(Method) accepts one and only one Var-Args Parameter.
  由于上述条件，每个Function（Method）都接受一个且仅一个Var-Args参数。
• The Var-Args Parameter does not accept “Default Parameter Values”.
  Var-Args参数不接受“默认参数值”。

Scala的Var-Args函数示例 (Scala’s Var-Args Functions Examples)

In this section, let us explore Var-Args rules one by one with some simple examples.

在本节中，让我们通过一些简单的示例逐一探讨Var-Args规则。

Example-1:-
Write a Scala program with a Var-Args Function.

示例1：-
用Var-Args函数编写一个Scala程序。

object ScalaVarArgsExample{
 
  def display(str: String*) {
    str.map(println)
  }
  
}

Scala REPL output:-

Scala REPL输出：

scala> object ScalaVarArgsExample{

  def display(str: String*) {
    str.map(println)
  }

}
defined module ScalaVarArgsExample

scala> ScalaVarArgsExample.display("Play","Scala","Java");
Play
Scala
Java

scala>

Example-2:-
Write a Scala program to use both Non-VarArgs and Var-Args in a Function.

示例2：-
编写一个Scala程序以在函数中同时使用Non-VarArgs和Var-Args。

def display(name:String, str: String*) {
    println("Non-VarArgs : " + name)

    println("VarArgs : ")
    str.map(println)
  }

  def main(args: Array[String]) {
      display("Rams", "Scala", "Java", "Play")
  }
}

If you execute this program in REPL or any Scala IDE, we will get the following output:

如果您在REPL或任何Scala IDE中执行此程序，我们将获得以下输出：

Non-VarArgs : Rams
VarArgs : 
Scala
Java
Play

NOTE:-
This program’s display method contains both kind of arguments: first argument is Non-VarArgs and last is VarArgs. We have followed both (2) and (3) rules.

注意：-
该程序的显示方法包含两种参数：第一个参数是Non-VarArgs，最后一个是VarArgs。 我们同时遵循（2）和（3）规则。

If we use in reverse order or if we use more than one Var-Args argument, then we will get compilation error.

如果使用相反的顺序，或者使用多个Var-Args参数，则会出现编译错误。

Scala中的@varargs注释 (The @varargs Annotation in Scala)

In Scala, we can annotate a Var-Args method with @varargs annotation as shown below:

在Scala中，我们可以使用@varargs注释来注释Var-Args方法，如下所示：

object ScalaVarArgsExample{
 
  @varargs def display(str: String*) {
    str.map(println)
  }
  
}

What is @varargs annotation in Scala?
@varargs annotation is defined in “scala.annotation” package. This annotation is used to mark a Scala’s VarArgs method as shown above.

Scala中的@varargs注释是什么？
@varargs批注在“ scala.annotation”包中定义。 该批注用于标记Scala的VarArgs方法，如上所示。

What is the use of this @varargs annotation in a Scala program?
If we have a requirement like we need to use a Scala’s VarArgs method in a Java Program, then we should mark that Scala’s VarArgs method with @varargs annotation.

这个@varargs注释在Scala程序中有什么用？
如果我们有一个需求，例如我们需要在Java程序中使用Scala的VarArgs方法，则应该使用@varargs批注标记该Scala的VarArgs方法。

Example-1:-
Write a Java Program to make a call to Scala’s VarArgs method.

示例1：-
编写一个Java程序来调用Scala的VarArgs方法。

Scala Program

Scala程序

import scala.annotation.varargs

object ScalaVarArgsExample{
 
  @varargs def display(str: String*) {
    str.map(println)
  }
  
}

Java Program

Java程序

public class JavaProgramToUseScalaVarArgs {

    public static void main(String args[]){
        ScalaVarArgsAndNonVarArgsDemo.display("Rams", "Scala", "Java", "Play");
    }

}

When we run this Java Program, we will get the following output (Same output like scala example):

运行此Java程序时，将获得以下输出（与scala示例相同的输出）：

Non-VarArgs : Rams
VarArgs : 
Scala
Java
Play

NOTE:-
If we remove @varargs annotation from Scala’s method definition and run Java program, then we will get the following compilation error:

注意：-
如果从Scala的方法定义中删除@varargs批注并运行Java程序，则将出现以下编译错误：

Error:(9, 38) java: method display in class com.journaldev.posts.ScalaVarArgsAndNonVarArgsDemo cannot be applied to given types;
  required: java.lang.String,scala.collection.Seq<java.lang.String>
  found: java.lang.String,java.lang.String,java.lang.String,java.lang.String
  reason: actual and formal argument lists differ in length

That means display’s VarArgs parameter’s type is not “java.lang.String”, it is referring “scala.collection.Seq” type. When we comment that Scala’s method with @varargs annotation, then Scala will convert this “Seq” type to “java.lang.String” type.

这意味着display的VarArgs参数的类型不是“ java.lang.String”，而是引用的“ scala.collection.Seq”类型。 当我们使用@varargs批注注释Scala的方法时，Scala会将这种“ Seq”类型转换为“ java.lang.String”类型。

What will happen under-the-hood, when we annotate a Scala’s VarArgs method with @varargs annotation?
By default, Scala’s VarArgs Parameter type is “scala.collection.Seq[T]”. In our display() method, as we are using String VarArgs parameter, its type is “scala.collection.Seq[String]”.

当我们使用@varargs注释对Scala的VarArgs方法进行注释时，在幕后会发生什么？
默认情况下，Scala的VarArgs参数类型为“ scala.collection.Seq [T]”。 在我们的display（）方法中，因为我们正在使用String VarArgs参数，所以其类型为“ scala.collection.Seq [String]”。

When we annotate that display method with @varargs annotation, Scala will automatically convert that “scala.collection.Seq[String]” type to “java.lang.String[ ]” type. So that we can use this method from a Java Program.

当我们使用@varargs注释注释该显示方法时，Scala会自动将“ scala.collection.Seq [String]”类型转换为“ java.lang.String []”类型。 这样我们就可以在Java程序中使用此方法。

That’s it all about Var-Args Parameters and @varargs Annotation in Scala. We will discuss some more Scala concepts in my coming posts.

这就是有关Scala中的Var-Args参数和@varargs注释的全部内容。 我们将在我的后续文章中讨论更多Scala概念。

Please drop me a comment if you like my post or have any issues/suggestions.

如果您喜欢我的帖子或有任何问题/建议，请给我评论。

翻译自: https://www.journaldev.com/9070/varargs-functions-and-varargs-annotation-in-scala

scala 函数中嵌套函数