Découvrons les indices Swift :

Syntaxe de l'indice

Les indices vous permettent d'interroger des instances d'un type en écrivant une ou plusieurs valeurs entre crochets après le nom de l'instance. Leur syntaxe est similaire à la syntaxe de méthode d'instance et à la syntaxe de propriété calculée. Vous écrivez des définitions d'indices avec le mot-clé subscript et spécifiez un ou plusieurs paramètres d'entrée et un type de retour, de la même manière que les méthodes d'instances.


subscript(index: Int) -> Int {
    get {
        // Renvoie une valeur d'indice appropriée
    }
    set(newValue) {
        // Effectue une action de réglage appropriée
    }
}

Le type de newValue est le même que la valeur de retour de l'indice.

Comme pour les propriétés calculées en lecture seule, vous pouvez simplifier la déclaration d'un indice en lecture seule en supprimant le mot-clé get et ses accolades.

subscript(index: Int) -> Int {
    // Renvoie une valeur d'indice appropriée
}

Dans l'exemple ci-dessous, une nouvelle instance de TimesTable est créée pour représenter la table trois fois. Ceci est indiqué en passant une valeur de 3 à la structure initializer comme valeur à utiliser pour le paramètre multiplier de l'instance.

Vous pouvez interroger l'instance threeTimesTable en appelant son indice, comme indiqué dans l'appel à threeTimesTable[6]. Cela demande la sixième entrée dans la table de trois fois, qui renvoie une valeur de 18 ou 3 fois 6.


struct TimesTable {
    let multiplier: Int
    subscript(index: Int) -> Int {
        return multiplier * index
    }
}
let threeTimesTable = TimesTable(multiplier: 3)
print("six times three is \(threeTimesTable[6])")
// Prints "six times three is 18"

Indices de types

Les indices d'instances, comme décrits ci-dessus, sont des indices que vous appelez sur une instance d'un type particulier. Vous pouvez également définir des indices qui sont appelés sur le type lui-même. Ce type d'indice est appelé indice de types. Vous indiquez un indice de types en écrivant le mot-clé static avant le mot-clé subscript. Les classes peuvent utiliser le mot-clé class à la place, pour permettre aux sous-classes de remplacer l'implémentation de la superclasse de cet indice.

L'exemple ci-dessous montre comment définir et appeler un indice de types :


enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
    static subscript(n: Int) -> Planet {
        return Planet(rawValue: n)!
    }
}
let mars = Planet[4]
print(mars)