将NSData序列化为十六进制字符串的最佳方法

Question

我正在寻找一种优雅的Cocoa方式将NSData对象序列化为十六进制字符串。这样做的目的是在将用于通知的deviceToken发送到我的服务器之前进行序列化。

我已经有了以下实现，但我认为肯定有更短更好的方法。

+ (NSString*) serializeDeviceToken:(NSData*) deviceToken
{
    NSMutableString *str = [NSMutableString stringWithCapacity:64];
    int length = [deviceToken length];
    char *bytes = malloc(sizeof(char) * length);

    [deviceToken getBytes:bytes length:length];

    for (int i = 0; i < length; i++)
    {
        [str appendFormat:@"%02.2hhX", bytes[i]];
    }
    free(bytes);

    return str;
}

- sarfata

Answer 1

这是我写的一个应用于NSData的类别。它会返回表示NSData的十六进制NSString，数据可以是任意长度。如果NSData为空，则返回空字符串。

NSData+Conversion.h

#import <Foundation/Foundation.h>

@interface NSData (NSData_Conversion)

#pragma mark - String Conversion
- (NSString *)hexadecimalString;

@end

NSData+Conversion.m

#import "NSData+Conversion.h"

@implementation NSData (NSData_Conversion)

#pragma mark - String Conversion
- (NSString *)hexadecimalString {
    /* Returns hexadecimal string of NSData. Empty string if data is empty.   */

    const unsigned char *dataBuffer = (const unsigned char *)[self bytes];

    if (!dataBuffer)
        return [NSString string];

    NSUInteger          dataLength  = [self length];
    NSMutableString     *hexString  = [NSMutableString stringWithCapacity:(dataLength * 2)];

    for (int i = 0; i < dataLength; ++i)
        [hexString appendString:[NSString stringWithFormat:@"%02lx", (unsigned long)dataBuffer[i]]];

    return [NSString stringWithString:hexString];
}

@end

使用方法：

NSData *someData = ...;
NSString *someDataHexadecimalString = [someData hexadecimalString];

这种方式“可能”比调用[someData description]并剥离空格、<'s和>'s更好。仅仅剥离字符感觉太“笨拙”。另外，你永远不知道苹果是否会在未来更改NSData的-description格式。

注意：有人联系我询问此回答中代码的许可证。我特此将我发布在此回答中的代码版权无偿捐赠给公共领域。

- Dave

---

好的，两个建议：（1）我认为对于大数据，使用appendFormat更有效，因为它避免了创建中间NSString。（2）%x代表一个unsigned int而不是unsigned long，尽管这种差异是无害的。 - svachalek

为了使这个工作正常，我必须去掉(unsigned long)转换，并使用@"%02hhx"作为格式字符串。 - Anton

根据https://developer.apple.com/library/ios/documentation/cocoa/conceptual/Strings/Articles/formatSpecifiers.html#//apple_ref/doc/uid/TP40004265-SW1的规定，格式应为`"%02lx"`，并进行强制转换，或者转换为`(unsigned int)，或者省略转换并使用@"%02hhx"` :) - qix

[hexString appendFormat:@"%02x", (unsigned int)dataBuffer[i]]; 更好（占用更少的内存空间）。 - Marek R

@NSProgrammer的解决方案大约快50倍（已测试）。 - Moose

Answer 2

这是一个高度优化的NSData分类方法，用于生成十六进制字符串。虽然@Dave Gallagher的答案对于相对较小的数据大小已经足够，但在处理大量数据时，其内存和CPU性能会变差。我在我的iPhone 5上使用了一个2MB的文件进行了分析。时间比较为0.05秒和12秒。使用此方法的内存占用非常小，而另一种方法使堆增长到了70MB！

- (NSString *) hexString
{
    NSUInteger bytesCount = self.length;
    if (bytesCount) {
        const char *hexChars = "0123456789ABCDEF";
        const unsigned char *dataBuffer = self.bytes;
        char *chars = malloc(sizeof(char) * (bytesCount * 2 + 1));       
        if (chars == NULL) {
            // malloc returns null if attempting to allocate more memory than the system can provide. Thanks Cœur
            [NSException raise:NSInternalInconsistencyException format:@"Failed to allocate more memory" arguments:nil];
            return nil;
        }
        char *s = chars;
        for (unsigned i = 0; i < bytesCount; ++i) {
            *s++ = hexChars[((*dataBuffer & 0xF0) >> 4)];
            *s++ = hexChars[(*dataBuffer & 0x0F)];
            dataBuffer++;
        }
        *s = '\0';
        NSString *hexString = [NSString stringWithUTF8String:chars];
        free(chars);
        return hexString;
    }
    return @"";
}

- Peter

---

不错，@Peter - 不过有一个更快的解决方案（比你的快不了多少）- 就在下面 ;) - Moose

@Moose，请更精确地引用你所谈论的答案：投票和新答案可能会影响答案的排名。[编辑：哦，让我猜猜，你是指你自己的答案...] - Cœur

添加了malloc的空指针检查。感谢@Cœur。 - Peter

Answer 3

使用NSData的description属性来进行HEX编码字符串不应被视为可接受的机制。该属性仅用于描述，并且随时可能更改。需要注意的是，在iOS之前，NSData的description属性甚至没有以十六进制形式返回其数据。

抱歉一直强调这个解决方案，但重要的是花费精力对其进行序列化，而不是依赖于旨在用于数据序列化以外其他目的的API。

@implementation NSData (Hex)

- (NSString*)hexString
{
    NSUInteger length = self.length;
    unichar* hexChars = (unichar*)malloc(sizeof(unichar) * (length*2));
    unsigned char* bytes = (unsigned char*)self.bytes;
    for (NSUInteger i = 0; i < length; i++) {
        unichar c = bytes[i] / 16;
        if (c < 10) {
            c += '0';
        } else {
            c += 'A' - 10;
        }
        hexChars[i*2] = c;

        c = bytes[i] % 16;
        if (c < 10) {
            c += '0';
        } else {
            c += 'A' - 10;
        }
        hexChars[i*2+1] = c;
    }
    NSString* retVal = [[NSString alloc] initWithCharactersNoCopy:hexChars length:length*2 freeWhenDone:YES];
    return [retVal autorelease];
}

@end

- NSProgrammer

---

在返回之前，您必须释放hexChars。 - karim

@karim，那是不正确的。通过使用initWithCharactersNoCopy:length:freeWhenDone:并将freeWhenDone设置为YES，NSString将控制该字节缓冲区。调用free(hexChars)会导致崩溃。这里的好处是相当大的，因为NSString不必进行昂贵的memcpy调用。 - NSProgrammer

@NSProgrammer 谢谢。我没有注意到 NSSting 的初始化器。 - karim

文件说明中指出description返回一个十六进制编码的字符串，所以这对我来说是合理的。 - Uncommon

我们不应该检查malloc返回的值是否可能为空吗？ - Cœur

Answer 4

这里有一个更快的转换方法：

基准测试（平均每次重复转换1024字节数据所需的时间，重复100次）:

Dave Gallagher : ~8.070 毫秒
NSProgrammer : ~0.077 毫秒
Peter : ~0.031 毫秒
This One : ~0.017 毫秒

@implementation NSData (BytesExtras)

static char _NSData_BytesConversionString_[512] = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";

-(NSString*)bytesString
{
    UInt16*  mapping = (UInt16*)_NSData_BytesConversionString_;
    register UInt16 len = self.length;
    char*    hexChars = (char*)malloc( sizeof(char) * (len*2) );

    // --- Coeur's contribution - a safe way to check the allocation
    if (hexChars == NULL) {
    // we directly raise an exception instead of using NSAssert to make sure assertion is not disabled as this is irrecoverable
        [NSException raise:@"NSInternalInconsistencyException" format:@"failed malloc" arguments:nil];
        return nil;
    }
    // ---

    register UInt16* dst = ((UInt16*)hexChars) + len-1;
    register unsigned char* src = (unsigned char*)self.bytes + len-1;

    while (len--) *dst-- = mapping[*src--];

    NSString* retVal = [[NSString alloc] initWithBytesNoCopy:hexChars length:self.length*2 encoding:NSASCIIStringEncoding freeWhenDone:YES];
#if (!__has_feature(objc_arc))
   return [retVal autorelease];
#else
    return retVal;
#endif
}

@end

- Moose

---

你可以在这里看到我如何实现malloc检查（_hexString方法）：https://github.com/ZipArchive/ZipArchive/blob/master/SSZipArchive/SSZipArchive.m#L1044 - Cœur

谢谢提供参考 - 顺便说一句，我喜欢“太长”的说法 - 这是真的，但现在我已经打出来了，任何人都可以复制/粘贴 - 我开玩笑的 - 我已经生成了它 - 你早就知道 :) 你对于长度的看法是正确的，我只是试图尽可能地赢得微秒！它将循环迭代次数除以2。但我承认它缺乏优雅。再见。 - Moose

Answer 5

函数式Swift版本

一句话概括：

let hexString = UnsafeBufferPointer<UInt8>(start: UnsafePointer(data.bytes),
count: data.length).map { String(format: "%02x", $0) }.joinWithSeparator("")

---

以下是可重复使用且自我记录的扩展形式:

extension NSData {
    func base16EncodedString(uppercase uppercase: Bool = false) -> String {
        let buffer = UnsafeBufferPointer<UInt8>(start: UnsafePointer(self.bytes),
                                                count: self.length)
        let hexFormat = uppercase ? "X" : "x"
        let formatString = "%02\(hexFormat)"
        let bytesAsHexStrings = buffer.map {
            String(format: formatString, $0)
        }
        return bytesAsHexStrings.joinWithSeparator("")
    }
}

---

或者，使用 reduce("", combine: +) 代替 joinWithSeparator("")，这样你就可以被同行视为一个函数式大师。

---

编辑：我将 String($0, radix: 16) 更改为 String(format: "%02x", $0)，因为一位数字需要有填充零。

- NiñoScript

Answer 6

Peter的回答转换成了Swift

func hexString(data:NSData)->String{
    if data.length > 0 {
        let  hexChars = Array("0123456789abcdef".utf8) as [UInt8];
        let buf = UnsafeBufferPointer<UInt8>(start: UnsafePointer(data.bytes), count: data.length);
        var output = [UInt8](count: data.length*2 + 1, repeatedValue: 0);
        var ix:Int = 0;
        for b in buf {
            let hi  = Int((b & 0xf0) >> 4);
            let low = Int(b & 0x0f);
            output[ix++] = hexChars[ hi];
            output[ix++] = hexChars[low];
        }
        let result = String.fromCString(UnsafePointer(output))!;
        return result;
    }
    return "";
}

swift3

func hexString()->String{
    if count > 0 {
        let hexChars = Array("0123456789abcdef".utf8) as [UInt8];
        return withUnsafeBytes({ (bytes:UnsafePointer<UInt8>) -> String in
            let buf = UnsafeBufferPointer<UInt8>(start: bytes, count: self.count);
            var output = [UInt8](repeating: 0, count: self.count*2 + 1);
            var ix:Int = 0;
            for b in buf {
                let hi  = Int((b & 0xf0) >> 4);
                let low = Int(b & 0x0f);
                output[ix] = hexChars[ hi];
                ix += 1;
                output[ix] = hexChars[low];
                ix += 1;
            }
            return String(cString: UnsafePointer(output));
        })
    }
    return "";
}

Swift 5

func hexString()->String{
    if count > 0 {
        let hexChars = Array("0123456789abcdef".utf8) as [UInt8];
        return withUnsafeBytes{ bytes->String in
            var output = [UInt8](repeating: 0, count: bytes.count*2 + 1);
            var ix:Int = 0;
            for b in bytes {
                let hi  = Int((b & 0xf0) >> 4);
                let low = Int(b & 0x0f);
                output[ix] = hexChars[ hi];
                ix += 1;
                output[ix] = hexChars[low];
                ix += 1;
            }
            return String(cString: UnsafePointer(output));
        }
    }
    return "";
}

- john07

Answer 7

我需要解决这个问题，发现这里的答案非常有用，但我担心性能。大多数这些答案都涉及将数据批量复制到NSData中，所以我编写了以下内容来进行低开销的转换：

@interface NSData (HexString)
@end

@implementation NSData (HexString)

- (NSString *)hexString {
    NSMutableString *string = [NSMutableString stringWithCapacity:self.length * 3];
    [self enumerateByteRangesUsingBlock:^(const void *bytes, NSRange byteRange, BOOL *stop){
        for (NSUInteger offset = 0; offset < byteRange.length; ++offset) {
            uint8_t byte = ((const uint8_t *)bytes)[offset];
            if (string.length == 0)
                [string appendFormat:@"%02X", byte];
            else
                [string appendFormat:@" %02X", byte];
        }
    }];
    return string;
}

这将在字符串中预先分配空间，以容纳整个结果，并通过使用enumerateByteRangesUsingBlock避免复制NSData内容。 将格式字符串中的X更改为x将使用小写十六进制数字。 如果您不想在字节之间使用分隔符，则可以缩短语句。

if (string.length == 0)
    [string appendFormat:@"%02X", byte];
else
    [string appendFormat:@" %02X", byte];

仅剩下

[string appendFormat:@"%02X", byte];

- John Stephen

---

我认为需要调整检索字节值的索引，因为“NSRange”指示了大型“NSData”表示中的范围，而不是在表示较小的字节缓冲区（供应给“enumerateByteRangesUsingBlock”块的第一个参数）内的范围。该缓冲区表示较大的“NSData”的单个连续部分。因此，“byteRange.length”反映了字节缓冲区的大小，但“byteRange.location”是较大“NSData”内的位置。因此，要检索字节，您希望仅使用“offset”，而不是“byteRange.location + offset”。 - Rob

@Rob 谢谢，我明白你的意思了，并已经调整了代码。 - John Stephen

如果您将语句修改为仅使用单个appendFormat，则应该将self.length * 3更改为self.length * 2。 - T. Colligan

Answer 8

更好的将NSData序列化/反序列化为NSString的方法是使用Google Toolbox for Mac Base64编码器/解码器。只需从Foundation包中拖动文件GTMBase64.m、GTMBase64.h和GTMDefines.h到您的应用程序项目中，然后执行类似以下操作的代码即可：

/**
 * Serialize NSData to Base64 encoded NSString
 */
-(void) serialize:(NSData*)data {

    self.encodedData = [GTMBase64 stringByEncodingData:data];

}

/**
 * Deserialize Base64 NSString to NSData
 */
-(NSData*) deserialize {

    return [GTMBase64 decodeString:self.encodedData];

}

- loretoparisi

---

从源代码来看，现在提供这个功能的类是GTMStringEncoding。虽然我还没有尝试过，但它看起来是这个问题的一个很好的新解决方案。 - sarfata

从 Mac OS X 10.6 / iOS 4.0 开始，NSData 支持 Base-64 编码。string = [data base64EncodedStringWithOptions:(NSDataBase64EncodingOptions)0] - jrc

@jrc 这是正确的，但考虑将真实工作字符串编码为Base-64。这样你就需要处理“Web安全”编码，而在iOS/MacOS中你没有像GTMBase64#webSafeEncodeData那样的选项。此外，您可能需要添加/删除Base64“填充”，因此您也可以使用此选项：GTMBase64#stringByWebSafeEncodingData:(NSData *)data padded:(BOOL)padded; - loretoparisi

Answer 9

这是一个使用Swift 3的解决方案。

extension Data {

    public var hexadecimalString : String {
        var str = ""
        enumerateBytes { buffer, index, stop in
            for byte in buffer {
                str.append(String(format:"%02x",byte))
            }
        }
        return str
    }

}

extension NSData {

    public var hexadecimalString : String {
        return (self as Data).hexadecimalString
    }

}

- Alex

Answer 10

我需要一个适用于可变长度字符串的答案，所以这就是我做的：

+ (NSString *)stringWithHexFromData:(NSData *)data
{
    NSString *result = [[data description] stringByReplacingOccurrencesOfString:@" " withString:@""];
    result = [result substringWithRange:NSMakeRange(1, [result length] - 2)];
    return result;
}

作为NSString类的扩展，非常好用。

- BadPirate

---

如果苹果改变了他们表示描述的方式，会怎样？ - Brenden

在iOS13中，description方法返回不同的格式。 - nacho4d