Swift Language
Conventions de style

Remarques

Effacer l'utilisation

Éviter l'ambiguïté

Le nom des classes, structures, fonctions et variables doit éviter toute ambiguïté.

Exemple:

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

L'appel de fonction à cette fonction ressemblera alors à ceci:

list.remove(at: 42)

De cette façon, l'ambiguïté est évitée. Si l'appel de fonction ne serait que list.remove(42) il serait difficile de savoir si un élément égal à 42 serait supprimé ou si l'élément de l'index 42 serait supprimé.

---

Éviter la redondance

Le nom des fonctions ne doit pas contenir d'informations redondantes.

Un mauvais exemple serait:

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

Un appel à la fonction peut ressembler à list.removeElement(someObject) . La variable someObject indique déjà qu'un élément est supprimé. Il serait préférable que la signature de la fonction ressemble à ceci:

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

L'appel à cette fonction ressemble à ceci: list.remove(someObject) .

---

Nommer les variables en fonction de leur rôle

Les variables doivent être nommées par leur rôle (par exemple fournisseur, message d'accueil) au lieu de leur type (par exemple, usine, chaîne, etc.)

Couplage élevé entre le nom du protocole et les noms de variables

Si le nom du type décrit son rôle dans la plupart des cas (par exemple Iterator), le type doit être nommé avec le suffixe `Type`. (par exemple, IteratorType)

---

Fournir des détails supplémentaires lors de l'utilisation de paramètres faiblement typés

Si le type d'un objet n'indique pas clairement son utilisation dans un appel de fonction, la fonction doit être nommée avec un nom précédent pour chaque paramètre faiblement typé, décrivant son utilisation.
Exemple:

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

à quoi un appel ressemblerait `object.addObserver (self, forKeyPath: path)

au lieu de

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

à quoi un appel ressemblerait à object.add(self, for: path)

Usage Courant

Utiliser le langage naturel

Les appels de fonctions doivent être proches de la langue anglaise naturelle.

Exemple:

list.insert(element, at: index) 

au lieu de

list.insert(element, position: index)

---

Méthodes de nommage

Les méthodes d'usine devraient commencer par le préfixe `make`.

Exemple:

factory.makeObject()

---

Paramètres de dénomination dans les initialiseurs et les méthodes d'usine

Le nom du premier argument ne doit pas être utilisé pour nommer une méthode de fabrique ou un initialiseur.

Exemple:

factory.makeObject(key: value)

Au lieu de:

factory.makeObject(havingProperty: value)

---

Nommer selon les effets secondaires

• Les fonctions avec effets secondaires (fonctions mutantes) doivent être nommées en utilisant des verbes ou des noms préfixés par form- .
• Fonctions sans effets secondaires (fonctions nonmutating) doivent être nommés en utilisant des noms ou des verbes avec le suffixe -ing ou -ed .

Exemple: Fonctions mutantes:

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

Fonctions non-mutantes:

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

---

Fonctions booléennes ou variables

Les instructions impliquant des booléens doivent se lire comme des assertions.

Exemple:

set.isEmpty
line.intersects(anotherLine)

---

Protocoles de nommage

• Les protocoles décrivant quelque chose doivent être nommés à l'aide de noms.
• Les protocoles décrivant les capacités doivent avoir un suffixe -able , -ible ou -ing .

Exemple:

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

---

Types et propriétés

Les types, les variables et les propriétés doivent être considérés comme des noms.

Exemple:

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

Capitalisation

Types et protocoles

Les noms de type et de protocole doivent commencer par une lettre majuscule.

Exemple:

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

Tout le reste...

Les variables, constantes, fonctions et énumérations doivent commencer par une lettre minuscule.

Exemple:

let greeting = "Hello"
let height = 42.0

enum Color {
    case red
    case green
    case blue
}

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

Affaire de chameau:

Tous les noms doivent utiliser le cas de chameau approprié. Boîtier supérieur pour les noms de type / protocole et boitier inférieur pour tout le reste.

Upper Camel Case:

protocol IteratorType { ... }

Boitier inférieur:

let inputView = ...

Abréviations

Les abréviations doivent être évitées, sauf si elles sont couramment utilisées (par exemple, URL, ID). Si une abréviation est utilisée, toutes les lettres doivent avoir la même casse.

Exemple:

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