Преобразование шестнадцатеричной строки в NSData в Swift

Ответ 1

Это моя шестнадцатеричная строка в подпрограмме Data:

extension String {

    /// Create 'Data' from hexadecimal string representation
    ///
    /// This creates a 'Data' object from hex string. Note, if the string has any spaces or non-hex characters (e.g. starts with '<' and with a '>'), those are ignored and only hex characters are processed.
    ///
    /// - returns: Data represented by this hexadecimal string.

    var hexadecimal: Data? {
        var data = Data(capacity: characters.count / 2)

        let regex = try! NSRegularExpression(pattern: "[0-9a-f]{1,2}", options: .caseInsensitive)
        regex.enumerateMatches(in: self, range: NSRange(startIndex..., in: self)) { match, _, _ in
            let byteString = (self as NSString).substring(with: match!.range)
            let num = UInt8(byteString, radix: 16)!
            data.append(num)
        }

        guard data.count > 0 else { return nil }

        return data
    }

}

И для полноты, это моя подпрограмма Data to hex:

extension Data {

    /// Hexadecimal string representation of 'Data' object.

    var hexadecimal: String {
        return map { String(format: "%02x", $0) }
            .joined()
    }
}

Обратите внимание, как показано выше, я обычно конвертирую только между шестнадцатеричными представлениями и экземплярами NSData (потому что, если бы информация могла быть представлена в виде строки, вы, вероятно, не создали бы шестнадцатеричное представление в первую очередь). Но ваш первоначальный вопрос хотел преобразовать шестнадцатеричные представления в объекты String, и это может выглядеть так:

extension String {

    /// Create 'String' representation of 'Data' created from hexadecimal string representation
    ///
    /// This takes a hexadecimal representation and creates a String object from that. Note, if the string has any spaces, those are removed. Also if the string started with a '<' or ended with a '>', those are removed, too.
    ///
    /// For example,
    ///
    ///     String(hexadecimal: "<666f6f>")
    ///
    /// is
    ///
    ///     Optional("foo")
    ///
    /// - returns: 'String' represented by this hexadecimal string.

    init?(hexadecimal string: String, encoding: String.Encoding = .utf8) {
        guard let data = string.hexadecimal() else {
            return nil
        }

        self.init(data: data, encoding: encoding)
    }

    /// Create hexadecimal string representation of 'String' object.
    ///
    /// For example,
    ///
    ///     "foo".hexadecimalString()
    ///
    /// is
    ///
    ///     Optional("666f6f")
    ///
    /// - parameter encoding: The 'String.Encoding' that indicates how the string should be converted to 'Data' before performing the hexadecimal conversion.
    ///
    /// - returns: 'String' representation of this String object.

    func hexadecimalString(encoding: String.Encoding = .utf8) -> String? {
        return data(using: encoding)?
            .hexadecimal
    }

}

Затем вы могли бы использовать вышеупомянутое так:

let hexString = "68656c6c 6f2c2077 6f726c64"
print(String(hexadecimal: hexString))

Или же,

let originalString = "hello, world"
print(originalString.hexadecimalString())

Перестановки приведенного выше для более ранних версий Swift см. В истории изменений этого вопроса.

Ответ 2

преобразовать шестнадцатеричную строку в данные и строку:

Swift1

func dataWithHexString(hex: String) -> NSData {
    var hex = hex
    let data = NSMutableData()
    while(countElements(hex) > 0) {
        var c: String = hex.substringToIndex(advance(hex.startIndex, 2))
        hex = hex.substringFromIndex(advance(hex.startIndex, 2))
        var ch: UInt32 = 0
        NSScanner(string: c).scanHexInt(&ch)
        data.appendBytes(&ch, length: 1)
    }
    return data
}

использовать:

let data = dataWithHexString("68656c6c6f2c20776f726c64") // <68656c6c 6f2c2077 6f726c64>
if let string = NSString(data: data, encoding: 1) {
    print(string) // hello, world
}

Swift2

func dataWithHexString(hex: String) -> NSData {
    var hex = hex
    let data = NSMutableData()
    while(hex.characters.count > 0) {
        let c: String = hex.substringToIndex(hex.startIndex.advancedBy(2))
        hex = hex.substringFromIndex(hex.startIndex.advancedBy(2))
        var ch: UInt32 = 0
        NSScanner(string: c).scanHexInt(&ch)
        data.appendBytes(&ch, length: 1)
    }
    return data
}

использовать:

let data = dataWithHexString("68656c6c6f2c20776f726c64") // <68656c6c 6f2c2077 6f726c64>
if let string = String(data: data, encoding: NSUTF8StringEncoding) {
    print(string) //"hello, world"
}

Swift3

func dataWithHexString(hex: String) -> Data {
    var hex = hex
    var data = Data()
    while(hex.characters.count > 0) {
        let c: String = hex.substring(to: hex.index(hex.startIndex, offsetBy: 2))
        hex = hex.substring(from: hex.index(hex.startIndex, offsetBy: 2))
        var ch: UInt32 = 0
        Scanner(string: c).scanHexInt32(&ch)
        var char = UInt8(ch)
        data.append(&char, count: 1)
    }
    return data
}

использовать:

let data = dataWithHexString(hex: "68656c6c6f2c20776f726c64") // <68656c6c 6f2c2077 6f726c64>
let string = String(data: data, encoding: .utf8) // "hello, world"

Swift4

func dataWithHexString(hex: String) -> Data {
    var hex = hex
    var data = Data()
    while(hex.count > 0) {
        let subIndex = hex.index(hex.startIndex, offsetBy: 2)
        let c = String(hex[..<subIndex])
        hex = String(hex[subIndex...])
        var ch: UInt32 = 0
        Scanner(string: c).scanHexInt32(&ch)
        var char = UInt8(ch)
        data.append(&char, count: 1)
    }
    return data
}

использовать:

let data = dataWithHexString(hex: "68656c6c6f2c20776f726c64") // <68656c6c 6f2c2077 6f726c64>
let string = String(data: data, encoding: .utf8) // "hello, world"

Ответ 3

Внедрение Swift 4 и Swift 5:

extension Data {
    init?(hexString: String) {
        let len = hexString.count / 2
        var data = Data(capacity: len)
        for i in 0..<len {
            let j = hexString.index(hexString.startIndex, offsetBy: i*2)
            let k = hexString.index(j, offsetBy: 2)
            let bytes = hexString[j..<k]
            if var num = UInt8(bytes, radix: 16) {
                data.append(&num, count: 1)
            } else {
                return nil
            }
        }
        self = data
    }
}

Использование:

let data = Data(hexString: "0a1b3c4d")

Ответ 4

Здесь простое решение, на котором я остановился:

extension NSData {
    public convenience init(hexString: String) {
        var index = hexString.startIndex
        var bytes: [UInt8] = []
        repeat {
            bytes.append(hexString[index...index.advancedBy(1)].withCString {
                return UInt8(strtoul($0, nil, 16))
            })

            index = index.advancedBy(2)
        } while index.distanceTo(hexString.endIndex) != 0

        self.init(bytes: &bytes, length: bytes.count)
    }
}

Использование:

let data = NSData(hexString: "b8dfb080bc33fb564249e34252bf143d88fc018f")

Вывод:

print(data)
>>> <b8dfb080 bc33fb56 4249e342 52bf143d 88fc018f>

Обновление 6/29/2016

Я обновил инициализатор для обработки некорректных данных (т.е. недопустимых символов или нечетного числа символов).

public convenience init?(hexString: String, force: Bool) {
    let characterSet = NSCharacterSet(charactersInString: "0123456789abcdefABCDEF")
    for scalar in hexString.unicodeScalars {
        if characterSet.characterIsMember(UInt16(scalar.value)) {
            hexString.append(scalar)
        }
        else if !force {
            return nil
        }
    }

    if hexString.characters.count % 2 == 1 {
        if force {
            hexString = "0" + hexString
        }
        else {
            return nil
        }
    }

    var index = hexString.startIndex
    var bytes: [UInt8] = []
    repeat {
        bytes.append(hexString[index...index.advancedBy(1)].withCString {
            return UInt8(strtoul($0, nil, 16))
            })

        index = index.advancedBy(2)
    } while index.distanceTo(hexString.endIndex) != 0

    self.init(bytes: &bytes, length: bytes.count)
}

Ответ 5

Вот мой взгляд на преобразование шестнадцатеричной строки в данные с использованием Swift 4:

extension Data {
    private static let hexRegex = try! NSRegularExpression(pattern: "^([a-fA-F0-9][a-fA-F0-9])*$", options: [])

    init?(hexString: String) {
        if Data.hexRegex.matches(in: hexString, range: NSMakeRange(0, hexString.count)).isEmpty {
            return nil // does not look like a hexadecimal string
        }

        let chars = Array(hexString)

        let bytes: [UInt8] = 
            stride(from: 0, to: chars.count, by: 2)
                .map {UInt8(String([chars[$0], chars[$0+1]]), radix: 16)}
                .compactMap{$0}

        self = Data(bytes)
    }

    var hexString: String {
        return map { String(format: "%02hhx", $0) }.joined()
    }
}

(Я добавил небольшую функцию для преобразования обратно в шестнадцатеричную строку, которую я нашел в этом ответе)

А вот как вы бы это использовали:

    let data = Data(hexString: "cafecafe")

    print(data?.hexString) // will print Optional("cafecafe")

Ответ 6

Вот мой Swifty 5 способ сделать это:

• заботится о префиксах "0x"
• используйте индекс вместо выделенного Array(), также нет стиля C [i + 1]
• добавить .hexadecimal в String.data(using encoding:) → Data?

,

Удлинение строки:

    extension String {
        enum ExtendedEncoding {
            case hexadecimal
        }

        func data(using encoding:ExtendedEncoding) -> Data? {
            let hexStr = self.dropFirst(self.hasPrefix("0x") ? 2 : 0)

            guard hexStr.count % 2 == 0 else { return nil }

            var newData = Data(capacity: hexStr.count/2)

            var indexIsEven = true
            for i in hexStr.indices {
                if indexIsEven {
                    let byteRange = i...hexStr.index(after: i)
                    guard let byte = UInt8(hexStr[byteRange], radix: 16) else { return nil }
                    newData.append(byte)
                }
                indexIsEven.toggle()
            }
            return newData
        }
    }

Использование:

    "5413".data(using: .hexadecimal)
    "0x1234FF".data(using: .hexadecimal)

тесты:

    extension Data {
        var bytes:[UInt8] { // fancy pretty call: myData.bytes -> [UInt8]
            return [UInt8](self)
        }

        // Could make a more optimized one~
        func hexa(prefixed isPrefixed:Bool = true) -> String {
            return self.bytes.reduce(isPrefixed ? "0x" : "") { $0 + String(format: "%02X", $1) }
        }
    }

    print("000204ff5400".data(using: .hexadecimal)?.hexa() ?? "failed") // OK
    print("0x000204ff5400".data(using: .hexadecimal)?.hexa() ?? "failed") // OK
    print("541".data(using: .hexadecimal)?.hexa() ?? "failed") // fails
    print("5413".data(using: .hexadecimal)?.hexa() ?? "failed") // OK

Ответ 7

Код работал у меня в Swift 3.0.2.

extension String {
    /// Expanded encoding
    ///
    /// - bytesHexLiteral: Hex string of bytes
    /// - base64: Base64 string
    enum ExpandedEncoding {
        /// Hex string of bytes
        case bytesHexLiteral
        /// Base64 string
        case base64
    }

    /// Convert to `Data` with expanded encoding
    ///
    /// - Parameter encoding: Expanded encoding
    /// - Returns: data
    func data(using encoding: ExpandedEncoding) -> Data? {
        switch encoding {
        case .bytesHexLiteral:
            guard self.characters.count % 2 == 0 else { return nil }
            var data = Data()
            var byteLiteral = ""
            for (index, character) in self.characters.enumerated() {
                if index % 2 == 0 {
                    byteLiteral = String(character)
                } else {
                    byteLiteral.append(character)
                    guard let byte = UInt8(byteLiteral, radix: 16) else { return nil }
                    data.append(byte)
                }
            }
            return data
        case .base64:
            return Data(base64Encoded: self)
        }
    }
}

Ответ 8

Swift 5

С поддержкой iOS 13 и iOS2...iOS12.

extension String {
  var hex: Data? {
    var value = self
    var data = Data()

    while value.count > 0 {
      let subIndex = value.index(value.startIndex, offsetBy: 2)
      let c = String(value[..<subIndex])
      value = String(value[subIndex...])

      var char: UInt8
      if #available(iOS 13.0, *) {
        guard let int = Scanner(string: c).scanInt32(representation: .hexadecimal) else { return nil }
        char = UInt8(int)
      } else {
        var int: UInt32 = 0
        Scanner(string: c).scanHexInt32(&int)
        char = UInt8(int)
      }

      data.append(&char, count: 1)
    }

    return data
  }
}

Ответ 9

Единственное, что вам нужно от кода Rob:

extension NSData {
    func toHexString() -> String {

        var string = NSMutableString(capacity: length * 2)
        var byte: UInt8 = 0

        for i in 0 ..< length {
            getBytes(&byte, range: NSMakeRange(i, 1))
            string.appendFormat("%02x", byte)
        }

        return string as String
    }
}

Тогда do

yourdataobject.toHexString()

Чтобы получить двоичные данные в виде шестнадцатеричной строки. Предполагая, что yourdataobject имеет тип NSData.