Swift-Initialisierung

Initialisierung ist der Prozess, eine Instanz einer Klasse, Struktur oder Aufzählung für die Verwendung vorzubereiten. Dieser Prozess umfasst das Festlegen eines Anfangswerts für jede gespeicherte Eigenschaft dieser Instanz und das Ausführen aller weiteren erforderlichen Einrichtungs- oder Initialisierungsaufgaben.

Swift-Initialisierer verwenden die Methode init().

Anders als Objective-C-Initialisierer geben Swift-Initialisierer keinen Wert zurück. Ihre Hauptaufgabe besteht darin, sicherzustellen, dass neue Instanzen korrekt initialisiert werden, bevor sie zum ersten Mal verwendet werden.

Klasseninstanzen können auch einen Deinitialisierer definieren, um Aufräumarbeiten durchzuführen, kurz bevor die Klasseninstanz freigegeben wird.


Festlegen von Anfangswerten für gespeicherte Eigenschaften

Klassen und Strukturen müssen beim Erstellen einer Instanz einen geeigneten Anfangswert für alle gespeicherten Eigenschaften festlegen.

Wenn gespeicherten Eigenschaften in einem Initialisierer Werte zugewiesen werden, werden ihre Werte direkt festgelegt und lösen keine Eigenschaftsbeobachter aus.

Der Prozess des Zuweisens gespeicherter Eigenschaften in einem Initialisierer:

  • Anfangswerte erstellen.

  • Standardwerte für Eigenschaften in der Eigenschaftsdefinition angeben.

  • Die Instanz initialisieren und die Methode init() aufrufen.


Initialisierer

Ein Initialisierer wird aufgerufen, wenn eine neue Instanz eines bestimmten Typs erstellt wird. In seiner einfachsten Form ähnelt er einer Instanzmethode ohne Parameter, die mit dem Schlüsselwort init geschrieben wird.

Syntax

init()
{
    // 实例化后执行的代码
}

Beispiel

Die folgende Struktur definiert einen Initialisierer init ohne Parameter und initialisiert darin die Werte der gespeicherten Eigenschaften length und breadth auf 6 bzw. 12:

struct rectangle {
    var length: Double
    var breadth: Double
    init() {
        length = 6
        breadth = 12
    }
}
var area = rectangle()
print("矩形面积为 \(area.length*area.breadth)")

Das obige Programm erzeugt die folgende Ausgabe:

矩形面积为 72.0

Standardwerte für Eigenschaften

Sie können Anfangswerte für gespeicherte Eigenschaften in einem Initialisierer festlegen; ebenso können Sie Standardwerte beim Deklarieren der Eigenschaft festlegen.

Die Verwendung von Standardwerten macht Ihren Initialisierer prägnanter und klarer, und der Typ der Eigenschaft kann automatisch aus ihrem Standardwert abgeleitet werden.

Im folgenden Beispiel legen wir Standardwerte beim Deklarieren der Eigenschaften fest:

struct rectangle {
    // 设置默认值
    var length = 6
    var breadth = 12
}
var area = rectangle()
print("矩形的面积为 \(area.length*area.breadth)")

Das obige Programm erzeugt die folgende Ausgabe:

矩形面积为 72

Initialisierer-Parameter

Sie können Initialisierer-Parameter beim Definieren eines Initialisierers init() angeben, wie unten gezeigt:

struct Rectangle {
    var length: Double
    var breadth: Double
    var area: Double
    
    init(fromLength length: Double, fromBreadth breadth: Double) {
        self.length = length
        self.breadth = breadth
        area = length * breadth
    }
    
    init(fromLeng leng: Double, fromBread bread: Double) {
        self.length = leng
        self.breadth = bread
        area = leng * bread
    }
}

let ar = Rectangle(fromLength: 6, fromBreadth: 12)
print("面积为: \(ar.area)")

let are = Rectangle(fromLeng: 36, fromBread: 12)
print("面积为: \(are.area)")

Das obige Programm erzeugt die folgende Ausgabe:

面积为: 72.0
面积为: 432.0

Interne und externe Parameternamen

Wie bei Funktions- und Methodenparametern haben Initialisierer-Parameter auch einen internen Parameternamen, der innerhalb des Initialisierers verwendet wird, und einen externen Parameternamen, der beim Aufrufen des Initialisierers verwendet wird.

Allerdings haben Initialisierer keinen unterscheidbaren Namen vor den Klammern wie Funktionen und Methoden. Daher werden beim Aufrufen eines Initialisierers hauptsächlich die Parameternamen und -typen im Initialisierer verwendet, um zu bestimmen, welcher Initialisierer aufgerufen werden soll.

Wenn Sie beim Definieren eines Initialisierers keine externen Namen für Parameter angeben, generiert Swift automatisch für jeden Initialisierer-Parameter einen externen Namen, der mit dem internen Namen identisch ist.

struct Color {
    let red, green, blue: Double
    init(red: Double, green: Double, blue: Double) {
        self.red   = red
        self.green = green
        self.blue  = blue
    }
    init(white: Double) {
        red   = white
        green = white
        blue  = white
    }
}

// 创建一个新的Color实例,通过三种颜色的外部参数名来传值,并调用构造器
let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)

print("red 值为: \(magenta.red)")
print("green 值为: \(magenta.green)")
print("blue 值为: \(magenta.blue)")

// 创建一个新的Color实例,通过三种颜色的外部参数名来传值,并调用构造器
let halfGray = Color(white: 0.5)
print("red 值为: \(halfGray.red)")
print("green 值为: \(halfGray.green)")
print("blue 值为: \(halfGray.blue)")

Das obige Programm erzeugt die folgende Ausgabe:

red 值为: 1.0
green 值为: 0.0
blue 值为: 1.0
red 值为: 0.5
green 值为: 0.5
blue 值为: 0.5

Initialisiererparameter ohne externe Namen

Wenn Sie keinen externen Namen für einen Parameter eines Initialisierers angeben möchten, können Sie einen Unterstrich verwenden_um seinen externen Namen explizit zu beschreiben.

struct Rectangle {
    var length: Double
    
    init(frombreadth breadth: Double) {
        length = breadth * 10
    }
    
    init(frombre bre: Double) {
        length = bre * 30
    }
    //不提供外部名字
    init(_ area: Double) {
        length = area
    }
}

// 调用不提供外部名字
let rectarea = Rectangle(180.0)
print("面积为: \(rectarea.length)")

// 调用不提供外部名字
let rearea = Rectangle(370.0)
print("面积为: \(rearea.length)")

// 调用不提供外部名字
let recarea = Rectangle(110.0)
print("面积为: \(recarea.length)")

Das obige Programm erzeugt die folgende Ausgabe:

面积为: 180.0
面积为: 370.0
面积为: 110.0

Optionale Eigenschaftstypen

Wenn Ihr benutzerdefinierter Typ eine gespeicherte Eigenschaft enthält, die logischerweise keinen Wert haben darf, müssen Sie sie als optionalen Typ definieren (optionaler Eigenschaftstyp).

Wenn eine gespeicherte Eigenschaft als optional deklariert wird, wird sie automatisch mit nil initialisiert.

struct Rectangle {
    var length: Double?
    
    init(frombreadth breadth: Double) {
        length = breadth * 10
    }
    
    init(frombre bre: Double) {
        length = bre * 30
    }
    
    init(_ area: Double) {
        length = area
    }
}

let rectarea = Rectangle(180.0)
print("面积为:\(rectarea.length)")

let rearea = Rectangle(370.0)
print("面积为:\(rearea.length)")

let recarea = Rectangle(110.0)
print("面积为:\(recarea.length)")

Das obige Programm erzeugt die folgende Ausgabe:

面积为:Optional(180.0)
面积为:Optional(370.0)
面积为:Optional(110.0)

Zuweisen konstanter Eigenschaften während der Initialisierung

Solange der Wert einer Konstante bis zum Ende der Initialisierung bestimmt werden kann, können Sie den Wert der konstanten Eigenschaft an jedem Punkt während der Initialisierung ändern.

Bei einer Klasseninstanz kann ihre konstante Eigenschaft nur während der Initialisierung der Klasse geändert werden, die sie definiert; in einer Unterklasse kann sie nicht geändert werden.

Obwohl die Eigenschaft length jetzt eine Konstante ist, können wir ihren Wert weiterhin im Initialisierer ihrer Klasse festlegen:

struct Rectangle {
    let length: Double?
    
    init(frombreadth breadth: Double) {
        length = breadth * 10
    }
    
    init(frombre bre: Double) {
        length = bre * 30
    }
    
    init(_ area: Double) {
        length = area
    }
}

let rectarea = Rectangle(180.0)
print("面积为:\(rectarea.length)")

let rearea = Rectangle(370.0)
print("面积为:\(rearea.length)")

let recarea = Rectangle(110.0)
print("面积为:\(recarea.length)")

Das obige Programm erzeugt die folgende Ausgabe:

面积为:Optional(180.0)
面积为:Optional(370.0)
面积为:Optional(110.0)

Standardinitialisierer

Ein Standardinitialisierer erstellt einfach eine Instanz, bei der alle Eigenschaftswerte auf ihre Standardwerte gesetzt sind:

Im folgenden Beispiel haben alle Eigenschaften in der Klasse ShoppingListItem Standardwerte, und da es sich um eine Basisklasse ohne Oberklasse handelt, erhält sie automatisch einen Standardinitialisierer, der Standardwerte für alle Eigenschaften festlegen kann.

class ShoppingListItem {
    var name: String?
    var quantity = 1
    var purchased = false
}
var item = ShoppingListItem()


print("名字为: \(item.name)")
print("数理为: \(item.quantity)")
print("是否付款: \(item.purchased)")

Das obige Programm erzeugt die folgende Ausgabe:

名字为: nil
数理为: 1
是否付款: false

Memberwise-Initialisierer für Strukturtypen

Wenn eine Struktur Standardwerte für alle ihre gespeicherten Eigenschaften bereitstellt und keine benutzerdefinierten Initialisierer bereitstellt, erhält sie automatisch einen Memberwise-Initialisierer.

Beim Aufrufen eines Memberwise-Initialisierers übergibt man Werte unter Verwendung von Parameternamen, die mit den Namen der Member-Eigenschaften übereinstimmen, wodurch die anfängliche Zuweisung der Member-Eigenschaften abgeschlossen wird.

Das folgende Beispiel definiert eine Struktur Rectangle mit zwei Eigenschaften, length und breadth. Swift kann ihre Typen automatisch als Double aus den Anfangswerten 100.0 und 200.0 ableiten.

struct Rectangle {
    var length = 100.0, breadth = 200.0
}
let area = Rectangle(length: 24.0, breadth: 32.0)

print("矩形的面积: \(area.length)")
print("矩形的面积: \(area.breadth)")

Da beide gespeicherten Eigenschaften Standardwerte haben, erhält die Struktur Rectangle automatisch einen Memberwise-Initialisierer init(width:height:). Man kann ihn verwenden, um neue Instanzen von Rectangle zu erstellen.

Das obige Programm erzeugt die folgende Ausgabe:

矩形的面积: 24.0
矩形的面积: 32.0

Initialisierer-Delegation für Werttypen

Ein Initialisierer kann andere Initialisierer aufrufen, um einen Teil des Instanzinitialisierungsprozesses abzuschließen. Dieser Vorgang wird als Initialisierer-Delegation bezeichnet und reduziert Codewiederholungen zwischen mehreren Initialisierern.

Im folgenden Beispiel ruft die Struktur Rect die Initialisierer von Size und Point auf:

struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}

struct Rect {
    var origin = Point()
    var size = Size()
    init() {}
    init(origin: Point, size: Size) {
        self.origin = origin
        self.size = size
    }
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}


// origin和size属性都使用定义时的默认值Point(x: 0.0, y: 0.0)和Size(width: 0.0, height: 0.0):
let basicRect = Rect()
print("Size 结构体初始值: \(basicRect.size.width, basicRect.size.height) ")
print("Rect 结构体初始值: \(basicRect.origin.x, basicRect.origin.y) ")

// 将origin和size的参数值赋给对应的存储型属性
let originRect = Rect(origin: Point(x: 2.0, y: 2.0),
    size: Size(width: 5.0, height: 5.0))

print("Size 结构体初始值: \(originRect.size.width, originRect.size.height) ")
print("Rect 结构体初始值: \(originRect.origin.x, originRect.origin.y) ")


//先通过center和size的值计算出origin的坐标。
//然后再调用(或代理给)init(origin:size:)构造器来将新的origin和size值赋值到对应的属性中
let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
    size: Size(width: 3.0, height: 3.0))

print("Size 结构体初始值: \(centerRect.size.width, centerRect.size.height) ")
print("Rect 结构体初始值: \(centerRect.origin.x, centerRect.origin.y) ")

Das obige Programm erzeugt die folgende Ausgabe:

Size 结构体初始值: (0.0, 0.0) 
Rect 结构体初始值: (0.0, 0.0) 
Size 结构体初始值: (5.0, 5.0) 
Rect 结构体初始值: (2.0, 2.0) 
Size 结构体初始值: (3.0, 3.0) 
Rect 结构体初始值: (2.5, 2.5) 

Regeln für die Initialisierer-Delegation

Werttypen Klassentypen
Werttypen unterstützen keine Vererbung, daher ist der Prozess der Initialisierer-Delegation relativ einfach, da sie nur an andere von ihnen selbst bereitgestellte Initialisierer delegieren können. Man kann self.init in einem benutzerdefinierten Initialisierer verwenden, um auf andere Initialisierer desselben Werttyps zu verweisen. Sie kann von anderen Klassen erben, was bedeutet, dass eine Klasse dafür verantwortlich ist, sicherzustellen, dass alle ihre geerbten gespeicherten Eigenschaften während der Konstruktion ebenfalls korrekt initialisiert werden.

Klassenvererbung und Initialisierung

Swift stellt zwei Arten von Klasseninitialisierern bereit, um sicherzustellen, dass alle gespeicherten Eigenschaften in einer Klasseninstanz Anfangswerte erhalten können. Es handelt sich um designierte Initialisierer und Convenience-Initialisierer.

Designierte Initialisierer Convenience-Initialisierer
Der primäre Initialisierer für eine Klasse. Ein sekundärer, unterstützender Initialisierer für eine Klasse.
Er initialisiert alle von der Klasse eingeführten Eigenschaften und ruft entlang der Oberklassenkette einen Oberklassen-Initialisierer auf, um die Oberklasse zu initialisieren. Sie können einen Convenience-Initialisierer definieren, der einen designierten Initialisierer in derselben Klasse aufruft und Standardwerte für dessen Parameter bereitstellt. Sie können auch einen Convenience-Initialisierer definieren, um eine Instanz für einen bestimmten Zweck oder eine bestimmte Eingabe zu erstellen.
Jede Klasse muss mindestens einen designierten Initialisierer besitzen. Stellen Sie Convenience-Initialisierer für eine Klasse nur bereit, wenn dies erforderlich ist.
Init(parameters) {
    statements
}
convenience init(parameters) {
      statements
}

Beispiel für einen designierten Initialisierer

class mainClass {
    var no1 : Int // 局部存储变量
    init(no1 : Int) {
        self.no1 = no1 // 初始化
    }
}
class subClass : mainClass {
    var no2 : Int // 新的子类存储变量
    init(no1 : Int, no2 : Int) {
        self.no2 = no2 // 初始化
        super.init(no1:no1) // 初始化超类
    }
}

let res = mainClass(no1: 10)
let res2 = subClass(no1: 10, no2: 20)

print("res 为: \(res.no1)")
print("res2 为: \(res2.no1)")
print("res2 为: \(res2.no2)")

Das obige Programm erzeugt die folgende Ausgabe:

res 为: 10
res 为: 10
res 为: 20

Beispiel für Convenience-Initialisierer

class mainClass {
    var no1 : Int // 局部存储变量
    init(no1 : Int) {
        self.no1 = no1 // 初始化
    }
}

class subClass : mainClass {
    var no2 : Int
    init(no1 : Int, no2 : Int) {
        self.no2 = no2
        super.init(no1:no1)
    }
    // 便利方法只需要一个参数
    override convenience init(no1: Int)  {
        self.init(no1:no1, no2:0)
    }
}
let res = mainClass(no1: 20)
let res2 = subClass(no1: 30, no2: 50)

print("res 为: \(res.no1)")
print("res2 为: \(res2.no1)")
print("res2 为: \(res2.no2)")

Das obige Programm erzeugt die folgende Ausgabe:

res 为: 20
res2 为: 30
res2 为: 50

Vererbung und Überschreiben von Initialisierern

Eine Unterklasse in Swift erbt standardmäßig nicht die Initialisierer der Oberklasse.

Initialisierer der Oberklasse werden nur unter bestimmten und sicheren Umständen geerbt.

Wenn du einen designierten Initialisierer der Oberklasse überschreibst, musst du den override-Modifikator angeben.

class SuperClass {
    var corners = 4
    var description: String {
        return "\(corners) 边"
    }
}
let rectangle = SuperClass()
print("矩形: \(rectangle.description)")

class SubClass: SuperClass {
    override init() {  //重载构造器
        super.init()
        corners = 5
    }
}

let subClass = SubClass()
print("五角型: \(subClass.description)")

Das obige Programm erzeugt die folgende Ausgabe:

矩形: 4 边
五角型: 5 边

Beispiel für designierte und Convenience-Initialisierer

Das folgende Beispiel demonstriert designierte Initialisierer, Convenience-Initialisierer und automatische Initialisierervererbung in Aktion.

Es definiert eine Klassenhierarchie mit zwei Klassen, MainClass und SubClass, und demonstriert, wie ihre Initialisierer interagieren.

class MainClass {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    convenience init() {
        self.init(name: "[匿名]")
    }
}
let main = MainClass(name: "Example")
print("MainClass 名字为: \(main.name)")

let main2 = MainClass()
print("没有对应名字: \(main2.name)")

class SubClass: MainClass {
    var count: Int
    init(name: String, count: Int) {
        self.count = count
        super.init(name: name)
    }
    
    override convenience init(name: String) {
        self.init(name: name, count: 1)
    }
}

let sub = SubClass(name: "Example")
print("MainClass 名字为: \(sub.name)")

let sub2 = SubClass(name: "Example", count: 3)
print("count 变量: \(sub2.count)")

Das obige Programm erzeugt die folgende Ausgabe:

MainClass 名字为: Example
没有对应名字: [匿名]
MainClass 名字为: Example
count 变量: 3

Fehlbare Initialisierer

Wenn ein Objekt eines Klassen-, Struktur- oder Enumerationstyps während seiner Konstruktion fehlschlagen kann, definiere einen fehlbaren Initialisierer dafür.

Mögliche Ursachen für das Fehlschlagen der Variableninitialisierung sind:

  • Übergeben ungültiger Parameterwerte.

  • Eine benötigte externe Ressource fehlt.

  • Eine bestimmte Bedingung wurde nicht erfüllt.

Um Situationen korrekt zu behandeln, in denen der Konstruktionsprozess fehlschlagen kann.

Du kannst der Definition einer Klasse, Struktur oder Aufzählung einen oder mehrere fehlbare Initialisierer hinzufügen. Die Syntax besteht darin, nach dem Schlüsselwort init ein Fragezeichen hinzuzufügen (init?).

Beispiel

Das folgende Beispiel definiert eine Struktur namens Animal, die eine konstante Eigenschaft namens species vom Typ String besitzt.

Die Struktur definiert außerdem einen fehlbaren Initialisierer, der einen String-Parameter namens species entgegennimmt. Dieser fehlbare Initialisierer wird verwendet, um zu prüfen, ob der übergebene Parameter eine leere Zeichenkette ist. Wenn er eine leere Zeichenkette ist, schlägt der fehlbare Initialisierer beim Konstruieren des Objekts fehl; andernfalls ist er erfolgreich.

struct Animal {
    let species: String
    init?(species: String) {
        if species.isEmpty { return nil }
        self.species = species
    }
}

//通过该可失败构造器来构建一个Animal的对象,并检查其构建过程是否成功
// someCreature 的类型是 Animal? 而不是 Animal
let someCreature = Animal(species: "长颈鹿")

// 打印 "动物初始化为长颈鹿"
if let giraffe = someCreature {
    print("动物初始化为\(giraffe.species)")
}

Die Ausgabe der obigen Programmausführung ist:

Animal initialized as giraffe

Fehlbare Initialisierer für Aufzählungstypen

Du kannst ein bestimmtes Enumerationselement in einem Aufzählungstyp erhalten, indem du einen fehlbaren Initialisierer mit einem oder mehreren Parametern erstellst.

Beispiel

Das folgende Beispiel definiert einen Aufzählungstyp namens TemperatureUnit, der drei mögliche Enumerationselemente (Kelvin, Celsius und Fahrenheit) sowie einen fehlbaren Initialisierer enthält, der verwendet wird, um das Enumerationselement zu finden, das einem Character-Wert entspricht:

enum TemperatureUnit {
    // 开尔文,摄氏,华氏
    case Kelvin, Celsius, Fahrenheit
    init?(symbol: Character) {
        switch symbol {
        case "K":
            self = .Kelvin
        case "C":
            self = .Celsius
        case "F":
            self = .Fahrenheit
        default:
            return nil
        }
    }
}


let fahrenheitUnit = TemperatureUnit(symbol: "F")
if fahrenheitUnit != nil {
    print("这是一个已定义的温度单位,所以初始化成功。")
}

let unknownUnit = TemperatureUnit(symbol: "X")
if unknownUnit == nil {
    print("这不是一个已定义的温度单位,所以初始化失败。")
}

Die Ausgabe der obigen Programmausführung ist:

This is a defined temperature unit, so initialization succeeded.
This is not a defined temperature unit, so initialization failed.

Fehlbare Initialisierer für Klassentypen

Fehlbare Initialisierer für Werttypen (wie Strukturen oder Aufzählungen) haben keine Einschränkungen dahingehend, wann und wo sie einen Initialisierungsfehler auslösen.

Ein fehlbarer Initialisierer für eine Klasse kann jedoch erst dann einen Fehlschlag auslösen, nachdem alle Klasseneigenschaften initialisiert wurden und alle Delegierungsaufrufe zwischen Initialisierern in der Klasse stattgefunden haben.

Beispiel

Im folgenden Beispiel wird eine Klasse namens StudRecord definiert. Da die Eigenschaft studname eine Konstante ist, hat die Eigenschaft studname nach erfolgreicher Konstruktion der Klasse StudRecord definitiv einen Nicht-nil-Wert.

class StudRecord {
    let studname: String!
    init?(studname: String) {
        self.studname = studname
        if studname.isEmpty { return nil }
    }
}
if let stname = StudRecord(studname: "失败构造器") {
    print("模块为 \(stname.studname)")
}

Die Ausgabe der obigen Programmausführung ist:

Module is a failed constructor

Überschreiben eines fehlbaren Initialisierers

Wie bei anderen Initialisierern können Sie auch den fehlbaren Initialisierer einer Basisklasse durch den fehlbaren Initialisierer einer Unterklasse überschreiben.

Oder Sie können den fehlbaren Initialisierer einer Basisklasse durch den nicht fehlbaren Initialisierer einer Unterklasse überschreiben.

Sie können einen nicht fehlbaren Initialisierer verwenden, um einen fehlbaren Initialisierer zu überschreiben, aber umgekehrt funktioniert das nicht.

Ein nicht fehlbarer Initialisierer kann niemals an einen fehlbaren Initialisierer delegieren.

Beispiel

Das folgende Beispiel beschreibt fehlbare und nicht fehlbare Initialisierer:

class Planet {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    convenience init() {
        self.init(name: "[No Planets]")
    }
}
let plName = Planet(name: "Mercury")
print("行星的名字是: \(plName.name)")

let noplName = Planet()
print("没有这个名字的行星: \(noplName.name)")

class planets: Planet {
    var count: Int
    
    init(name: String, count: Int) {
        self.count = count
        super.init(name: name)
    }
    
    override convenience init(name: String) {
        self.init(name: name, count: 1)
    }
}

Die Ausgabe der obigen Programmausführung ist:

行星的名字是: Mercury
没有这个名字的行星: [No Planets]

Der fehlbare Initialisierer init!

Im Allgemeinen definieren wir einen fehlbaren Initialisierer, indem wir nach dem Schlüsselwort init ein Fragezeichen hinzufügen (init?), aber Sie können einen fehlbaren Initialisierer auch definieren, indem Sie nach init ein Ausrufezeichen hinzufügen (init!). Beispiel:

struct StudRecord {
    let stname: String
    
    init!(stname: String) {
        if stname.isEmpty {return nil }
        self.stname = stname
    }
}

let stmark = StudRecord(stname: "Example")
if let name = stmark {
    print("指定了学生名")
}

let blankname = StudRecord(stname: "")
if blankname == nil {
    print("学生名为空")
}

Die Ausgabe der obigen Programmausführung ist:

Student name specified
Student name is empty
Andere Erweiterungen