Swift Decoder是否支持无键外部数据表示（如UInt8数组）？

答案是肯定的，Swift的Codable体系完全支持处理无键的外部数据（比如从蓝牙设备读取的UInt8数组）——官方示例大多聚焦于JSON、PLIST这类带键格式，但你可以通过自定义编解码逻辑来适配字节流场景。

核心实现思路 #

1. 先将UInt8数组转为Data

[UInt8]可以直接转为Data类型，而Codable的本质就是处理数据的序列化/反序列化，基于Data来实现逻辑会更便捷。

2. 自定义Decoder适配无键字节流

如果想完全贴合Codable协议规范，可以自定义一个遵循Decoder协议的类型，专门处理无键的字节序列。核心是实现unkeyedContainer()方法，返回自定义的UnkeyedDecodingContainer，按顺序读取字节数据。

示例代码 #

自定义字节解码器

class ByteDecoder: Decoder {
    var codingPath: [CodingKey] = []
    var userInfo: [CodingUserInfoKey : Any] = [:]
    
    private let data: Data
    private var offset: Int = 0
    
    init(data: Data) {
        self.data = data
    }
    
    func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key> where Key : CodingKey {
        throw DecodingError.dataCorrupted(.init(codingPath: codingPath, debugDescription: "本解码器仅支持无键字节流"))
    }
    
    func unkeyedContainer() throws -> UnkeyedDecodingContainer {
        return ByteUnkeyedContainer(data: data, offset: &offset, codingPath: codingPath)
    }
    
    func singleValueContainer() throws -> SingleValueDecodingContainer {
        throw DecodingError.dataCorrupted(.init(codingPath: codingPath, debugDescription: "本解码器仅支持无键字节流"))
    }
}

struct ByteUnkeyedContainer: UnkeyedDecodingContainer {
    var codingPath: [CodingKey]
    var count: Int? { data.count }
    var isAtEnd: Bool { offset >= data.count }
    var currentIndex: Int { offset }
    
    private let data: Data
    private var offset: UnsafeMutablePointer<Int>
    
    init(data: Data, offset: UnsafeMutablePointer<Int>, codingPath: [CodingKey]) {
        self.data = data
        self.offset = offset
        self.codingPath = codingPath
    }
    
    // 解码UInt8
    mutating func decode(_ type: UInt8.Type) throws -> UInt8 {
        guard offset.pointee < data.count else {
            throw DecodingError.dataCorrupted(.init(codingPath: codingPath, debugDescription: "字节数据不足"))
        }
        let value = data[offset.pointee]
        offset.pointee += 1
        return value
    }
    
    // 解码UInt16（按大端字节序，可根据设备调整为littleEndian）
    mutating func decode(_ type: UInt16.Type) throws -> UInt16 {
        guard offset.pointee + MemoryLayout<UInt16>.size <= data.count else {
            throw DecodingError.dataCorrupted(.init(codingPath: codingPath, debugDescription: "字节数据不足"))
        }
        let value = data.subdata(in: offset.pointee..<offset.pointee+2).withUnsafeBytes {
            $0.load(as: UInt16.self).bigEndian
        }
        offset.pointee += 2
        return value
    }
    
    // 按需扩展其他类型的解码方法（如Int、Float等）
    mutating func decodeNil() throws -> Bool { false }
    mutating func decode(_ type: Bool.Type) throws -> Bool {
        throw DecodingError.typeMismatch(type, .init(codingPath: codingPath, debugDescription: "暂不支持Bool类型解码"))
    }
}

自定义蓝牙数据模型及用法

struct BluetoothSensorData: Codable {
    let deviceID: UInt8
    let temperature: UInt16 // 假设是放大10倍的数值，比如370代表37.0°C
    let batteryLevel: UInt8
    
    // 自定义解码逻辑
    init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()
        deviceID = try container.decode(UInt8.self)
        temperature = try container.decode(UInt16.self)
        batteryLevel = try container.decode(UInt8.self)
    }
    
    // 自定义编码逻辑（如果需要回传数据给蓝牙设备）
    func encode(to encoder: Encoder) throws {
        var container = encoder.unkeyedContainer()
        try container.encode(deviceID)
        try container.encode(temperature.bigEndian)
        try container.encode(batteryLevel)
    }
}

// 实际使用
let rawBluetoothBytes: [UInt8] = [0x01, 0x00, 0xEA, 0x7F] // 对应设备ID=1，温度=370，电量=127
let data = Data(rawBluetoothBytes)
let decoder = ByteDecoder(data: data)

do {
    let sensorData = try BluetoothSensorData(from: decoder)
    print("设备ID: \(sensorData.deviceID)")
    print("温度: \(Double(sensorData.temperature)/10)°C")
    print("电量: \(sensorData.batteryLevel)%")
} catch {
    print("解码失败: \(error.localizedDescription)")
}

简化方案：直接解析Data #

如果场景简单，也可以跳过自定义Decoder，直接通过Data的API手动解析：

let rawBytes: [UInt8] = [0x01, 0x00, 0xEA, 0x7F]
let data = Data(rawBytes)

let deviceID = data[0]
let temperature = data.subdata(in: 1..<3).withUnsafeBytes { $0.load(as: UInt16.self).bigEndian }
let batteryLevel = data[3]

print("设备ID: \(deviceID), 温度: \(Double(temperature)/10)°C, 电量: \(batteryLevel)%")

这种方式更轻量，适合不需要严格遵循Codable协议的简单场景。

内容的提问来源于stack exchange，提问作者3366784