我们正在使用SWIFT5.0。我需要定期地将字符串列表转换成一组枚举案例。我轻松地编写了一个Kotlin函数,它在运行时接受一个枚举类和一个字符串列表,并将它转换为一个Java EnumSet (两个一起工作的函数):
fun <EnumT : Enum<EnumT>> ConvertStrToEnum(enumClass: Class<EnumT>, str: String?): EnumT? {
if (str == null)
return null
for (enumval in enumClass.enumConstants) {
if (enumval.toString() == str)
return enumval
}
throw IllegalArgumentException("Gave an invalid enum value for class ${enumClass.canonicalName}: [$str]")
}
fun <EnumT : Enum<EnumT> > ConvertStrArrayToEnumSet(enumClass: Class<EnumT>, array: List<String>?) : EnumSet<EnumT> {
val set = EnumSet.noneOf(enumClass)
array?.forEach { value -> ignoreExceptions { set.add(ConvertStrToEnum(enumClass, value)) } }
return set
}而且,要明确的是,实际使用是:
var intent: EnumSet<Intent>
intent = ConvertStrArrayToEnumSet(Intent::class.java, filters.array(MatchFilter.Intent.jsonName))我能否在Swift 5中编写一个实现相同结果的函数?我写这个是为了一次转换,下面是一个例子。如果我不能编写这个函数,我将在整个应用程序中重复这个样板代码。
public var intents: Set<Intent>
if let jsonIntents = filters?["intent"] as? Array<String> {
for jsonIntent in jsonIntents {
if let intent = Intent(rawValue: jsonIntent) {
intents.insert(intent)
}
}
}发布于 2020-05-12 20:33:14
假设你的墓穴是RawRepresentable和RawValue == String..。
Swift中的Enum没有像Enum那样的特殊“基类”。但在这种情况下,我们确实需要利用它们的共同属性-- RawRepresentable和Hashable。当然,很多非公立学校也有这样的财产。因此,我们的方法不仅适用于枚举,而且适用于符合这两种协议的任何类型。太好了不是吗?
func convertStringArrayToEnumSet<T>(type: T.Type, _ strings: [String]) -> Set<T>
where T : RawRepresentable & Hashable, T.RawValue == String {
Set(strings.compactMap(T.init(rawValue:)))
}注意compactMap的使用,它丢弃任何无效的原始值。
实际上,您可以将其概括为不只是字符串数组,而是任何数组:
func convertRawValueArrayToEnumSet<T>(type: T.Type, _ rawValues: [T.RawValue]) -> Set<T>
where T : RawRepresentable & Hashable {
Set(rawValues.compactMap(T.init(rawValue:)))
}发布于 2020-05-12 23:09:43
清洗机的答案是好的,但我看到你在错误处理方面付出了一些努力。Swift不太适合帮助你,所以你必须自己做扩展。
(Dictionary和RawRepresentable来自Swift 1,没有错误。他们从来没有得到现代化,只是退赛。)
/// Acts as a dictionary that `throw`s instead of returning optionals.
public protocol valueForKeyThrowingAccessor {
associatedtype Key
/// Should just be a throwing subscript, but those don't exist yet.
func value<Value>(for: Key) throws -> Value
}/// Acts as a dictionary.
public protocol valueForKeySubscript: valueForKeyThrowingAccessor {
associatedtype Value
subscript(key: Key) -> Value? { get }
}
public extension valueForKeySubscript {
/// - Throws: `KeyValuePairs<Key, Value>.AccessError.noValue`
func value(for key: Key) throws -> Value {
guard let value = self[key]
else { throw KeyValuePairs<Key, Value>.AccessError.noValue(key: key) }
return value
}
/// - Throws: `KeyValuePairs<Key, Value>.AccessError.typeCastFailure`
func value<Value>(for key: Key) throws -> Value {
guard let value = try value(for: key) as? Value
else { throw KeyValuePairs<Key, Value>.AccessError.typeCastFailure(key: key) }
return value
}
}
extension Dictionary: valueForKeySubscript { }public extension KeyValuePairs {
/// An error throw from trying to access a value for a key.
enum AccessError: Error {
case noValue(key: Key)
case typeCastFailure(key: Key)
}
}public extension RawRepresentable {
/// Like `init(rawValue:)`, if it was throwing instead of failable.
/// - Throws: `RawRepresentableExtensions<Self>.Error.invalidRawValue`
/// if there is no value of the type that corresponds with the specified raw value.
init(_ rawValue: RawValue) throws {
guard let instance = Self(rawValue: rawValue)
else { throw RawRepresentableExtensions<Self>.Error.invalidRawValue(rawValue) }
self = instance
}
}
/// A namespace for nested types within `RawRepresentable`.
public enum RawRepresentableExtensions<RawRepresentable: Swift.RawRepresentable> {
public enum Error: Swift.Error {
case invalidRawValue(RawRepresentable.RawValue)
}
}
public extension InitializableWithElementSequence where Element: RawRepresentable {
/// - Throws: `RawRepresentableExtensions<Element>.Error.invalidRawValue`
init<RawValues: Sequence>(rawValues: RawValues) throws
where RawValues.Element == Element.RawValue {
self.init(
try rawValues.map(Element.init)
)
}
}/// A type that can be initialized with a `Sequence` of its `Element`s.
public protocol InitializableWithElementSequence: Sequence {
init<Sequence: Swift.Sequence>(_: Sequence)
where Sequence.Element == Element
}
extension Array: InitializableWithElementSequence { }
extension Set: InitializableWithElementSequence { }extension InitializableWithElementSequence where Element == Intent {
init(filters: [String: Any]) throws {
try self.init(
rawValues: try filters.value(for: "intent") as [String]
)
}
}try filters.map(Set.init)https://stackoverflow.com/questions/61761239
复制相似问题