Saya mencari cara yang bagus untuk membuat serial objek NSData menjadi string heksadesimal. Idenya adalah untuk membuat serial deviceToken yang digunakan untuk pemberitahuan sebelum mengirimnya ke server saya.

Saya memiliki implementasi berikut, tetapi saya berpikir pasti ada cara yang lebih pendek dan lebih bagus untuk melakukannya.

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

Ini adalah kategori yang diterapkan pada NSData yang saya tulis. Ini mengembalikan NSString heksadesimal yang mewakili NSData, di mana datanya bisa berapa pun panjangnya. Mengembalikan string kosong jika NSData kosong.

NSData + Konversi. H

#import <Foundation/Foundation.h>

@interface NSData (NSData_Conversion)

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

@end

NSData + Konversi. 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

Pemakaian:

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

Ini "mungkin" lebih baik daripada menelepon [someData description]dan kemudian menghilangkan spasi, <, dan>. Menelanjangi karakter terasa terlalu "hacky". Ditambah Anda tidak pernah tahu apakah Apple akan mengubah format NSData -descriptiondi masa depan.

CATATAN: Saya telah meminta orang-orang menghubungi saya tentang pemberian lisensi untuk kode dalam jawaban ini. Dengan ini saya mempersembahkan hak cipta saya dalam kode yang saya posting dalam jawaban ini ke domain publik.

Berikut adalah metode kategori NSData yang sangat dioptimalkan untuk menghasilkan string hex. Meskipun jawaban @Dave Gallagher cukup untuk ukuran yang relatif kecil, kinerja memori dan cpu memburuk untuk data dalam jumlah besar. Saya membuat profil ini dengan file 2MB di iPhone 5. Perbandingan waktu adalah 0,05 vs 12 detik. Jejak memori dapat diabaikan dengan metode ini sementara metode lain meningkatkan tumpukan menjadi 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 @"";
}

Menggunakan properti deskripsi NSData tidak boleh dianggap sebagai mekanisme yang dapat diterima untuk HEX yang mengkodekan string. Properti itu hanya untuk deskripsi dan dapat berubah kapan saja. Sebagai catatan, sebelum iOS, properti deskripsi NSData bahkan tidak mengembalikan datanya dalam bentuk hex.

Maaf telah mengacaukan solusinya tetapi penting untuk mengambil energi untuk membuat serialnya tanpa membonceng API yang dimaksudkan untuk sesuatu yang lain selain serialisasi data.

@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

Berikut adalah cara yang lebih cepat untuk melakukan konversi:

BenchMark (waktu rata-rata untuk konversi data 1024 byte yang diulangi 100 kali):

Dave Gallagher: ~ 8.070 ms
NP Programmer: ~ 0.077 ms
Peter: ~ 0.031 ms Yang
Ini: ~ 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

Versi Swift fungsional

Satu liner:

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

Berikut adalah formulir ekstensi yang dapat digunakan kembali dan mendokumentasikan sendiri:

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

Atau, gunakan reduce("", combine: +)alih-alih joinWithSeparator("")dilihat sebagai master fungsional oleh rekan-rekan Anda.

Sunting: Saya mengubah String ($ 0, radix: 16) menjadi String (format: "% 02x", $ 0), karena satu digit angka diperlukan untuk padding nol

Jawaban Peter ditransfer ke 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 "";
}

Cepat 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 "";
}

Saya perlu memecahkan masalah ini dan menemukan jawabannya di sini sangat berguna, tetapi saya khawatir tentang kinerja. Sebagian besar jawaban ini melibatkan penyalinan data secara massal dari NSData, jadi saya menulis yang berikut ini untuk melakukan konversi dengan overhead rendah:

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

Ini mengalokasikan ruang dalam string untuk seluruh hasil dan menghindari menyalin konten NSData dengan menggunakan enumerateByteRangesUsingBlock. Mengubah X menjadi x dalam format string akan menggunakan digit hex huruf kecil. Jika Anda tidak menginginkan pemisah antara byte, Anda dapat mengurangi pernyataan tersebut

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

turun menjadi adil

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

Saya membutuhkan jawaban yang akan berfungsi untuk string panjang variabel, jadi inilah yang saya lakukan:

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

Berfungsi bagus sebagai ekstensi untuk kelas NSString.

Anda selalu dapat menggunakan [yourString uppercaseString] untuk membuat huruf kapital dalam deskripsi data

Cara yang lebih baik untuk membuat serial / deserialisasi NSData ke NSString adalah dengan menggunakan encoder / decoder Google Toolbox untuk Mac Base64. Cukup seret ke Proyek Aplikasi Anda file GTMBase64.m, GTMBase64.he GTMDefines.h dari paket Foundation dan lakukan sesuatu seperti

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

}

Berikut adalah solusi menggunakan 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)

Ubah %08xuntuk %08Xmendapatkan karakter kapital.

Swift + Properti.

Saya lebih suka memiliki representasi hex sebagai properti (sama dengan bytesdan descriptionproperti):

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

Ide dipinjam dari jawaban ini

[deviceToken description]

Anda harus menghapus spasi.

Secara pribadi saya base64menyandikannya deviceToken, tapi ini masalah selera.