Question

请参阅：Can I specify a meaningful name for an anonymous class in C#?

在C＃中你可以写：

var e = new { ID = 5, Name= "Prashant" };
assertEquals( 5, e.ID )

但在Scala中我最终写道：

var e = (5, "Prashant")
assertEquals( 5, e._1 )

Scala通过使用泛型来保持类型安全（就像C＃一样），但是丢失了每个字段名称的可读性，例如我使用“_1”而不是“ID”。

Scala中有这样的东西吗？

Answer 1

object T {
  def main(args: Array[String]) {  
    val e = new { var id = 5; var name = "Prashant" }
    assert(e.id == 5)
  }
}

好的，让我们说清楚。这确实使用了对Scala 2.7和Scala 2.8的反射，因为e的类型在这种情况下是结构类型，Scala通过反射处理。这是生成的代码，在清理时（scalac -Xprint:cleanup）：

package <empty> {
  final class T extends java.lang.Object with ScalaObject {
    private <synthetic> <static> var reflMethod$Cache1: java.lang.reflect.Method = null;
    private <synthetic> <static> var reflClass$Cache1: java.lang.Class = null;
    <synthetic> <static> def reflMethod$Method1(x$1: java.lang.Class): java.lang.reflect.Method = {
      if (T.this.reflMethod$Cache1.eq(null).||(T.this.reflClass$Cache1.ne(x$1)))
        {
          T.this.reflMethod$Cache1 = x$1.getMethod("id", Array[java.lang.Class]{});
          T.this.reflClass$Cache1 = x$1;
          ()
        };
      T.this.reflMethod$Cache1
    };
    @remote def $tag(): Int = scala.ScalaObject$class.$tag(T.this);
    def main(args: Array[java.lang.String]): Unit = {
      val e: java.lang.Object = {
        new T$$anon$1()
      };
      scala.this.Predef.assert(scala.Int.unbox({
        var exceptionResult1: java.lang.Object = _;
        try {
          exceptionResult1 = T.reflMethod$Method1(e.getClass()).invoke(e, Array[java.lang.Object]{})
        } catch {
          case ($1$ @ (_: java.lang.reflect.InvocationTargetException)) => {
            exceptionResult1 = throw $1$.getCause()
          }
        };
        exceptionResult1
      }.$asInstanceOf[java.lang.Integer]()).==(5))
    };
    def this(): object T = {
      T.super.this();
      ()
    }
  };
  final class T$$anon$1 extends java.lang.Object {
    private[this] var id: Int = _;
    <accessor> def id(): Int = T$$anon$1.this.id;
    <accessor> def id_=(x$1: Int): Unit = T$$anon$1.this.id = x$1;
    private[this] var name: java.lang.String = _;
    <accessor> def name(): java.lang.String = T$$anon$1.this.name;
    <accessor> def name_=(x$1: java.lang.String): Unit = T$$anon$1.this.name = x$1;
    def this(): T$$anon$1 = {
      T$$anon$1.this.id = 5;
      T$$anon$1.this.name = "Prashant";
      T$$anon$1.super.this();
      ()
    }
  }
}

有一些缓存正在进行，但如果我在id和name之间轮换，它将使缓存无效。 Scala 2.8也可以进行反射，也可以进行缓存，但它使用了更高效的缓存技术，可以提供更好的整体性能。作为参考，这里是Scala 2.8的清理：

package <empty> {
  final class T extends java.lang.Object with ScalaObject {
    final private <synthetic> <static> var reflParams$Cache1: Array[java.lang.Class] = Array[java.lang.Class]{};
    @volatile
    private <synthetic> <static> var reflPoly$Cache1: scala.runtime.MethodCache = new scala.runtime.EmptyMethodCache();
    <synthetic> <static> def reflMethod$Method1(x$1: java.lang.Class): java.lang.reflect.Method = {
      var method1: java.lang.reflect.Method = T.reflPoly$Cache1.find(x$1);
      if (method1.ne(null))
        return method1
      else
        {
          method1 = x$1.getMethod("id", T.reflParams$Cache1);
          T.reflPoly$Cache1 = T.reflPoly$Cache1.add(x$1, method1);
          return method1
        }
    };
    def main(args: Array[java.lang.String]): Unit = {
      val e: java.lang.Object = {
        new T$$anon$1()
      };
      scala.this.Predef.assert(scala.Int.unbox({
        val qual1: java.lang.Object = e;
        {
          var exceptionResult1: java.lang.Object = _;
          try {
            exceptionResult1 = T.reflMethod$Method1(qual1.getClass()).invoke(qual1, Array[java.lang.Object]{})
          } catch {
            case ($1$ @ (_: java.lang.reflect.InvocationTargetException)) => {
              exceptionResult1 = throw $1$.getCause()
            }
          };
          exceptionResult1
        }.$asInstanceOf[java.lang.Integer]()
      }).==(5))
    };
    def this(): object T = {
      T.reflParams$Cache1 = Array[java.lang.Class]{};
      T.reflPoly$Cache1 = new scala.runtime.EmptyMethodCache();
      T.super.this();
      ()
    }
  };
  final class T$$anon$1 extends java.lang.Object {
    private[this] var id: Int = _;
    <accessor> def id(): Int = T$$anon$1.this.id;
    <accessor> def id_=(x$1: Int): Unit = T$$anon$1.this.id = x$1;
    private[this] var name: java.lang.String = _;
    <accessor> def name(): java.lang.String = T$$anon$1.this.name;
    <accessor> def name_=(x$1: java.lang.String): Unit = T$$anon$1.this.name = x$1;
    def this(): T$$anon$1 = {
      T$$anon$1.super.this();
      T$$anon$1.this.id = 5;
      T$$anon$1.this.name = "Prashant";
      ()
    }
  }
}

Answer 2

您还可以命名要分配的元组的部分，如：

val (ID, Name) = (5, "Prashant")
assertEquals( 5, ID )

你也可以这样使用：

val (ID, Name, Age) = functionThatReturnsATuple3
println("ID: " + ID + ", age: " + Age)

当我第一次阅读_x语法时，我认为它很棒并且使用了很多。我已经基本上停止使用它了，因为当我必须查看两个月前写的代码时，我不得不花费大量时间来尝试找出_1，_2等类型的内容。是。我认为事后证明id比pair._1更具可读性。

这也可以在map，filter等功能中使用，例如：

val list: List[ (Int, String, Double) ] = ...
list map { case (id, name, time) => ... }
list filter { case (_, name, _) => name == "X" }

请注意，在filter中，您可以将_用于您不会在函数体中使用的元素。当浏览这样的代码以确定正在使用哪些结构部分以及如何构建值时，这非常有用。

Answer 3

我只想做一个案例类：

object Yo{
  case class E(id: Int, name: String)

  def main(){
    val e = E(5,"Prashant")
    println("name="+e.name+", id="+e.id)
  }
}

不确定它是否与Daniel's answer一样高效，但我希望它是相同的（我对此表示赞赏）。在任何情况下，我发现它更具可读性，如果E有多个实例，则只使用一个共享的额外行。您还可以向case类添加方法，例如：

case class E(id: Int, name: String){
  def hasId(id: Int) = this.id==id
}

val e = E(5,"Prashant")
assert(e hasId 5)

Answer 4

正如Juh_所建议的那样，扩展案例类应该做你想做的事情：

scala> case class E(id: Int, name: String)
defined class E

scala> val e = new E(5, "Prashant")
e: E = E(5,Prashant)

scala> e.name
res3: String = Prashant

Case类提供了一个equals方法，它们还扩展了Product特征，这与Scala元组扩展的特性相同。也许将来他们也会extend the ProductN traits。

如果您按照其他一些答案的建议使用匿名类，那么您最终不会得到真正的元组！例如，您没有获得equals方法：

scala> val x = new { val count = 5 }
x: AnyRef{val count: Int} = $anon$1@29ca901e

scala> val y = new { val count = 5 }
y: AnyRef{val count: Int} = $anon$1@1dfe2924

scala> x == y
res4: Boolean = false

从Scala 2.11开始，扩展Tuple2确实有效，但这已被弃用，因为你不应该扩展案例类。

您还可以扩展Product2特征，但这不提供任何方法的实现，因此您必须自己编写所有方法。

您可能还可以使用Shapeless HList，这会以添加外部依赖项为代价为您提供许多花哨的功能。

我也尝试过Twitter的jaqen库，但是在Scala 2.11中没有为我编译。

我目前正在使用Scala 2.11，因此我无法保证此建议适用于其他版本的Scala。

Answer 5

Scala 2.8改进了类型系统，使得可以使用静态和异构类型的数组和列表，因此可能与地图相同。查看Jesper Nordenberg's blog on "Type Lists and Heterogeneously Typed Arrays"了解其实施情况。

有没有办法在Scala中使用带有命名字段的元组，类似于C＃中的匿名类？

5 个答案: