给定 Swift 中的十六进制字符串，转换为十六进制值

Question

假设我得到这样一个字符串：

D7C17A4F

如何将每个单独的字符转换为十六进制值？

所以D应该是0xD，7应该是0x7…

现在，我将每个单独的字符表示为它的 ASCII 值。 D 是 68，7 是 55。我试图将这两个值打包成一个字节。例如：D7 变为 0xD7，C1 变为 0xC1。不过，我不能使用 ASCII 十进制值来做到这一点。

Answer 1

可能的解决方案：

let string = "D7C17A4F"

let chars = Array(string)
let numbers = map (stride(from: 0, to: chars.count, by: 2)) {
    strtoul(String(chars[[=10=] ..< [=10=]+2]), nil, 16)
}

使用中的方法，该字符串被拆分为两个字符的子字符串。每个子字符串被解释为一个数字序列以 16 为基数，并使用 strtoul().

转换为数字

验证结果：

println(numbers)
// [215, 193, 122, 79]

println(map(numbers, { String(format: "%02X", [=11=]) } ))
// [D7, C1, 7A, 4F]

更新 Swift 2 (Xcode 7):

let string = "D7C17A4F"
let chars = Array(string.characters)

let numbers = 0.stride(to: chars.count, by: 2).map {
    UInt8(String(chars[[=12=] ..< [=12=]+2]), radix: 16) ?? 0
}

print(numbers)

或

let string = "D7C17A4F"

var numbers = [UInt8]()
var from = string.startIndex
while from != string.endIndex {
    let to = from.advancedBy(2, limit: string.endIndex)
    numbers.append(UInt8(string[from ..< to], radix: 16) ?? 0)
    from = to
}

print(numbers)

第二个解决方案看起来有点复杂，但体积小优点是不需要额外的 chars 数组。

Answer 2

我对@martin-r 回答的变体：

extension String {

    func hexToByteArray() -> [UInt8] {
        let byteCount = self.utf8.count / 2
        var array = [UInt8](count: byteCount, repeatedValue: 0)
        var from = self.startIndex
        for i in 0..<byteCount {
            let to = from.successor()
            let sub = self.substringWithRange(from...to)
            array[i] = UInt8(sub, radix: 16) ?? 0
            from = to.successor()
        }
        return array
    }

}

Answer 3

Swift 3 版本，根据@Martin R 的回答修改。此变体还接受奇数长度的传入字符串。

let string = "D7C17A4F"

let chars = Array(string.characters)
let numbers = stride(from: 0, to: chars.count, by: 2).map() {
    strtoul(String(chars[[=10=] ..< min([=10=] + 2, chars.count)]), nil, 16)
}

Answer 4

这是更通用的 "pure swift" 方法（不需要基础 :-)）

extension UnsignedInteger {
    var hex: String {
        var str = String(self, radix: 16, uppercase: true)
        while str.characters.count < 2 * MemoryLayout<Self>.size {
            str.insert("0", at: str.startIndex)
        }
        return str
    }
}

extension Array where Element: UnsignedInteger {
    var hex: String {
        var str = ""
        self.forEach { (u) in
            str.append(u.hex)
        }
        return str
    }
}

let str = [UInt8(1),22,63,41].hex  // "01163F29"
let str2 = [UInt(1),22,63,41].hex  // "00000000000000010000000000000016000000000000003F0000000000000029"

extension String {
    func toUnsignedInteger<T:UnsignedInteger>()->[T]? {
        var ret = [T]()
        let nibles = MemoryLayout<T>.size * 2
        for i in stride(from: 0, to: characters.count, by: nibles) {
            let start = self.index(startIndex, offsetBy: i)
            guard let end = self.index(start, offsetBy: nibles, limitedBy: endIndex),
                let ui = UIntMax(self[start..<end], radix: 16) else { return nil }
            ret.append(T(ui))
        }
        return ret
    }
}

let u0:[UInt8]? = str.toUnsignedInteger()                   // [1, 22, 63, 41]
let u1 = "F2345f".toUnsignedInteger() as [UInt8]?           // [18, 52, 95]
let u2 = "12345f".toUnsignedInteger() as [UInt16]?          // nil
let u3 = "12345g".toUnsignedInteger() as [UInt8]?           // nil
let u4 = "12345f".toUnsignedInteger() as [UInt]?            // nil
let u5 = "12345678".toUnsignedInteger() as [UInt8]?         // [18, 52, 86, 120]
let u6 = "12345678".toUnsignedInteger() as [UInt16]?        // [4660, 22136]
let u7 = "1234567812345678".toUnsignedInteger() as [UInt]?  // [1311768465173141112]

对 SignedInteger 做同样的事情也很容易，但更好的方法是将结果映射到有符号类型

let u8 = u1?.map { Int8(bitPattern: [=11=]) }                    // [-14, 52, 95]

Answer 5

使用chunks!

"D7C17A4F"
  .chunks(ofCount: 2)
  .map { UInt8([=10=], radix: 0x10)! }

给定 Swift 中的十六进制字符串，转换为十六进制值

Given a hexadecimal string in Swift, convert to hex value

hex

ascii

swift