La conversion de Chaîne Hexadécimale à NSData en Swift

J'ai obtenu le code de convertir la Chaîne de HEX-String en objective-C.

- (NSString *) CreateDataWithHexString:(NSString*)inputString
{
NSUInteger inLength = [inputString length];
unichar *inCharacters = alloca(sizeof(unichar) * inLength);
[inputString getCharacters:inCharacters range:NSMakeRange(0, inLength)];
UInt8 *outBytes = malloc(sizeof(UInt8) * ((inLength / 2) + 1));
NSInteger i, o = 0;
UInt8 outByte = 0;
for (i = 0; i < inLength; i++) {
UInt8 c = inCharacters[i];
SInt8 value = -1;
if      (c >= '0' && c <= '9') value =      (c - '0');
else if (c >= 'A' && c <= 'F') value = 10 + (c - 'A');
else if (c >= 'a' && c <= 'f') value = 10 + (c - 'a');
if (value >= 0) {
if (i % 2 == 1) {
outBytes[o++] = (outByte << 4) | value;
outByte = 0;
} else {
outByte = value;
}
} else {
if (o != 0) break;
}
}
NSData *a = [[NSData alloc] initWithBytesNoCopy:outBytes length:o freeWhenDone:YES];
NSString* newStr = [NSString stringWithUTF8String:[a bytes]];
return newStr;
}

Je veux le même en Swift. Quelqu'un peut-il traduire ce code en Swift, ou est-il un moyen facile de le faire dans Swift?

InformationsquelleAutor Qadir Hussain | 2014-10-22
  1. 89

    C'est ma chaîne hexadécimale à Data routine:

    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
}
}

    Et par souci d'exhaustivité, c'est mon Data de chaîne hexadécimale de routine:

    extension Data {
///Hexadecimal string representation of `Data` object.
var hexadecimal: String {
return map { String(format: "%02x", $0) }
.joined()
}
}

    Remarque, comme indiqué ci-dessus, de manière générale, j'seulement de convertir des entre des représentations hexadécimales et NSData cas (parce que si l'information pourrait avoir été représenté comme une chaîne de caractères, vous probablement n'aurait pas créé une représentation hexadécimale en premier lieu). Mais votre question initiale voulu convertir entre les représentations hexadécimales et String les objets, et qui pourrait ressembler à de la sorte:

    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
}
}

    Vous pouvez ensuite utiliser le ci-dessus comme suit:

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

    Ou,

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

    Pour les permutations de la ci-dessus pour plus tôt Swift versions, voir l'historique de la révision de cette question.

    • extension NSData { /// Create hexadecimal string representation of NSData object. /// /// :returns: String representation of this NSData object. func hexadecimalString() -> String { var string = NSMutableString(capacity: length * 2) var byte: Byte? for i in 0 ..< length { getBytes(&byte, range: NSMakeRange(i, 1)) string.appendFormat("%02x", byte!) } return string } } Cela semble un crash dans l'Swift 1.2...essayer de comprendre pourquoi.
    • merci de mettre à jour le fil. Im en utilisant la fonction dataFromHexadecimalString() uniquement, et non de l'ensemble de l'extension dans mon AppDelegate.swift et Im obtenir cette erreur "AppDelegate" n'ont pas un membre nommé "stringByTrimmingCharactersInSet'
    • pouvez-vous mettre à jour cette swift 3. Je suis d'erreur Membre 'index' ne peut pas être utilisé sur la valeur de type de protocole "Collection"; l'utilisation d'une contrainte générique à la place
    • Salut @Rob, je l'ai mise à jour mon application iOS afin de Swift 4 code ci-dessus ne fonctionne pas maintenant, pouvez-vous s'il vous plaît mettre à jour le code Swift 4. merci
    • Le code ci-dessus fonctionne très bien dans Swift 4. Je viens de tester à nouveau. Je soupçonne un autre problème dans votre projet.
    • Merci pour votre extension , mais malheureusement j'ai testé cette méthode dans le cas qui incluent des chaîne ( anglais et arabe ) et le résultat a été nul
    • Il fonctionne pour moi, par exemple, let string = "Hello السلام عليكم" et let hex = string.hexadecimalString()! et let string2 = String(hexadecimal: hex)!. Il fonctionne très bien. Vous avez besoin de nous montrer un exemple qui ne fonctionne pas. Je vous suggère de poster votre propre question de nous montrer un exemple qui fonctionne très bien. Je parie que vous avez affaire à une chaîne hexadécimale qui n'est pas valide UTF8 représentation, mais je ne peux pas dire sans la voir. Et nous ne devrions pas utiliser les commentaires ici pour gérer ce genre de Q&A, donc, il vous suffit de poster votre propre question.
    • J'ai juste comparé les hexadécimal() la fonction à l'encontre de la république de Corée Gregorič réponse ci-dessous et Rob est presque exactement deux fois plus vite (sur mon Mac)

    InformationsquelleAutor Rob
  2. 21

    convertir en chaîne hexadécimale de données et à la chaîne:

    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
}

    utilisation:

    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
}

    utilisation:

    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
}

    utilisation:

    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
}

    utilisation:

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

    Swift 4 & Swift 5 mise en œuvre:

    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
}
}

    Utilisation:

    let data = Data(hexString: "0a1b3c4d")
    • Cela ne fonctionne pas dans Swift 4. Il n'est pas natif indice pour hexString[j..<j+2]. Vous avez probablement un indice quelque part ou à partir d'une extension
    • Merci pour cette remarque. Oui, j'ai une extension de la chaîne des indices. J'ai modifié le code pour fonctionner sans eux.
    InformationsquelleAutor Rok Gregorič
  4. 2

    Voici une solution simple que j'ai réglé sur:

    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)
}
}

    Utilisation:

    let data = NSData(hexString: "b8dfb080bc33fb564249e34252bf143d88fc018f")

    De sortie:

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

    Mise à jour 6/29/2016

    J'ai mis à jour l'initialiseur de gérer des données malformées (c'est à dire, les caractères non valides ou un nombre impair de caractères).

    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)
}
    InformationsquelleAutor Dan Loewenherz
  5. 2

    Ici est mon point de vue sur la conversion de la chaîne hexadécimale de Données à l'aide de 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()
}
}

    (J'y ai ajouté une petite fonction pour convertir retour à la chaîne hexadécimale j'ai trouvé dans cette réponse)

    Et voici comment vous pouvez l'utiliser:

        let data = Data(hexString: "cafecafe")
print(data?.hexString) //will print Optional("cafecafe")
    InformationsquelleAutor Peter Lamberg
  6. 0

    Le code a fonctionné pour moi dans 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)
}
}
}
    InformationsquelleAutor jqgsninimo