在 Swift 中通过计算属性访问静态属性效率低吗？

Question

假设我有一些应该被视为类变量的常量。

static let constant1 = 1
static let constant2 = 2
static let constant3 = 3

为了访问 constant1，我需要遍历该类，例如 OwnerClass.constant1。

但我也可以通过计算属性访问它们。例如，

var constant1:Int { get{ return OwnerClass.constant1 }}

这样做是为了避免重复输入 OwnerClass.。

但问题是，这样效率低吗？

Answer 1

与大多数优化问题一样，这取决于您的精确代码和编译器的版本，而且我们不必猜测，我们可以检查。

我所说的“效率低下”是指“无法内联访问器调用”。

TL;DR 是：在几乎所有情况下，优化器都会以任何一种方式内联它。在某些特殊情况下，访问器版本不是内联的，例如，如果调用者位于顶层（不在函数内部）并且该类不是最终类。 （我不知道为什么这是一个极端情况；它可能是一个优化器错误。）

我对这是否是一个好的设计持中立态度。我对此很满意（我自己偶尔也会使用这种模式）。但我当然不会出于性能考虑而避免它。 （如果一个额外的函数调用会成为问题，无论如何您都需要手动优化。）

细节

与大多数优化/性能问题一样，这将取决于您的确切代码和编译器的版本。正如我所说，在某些极端情况下，这一点没有得到优化。我用 Swift 5.5.2 进行了测试。

首先，我创建了一个测试程序：

// Avoid the complexity around calling print()
// while ensuring that the variable is not optimized away
@inline(never)
func handle(_ x: Int) {
    print(x)
}

// Stick it in a function to avoid the special handling of
// global variables
func f() {
    let c = OwnerClass()

    let x = OwnerClass.constant1
    handle(x)
    let y = c.constant1
    handle(y)
}

// Make sure to call the function so it's not optimized away
f()

然后我用 OwnerClass 的几个版本检查了它（我使用 12345678 以便更容易在输出中找到）：

// Class
class OwnerClass {
    static let constant1 = 12345678
    var constant1:Int { get{ return OwnerClass.constant1 }}
}

// Final class
final class OwnerClass {
    static let constant1 = 12345678
    var constant1:Int { get{ return OwnerClass.constant1 }}
}

// Struct
struct OwnerClass {
    static let constant1 = 12345678
    var constant1:Int { get{ return OwnerClass.constant1 }}
}

// Instance constant 
class OwnerClass {
    static let constant1 = 12345678
    let constant1:Int = OwnerClass.contant1
}

唯一遇到问题的程序（例如，当我没有包装它时）全部在一个函数中），是带有访问器的非最终类。

为了了解优化器的作用，我使用 swiftc -emit-sil -O x.swift 进行编译。在所有情况下，这都是 f() 编译的结果：

// f()
sil hidden @$s1x1fyyF : $@convention(thin) () -> () {
bb0:
  %0 = integer_literal $Builtin.Int64, 12345678   // user: %1
  %1 = struct $Int (%0 : $Builtin.Int64)          // users: %6, %5, %4, %2
  debug_value %1 : $Int, let, name "x"            // id: %2
  // function_ref handle(_:)
  %3 = function_ref @$s1x6handleyySiF : $@convention(thin) (Int) -> () // users: %6, %4
  %4 = apply %3(%1) : $@convention(thin) (Int) -> ()
  debug_value %1 : $Int, let, name "y"            // id: %5
  %6 = apply %3(%1) : $@convention(thin) (Int) -> ()
  %7 = tuple ()                                   // user: %8
  return %7 : $()                                 // id: %8
} // end sil function '$s1x1fyyF'

需要注意的重要一点是，常量 12345678 作为 %0 内联到函数中（包装到 %1 中），然后使用两次在%4和%6中调用handle()。不会调用访问器。 OwnerClass 甚至没有被引用（c 的创建被优化掉了）。