Comment convertir des Données de chaîne hexadécimale en swift

Une alternative de mise en œuvre (prise de Comment crypte de la chaîne d'sha1 avec Swift?, avec une option supplémentaire pour la majuscule de sortie) serait

extension Data {
    struct HexEncodingOptions: OptionSet {
        let rawValue: Int
        static let upperCase = HexEncodingOptions(rawValue: 1 << 0)
    }

    func hexEncodedString(options: HexEncodingOptions = []) -> String {
        let format = options.contains(.upperCase) ? "%02hhX" : "%02hhx"
        return map { String(format: format, $0) }.joined()
    }
}

J'ai choisi un hexEncodedString(options:) méthode dans le style de la méthode existante base64EncodedString(options:).

Data est conforme à la Collection protocole, donc on peut utiliser
map() à la carte chaque octet correspondant de la chaîne hexadécimale.
Le %02x format de l'argument en base 16, rempli jusqu'à deux chiffres
avec un zéro si nécessaire. Le hh causes modificateur argument
(qui est passé comme un entier sur la pile) d'être traité comme un octet
quantité. On pourrait omettre le modificateur ici parce que $0 est un unsigned
nombre (UInt8) et pas de signe-extension va se produire, mais il ne fait pas de mal de quitter
il en.

Le résultat est ensuite jointe à une seule chaîne.

Exemple:

let data = Data(bytes: [0, 1, 127, 128, 255])
print(data.hexEncodedString()) //00017f80ff
print(data.hexEncodedString(options: .upperCase)) // 00017F80FF

---

La suite de la mise en œuvre est plus rapide d'un facteur d'environ 120
(testé avec 1000 octets aléatoires). Il est similaire à
RenniePet de la solution
et Nick Moore solution, mais sur la base de code UTF-16 unités, ce qui est le Swift
cordes (actuellement) de l'utiliser comme espace de stockage interne.

extension Data {
    struct HexEncodingOptions: OptionSet {
        let rawValue: Int
        static let upperCase = HexEncodingOptions(rawValue: 1 << 0)
    }

    func hexEncodedString(options: HexEncodingOptions = []) -> String {
        let hexDigits = Array((options.contains(.upperCase) ? "0123456789ABCDEF" : "0123456789abcdef").utf16)
        var chars: [unichar] = []
        chars.reserveCapacity(2 * count)
        for byte in self {
            chars.append(hexDigits[Int(byte / 16)])
            chars.append(hexDigits[Int(byte % 16)])
        }
        return String(utf16CodeUnits: chars, count: chars.count)
    }
}

Ma version. Ce n'est pas aussi élégante, mais elle est environ 10 fois plus rapide que l'on a accepté la réponse de Martin R.

extension Data {
    private static let hexAlphabet = "0123456789abcdef".unicodeScalars.map { $0 }

    public func hexEncodedString() -> String {
        return String(self.reduce(into: "".unicodeScalars, { (result, value) in
            result.append(Data.hexAlphabet[Int(value/16)])
            result.append(Data.hexAlphabet[Int(value%16)])
        }))
    }
}

Swift 4 - à Partir des Données de Chaîne Hexadécimale de

Basé sur Martin R solution mais même un tout petit peu plus rapide.

extension Data {
  ///A hexadecimal string representation of the bytes.
  func hexEncodedString() -> String {
    let hexDigits = Array("0123456789abcdef".utf16)
    var hexChars = [UTF16.CodeUnit]()
    hexChars.reserveCapacity(count * 2)

    for byte in self {
      let (index1, index2) = Int(byte).quotientAndRemainder(dividingBy: 16)
      hexChars.append(hexDigits[index1])
      hexChars.append(hexDigits[index2])
    }

    return String(utf16CodeUnits: hexChars, count: hexChars.count)
  }
}

Swift 4 - De la Chaîne Hexadécimale de Données

J'ai aussi ajouté une solution rapide pour la conversion d'une Chaîne hexadécimale de Données (basé sur un C la solution).

extension String {
  ///A data representation of the hexadecimal bytes in this string.
  func hexDecodedData() -> Data {
    //Get the UTF8 characters of this string
    let chars = Array(utf8)

    //Keep the bytes in an UInt8 array and later convert it to Data
    var bytes = [UInt8]()
    bytes.reserveCapacity(count / 2)

    //It is a lot faster to use a lookup map instead of strtoul
    let map: [UInt8] = [
      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, //01234567
      0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //89:;<=>?
      0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, //@ABCDEFG
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  //HIJKLMNO
    ]

    //Grab two characters at a time, map them and turn it into a byte
    for i in stride(from: 0, to: count, by: 2) {
      let index1 = Int(chars[i] & 0x1F ^ 0x10)
      let index2 = Int(chars[i + 1] & 0x1F ^ 0x10)
      bytes.append(map[index1] << 4 | map[index2])
    }

    return Data(bytes)
  }
}

Remarque: cette fonction ne permet pas de valider l'entrée. Assurez-vous qu'il est seulement utilisé pour les chaînes hexadécimales avec (une même quantité de caractères.

Peut-être pas le plus rapide, mais data.map({ String($0, radix: 16) }).joined() fait le travail. Comme mentionné dans les commentaires, cette solution a été entaché d'irrégularités.