1

2019 年 6 月 20 日更新：感谢@rudedog，我找到了一个可行的解决方案。我在我原来的帖子下面附加了实现......

请注意，我不是在您的结构/枚举声明中寻找“使用私有枚举 CodingKeys：字符串，CodingKey”。

我有一种情况，我调用的服务需要UPPER_SNAKE_CASE所有枚举的上端蛇形大小写（）。

鉴于以下情况struct：

public struct Request: Encodable {
    public let foo: Bool?
    public let barId: BarIdType
    
    public enum BarIdType: String, Encodable {
        case test
        case testGroup
    }
}

任何请求中的所有枚举都应转换为 UPPER_SNAKE_CASE。

例如，let request = Request(foo: true, barId: testGroup)发送时应最终如下所示：

{
    "foo": true,
    "barId": "TEST_GROUP"
}

我想提供一个JSONEncoder.KeyEncodingStrategy只适用于enum类型的自定义。

至少根据 Apple 的JSONEncoder.KeyEncodingStrategy.custom(_:)文档，创建自定义策略似乎很简单。

这是我到目前为止所拥有的：

public struct AnyCodingKey : CodingKey {

    public var stringValue: String
    public var intValue: Int?

    public init(_ base: CodingKey) {
        self.init(stringValue: base.stringValue, intValue: base.intValue)
    }

    public init(stringValue: String) {
        self.stringValue = stringValue
    }

    public init(intValue: Int) {
        self.stringValue = "\(intValue)"
        self.intValue = intValue
    }

    public init(stringValue: String, intValue: Int?) {
        self.stringValue = stringValue
        self.intValue = intValue
    }
}

extension JSONEncoder.KeyEncodingStrategy {

    static var convertToUpperSnakeCase: JSONEncoder.KeyEncodingStrategy {
        return .custom { keys in // codingKeys is [CodingKey]
            // keys = Enum ???

            var key = AnyCodingKey(keys.last!)
            // key = Enum ???

            key.stringValue = key.stringValue.toUpperSnakeCase // toUpperSnakeCase is a String extension
            return key
        }
    }
}

我一直试图确定 [CodingKey] 是否代表一个枚举，或者单个 CodingKey 是否代表一个枚举，因此应该成为 UPPER_SNAKE_CASE。

我知道这听起来毫无意义，因为我可以简单地提供硬编码的 CodingKeys，但是我们有很多服务调用，都需要对枚举案例进行相同的处理。为编码器指定自定义 KeyEncodingStrategy 会更简单。

理想的是申请JSONEncoder.KeyEncodingStrategy.convertToSnakeCase自定义策略，然后只返回大写的值。但同样，只有当该值代表一个枚举案例时。

有什么想法吗？

这是我在@rudedog 的帮助下解决我的问题的代码：

import Foundation

public protocol UpperSnakeCaseRepresentable: Encodable {
    var upperSnakeCaseValue: String { get }
}

extension UpperSnakeCaseRepresentable where Self: RawRepresentable, Self.RawValue == String {
    var upperSnakeCaseValue: String {
        return _upperSnakeCaseValue(rawValue)
    }
}

extension KeyedEncodingContainer {
    mutating func encode(_ value: UpperSnakeCaseRepresentable, forKey key: KeyedEncodingContainer<K>.Key) throws {
        try encode(value.upperSnakeCaseValue, forKey: key)
    }
}

// The following is copied verbatim from https://github.com/apple/swift/blob/master/stdlib/public/Darwin/Foundation/JSONEncoder.swift
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
// The only change is to call uppercased() on the encoded value as part of the return.
fileprivate func _upperSnakeCaseValue(_ stringKey: String) -> String {
    guard !stringKey.isEmpty else { return stringKey }

    var words : [Range<String.Index>] = []
    // The general idea of this algorithm is to split words on transition from lower to upper case, then on transition of >1 upper case characters to lowercase
    //
    // myProperty -> my_property
    // myURLProperty -> my_url_property
    //
    // We assume, per Swift naming conventions, that the first character of the key is lowercase.
    var wordStart = stringKey.startIndex
    var searchRange = stringKey.index(after: wordStart)..<stringKey.endIndex

    // Find next uppercase character
    while let upperCaseRange = stringKey.rangeOfCharacter(from: CharacterSet.uppercaseLetters, options: [], range: searchRange) {
        let untilUpperCase = wordStart..<upperCaseRange.lowerBound
        words.append(untilUpperCase)

        // Find next lowercase character
        searchRange = upperCaseRange.lowerBound..<searchRange.upperBound
        guard let lowerCaseRange = stringKey.rangeOfCharacter(from: CharacterSet.lowercaseLetters, options: [], range: searchRange) else {
            // There are no more lower case letters. Just end here.
            wordStart = searchRange.lowerBound
            break
        }

        // Is the next lowercase letter more than 1 after the uppercase? If so, we encountered a group of uppercase letters that we should treat as its own word
        let nextCharacterAfterCapital = stringKey.index(after: upperCaseRange.lowerBound)
        if lowerCaseRange.lowerBound == nextCharacterAfterCapital {
            // The next character after capital is a lower case character and therefore not a word boundary.
            // Continue searching for the next upper case for the boundary.
            wordStart = upperCaseRange.lowerBound
        } else {
            // There was a range of >1 capital letters. Turn those into a word, stopping at the capital before the lower case character.
            let beforeLowerIndex = stringKey.index(before: lowerCaseRange.lowerBound)
            words.append(upperCaseRange.lowerBound..<beforeLowerIndex)

            // Next word starts at the capital before the lowercase we just found
            wordStart = beforeLowerIndex
        }
        searchRange = lowerCaseRange.upperBound..<searchRange.upperBound
    }
    words.append(wordStart..<searchRange.upperBound)
    let result = words.map({ (range) in
        return stringKey[range].lowercased()
    }).joined(separator: "_")
    return result.uppercased()
}

enum Snake: String, UpperSnakeCaseRepresentable, Encodable {
    case blackAdder
    case mamba
}

struct Test: Encodable {
    let testKey: String?
    let snake: Snake
}
let test = Test(testKey: "testValue", snake: .mamba)

let enumData = try! JSONEncoder().encode(test)
let json = String(data: enumData, encoding: .utf8)!
print(json)
4

1 回答 1

3

我认为您实际上是在寻找价值编码策略？密钥编码策略改变了密钥的编码方式，而不是它们的值的编码方式。值编码策略类似于JSONDecoder's dateDecodingStrategy，而您正在寻找一个用于枚举的策略。

这是一种可能对您有用的方法：

protocol UpperSnakeCaseRepresentable {
  var upperSnakeCaseValue: String { get }
}

extension UpperSnakeCaseRepresentable where Self: RawRepresentable, RawValue == String {
  var upperSnakeCaseValue: String {
    // Correct implementation left as an exercise
    return rawValue.uppercased()
  }
}

extension KeyedEncodingContainer {
  mutating func encode(_ value: UpperSnakeCaseRepresentable, forKey key: KeyedEncodingContainer<K>.Key) throws {
    try encode(value.upperSnakeCaseValue, forKey: key)
  }
}

enum Snake: String, UpperSnakeCaseRepresentable, Encodable {
  case blackAdder
  case mamba
}

struct Test: Encodable {
  let snake: Snake
}
let test = Test(snake: .blackAdder)

let data = try! JSONEncoder().encode(test)
let json = String(data: data, encoding: .utf8)!
print(json)

现在，您声明为符合的任何枚举都UpperSnakeCaseRepresentable将根据需要进行编码。

您可以以相同的方式扩展其他编码和解码容器。

于 2019-06-19T16:54:16.297 回答