Question

我在我的函数中有这些定义

class MyClass {
    func myFunc() {
        let testStr = "test"
        let testStrLen = countElements(testStr)
    }
}

但是如果我将'testStr'和'testStrLen'移到类级别，它将无法编译。它说'MyClass.Type没有名为'testStr'的成员。

class MyClass {
    let testStr = "test"
    let testStrLen = countElements(testStr)

    func myFunc() {

    }
}

我该如何解决这个问题？我不想每次都计算一次不断“测试”的罚款。

根据我对下面评论的理解，我需要这样做：

class MyClass {
    let testStr = "test"
    let testStrLen = countElements("test")

    func myFunc() {

    }
}

有没有办法我不需要输入/输入“test”两次？感谢。

Answer 1

在Swift中为一个类声明常量的一个很好的习惯用法就是使用一个名为MyClassConstants的结构，如下所示。

struct MyClassConstants{
    static let testStr = "test"
    static let testStrLength = countElements(testStr)

    static let arrayOfTests: [String] = ["foo", "bar", testStr]
}

通过这种方式，您的常量将在声明的构造中进行范围化，而不是全局浮动。

更新

我添加了一个静态数组常量，以响应有关静态数组初始化的注释。请参阅“Swift编程语言”中的Array Literals。

请注意，字符串文字和字符串常量都可用于初始化数组。但是，由于数组类型是已知的，因此不能在数组初始值设定项中使用整数常量testStrLength。

Answer 2

添加@ Martin的答案......

如果有人计划保持应用程序级别的常量文件，您可以根据其类型或性质对常量进行分组

struct Constants {
    struct MixpanelConstants {
        static let activeScreen = "Active Screen";
    }
    struct CrashlyticsConstants {
        static let userType = "User Type";
    }
}

致电：Constants.MixpanelConstants.activeScreen

更新 5/5/2019（有点偏离主题但是♂️）

阅读一些代码指南＆amp;从个人经验看，结构似乎不是存储全局常量的最佳方法，原因有两个。特别是上面的代码并没有阻止结构的初始化。我们可以通过添加一些样板代码来实现它，但有更好的方法

<强> ENUMS

使用更安全和更安全的枚举可以实现同样的目的。明确的代表性

enum Constants {
    enum MixpanelConstants: String {
        case activeScreen = "Active Screen";
    }
    enum CrashlyticsConstants: String {
        case userType = "User Type";
    }
}

print(Constants.MixpanelConstants.activeScreen.rawValue)

Answer 3

如果你真的想要你的类的静态属性，那么Swift目前不支持。目前的建议是通过使用全局常量来解决这个问题：

let testStr = "test"
let testStrLen = countElements(testStr)

class MyClass {
    func myFunc() {
    }
}

如果你想让它们成为实例属性，你可以使用lazy stored property作为长度 - 它只会在第一次被访问时得到评估，所以你不会一遍又一遍地计算它

class MyClass {
    let testStr: String = "test"
    lazy var testStrLen: Int = countElements(self.testStr)

    func myFunc() {
    }
}

Answer 4

使用计算属性怎么样？

class MyClass {
  class var myConstant: String { return "What is Love? Baby don't hurt me" }
}

MyClass.myConstant

Answer 5

有些人可能希望某些类常量公开，而其他类私有。

private 关键字可用于限制同一swift文件中的常量范围。

class MyClass {

struct Constants {

    static let testStr = "test"
    static let testStrLen = testStr.characters.count

    //testInt will not be accessable by other classes in different swift files
    private static let testInt = 1
}

func ownFunction()
{

    var newInt = Constants.testInt + 1

    print("Print testStr=\(Constants.testStr)")
}

}

其他类将能够访问您的类常量，如下所示

class MyClass2
{

func accessOtherConstants()
{
    print("MyClass's testStr=\(MyClass.Constants.testStr)")
}

}

Answer 6

在游乐场尝试


class MyClass {

struct Constants {

    static let testStr = "test"
    static let testStrLen = testStr.characters.count

    //testInt will not be accessable by other classes in different swift files
    private static let testInt = 1

    static func singletonFunction()
    {
        //accessable
        print("Print singletonFunction testInt=\(testInt)")

        var newInt = testStrLen
        newInt = newInt + 1
        print("Print singletonFunction testStr=\(testStr)")
    }
}

func ownFunction() {
    //not accessable
    //var newInt1 = Constants.testInt + 1

    var newInt2 = Constants.testStrLen
    newInt2 = newInt2 + 1
    print("Print ownFunction testStr=\(Constants.testStr)")
    print("Print ownFunction newInt2=\(newInt2)")
}
}


let newInt = MyClass.Constants.testStrLen
print("Print testStr=\(MyClass.Constants.testStr)")
print("Print testInt=\(newInt)")


let myClass = MyClass()
myClass.ownFunction()
MyClass.Constants.singletonFunction()

如何在swift中定义类中的静态常量

6 个答案:

更新