Tôi đang tìm một cách hay ho để tuần tự hóa một đối tượng NSData thành một chuỗi thập lục phân. Ý tưởng là tuần tự hóa deviceToken được sử dụng để thông báo trước khi gửi nó đến máy chủ của tôi.

Tôi có cách triển khai sau đây, nhưng tôi đang nghĩ phải có một số cách ngắn hơn và đẹp hơn để thực hiện nó.

+ (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;
}

Đây là một danh mục áp dụng cho NSData mà tôi đã viết. Nó trả về một Chuỗi NSSt thập lục phân đại diện cho NSData, nơi dữ liệu có thể có độ dài bất kỳ. Trả về một chuỗi trống nếu NSData trống.

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

Sử dụng:

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

Điều này "có lẽ" tốt hơn là gọi [someData description]và sau đó loại bỏ các dấu cách, <'s và>. Nhân vật lột đồ chỉ cảm thấy quá "hacky". Thêm vào đó, bạn không bao giờ biết liệu Apple có thay đổi định dạng của NSData -descriptiontrong tương lai hay không.

LƯU Ý: Tôi đã có người liên hệ với tôi về việc cấp phép cho mã trong câu trả lời này. Bằng cách này, tôi dành bản quyền của mình trong mã mà tôi đã đăng trong câu trả lời này cho miền công cộng.

Đây là một phương pháp danh mục NSData được tối ưu hóa cao để tạo một chuỗi hex. Mặc dù câu trả lời của @Dave Gallagher là đủ cho kích thước tương đối nhỏ, nhưng hiệu suất bộ nhớ và cpu sẽ kém đi đối với lượng lớn dữ liệu. Tôi đã lập hồ sơ này bằng một tệp 2MB trên iPhone 5. So sánh thời gian là 0,05 so với 12 giây. Dấu chân bộ nhớ là không đáng kể với phương pháp này trong khi phương pháp khác đã tăng bộ nhớ lên 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 @"";
}

Việc sử dụng thuộc tính mô tả của NSData không nên được coi là một cơ chế được chấp nhận để mã hóa chuỗi HEX. Thuộc tính đó chỉ để mô tả và có thể thay đổi bất kỳ lúc nào. Như một lưu ý, trước iOS, thuộc tính mô tả NSData thậm chí không trả về dữ liệu của nó ở dạng hex.

Xin lỗi vì đã làm hỏng giải pháp này nhưng điều quan trọng là phải dành sức lực để tuần tự hóa nó mà không cần hỗ trợ một API dành cho một thứ khác ngoài tuần tự hóa dữ liệu.

@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

Đây là một cách nhanh hơn để thực hiện chuyển đổi:

BenchMark (thời gian trung bình cho một chuyển đổi dữ liệu 1024 byte lặp lại 100 lần):

Dave Gallagher: ~ 8.070 ms
NSProgrammer: ~ 0.077 ms
Peter: ~ 0.031 ms
Cái này: ~ 0.017 ms

@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

Phiên bản Swift chức năng

Lót:

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

Đây là một dạng tiện ích mở rộng có thể tái sử dụng và tự ghi lại:

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

Ngoài ra, hãy sử dụng reduce("", combine: +)thay vì joinWithSeparator("")được đồng nghiệp của bạn coi là bậc thầy chức năng.

Chỉnh sửa: Tôi đã thay đổi Chuỗi ($ 0, cơ số: 16) thành Chuỗi (định dạng: "% 02x", $ 0), bởi vì các số có một chữ số cần có phần đệm bằng 0

Câu trả lời của Peter được chuyển sang 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 "";
}

Tôi cần giải quyết vấn đề này và thấy các câu trả lời ở đây rất hữu ích, nhưng tôi lo lắng về hiệu suất. Hầu hết các câu trả lời này liên quan đến việc sao chép dữ liệu hàng loạt ra khỏi NSData, vì vậy tôi đã viết phần sau để thực hiện chuyển đổi với chi phí thấp:

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

Điều này phân bổ trước không gian trong chuỗi cho toàn bộ kết quả và tránh sao chép nội dung NSData ra ngoài bằng cách sử dụng enumerateByteRangesUsingBlock. Thay đổi X thành x trong chuỗi định dạng sẽ sử dụng các chữ số hex viết thường. Nếu bạn không muốn có dấu phân cách giữa các byte, bạn có thể giảm câu lệnh

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

xuống chỉ

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

Tôi cần một câu trả lời phù hợp với các chuỗi có độ dài thay đổi, vì vậy đây là những gì tôi đã làm:

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

Hoạt động tuyệt vời như một phần mở rộng cho lớp NSString.

Bạn luôn có thể sử dụng [yourString uppercaseString] để viết hoa các chữ cái trong mô tả dữ liệu

Cách tốt hơn để tuần tự hóa / giải mã hóa NSData thành NSString là sử dụng bộ mã hóa / giải mã Base64 của Hộp công cụ Google dành cho Mac . Chỉ cần kéo vào Dự án ứng dụng của bạn các tệp GTMBase64.m, GTMBase64.he GTMDefines.h từ gói Foundation và làm điều gì đó như

/**
 * 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];

}

Đây là một giải pháp sử dụng 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
    }

}

@implementation NSData (Extn)

- (NSString *)description
{
    NSMutableString *str = [[NSMutableString alloc] init];
    const char *bytes = self.bytes;
    for (int i = 0; i < [self length]; i++) {
        [str appendFormat:@"%02hhX ", bytes[i]];
    }
    return [str autorelease];
}

@end

Now you can call NSLog(@"hex value: %@", data)

Thay đổi %08xthành %08Xđể có các ký tự viết hoa.

Swift + Thuộc tính.

Tôi muốn có biểu diễn hex làm thuộc tính (giống bytesvà descriptionthuộc tính):

extension NSData {

    var hexString: String {

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

    var heXString: String {

        let buffer = UnsafeBufferPointer<UInt8>(start: UnsafePointer(self.bytes), count: self.length)
        return buffer.map { String(format: "%02X", $0) }.joinWithSeparator("")
    }
}

Ý tưởng được mượn từ câu trả lời này

[deviceToken description]

Bạn sẽ cần xóa khoảng trắng.

Cá nhân tôi base64mã hóa deviceToken, nhưng đó là vấn đề của thị hiếu.