Question

我想使用带有本地化字符串的枚举，所以我喜欢这样，它可以工作，但是这个解决方案的问题是：我无法轻易地从本地化字符串中获取枚举值，我必须有密钥才能完成：

let option = DietWithoutResidueOption(rawValue: "NoDiet")

如果不是，我必须调用dietWithoutResidueOptionWith方法来获取枚举值...：/

有一个更好的解决方案来直接存储localizedString而不是枚举中的键吗？

谢谢

枚举

  enum DietWithoutResidueOption: String {
  case NoDiet = "NoDiet"
  case ThreeDays = "ThreeDays"
  case FiveDays  = "FiveDays"

  private func localizedString() -> String {
    return NSLocalizedString(self.rawValue, comment: "")
  }

  static func dietWithoutResidueOptionWith(#localizedString: String) -> DietWithoutResidueOption {
    switch localizedString {
    case DietWithoutResidueOption.ThreeDays.localizedString():
      return DietWithoutResidueOption.ThreeDays
    case DietWithoutResidueOption.FiveDays.localizedString():
      return DietWithoutResidueOption.FiveDays
    default:
      return DietWithoutResidueOption.NoDiet
    }
  }
}

Localizable.strings

"NoDiet" = "NON, JE N'AI PAS DE RÉGIME";
"ThreeDays" = "OUI, SUR 3 JOURS";
"FiveDays"  = "OUI, SUR 5 JOURS";

拨打

println(DietWithoutResidueOption.FiveDays.localizedString())

Answer 1

您可以对StringLiteralConvertible, Equatable类型的RawValue使用任何enum类型。

那么，怎么样：

import Foundation

struct LocalizedString: StringLiteralConvertible, Equatable {

    let v: String

    init(key: String) {
        self.v = NSLocalizedString(key, comment: "")
    }
    init(localized: String) {
        self.v = localized
    }
    init(stringLiteral value:String) {
        self.init(key: value)
    }
    init(extendedGraphemeClusterLiteral value: String) {
        self.init(key: value)
    }
    init(unicodeScalarLiteral value: String) {
        self.init(key: value)
    }
}

func ==(lhs:LocalizedString, rhs:LocalizedString) -> Bool {
    return lhs.v == rhs.v
}

enum DietWithoutResidueOption: LocalizedString {
    case NoDiet = "NoDiet"
    case ThreeDays = "ThreeDays"
    case FiveDays  = "FiveDays"

    var localizedString: String {
        return self.rawValue.v
    }

    init?(localizedString: String) {
        self.init(rawValue: LocalizedString(localized: localizedString))
    }
}

使用此功能，您可以通过3种方式构建DietWithoutResidueOption：

let option1 = DietWithoutResidueOption.ThreeDays
let option2 = DietWithoutResidueOption(rawValue: "ThreeDays") // as Optional
let option3 = DietWithoutResidueOption(localizedString: "OUI, SUR 3 JOURS")  // as Optional

并使用：

提取本地化字符串

let localized = option1.localizedString

Answer 2

试试这个，它非常简单直接：

enum ChoicesTitle: String {
    case choice1 = "Choice 1"
    case choice2 = "Choice 2"
    case choice3 = "Choice 3"
    case choice4 = "Choice 4"
    case choice5 = "Choice 5"
    case choice6 = "Choice 6"

    func localizedString() -> String {
        return NSLocalizedString(self.rawValue, comment: "")
    }

    static func getTitleFor(title:ChoicesTitle) -> String {
        return title.localizedString()
    }
}

你可以像这样使用它：

let stringOfChoice1: String = ChoicesTitle.getTitleFor(title: .choice1)

希望这适合你

Answer 3

替代方案：

枚举

enum Title : String {

  case CEO = "CEOKey"
  case CTO = "CTOKey"
  case CFO = "CFOKey"

  private static let allTitles = [CEO, CTO, CFO]

  var localizedString: String {
    return NSLocalizedString(self.rawValue, comment: "")
  }

  init!(rawValue: String) {
    var keys =  Title.allTitles
    var filtered = keys.filter { $0.rawValue == rawValue }

    self = filtered.first!
  }

  init!(localizedString: String) {
    var keys =  Title.allTitles
    var filtered = keys.filter { $0.localizedString == localizedString }

    self = filtered.first!
  }
}

<强> Localizable.strings

"CEOKey" = "Chief Executive Officer";
"CTOKey" = "Chief Technical Officer";
"CFOKey" = "Chief Financial Officer";

Constract enum：

let option1 = Title.CFO
let option2 = Title(rawValue: "CTOKey") // init from key
let option3 = Title(localizedString: NSLocalizedString("CEOKey", comment: ""))  // init from value

提取本地化字符串：

println("option1 localized string : \(option1.localizedString)")
println("option2 localized string : \(option2.localizedString)")
println("option3 localized string : \(option3.localizedString)")

输入

option1 localized string : Chief Financial Officer
option2 localized string : Chief Technical Officer
option3 localized string : Chief Executive Officer

如果未找到本地化字符串或键，则此代码将生成异常

Answer 4

这是一个较晚的答案，但我刚刚与Apple工程师进行了一次有关他们建议采用这种方式的话题的聊天：

    enum LocalizedStrings {
        case title

        var localized: String {
            switch self {
            case .title:
                return NSLocalizedString("My Title", comment: "My Comment")
            }
        }
    }

在您的情况下，解决方案与原始代码没有太大不同：

    enum DietWithoutResidueOption {
        case NoDiet
        case ThreeDays
        case FiveDays

        var localizedString: String {
            switch self {
            case .NoDiet:
                return NSLocalizedString("NoDiet", comment: "Some comment")
            case .ThreeDays:
                return NSLocalizedString("ThreeDays", comment: "Some comment")
            case .FiveDays:
                return NSLocalizedString("FiveDays", comment: "Some comment")
            }
        }

        static func dietWithoutResidueOptionWith(localizedString: String) -> DietWithoutResidueOption {
            switch localizedString {
            case DietWithoutResidueOption.ThreeDays.localizedString:
                return DietWithoutResidueOption.ThreeDays
            case DietWithoutResidueOption.FiveDays.localizedString:
                return DietWithoutResidueOption.FiveDays
            default:
                return DietWithoutResidueOption.NoDiet
            }
        }
    }

原因是他们不希望您将变量传递到NSLocalizedString（）中。这与优化和解析字符串有关。想象一下Xcode在某个时候自己生成了localizable.strings文件，但是找不到字符串，因为它们是作为变量传递的。

Answer 5

一种不错的方法是使用静态变量创建一个可本地化字符串的结构，如下所示：

LocalizableStrings.swift

struct LocalizableStrings {
    static let noDiet  = NSLocalizedString("NoDiet", comment: "")
    static let threeDays  = NSLocalizedString("ThreeDays", comment: "")
    static let fiveDays  = NSLocalizedString("FiveDays", comment: "")
}

Localizable.strings

"NoDiet" = "NON, JE N'AI PAS DE RÉGIME";
"ThreeDays" = "OUI, SUR 3 JOURS";
"FiveDays"  = "OUI, SUR 5 JOURS";

您的枚举应如下所示：

枚举

enum DietWithoutResidueOption {
    case NoDiet,
    ThreeDays,
    FiveDays

    var description : String {
        get {
            switch(self) {
            case .NoDiet:
                return LocalizableStrings.noDiet
            case .ThreeDays:
                return LocalizableStrings.threeDays
            case .FiveDays:
                return LocalizableStrings.fiveDays
            }
        }
    }
}

例如，要获取您的描述，您可以按照以下步骤操作：

DietWithoutResidueOption.NoDiet.description

这种方法的好处是，您可以将可本地化字符串的键放在单个文件中。因此，例如，如果您更改Localizable.strings文件上的 NoDiet 键，则只需要更新LocalizableStrings.swift文件即可，而无需更新拥有 NoDiet 的所有地方键作为字符串。此外，您可能会在使用某个文件的文件中误输入 NoDiet 键的风险，并且您的代码将无错误地编译，同时使用LocalizableStrings.swift中的静态变量，您可以避免这种情况，因为代码不会编译，并且您会看到一条错误消息，指出错误在哪里。

Answer 6

尝试使用我创建的此协议，您可以像下面那样导入，使用它。

https://github.com/Wei18/Self-Study-Protocol/blob/master/Localizable.swift

enum SomeKey: String, Localizable {
  case MenuGreeting = "lb_menu_greeting"
  case HaveBook = "I have %@ books"
}

// Sample
let menuGreeting: String = SomeKey.MenuGreeting.localized()
let iHaveBoxes: String = SomeKey.HaveBook.localized([3])

/*
// You also can make it with html.
SomeKey.CustomCase.localizedHTML()
SomeKey.CustomCase.localizedHTML([])
*/

Answer 7

这是我的例子

enum Localization: String {
    case appName = "app_name"
    case appOk = "app_ok"
    case appError = "app_error"
    case placeholderNoContent = "placeholder_no_content"
    case homeTitle = "home_title"

    public func localized(args: CVarArg...) -> String {
        let localizedString = NSLocalizedString(self.rawValue, comment: "")
        return String.init(format: localizedString, args)
    }
}

用法

self.homeTitleLabel = Localization.homeTitle.localized()

此本地化枚举可以轻松地用于字符串格式。

在swift中使用本地化字符串的枚举

7 个答案: