Le Tutoriel de Swift Enum

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


// Defines the constants are the days of the week.
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

// Input parameter is the day of the week.
// Returns name of Job will do
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


// Returns name of Job will do.
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

// The seasons
enum Season  {
    
    case Spring
    
    case Summer
    
    case Autumn
    
    case Winter
    
    
    // A static Constant, contains all the elements of the 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

// Define an Enum is enumeration of months in year.
// It extends from Int
enum Month : Int  {
    
    // Assign the value (raw value) for the first element.
    // (If the element is not assigned the value,
    // Default its value equal to the value of the previous element plus 1).
    case January = 1,
    
    February, March, April, May, June,
    
    July, August, September, October, November, December
    
    // A static Constant contains all the values of 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 = "♣"
    
    // A Static Constant contains all the elements of 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()   {
    
    // Print out all elements and raw values of 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("---------------------");
    
    // Print out all elements and raw values of 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

// Promotion types
enum Promotion   {
    
    // Gift (Name and quantity)
    case GIFT (name: String, quantity: Int)
    
    // Discount (percel: 0 - 100)
    case DISCOUNT(percent: Int)
    
    // Money
    case MONEY(amount : Int)
    
    // Free shipping.
    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

// Simulate a purchase, and get promotions.
func getRandomPromotion() -> Promotion {
    
    // A random value
    var random: UInt32 = arc4random()
    
    // Divided by 4 and returns the remainder (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


// Currencies.
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: