Mutating Methods क्या हैं

struct TypeName {
    var property: Type

    mutating func methodName() {
        property = newValue
    }
}

var instance = TypeName(property: value)   // must be var
instance.methodName()

// Define a struct `Counter`
struct Counter {
    // Declare a mutable variable `count`, initialized to `0`
    var count = 0
    mutating func increment() {
        count += 1
    }
}
// Declare a mutable variable `counter`, initialized to `Counter()`
var counter = Counter()
counter.increment()
counter.increment()
// Print "Count: \(counter.count)" to the console
print("Count: \(counter.count)")

// Define a struct `Switch`
struct Switch {
    // Declare a mutable variable `isOn`, initialized to `false`
    var isOn = false
    mutating func toggle() {
        isOn.toggle()
    }
}
// Declare a mutable variable `lightSwitch`, initialized to `Switch()`
var lightSwitch = Switch()
lightSwitch.toggle()
// Print "Is on: \(lightSwitch.isOn)" to the console
print("Is on: \(lightSwitch.isOn)")

Methods क्या हैं · Enums में Methods · Initializers क्या हैं · Property Observers क्या हैं

1. किसी struct method पर mutating keyword भूल जाना जो self या इसकी किसी property modify करता है, एक compile error का कारण बनते हुए।
2. एक let से declared struct instance पर एक mutating method call करने की कोशिश करना; सिर्फ var instances mutation allow करते हैं।
3. गलती से एक class method पर mutating जोड़ना; keyword सिर्फ structs और enums के लिए मायने रखता है, classes के लिए नहीं।

• Struct methods जो properties modify करते हैं उन्हें func से पहले mutating चिह्नित किया जाना चाहिए।
• एक mutating method सिर्फ एक var में stored instance पर call किया जा सकता है, let में नहीं।
• Classes को कभी mutating की ज़रूरत नहीं क्योंकि उनके methods हमेशा properties बदल सकते हैं।
• एक mutating method यहां तक कि self को उसी struct के एक नए instance में पूरी तरह reassign भी कर सकता है।