Metody Swift od podstaw - instancje, static i mutating

Gdy obiekt w aplikacji ma nie tylko przechowywać dane, ale też wykonywać działania, sama właściwość już nie wystarcza. Właśnie wtedy przydaje się metoda Swift, czyli funkcja przypisana do klasy, struktury albo wyliczenia. Pokażę, jak ją definiować i wywoływać, czym różni się metoda instancji od metody typu oraz kiedy potrzebne są parametry, mutating, static i rozszerzenia.

Czym jest metoda w języku Swift

Metoda jest funkcją umieszczoną wewnątrz definicji typu. Może należeć do klasy, struktury albo wyliczenia i zwykle opisuje działanie związane z danymi tego typu.

Najprostszy przykład to licznik. Jego stan przechowuje właściwość value, a metody odpowiadają za zwiększanie i zerowanie wartości.

struct Counter {
    var value = 0

    mutating func increment() {
        value += 1
    }

    mutating func reset() {
        value = 0
    }
}

var counter = Counter()
counter.increment()
print(counter.value) // 1

W tym przykładzie increment() i reset() są metodami instancji. Działają na konkretnym egzemplarzu struktury, dlatego najpierw trzeba utworzyć zmienną counter. Bez niej nie ma obiektu, którego stan można zmienić.

Swift pozwala definiować metody także w strukturach i wyliczeniach. To ważna różnica względem języków, w których zachowanie obiektów kojarzy się wyłącznie z klasami. W praktyce dobrze zaprojektowana struktura może zawierać zarówno dane, jak i operacje na tych danych.

Jak zdefiniować i wywołać metodę

Metodę zapisuje się podobnie jak zwykłą funkcję, ale jej deklaracja znajduje się wewnątrz typu. Podstawowy schemat wygląda tak:

struct User {
    let name: String

    func greeting() -> String {
        return "Cześć, \(name)!"
    }
}

let user = User(name: "Ola")
let message = user.greeting()

Metoda greeting() ma dostęp do właściwości name należącej do tej samej instancji. Swift pozwala pominąć zapis self, gdy nie ma ryzyka pomylenia właściwości z parametrem lub zmienną lokalną.

Jawne użycie self jest przydatne wtedy, gdy parametr ma taką samą nazwę jak właściwość:

struct Product {
    var name: String

    mutating func rename(name: String) {
        self.name = name
    }
}

Po lewej stronie znajduje się właściwość obiektu, a po prawej parametr metody. Taki zapis jest prosty, ale początkujący często próbują napisać name = name, co nie zmienia właściwości w oczekiwany sposób.

Parametry, etykiety i wartości zwracane

Metody mogą przyjmować argumenty i zwracać wynik. Swift rozdziela nazwę parametru używaną wewnątrz metody od etykiety widocznej podczas wywołania. Dzięki temu kod można czytać niemal jak zdanie.

struct Rectangle {
    var width: Double
    var height: Double

    func area() -> Double {
        width * height
    }

    func scaled(by factor: Double) -> Rectangle {
        Rectangle(
            width: width * factor,
            height: height * factor
        )
    }
}

let rectangle = Rectangle(width: 4, height: 3)
let bigger = rectangle.scaled(by: 2)

W wywołaniu scaled(by: 2) słowo by jest etykietą parametru. Nazwa factor służy implementacji metody, a etykieta poprawia czytelność kodu w miejscu użycia.

Jeżeli etykieta nie ma sensu albo wywołanie ma być krótsze, można użyć podkreślenia:

struct Temperature {
    var celsius: Double

    func converted(to scale: String) -> Double {
        if scale == "F" {
            return celsius * 9 / 5 + 32
        }

        return celsius
    }

    func adding(_ degrees: Double) -> Temperature {
        Temperature(celsius: celsius + degrees)
    }
}

let temperature = Temperature(celsius: 20)
let result = temperature.adding(5)

Nie przesadzałbym jednak z usuwaniem etykiet. W większości metod czytelne wywołanie jest ważniejsze niż kilka znaków mniej. Etykieta powinna zostać pominięta wtedy, gdy znaczenie argumentu wynika bezpośrednio z nazwy metody.

Swift pozwala również przeciążać metody, czyli tworzyć kilka metod o tej samej nazwie, ale z innymi parametrami:

struct Logger {
    func write(_ message: String) {
        print(message)
    }

    func write(_ message: String, level: String) {
        print("[\(level)] \(message)")
    }
}

let logger = Logger()
logger.write("Gotowe")
logger.write("Nie udało się połączyć", level: "ERROR")

Przeciążanie bywa wygodne, ale zbyt wiele podobnych wariantów utrudnia orientację. Gdy metody zaczynają różnić się nie tylko parametrami, lecz także odpowiedzialnością, lepiej nadać im konkretne nazwy.

Metody instancji i metody typu

Najczęściej spotykane są metody instancji, które wywołuje się na konkretnym obiekcie. Istnieje jednak także metoda typu, związana z samym typem, a nie z jego pojedynczym egzemplarzem.

Przykładem metody typu może być fabryka tworząca obiekt albo narzędzie obliczeniowe:

struct User {
    let name: String

    static func guest() -> User {
        User(name: "Gość")
    }
}

let guest = User.guest()

Metoda guest() nie potrzebuje istniejącego użytkownika, bo sama tworzy nową wartość. Słowo static jasno komunikuje, że działanie należy do typu User, a nie do konkretnego użytkownika.

W klasach można użyć także class func. Taka metoda może zostać przesłonięta w klasie potomnej, podczas gdy zwykłej metody statycznej nie można nadpisać w ten sam sposób. To szczegół potrzebny głównie przy projektowaniu hierarchii klas, a nie przy każdym prostym modelu danych.

Kiedy potrzebne jest mutating

Struktury i wyliczenia są typami wartości. Oznacza to, że ich dane są traktowane jak wartość, którą można skopiować. Jeżeli metoda ma zmienić właściwość struktury albo przypisać nową wartość do self, trzeba oznaczyć ją słowem mutating.

enum TrafficLight {
    case red
    case yellow
    case green

    mutating func next() {
        switch self {
        case .red:
            self = .green
        case .green:
            self = .yellow
        case .yellow:
            self = .red
        }
    }
}

var light = TrafficLight.red
light.next()

Bez mutating kompilator zgłosi błąd, ponieważ metoda próbuje zmodyfikować stan wartości. Właśnie dlatego wywołująca zmienna musi być zadeklarowana jako var, a nie let.

Klasy działają inaczej, ponieważ ich instancje są typami referencyjnymi. Metoda klasy może zmieniać właściwości obiektu bez słowa mutating:

final class ShoppingCart {
    var items: [String] = []

    func add(_ item: String) {
        items.append(item)
    }
}

let cart = ShoppingCart()
cart.add("Klawiatura")

Stała cart nie może wskazywać na inny obiekt, ale sam obiekt nadal może zmienić zawartość tablicy. To jedno z miejsc, w których różnica między typem wartości a typem referencyjnym ma praktyczne znaczenie.

Rozszerzenia, protokoły i organizacja kodu

Metod nie trzeba umieszczać wyłącznie w głównej definicji typu. Rozszerzenie, czyli extension, pozwala dodać nowe zachowanie bez modyfikowania pierwotnego kodu.

extension String {
    var isBlank: Bool {
        trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
    }

    func shortened(to limit: Int) -> String {
        if count <= limit {
            return self
        }

        return String(prefix(limit)) + "..."
    }
}

let title = "   Swift   "
print(title.isBlank)
print(title.shortened(to: 5))

Rozszerzenia dobrze sprawdzają się przy porządkowaniu większych plików. Można oddzielić metody związane z formatowaniem, walidacją albo komunikacją z API, ale trzeba pilnować, żeby typ nie zaczął gromadzić przypadkowych funkcji bez wspólnego celu.

Metody mogą też realizować wymagania protokołu. Protokół opisuje, jakie zachowanie typ ma udostępniać, ale nie musi wskazywać konkretnej klasy czy struktury:

protocol Describable {
    func description() -> String
}

struct Book: Describable {
    let title: String

    func description() -> String {
        "Książka: \(title)"
    }
}

To podejście ułatwia testowanie i wymianę implementacji. Kod korzystający z protokołu zamiast konkretnej klasy jest zwykle mniej zależny od szczegółów projektu.

Typowe błędy przy pisaniu metod

Najczęstszy problem nie wynika ze składni, ale z niewłaściwego podziału odpowiedzialności. Metoda, która jednocześnie waliduje dane, zapisuje je do bazy i buduje widok, szybko staje się trudna do przetestowania.

• Brak mutating przy modyfikowaniu struktury lub wyliczenia.
• Wywoływanie metody instancji na typie, na przykład User.greeting() zamiast user.greeting().
• Niezgodne etykiety parametrów, przez co wywołanie nie pasuje do deklaracji.
• Nadmierne używanie metod statycznych tam, gdzie potrzebny jest stan konkretnego obiektu.
• Zbyt szeroka odpowiedzialność, która prowadzi do długich i trudnych metod.

Dobrym testem jest pytanie, czy nazwa metody jasno mówi, co się wydarzy. calculateTotal() jest zrozumiałe, ale process() niewiele wyjaśnia. W swoim kodzie preferuję metody krótkie, które robią jedną rzecz i zwracają wynik bez ukrytych efektów ubocznych.

Trzeba też uważać na zmianę stanu. Metoda o nazwie formattedDate() powinna raczej zwracać sformatowaną datę, a nie dodatkowo zapisywać ją w innej właściwości. Przewidywalność oszczędza czas podczas debugowania i ułatwia pracę całemu zespołowi.

Jak myśleć o metodach, żeby kod pozostał czytelny

Najprościej traktować metodę jako zachowanie przypisane do właściwego miejsca. Jeżeli działanie wykorzystuje stan konkretnej instancji, metoda instancji będzie naturalnym wyborem. Jeżeli nie potrzebuje żadnych danych obiektu, rozważ metodę typu albo osobną funkcję.

Na początku nauki nie skupiałbym się na zapamiętaniu wszystkich wariantów. Największą różnicę robi praktyka z trzema pytaniami: do czego należy ta operacja, czy zmienia stan oraz czy jej wywołanie jest czytelne bez zaglądania do implementacji.

Dobrze zaprojektowane metody nie są tylko skrótem dla kilku linii kodu. Tworzą czytelny interfejs typu, ograniczają powielanie logiki i sprawiają, że kolejne elementy aplikacji łatwiej rozwijać. To właśnie ten sposób myślenia, a nie sama znajomość słowa func, robi największą różnicę w codziennym programowaniu w Swift.