[Swift] À propos du type d'énumération

1.Tout d'abord

Swift a une notation très importante ** appelée ʻenumeration` ** que nous n'avons pas encore introduite. Il existe de nombreuses situations dans lesquelles le «type d'énumération» est très efficace lorsqu'il est utilisé, alors veuillez consulter mon article, surtout si vous êtes nouveau sur Swift. Il existe également un «type d'énumération de type partagé» dans le type d'énumération, mais j'aimerais l'expliquer la prochaine fois.

2. Qu'est-ce qu'un type d'énumération?

Le «type d'énumération» dans Swift est considérablement étendu par rapport au «type d'énumération» en langage C, comme la possibilité de définir sa propre méthode. Voici un exemple simple.

python

enum Direction {
    case up
    case down
    case right
    case left
}

Vous avez maintenant défini une «Direction énumérée». Le haut et le bas sont appelés «cas d'énumération» («case»). Le nom de cas est généralement écrit dans un cas de chameau en commençant par une minuscule.

Vous pouvez également écrire l'exemple précédent comme suit:

python

enum Direction {
    case up, down, right, left
}

Le «cas d'énumération» déclaré ici peut être affecté à une variable ou une constante. Les noms de cas ne sont pas globaux et peuvent être décrits en utilisant des noms énumérés et ".". Cependant, si vous connaissez le type d'énumération à utiliser, vous pouvez omettre le nom du type d'énumération. En d'autres termes, ** les noms de cas ne sont pas utilisés seuls, il est donc prudent de dupliquer les noms de cas d'autres types énumérés **. Par exemple.

python

let d = Direction.up          
var x : Direction = .right    //Si le type est décidé"."Peut être décrit à partir de
d == x                        //Ce sont des valeurs différentes(false)

3. Définition de la méthode

Contrairement au langage C, Swift vous permet d'inclure des méthodes dans la définition du «type d'énumération» pour représenter le comportement et la fonctionnalité du type dans son ensemble. Par exemple, disons que vous voulez connaître la direction dans laquelle le magasin s'est ouvert à 90 ° dans le sens des aiguilles d'une montre à partir de chaque direction dans le «type d'énumération» qui montre les quatre directions dans l'exemple ci-dessus. Cela peut être défini avec une méthode comme celle-ci:

python

enum Direction {
    case up, down, right, left
    func clockwise() -> Direction {
        switch self {
            case .up:    return .right
            case .down:  return .left
            case .right: return .down
            case .left:  return .up
        }
    }
}

Par exemple, cette méthode peut être utilisée comme suit:

python

let d = Direction.up
d.clockwise() == Direction.down              // false
d.clockwise().clockwise() == Direction.down  // true

De cette manière, le cas du «type d'énumération» et les procédures qui en dépendent peuvent être définis comme un.

4. Type d'énumération du type de valeur

Le «type d'énumération» de Swift a, en plus du «type d'énumération simple» décrit jusqu'à présent, ** un «type de valeur» ** dans lequel tous les cas ont une valeur du même type de données. Il y a. Le type d'énumération de type valeur vous permet de définir tous les cas d'énumération pour avoir différentes valeurs du même type. Le type de la valeur est appelé le «type substantiel» du «type d'énumération», et la valeur attribuée à chaque cas est appelée «valeur substantielle». Après le nom de type nouvellement défini, écrivez «:» et «type substantiel». Vous pouvez écrire une valeur dans chaque cas, mais vous ne pouvez écrire qu'un entier, un nombre réel, une valeur booléenne ou une chaîne littérale. Par conséquent, ce qui peut être un type réel est ** un type qui peut être initialisé avec ces valeurs **. Consultez l'aperçu suivant.

nom du type enum: type d'entité{
cas Nom du cas=littéral
cas Nom du cas=littéral
    ... ...

Si le «type substantiel» est un entier, le cas où aucune valeur n'est spécifiée dans le littéral est la valeur du cas précédent plus 1. S'il n'y a pas de littéral dans le premier cas, la valeur sera 0. Vous pouvez spécifier la valeur librement, mais vous devez vous assurer qu'il n'y a pas de cas avec la même valeur.

Si «type substantiel» est une chaîne de caractères et qu'aucun littéral n'est spécifié, la chaîne de caractères du nom de cas sera la valeur de «type réel». Si le type autre que les entiers et les chaînes est «type substantiel», vous devez écrire un littéral pour chaque cas afin que chacun ait une valeur différente.

Vous pouvez convertir des types entre le «type d'énumération» et son «type d'entité». Vérifiez l'exemple suivant. Définissez le type Direction mentionné dans l'exemple précédent afin que le type Int soit le type réel.

python

enum Direction : Int {
    case up = 0, down, right, left
}

Puisque la «valeur réelle» du premier haut est fixée à 0, les valeurs suivantes en bas, à droite et à gauche auront respectivement les valeurs 1, 2 et 3. En supposant que vous ayez créé plusieurs instances d'un tel «type d'énumération», vous pouvez utiliser une propriété appelée rawValue pour récupérer la valeur réelle de chacune.

python

let a = Direction.right
let i = a.rawValue                // i = 2(Int)
let k = Direction.down.rawValue   // k = 1(Int)

Inversement, pour obtenir une instance du «type d'énumération» correspondant à partir de la valeur du «type d'entité», utilisez l'initialiseur init? (RawValue :). Cet initialiseur est un "initialiseur ayant échoué" car la valeur correcte ne peut pas être retournée s'il n'y a pas de "cas d'énumération" correspondant à la valeur du "type réel". Voir l'exemple ci-dessous.

python

let b : Direction? = Direction(rawValue:3)
b! == Direction.left                  // true
if let c = Direction(rawValue:2) {    //Syntaxe de liaison facultative
    print("OK \(c.rawValue)")         // "OK 2"
}

Réécrivons le plan que nous avons écrit précédemment en utilisant le type de valeur ʻenumeration type`. Si vous définissez les cas directionnels dans le sens des aiguilles d'une montre, vous n'avez pas à tout énumérer dans l'instruction switch. Vous devez représenter l'instance elle-même dans la fonction, mais pour cela, nous utilisons le mot réservé self. Regardez l'exemple.

python

enum Direction : Int {
    case up = 0, right, down, left       //Réorganiser dans le sens des aiguilles d'une montre
    func clockwise() -> Direction {
        let t = (self.rawValue + 1) % 4  //soi est l'instance elle-même
        return Direction(rawValue:t)!    //Ne sera pas nul

5. Méthodes et propriétés des types d'énumération

Vous pouvez également définir des propriétés pour le «type d'énumération», mais contrairement aux structures, vous ne pouvez définir que des ** propriétés de calcul **. Laissez-moi vous donner un exemple.

python

enum Direction : Int {
    case up = 0, right, down, left  //sens horaire
    /* ...Omission... */
    var horizontal: Bool {          //Définition de propriété uniquement pour la clause get
        switch self {
        case .right, .left: return true
        default: return false
        }
    }
    mutating func turnBack() {
        self = Direction(rawValue:((self.rawValue + 2) % 4))!
    }
}

Pour le type Direction donné à titre d'exemple jusqu'à présent, nous avons défini une propriété de calcul horizontale qui renvoie true si la valeur représente horizontal, right ou left. Cet exemple montre également un exemple de définition d'une méthode avec un attribut de muting pour un ʻenumeration type`.

Contrairement aux structures, il modifie la «valeur du type d'énumération lui-même» stockée dans la variable en attribuant une autre valeur au «self» qui se représente lui-même. Non disponible si la valeur est stockée dans une constante. Ici, une méthode turnBack qui s'inverse dans la direction opposée est ajoutée au type Direction.

Voyons un exemple d'exécution.

python

var d = Direction.left
print(d.rawValue)    //3 est la sortie
d.turnBack()
print(d.rawValue)    //1 est la sortie(3 directions opposées)
print(d.horizontal)  //vrai est la sortie

6. Initialiseur de type d'énumération et méthode de type

Vous pouvez définir des méthodes de type, des propriétés de type et des initialiseurs pour les «types énumératifs» ainsi que les structures. Pour les méthodes de type et les méthodes de type, écrivez le mot-clé static au début de la définition de fonction ou de la définition de variable. L'initialiseur définira ce qu'il faut attribuer à «self». Il est également possible de redéfinir l'initialiseur init? Automatiquement préparé (RawValue :). Consultez l'exemple ci-dessous.

python

enum Direction : Int {
    case up = 0, right, down, left
    static var defaultDirection = Direction.up
    init() {
        self = Direction.defaultDirection
    }
    // ...Omission...
}

Ici, une variable appelée defaultDirection est préparée, et lorsqu'une instance est créée à l'aide de l'initialiseur init (), cette valeur est utilisée comme valeur initiale.

Un exemple d'exécution est présenté ci-dessous.

python

Direction.defaultDirection = .right    //Définir vers la droite comme valeur initiale
let e = Direction()                    //Utiliser l'initialiseur
let g = Direction(rawValue:1)          //Initialiseur d'énumération de type valeur
print(e == g)                          // true

7. Conclusion

Cette fois, j'ai expliqué le «type d'énumération» qui est une notation très importante dans Swift. La prochaine fois, j'écrirai un article sur le "type d'énumération partagé", alors jetez-y un œil lorsque l'article sera téléchargé la semaine prochaine. Merci d'avoir lu jusqu'ici.