Swift Language
Konwencje stylu

Uwagi

Wyczyść użycie

Unikaj dwuznaczności

Nazwy klas, struktur, funkcji i zmiennych powinny unikać dwuznaczności.

Przykład:

extension List {
    public mutating func remove(at position: Index) -> Element {
        // implementation
    }
}

Wywołanie funkcji dla tej funkcji będzie wtedy wyglądać następująco:

list.remove(at: 42)

W ten sposób unika się dwuznaczności. Jeśli wywołanie funkcji byłoby po prostu list.remove(42) nie byłoby jasne, czy element równy 42 zostałby usunięty, czy też element o indeksie 42 zostałby usunięty.

---

Unikaj redundancji

Nazwa funkcji nie powinna zawierać zbędnych informacji.

Zły przykład to:

extension List {
    public mutating func removeElement(element: Element) -> Element? {
        // implementation
    }
}

Wywołanie funkcji może wyglądać jak list.removeElement(someObject) . Zmienna someObject już wskazuje, że element został usunięty. Byłoby lepiej, gdyby podpis funkcji wyglądał tak:

extension List {
    public mutating func remove(_ member: Element) -> Element? {
        // implementation
    }
}

Wywołanie tej funkcji wygląda następująco: list.remove(someObject) .

---

Nazwy zmiennych według ich roli

Zmienne powinny być nazwane według ich roli (np. Dostawca, powitanie) zamiast ich typu (np. Fabryka, łańcuch itp.)

Wysokie sprzężenie między nazwą protokołu a nazwami zmiennych

Jeśli nazwa typu opisuje jego rolę w większości przypadków (np. Iterator), typ powinien być nazwany sufiksem `Type`. (np. IteratorType)

---

Podaj dodatkowe szczegóły, gdy używasz słabo wpisanych parametrów

Jeśli typ obiektu nie wskazuje wyraźnie jego użycia w wywołaniu funkcji, funkcję należy nazwać poprzedzającym rzeczownikiem dla każdego słabo wpisanego parametru, opisującego jego użycie.
Przykład:

func addObserver(_ observer: NSObject, forKeyPath path: String)

do którego wywołanie wyglądałoby jak `object.addObserver (self, forKeyPath: path)

zamiast

func add(_ observer: NSObject, for keyPath: String)

do którego wywołanie wyglądałoby jak object.add(self, for: path)

Płynne użytkowanie

Używanie języka naturalnego

Połączenia funkcji powinny być zbliżone do naturalnego języka angielskiego.

Przykład:

list.insert(element, at: index) 

zamiast

list.insert(element, position: index)

---

Nazewnicze metody fabryczne

Metody fabryczne powinny zaczynać się od przedrostka `make`.

Przykład:

factory.makeObject()

---

Nazwy parametrów w inicjalizatorach i metodach fabrycznych

Nazwa pierwszego argumentu nie powinna brać udziału w nazywaniu metody fabrycznej lub inicjalizatora.

Przykład:

factory.makeObject(key: value)

Zamiast:

factory.makeObject(havingProperty: value)

---

Nazewnictwo według skutków ubocznych

• Funkcje z efektami ubocznymi (funkcje mutujące) powinny być nazwane przy użyciu czasowników lub rzeczowników poprzedzonych form- .
• Funkcje bez efektów ubocznych (funkcje niemutujące) należy nazwać za pomocą rzeczowników lub czasowników z sufiksem -ing lub -ed .

Przykład: funkcje mutacji:

print(value)
array.sort()                 // in place sorting
list.add(value)              // mutates list
set.formUnion(anotherSet)    // set is now the union of set and anotherSet

Funkcje niemutujące:

let sortedArray = array.sorted()     // out of place sorting
let union = set.union(anotherSet)    // union is now the union of set and another set

---

Funkcje boolowskie lub zmienne

Oświadczenia dotyczące wartości logicznych należy odczytywać jako twierdzenia.

Przykład:

set.isEmpty
line.intersects(anotherLine)

---

Protokoły nazewnictwa

• Protokoły opisujące, co to jest, należy nazwać za pomocą rzeczowników.
• Protokoły opisujące możliwości powinny mieć -able , -ible lub -ing jako przyrostek.

Przykład:

Collection        // describes that something is a collection
ProgressReporting // describes that something has the capability of reporting progress
Equatable         // describes that something has the capability of being equal to something

---

Rodzaje i właściwości

Typy, zmienne i właściwości należy odczytywać jako rzeczowniki.

Przykład:

let factory = ...
let list = [1, 2, 3, 4]

Kapitalizacja

Rodzaje i protokoły

Nazwy typów i protokołów powinny zaczynać się od dużej litery.

Przykład:

protocol Collection {}
struct String {}
class UIView {}
struct Int {}
enum Color {}

Wszystko inne...

Zmienne, stałe, funkcje i przypadki wyliczenia powinny zaczynać się od małej litery.

Przykład:

let greeting = "Hello"
let height = 42.0

enum Color {
    case red
    case green
    case blue
}

func print(_ string: String) {
    ...
}

Etui na wielbłądy:

Wszystkie nazwy powinny zawierać odpowiednie etui na wielbłądy. Wielkie litery wielbłądów dla nazw typów / protokołów i małe litery wielbłądów dla wszystkich innych elementów.

Upper Camel Case:

protocol IteratorType { ... }

Dolna obudowa wielbłąda:

let inputView = ...

Skróty

Skrótów należy unikać, chyba że są powszechnie używane (np. Adres URL, identyfikator). Jeśli użyjesz skrótu, wszystkie litery powinny mieć tę samą wielkość liter.

Przykład:

let userID: UserID = ...
let urlString: URLString = ...