web-dev-qa-db-fra.com

Comment obtenir de la valeur brute dans Swift?

J'essaie d'obtenir le type enum de la valeur brute:

enum TestEnum: String {
    case Name
    case Gender
    case Birth

    var rawValue: String {
        switch self {
        case .Name: return "Name"
        case .Gender: return "Gender"
        case .Birth: return "Birth Day"
        }
    }
}

let name = TestEnum(rawValue: "Name")       //Name
let gender = TestEnum(rawValue: "Gender")   //Gender

Mais il semble que rawValue ne fonctionne pas pour les chaînes avec des espaces:

let birth = TestEnum(rawValue: "Birth Day") //nil

Des suggestions comment l'obtenir?

iosswiftenums
51
Leo

Trop compliqué, il suffit d’attribuer les valeurs brutes directement aux cas

enum TestEnum: String {
  case Name = "Name"
  case Gender = "Gender"
  case Birth = "Birth Day"
}

let name = TestEnum(rawValue: "Name")!       //Name
let gender = TestEnum(rawValue: "Gender")!   //Gender
let birth = TestEnum(rawValue: "Birth Day")! //Birth

Si le nom de l'affaire correspond à la valeur brute, vous pouvez même l'omettre

enum TestEnum: String {
  case Name, Gender, Birth = "Birth Day"
}

Dans Swift 3+, tous les cas d’énumération sont lowercased

87
vadian

Exemple de travail complet:

enum TestEnum: String {
    case name = "A Name"
    case otherName
    case test = "Test"
}

let first: TestEnum? = TestEnum(rawValue: "A Name")
let second: TestEnum? = TestEnum(rawValue: "OtherName")
let third: TestEnum? = TestEnum(rawValue: "Test")

print("\(first), \(second), \(third)")

Tout cela fonctionnera, mais lors de l'initialisation en utilisant une valeur brute, ce sera une option. Si cela pose problème, vous pouvez créer un initialiseur ou un constructeur pour que l'énum tente de le gérer, en ajoutant un cas none et en le renvoyant si l'énum n'a pas pu être créé. Quelque chose comme ça:

static func create(rawValue:String) -> TestEnum {
        if let testVal = TestEnum(rawValue: rawValue) {
            return testVal
        }
        else{
            return .none
        }
    }
9
PeejWeej

Vous pouvez définir une énumération comme ceci - 

enum TestEnum: String {
    case Name, Gender, Birth
}

OU

enum TestEnum: String {
    case Name
    case Gender
    case Birth
}

vous pouvez fournir une méthode init qui defaults à l'une des valeurs de membre.

enum TestEnum: String {
    case Name, Gender, Birth

    init() {
        self = .Gender
    }
}

Dans l'exemple ci-dessus, TestEnum.Name a une valeur brute implicite de "Nom", etc.

Vous accédez à la valeur brute d'un cas d'énumération avec sa propriété rawValue:

let testEnum = TestEnum.Name.rawValue
// testEnum is "Name"
let testEnum1 = TestEnum() 
// testEnum1 is "Gender"
3
keshav vishwkarma

Voici un exemple de code plus utilisable dans Swift 4.1

import UIKit

enum FormData {
  case userName
  case password

  static let array = [userName, password]

  var placeHolder: String {
    switch self {
    case .userName:
      return AppString.name.localized // will return "Name" string
    case .password:
      return AppString.password.localized // will return "Password" string
    }
  }
}

enum AppString: String {
  case name = "Name"
  case password = "Password"

  var localized: String {
    return NSLocalizedString(self.rawValue, comment: "")
  }
}
0
GSK

Avec Swift 4.2 et CaseIterable protocol, ce n'est pas si difficile du tout!

Voici un exemple de mise en œuvre.

import UIKit

private enum DataType: String, CaseIterable {
    case someDataOne = "an_awesome_string_one"
    case someDataTwo = "an_awesome_string_two"
    case someDataThree = "an_awesome_string_three"
    case someDataFour = "an_awesome_string_four"

    func localizedString() -> String {
        // Internal operation
        // I have a String extension which returns its localized version
        return self.rawValue.localized
    }

    static func fromLocalizedString(localizedString: String) -> DataType? {
        for type in DataType.allCases {
            if type.localizedString() == localizedString {
                return type
            }
        }
        return nil
    }

}

// USAGE EXAMPLE
override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    if let dataType = DataType.fromLocalizedString(localizedString: self.title) {
        loadUserData(type: dataType)
    }
}

Vous pouvez facilement le modifier pour renvoyer le DataType basé sur la rawValue. J'espère que ça aide!

0
BelfDev

Je pense que ceci est une solution rapide et propre pour Swift 4.2 (vous pouvez c & p au terrain de jeu)

import UIKit

public enum SomeEnum: String, CaseIterable {
    case Sun,moon,venus,pluto
}

let str = "venus"
let newEnum = SomeEnum.allCases.filter{$0.rawValue == str}.first
// newEnum is optional
if let result = newEnum {
    print(result.rawValue)
}
0
Zvika Ashkenazi

Afficher la valeur brute en utilisant Enum

import UIKit

enum car: String {
    case bmw =  "BMW"
    case jaquar = "JAQUAR"
    case rd = "RD"
    case benz = "BENZ"

}


class ViewController: UIViewController {

    @IBOutlet weak var label: UILabel!

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
        label.text = car.bmw.rawValue

    }


}
0
CSE 1994