Swift Academy · Lekcja

Alternatywy dla mutating

Zwracanie nowych wartości zamiast modyfikowania ich w miejscu.

Alternatywy dla mutating to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Zwracanie zamiast modyfikowania

Zamiast zmieniać instancję w miejscu, metoda niemutująca może zwrócić zupełnie nową wartość z zastosowaną zmianą.

struct Counter {
    var value: Int
    func incremented() -> Counter {
        return Counter(value: value + 1)
    }
}
let c = Counter(value: 0)
let next = c.incremented()
print(c.value, next.value)

Oryginał pozostaje niezmieniony

Ponieważ nic nie jest modyfikowane, pierwotna wartość zostaje zachowana, a tworzona jest nowa wartość.

struct Vector {
    var x: Int
    var y: Int
    func scaled(by factor: Int) -> Vector {
        return Vector(x: x * factor, y: y * factor)
    }
}
let v = Vector(x: 2, y: 3)
let big = v.scaled(by: 10)
print(v.x, v.y, big.x, big.y)

Działa z instancjami let

Metody niemutujące można wywoływać na stałych let, ponieważ nie zmieniają odbiorcy.

struct Money {
    var cents: Int
    func plus(_ other: Int) -> Money {
        return Money(cents: cents + other)
    }
}
let m = Money(cents: 100)
print(m.plus(50).cents)

Konwencja nazewnicza

Konwencja Swift: metody mutujące używają czasowników w trybie rozkazującym (sort), a niemutujące — form imiesłowowych lub zakończonych na -ed/-ing (sorted).

var nums = [3, 1, 2]
let ordered = nums.sorted()
nums.sort()
print(ordered, nums)

sorted a sort

Biblioteka standardowa stosuje tę konwencję: sorted() zwraca nową tablicę, a sort() modyfikuje ją w miejscu.

let a = [5, 2, 8, 1]
let b = a.sorted()
print(a)
print(b)

reversed a reverse

Podobnie reversed() jest metodą niemutującą. W tym przypadku materializujemy jej wynik za pomocą Array.

let a = [1, 2, 3]
let b = Array(a.reversed())
print(a, b)

Łączenie wywołań niemutujących

Metody niemutujące zwracają wartości, dlatego można je płynnie łączyć.

let result = [4, 2, 9, 1].sorted().map { $0 * 2 }
print(result)

Styl funkcyjny

Zwracanie nowych wartości zamiast modyfikowania wspiera styl funkcyjny, który ułatwia testowanie i rozumowanie o kodzie.

struct Account {
    var balance: Int
    func deposited(_ n: Int) -> Account {
        return Account(balance: balance + n)
    }
}
let a0 = Account(balance: 0)
let a1 = a0.deposited(100).deposited(50)
print(a0.balance, a1.balance)

Unikanie błędów współdzielonego stanu

Tworzenie nowych wartości zapobiega przypadkowym współdzielonym modyfikacjom, co jest szczególnie cenne w przypadku wielu wątków.

struct Settings {
    var volume: Int
    func with(volume newVolume: Int) -> Settings {
        return Settings(volume: newVolume)
    }
}
let base = Settings(volume: 5)
let loud = base.with(volume: 11)
print(base.volume, loud.volume)

Kiedy lepiej modyfikować

Jeśli w pętli wielokrotnie aktualizuje się jedną instancję, modyfikowanie w miejscu może być wydajniejsze niż tworzenie wielu kopii.

var total = 0
for n in 1...5 {
    total += n
}
print(total)

Udostępnianie obu form

Dobrze zaprojektowane typy czasami udostępniają obie formy, podobnie jak biblioteka standardowa, dzięki czemu wywołujący może wybrać modyfikowanie lub nową wartość.

struct Text {
    var value: String
    func uppercased() -> Text {
        return Text(value: value.uppercased())
    }
    mutating func uppercase() {
        value = value.uppercased()
    }
}
var t = Text(value: "hi")
let u = t.uppercased()
t.uppercase()
print(u.value, t.value)

Szybkie sprawdzenie

Sprawdź projekt niemutujący.

Podsumowanie

Alternatywą dla modyfikowania jest metoda niemutująca, która zwraca nową wartość z zastosowaną zmianą, pozostawia oryginał bez zmian i działa z instancjami let. Konwencja Swift łączy nazwy rozkazujące (sort) z nazwami zakończonymi na -ed/-ing (sorted).

let a = [3, 1, 2]
let b = a.sorted()
print(a, b)

Często zadawane pytania

Czy lekcja „Alternatywy dla mutating” jest bezpłatna?

Tak — pełny tekst „Alternatywy dla mutating” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Alternatywy dla mutating”?

Zwracanie nowych wartości zamiast modyfikowania ich w miejscu. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Alternatywy dla mutating”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Swift Academy