如何将Swift JSON / Dict Key camel转换为下划线而不编码？

enum KeyEncodingStrategy {
    case convertToSnakeCase

    func convert(_ key: String) -> String {
        switch self {
        case .convertToSnakeCase:
            return convertToSnakeCase(key)
        }
    }

    private func convertToSnakeCase(_ key: String) -> String {
        guard !key.isEmpty else { return key }

        var convertedKey = ""
        var wasUppercase = false

        for character in key {
            if character.isUppercase {
                if !convertedKey.isEmpty && !wasUppercase {
                    convertedKey.append("_")
                }
                wasUppercase = true
            } else {
                wasUppercase = false
            }
            convertedKey.append(character.lowercased())
        }

        return convertedKey
    }
}

struct KeyedCodingContainer<K: CodingKey>: KeyedDecodingContainerProtocol, KeyedEncodingContainerProtocol {
    typealias Key = K

    private let container: KeyedEncodingContainer<K>
    private let keyEncodingStrategy: KeyEncodingStrategy

    init(container: KeyedEncodingContainer<K>, keyEncodingStrategy: KeyEncodingStrategy) {
        self.container = container
        self.keyEncodingStrategy = keyEncodingStrategy
    }

    // KeyedDecodingContainerProtocol methods

    var codingPath: [CodingKey] {
        return container.codingPath
    }

    func contains(_ key: K) -> Bool {
        return container.contains(key)
    }

    func decodeNil(forKey key: K) throws -> Bool {
        return try container.decodeNil(forKey: key)
    }

    func decode<T: Decodable>(_ type: T.Type, forKey key: K) throws -> T {
        return try container.decode(type, forKey: key)
    }

    func nestedContainer<NestedKey: CodingKey>(keyedBy type: NestedKey.Type, forKey key: K) throws -> KeyedDecodingContainer<NestedKey> {
        return try container.nestedContainer(keyedBy: type, forKey: key)
    }

    func nestedUnkeyedContainer(forKey key: K) throws -> UnkeyedDecodingContainer {
        return try container.nestedUnkeyedContainer(forKey: key)
    }

    func superDecoder() throws -> Decoder {
        return try container.superDecoder()
    }

    func superDecoder(forKey key: K) throws -> Decoder {
        return try container.superDecoder(forKey: key)
    }

    // KeyedEncodingContainerProtocol methods

    mutating func encodeNil(forKey key: K) throws {
        try container.encodeNil(forKey: key)
    }

    mutating func encode<T: Encodable>(_ value: T, forKey key: K) throws {
        let convertedKey = keyEncodingStrategy.convert(key.stringValue)
        try container.encode(value, forKey: K(stringValue: convertedKey)!)
    }

    mutating func nestedContainer<NestedKey: CodingKey>(keyedBy keyType: NestedKey.Type, forKey key: K) -> KeyedEncodingContainer<NestedKey> {
        return container.nestedContainer(keyedBy: keyType, forKey: key)
    }

    mutating func nestedUnkeyedContainer(forKey key: K) -> UnkeyedEncodingContainer {
        return container.nestedUnkeyedContainer(forKey: key)
    }

    mutating func superEncoder() -> Encoder {
        return container.superEncoder()
    }

    mutating func superEncoder(forKey key: K) -> Encoder {
        return container.superEncoder(forKey: key)
    }
}

class SnakeCaseJSONEncoder: JSONEncoder {
    override func encode<T>(_ value: T) throws -> Data where T : Encodable {
        userInfo[.keyEncodingStrategy] = KeyEncodingStrategy.convertToSnakeCase
        return try super.encode(value)
    }

    override func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key : CodingKey {
        let container = super.container(keyedBy: type)
        let keyEncodingStrategy = userInfo[.keyEncodingStrategy] as? KeyEncodingStrategy ?? .useDefaultKeys
        return KeyedEncodingContainer(KeyedCodingContainer(container: container, keyEncodingStrategy: keyEncodingStrategy))
    }
}

struct Person: Codable {
    let firstName: String
    let lastName: String
    let age: Int
}

let person = Person(firstName: "John", lastName: "Doe", age: 30)

let encoder = SnakeCaseJSONEncoder()
encoder.outputFormatting = .prettyPrinted

do {
    let jsonData = try encoder.encode(person)
    if let jsonString = String(data: jsonData, encoding: .utf8) {
        print(jsonString)
    }
} catch {
    print(error)
}