Jak zdefiniować stałą statyczną w klasie w języku swift

Mam te definicje w mojej funkcji, które działają

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

Ale jeśli przeniosę „testStr” i „testStrLen” na poziom klasy, to się nie skompiluje. Mówi się, że „MyClass.Type nie ma elementu członkowskiego o nazwie„ testStr ”.

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

    func myFunc() {

    }
}

Jak mogę to naprawić? Nie chcę płacić kary za odliczanie za każdym razem len ciągłego „testu”.

Na podstawie mojego zrozumienia poniższych komentarzy muszę to zrobić:

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

    func myFunc() {

    }
}

Czy jest sposób, żebym nie musiał dwukrotnie wpisywać / wpisywać słowa „test”? Dzięki.

Być może fajnym idiomem do deklarowania stałych dla klasy w Swift jest po prostu użycie struktury o nazwie MyClassConstants, takiej jak poniżej.

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

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

W ten sposób twoje stałe będą objęte zakresem zadeklarowanej konstrukcji zamiast unosić się globalnie.

Aktualizacja

Dodałem statyczną stałą tablicową w odpowiedzi na komentarz z pytaniem o statyczną inicjalizację tablicy. Zobacz Array Literals w „The Swift Programming Language”.

Zwróć uwagę, że do zainicjowania tablicy można użyć zarówno literałów łańcuchowych, jak i stałej ciągu. Jednak ponieważ typ tablicy jest znany, testStrLengthnie można użyć stałej liczby całkowitej w inicjatorze tablicy.

Dodawanie do odpowiedzi @ Martina ...

Jeśli ktoś planuje przechowywanie stałego pliku na poziomie aplikacji, można pogrupować stałą na podstawie ich typu lub charakteru

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

Połączenie : Constants.MixpanelConstants.activeScreen

AKTUALIZACJA 05.05.2019 (trochę poza tematem, ale 🤷🏽‍♂️)

Po przeczytaniu kilku wskazówek dotyczących kodu i osobistych doświadczeń wydaje się, że struktury nie są najlepszym podejściem do przechowywania stałych globalnych z kilku powodów. Zwłaszcza powyższy kod nie zapobiega inicjalizacji struktury. Możemy to osiągnąć, dodając jakiś standardowy kod, ale jest lepsze podejście

ENUMS

To samo można osiągnąć, używając wyliczenia z bezpieczniejszą i bardziej przejrzystą reprezentacją

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

print(Constants.MixpanelConstants.activeScreen.rawValue)

Jeśli dobrze rozumiem twoje pytanie, pytasz, jak możesz stworzyć stałe na poziomie klasy (statyczne - w języku C ++) tak, aby a) nie powielać narzutu w każdym przypadku i b musisz ponownie obliczyć to, co w innym przypadku jest stałe.

Język ewoluował - jak każdy czytelnik wie, ale gdy testuję to w Xcode 6.3.1, rozwiązaniem jest:

import Swift

class MyClass {
    static let testStr = "test"
    static let testStrLen = count(testStr)

    init() {
        println("There are \(MyClass.testStrLen) characters in \(MyClass.testStr)")
    }
}

let a = MyClass()

// -> There are 4 characters in test

Nie wiem, czy statyczne jest absolutnie konieczne, ponieważ kompilator z pewnością dodaje tylko jeden wpis na zmienną const do sekcji statycznej pliku binarnego, ale ma to wpływ na składnię i dostęp. Za pomocą statycznych, można zwrócić się do niego nawet wtedy, gdy nie masz instancji: MyClass.testStrLen.

Jeśli faktycznie chcesz mieć statyczną właściwość swojej klasy, nie jest ona obecnie obsługiwana w języku Swift. Obecnie radzimy obejść ten problem za pomocą stałych globalnych:

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

class MyClass {
    func myFunc() {
    }
}

Jeśli zamiast tego chcesz, aby były to właściwości instancji, możesz użyć leniwej przechowywanej właściwości dla długości - zostanie ona oceniona tylko przy pierwszym dostępie, więc nie będziesz jej obliczać w kółko.

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

    func myFunc() {
    }
}

A co z wykorzystaniem obliczonych właściwości?

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

MyClass.myConstant

Niektórzy mogą chcieć, aby niektóre stałe klasy były publiczne, a inne prywatne.

private słowo kluczowe może służyć do ograniczenia zakresu stałych w tym samym pliku 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)")
}

}

Inne klasy będą miały dostęp do stałych klas, jak poniżej

class MyClass2
{

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

} 

Próbowałem na placu zabaw

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()