Klassenmethode für Klassen in Swift "initialisieren"?

Ich suche nach einem Verhalten ähnlich der +(void)initializeKlassenmethode von Objective-C , da die Methode einmal aufgerufen wird, wenn die Klasse initialisiert wird, und danach nie wieder.

Ein einfaches class init () {}in einem classVerschluss wäre wirklich schlank! Und wenn wir " class vars" anstelle von " static vars in einem Strukturabschluss" verwenden, passt das natürlich alles sehr gut zusammen!

Wenn Sie eine Objective-C-Klasse haben, ist es am einfachsten, diese einfach zu überschreiben +initialize. Stellen Sie jedoch sicher, dass Unterklassen Ihrer Klasse ebenfalls überschrieben werden, da +initializesonst die Klassen Ihrer Klasse +initializemöglicherweise mehrmals aufgerufen werden! Wenn Sie möchten, können Sie dispatch_once()(siehe unten) zum Schutz vor mehreren Anrufen verwenden.

class MyView : UIView {
  override class func initialize () {
    // Do stuff
  }
}

Wenn Sie eine Swift-Klasse haben, ist das Beste, was Sie bekommen können, dispatch_once()in der init()Anweisung.

private var once = dispatch_once_t()

class MyObject {
  init () {
    dispatch_once(&once) {
      // Do stuff
    }
  }
}

Diese Lösung unterscheidet sich von +initialize(die beim ersten Messaging einer Objective-C-Klasse aufgerufen wird) und ist daher keine echte Antwort auf die Frage. Aber es funktioniert gut genug, IMO.

In Swift gibt es keinen Typinitialisierer .

„Im Gegensatz zu Eigenschaften gespeicherter Instanzen müssen Sie Eigenschaften gespeicherter Typen immer einen Standardwert geben. Dies liegt daran, dass der Typ selbst keinen Initialisierer hat , der einer gespeicherten Typeneigenschaft zum Zeitpunkt der Initialisierung einen Wert zuweisen kann. “

Auszug aus: Apple Inc. "Die schnelle Programmiersprache". iBooks .

Sie können eine type-Eigenschaft verwenden, deren Standardwert ein Abschluss ist. Der Code im Abschluss würde also ausgeführt, wenn die Eigenschaft type (oder die Klassenvariable) festgelegt wird.

class FirstClass {
    class var someProperty = {
     // you can init the class member with anything you like or perform any code
        return SomeType
    }()
}

Aber class stored properties not yet supported(getestet in Xcode 8).

Eine Antwort ist zu verwenden static, es ist die gleiche wie class final.

Guter Link dafür ist

Festlegen eines Standardeigenschaftswerts mit einem Abschluss oder einer Funktion

Auszug aus: Apple Inc. "Die schnelle Programmiersprache". iBooks .

Codebeispiel:

class FirstClass {
    static let someProperty = {
        () -> [Bool] in
        var temporaryBoard = [Bool]()
        var isBlack = false
        for i in 1...8 {
            for j in 1...8 {
                temporaryBoard.append(isBlack)
                isBlack = !isBlack
            }
            isBlack = !isBlack
        }

        print("setting default property value with a closure")
        return temporaryBoard
    }()
}

print("start")
FirstClass.someProperty

Druckt

Start

Festlegen des Standardeigenschaftswerts mit einem Abschluss

Also ist es faul ausgewertet.

Für @objcKlassen class func initialize()funktioniert das definitiv, da +initializees von der Objective-C-Laufzeit implementiert wird. Aber für "native" Swift-Klassen müssen Sie die anderen Antworten sehen.

@aleclarson hat es geschafft, aber ab dem letzten Swift 4 können Sie nicht direkt überschreiben initialize. Sie können dies weiterhin mit Objective-C und Kategorien für Klassen erreichen, von denen NSObjectmit einer class / static- swiftyInitializeMethode geerbt wird, die von Objective-C in aufgerufen wird MyClass.mund die Sie neben MyClass.swift:

# MyView.swift

import Foundation
public class MyView: UIView
{
    @objc public static func swiftyInitialize() {
        Swift.print("Rock 'n' roll!")
    }
}

# MyView.m

#import "MyProject-Swift.h"
@implementation MyView (private)
    + (void)initialize { [self swiftyInitialize]; }
@end

Wenn Ihre Klasse nicht von erben erben kann NSObjectund +loadstattdessen +initializeeine geeignete Anpassung verwendet, können Sie Folgendes tun:

# MyClass.swift

import Foundation
public class MyClass
{
    public static func load() {
        Swift.print("Rock 'n' roll!")
    }
}
public class MyClassObjC: NSObject
{
    @objc public static func swiftyLoad() {
        MyClass.load()
    }
}

# MyClass.m

#import "MyProject-Swift.h"
@implementation MyClassObjC (private)
    + (void)load { [self swiftyLoad]; }
@end

Es gibt einige Fallstricke, insbesondere wenn Sie diesen Ansatz in statischen Bibliotheken verwenden. Weitere Informationen finden Sie im vollständigen Beitrag auf Medium! ✌️

Sie können gespeicherte Typeneigenschaften anstelle der initializeMethode verwenden.

class SomeClass: {
  private static let initializer: Void = {
    //some initialization
  }()
}

Da die Eigenschaften gespeicherter Typen beim ersten Zugriff tatsächlich träge initialisiert werden, müssen Sie sie irgendwo weiterleiten. Sie können dies mit gewöhnlichen gespeicherten Objekten tun:

class SomeClass: {
  private static let initializer: Void = {
    //some initialization
  }()
  private let initializer: Void = SomeClass.initializer
}

Ich kann keinen gültigen Anwendungsfall finden, um so etwas wie +[initialize]in Swift zu haben. Vielleicht erklärt dies, wie es nicht existiert

Warum brauchen wir +[initialize]in ObjC?

Initialisieren einer globalen Variablen

static NSArray *array;

+ (void)initialize {
    array = @[1,2,3];
}

was in Swift

struct Foo {
    static let array = [1,2,3]
}

Um etwas zu hacken

+ (void)initialize {
    swizzle_methodImplementation()
}

was von Swift nicht unterstützt wird (ich kann nicht herausfinden, wie es für die reine Swift-Klasse / struct / enum geht)