Scala 相当于 C# 的扩展方法？

发布于 2024-09-07 05:19:44 字数 491 浏览 5 评论 0原文

在 C# 中，你可以这样写：

using System.Numerics;
namespace ExtensionTest {
public static class MyExtensions {
    public static BigInteger Square(this BigInteger n) {
        return n * n;
    }
    static void Main(string[] args) {
        BigInteger two = new BigInteger(2);
        System.Console.WriteLine("The square of 2 is " + two.Square());
    }
}}

这个简单的扩展方法在 Scala 中是什么样子？

原文

In C# you can write:

using System.Numerics;
namespace ExtensionTest {
public static class MyExtensions {
    public static BigInteger Square(this BigInteger n) {
        return n * n;
    }
    static void Main(string[] args) {
        BigInteger two = new BigInteger(2);
        System.Console.WriteLine("The square of 2 is " + two.Square());
    }
}}

How would this simple extension method look like in Scala?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

巴黎夜雨 2024-09-14 05:19:44

Pimp My Library 模式是类似的结构：

object MyExtensions {
  implicit def richInt(i: Int) = new {
    def square = i * i
  }
}


object App extends Application {
  import MyExtensions._

  val two = 2
  println("The square of 2 is " + two.square)

}

Per @Daniel Spiewak 的评论，这将避免方法调用的反射，从而提高性能：

object MyExtensions {
  class RichInt(i: Int) {
    def square = i * i
  }
  implicit def richInt(i: Int) = new RichInt(i)
}

The Pimp My Library pattern is the analogous construction:

object MyExtensions {
  implicit def richInt(i: Int) = new {
    def square = i * i
  }
}


object App extends Application {
  import MyExtensions._

  val two = 2
  println("The square of 2 is " + two.square)

}

Per @Daniel Spiewak's comments, this will avoid reflection on method invocation, aiding performance:

object MyExtensions {
  class RichInt(i: Int) {
    def square = i * i
  }
  implicit def richInt(i: Int) = new RichInt(i)
}

回复收藏 0 原文

或十年 2024-09-14 05:19:44

从 Scala 2.10 版开始，可以使整个类符合隐式转换的条件。

implicit class RichInt(i: Int) {
  def square = i * i
}

此外，可以通过扩展 AnyVal 来避免创建扩展类型的实例。

implicit class RichInt(val i: Int) extends AnyVal {
  def square = i * i
}

有关隐式类和 AnyVal、限制和怪癖的更多信息，查阅官方文档：

Since version 2.10 of Scala, it is possible to make an entire class eligible for implicit conversion

implicit class RichInt(i: Int) {
  def square = i * i
}

In addition, it is possible to avoid creating an instance of the extension type by having it extend AnyVal

implicit class RichInt(val i: Int) extends AnyVal {
  def square = i * i
}

For more information on implicit classes and AnyVal, limitations and quirks, consult the official documentation:

回复收藏 0 原文

往昔成烟 2024-09-14 05:19:44

这将是 Daniel 的评论之后的代码。

object MyExtensions {
    class RichInt( i: Int ) {
        def square = i * i
    }
    implicit def richInt( i: Int ) = new RichInt( i )

    def main( args: Array[String] ) {
        println("The square of 2 is: " + 2.square )
    }
}

This would be the code after Daniel's comment.

object MyExtensions {
    class RichInt( i: Int ) {
        def square = i * i
    }
    implicit def richInt( i: Int ) = new RichInt( i )

    def main( args: Array[String] ) {
        println("The square of 2 is: " + 2.square )
    }
}

回复收藏 0 原文