0Mutating methods let you change the data inside value types like structs. Without them, value types cannot change their own properties.
struct MyStruct { var value: Int mutating func changeValue(newValue: Int) { value = newValue } }
The mutating keyword must be before the function name.
Only value types like struct and enum need mutating for methods that change properties.
struct Counter { var count = 0 mutating func increment() { count += 1 } }
struct Point { var x = 0, y = 0 mutating func moveBy(dx: Int, dy: Int) { x += dx y += dy } }
enum LightSwitch { case on, off mutating func toggle() { switch self { case .on: self = .off case .off: self = .on } } }
This program shows a bank account struct that can add or remove money using mutating methods. It prints the balance after each change and warns if there is not enough money.
struct BankAccount { var balance: Double mutating func deposit(amount: Double) { balance += amount } mutating func withdraw(amount: Double) { if amount <= balance { balance -= amount } else { print("Insufficient funds") } } } var myAccount = BankAccount(balance: 100.0) myAccount.deposit(amount: 50.0) print("Balance after deposit: \(myAccount.balance)") myAccount.withdraw(amount: 30.0) print("Balance after withdrawal: \(myAccount.balance)") myAccount.withdraw(amount: 150.0)
You cannot call mutating methods on constants (let) because they cannot change.
Mutating methods can also assign a new value to self to replace the whole instance.
Use mutating before methods that change properties in structs or enums.
Mutating methods let value types update their own data safely.
They cannot be used on constants because constants cannot change.
mutating keyword in Swift when used with methods inside a struct?mutating in structsmutating.mutating keywordmutating keyword allows the method to modify the struct's properties safely.mutating lets methods change struct data [OK]updateValue inside a struct in Swift?mutating keyword comes before func when declaring a mutating method.mutating func updateValue() { }, which is the proper syntax.struct Counter {
var count = 0
mutating func increment() {
count += 1
}
}
var myCounter = Counter()
myCounter.increment()
print(myCounter.count)increment() method is marked mutating, so it can increase the count property by 1.myCounter as a variable instance, call increment(), so count changes from 0 to 1, then print outputs 1.struct Point {
var x = 0
var y = 0
mutating func moveTo(newX: Int, newY: Int) {
x = newX
y = newY
}
}
let p = Point()
p.moveTo(newX: 10, newY: 20)p is declared with let, making it a constant.BankAccount with a balance property. You need a mutating method deposit(amount:) that adds money to the balance only if the amount is positive. Which implementation correctly uses a mutating method to safely update the balance?mutating to change balance, which must be a variable (var), not constant.amount only if positive, correctly updating balance. struct BankAccount {
var balance: Double = 0
func deposit(amount: Double) {
if amount > 0 {
balance += amount
}
}
} lacks mutating, so it cannot change balance. struct BankAccount {
let balance: Double = 0
mutating func deposit(amount: Double) {
balance += amount
}
} uses let for balance, so it cannot be changed. struct BankAccount {
var balance: Double = 0
mutating func deposit(amount: Double) {
balance = amount
}
} replaces balance with amount without checking positivity.Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.