Le Tutoriel de Swift Enum

View more categories:

1- Qu'est-ce que Swift Enum?

Dans  Swift, le mot- clés enum est utilisé pour le type de données énuméré défini et fixe que vous ne pouvez pasajouter ou enlever le nombre des éléments. Par exemple, vous pouvez définir une énumération pour les jours de semaine.
S'il n'y a pas  enum, pour obtenir une série de jours dans une semaine, vous pouvez définir 7 constantes qui représentent des jours par semaine.
WeekDayConstants.swift
import Foundation


// Définit les constantes sont 7 qui représentent les jours de la semaine.
let CONST_MONDAY = 2;
let CONST_TUESDAY = 3;
let CONST_WEDNESDAY = 4;
let CONST_THURSDAY = 5;

let CONST_FRIDAY = 6;
let CONST_SATURDAY = 7;
let CONST_SUNDAY = 1;
Une fonction renvoie les tâches à faire de chaque jour spécifique dans la semaine. ( Une sorte d'un horaire)
 
GetJobByDay.swift
import Foundation

// Le paramètre d'entrée est le jour de la semaine.
// Renvoie le nom des tâches feront.
func getJobByDay(dayInWeek: Int) -> String {
    
    if (dayInWeek == CONST_SATURDAY
        || dayInWeek == CONST_SUNDAY) {
        return "Nothing";
    }
    return "Coding";
    
}
Il est évident que de tels lignes de code ne sont pas bien sécurisées. Par exemple, vous pouvez nommer la fonction  getJobByDay(Int) mais les paramètres de saisie n'appartenissent pas dans un ensemble défini.
  1. Elle n'est pas « Type-Safe », c'est-à-dire qu'elle n'empêche pas d'affecter une valeur inconnue à la variable de type int, entraînant des erreurs à l'exécution, qui ne sont donc pas levées à la compilation.
  2. Aucune signification dans l'impression: Si vous voulez imprimer les jours dans une semaine sous forme des numéro à la place de nom évocateur. Par exemple, vous voulez imprimer LUNDI, il va imprimer "2" au lieu de "LUNDI". 
Et c'est la manière de création une  enum, c'est une particulière compilation.
WeekDay.swift
import Foundation

// Define an Enumeration.
enum WeekDay
{
    // Elements
    case MONDAY
    case TUESDAY
    case WEDNESDAY
    case THURSDAY
    case FRIDAY
    case SATURDAY
    case SUNDAY
    
}
Par exemple, utilisez  Enum:
WeekDayTest.swift
import Foundation


// Renvoie le nom de tâche fera
func getJob(weekDay: WeekDay) -> String  {
    
    if (weekDay == WeekDay.SATURDAY || weekDay == WeekDay.SUNDAY) {
        
        return "Nothing"
        
    }
    return "Coding"
    
}

func test_getJob()   {
    
    var weekDay = WeekDay.TUESDAY
    
    print("Day = \(weekDay)")
    
    var job = getJob(weekDay)
    
    print("Job = \(job)")
    
}

2- Obtenir tous les éléments de Enum

Il n'y a pas de la fonction ou de méthode disponible qui vous permet d'extraire une liste des éléments d'une  enum quelconque mais vous pouvez définir une variable qui contient tous ces éléments de l' enum.
.
 
Cet exemple ci-desous définit une  enum, dans cette enum définit également une constante qui comprend tous les éléments de cette  enum.
Season.swift
import Foundation

// Les saisons dans un an.
enum Season  {
    
    case Spring
    
    case Summer
    
    case Autumn
    
    case Winter
    
    
    // Une constante statique, comprend tous les éléments (element) de Enum.
    static let allValues = [Spring, Summer, Autumn, Winter]
    
    
}
GetAllSeasons.swift
import Foundation



func test_getAllSeasons()   {
 
 
   for season in Season.allValues  {
       print(season)
   }
 
}
Exécutez l'exemple:

3- Enum dans la déclaration switch

Comme les types de données primitives ( Int, Float,..)  Enum peut être usée comme un paramètre dans l'intruction switch.
Observez  un exemple:
SwitchDemo.swift
import Foundation


func test_switchEnum() {
   
    var day = WeekDay.THURSDAY;
   
    switch (day) {
       
    case .MONDAY:
       
        print("Working day");
       
    case .SATURDAY, .SUNDAY :
       
        print("Holiday");
       
    default:
        print(day);
       
    }
   
}
 
Editez le code de  main.swift:
main.swift
import Foundation

test_switchEnum()
Exécutez l'exemple:

4- Enum avec des valeurs brutes (raw value)

Vous pouvez définir une enum par des valeurs brutes (raw values). Les valeurs brutes peuvent être des chaînes (string), des caractères, ou l'un des entier Int ou des types de nombres Number à virgule flottante. Chaque telle Enum peut répandre une de ces  StringCharacterInt,..
Par exemple, vous pouvez définir une enum qui comprend les mois d'un an, cette énumération va comprendre la valeur brute de 1 à 12. 
RawValueEnum.swift
import Foundation

// Définir un Enum est une énumération de mois dans l'année.
// Il s'étend (extends) de Int
enum Month : Int  {
    
    // Attribuez la valeur brute (raw value) au premier élément.
    // (Si l'élément n'a pas la valeur,
    // Par défaut, sa valeur est égale à la valeur de l'élément précédent plus 1).
    case January = 1,
    
    February, March, April, May, June,
    
    July, August, September, October, November, December
    
    // Une constante statique contient toutes les valeurs de Month enum.
    static let allValues = [January,February, March,
                            April, May, June, July, August,
                            September, October, November, December]
    
}

// 
enum Suit:String {
    
    case Spades = "♠"
    
    case Hearts = "♥"
    
    case Diamonds = "♦"
    
    case Clubs = "♣"
    
    // Une constante statique contient tous les éléments de Suit enum.
    static let allValues = [Spades,Hearts,Diamonds,Clubs]
    
}
Imprimez les éléments de enum Month et les valeurs brutes respectives. 
RawValueEnumTest.swift
import Foundation


func test_MonthEnum()   {
    
    // Imprimez tous les éléments et les valeurs brutes (raw value) de Enum.
    print("All element/raw value of Month enum");
    
    for e in Month.allValues  {
        
        let rawValue = e.rawValue
        
        print("Element \(e), raw value: \(rawValue)"  );
    }
    
    print("---------------------");
    
    // Imprimez tous les éléments et les valeurs brutes (raw value) de Enum.
    print("All element/raw value of Suit enum");
    
    for e in Suit.allValues  {
        
        let rawValue = e.rawValue
        
        print("Element \(e), raw value: \(rawValue)"  );
    }
    
}
Exécutez l'exemple:

5- Enum avec des valeurs associées

Vous pouvez créer une  Enum avec des éléments qui peuvent contenir des valeurs associées avec elle.
Par exemple, je crée une   Enum qui comprend des types de promotion:
  1. GIFT: L'offre des cadeaux
  2. DISCOUNT: La réduction
  3. MONEY: L'offre de l'argent
  4. SHIPPING: La livraison gratuite.
Le problème est que chaque forme de la promotion est ses valeus associées, par exemple  GIFT ( le nom de cadeau et la qualité), ou MONEY ( la somme), ...
Chaque élément d' enum donc a de paramètres différents. Considez l'exemple suivant:
Promotion.swift
import Foundation

// Les types de promotions
enum Promotion   {
    
    // Le cadeau (nom et quantité)
    case GIFT (name: String, quantity: Int)
    
    // La remise (percel: 0 - 100)
    case DISCOUNT(percent: Int)
    
    // L'argent
    case MONEY(amount : Int)
    
    // La livraison gratuite.
    case SHIPPING
    
}
Enum Promotion a seulement 4 éléments, vous ne pouvez pas ajouter ou relever ses éléments. Ses valeurs associées est déterminées dans le temps de fonctionnement du programme.
PromotionTest.swift
import Foundation

// Simulez un achat et obtenez des promotions.
func getRandomPromotion() -> Promotion {
    
    // Une valeur aléatoire
    var random: UInt32 = arc4random()
    
    // Divisé par 4 et renvoie le reste (0, 1, 2, 3).
    random = random % 4
    
    switch random  {
        
    case 0:
        return Promotion.DISCOUNT(percent: 10)
    case 1:
        return Promotion.GIFT(name: "Doll", quantity: 1)
    case 2:
        return Promotion.MONEY(amount: 100)
    case 3:
        return Promotion.SHIPPING
    default:
        return Promotion.SHIPPING
    }
    
}


func test_Promotion()   {
    
    
    var myProm = getRandomPromotion()
    
    print("Get Promotion: \(myProm)")
    
    
    switch myProm {
    case .DISCOUNT(let percent):
        print("Percent is: \(percent)")
    case .GIFT(let name, let quantity ):
        print("Gift name: \(name), quantity: \(quantity)")
    case .MONEY(let amount) :
        print("Amount: \(amount)")
    default:
        print(myProm)
    }
}
Editez  main.swift:
main.swift
import Foundation

test_Promotion()
Exécutez l'exemple:

6- Les méthodes dans Enum

Vous pouvez définir les méthodes dans enum, prennez un exemple:
Currency.swift
import Foundation


// ​​​​​​​
// La monnaie (Currency).
enum Currency   {
    
    case USD
    case YEN
    case VND
    
    
    
    func description() -> String  {
        
        switch self {
        case USD:
            return "America's currency"
        case YEN:
            return "Japan's currency"
        case VND :
            return "Vietnam's currency"
        }
    }
    
}

View more categories: