Melhor maneira de serializar um NSData em uma string hexadeximal

101

Estou procurando uma maneira bacana de serializar um objeto NSData em uma string hexadecimal. A ideia é serializar o deviceToken usado para notificação antes de enviá-lo ao meu servidor.

Tenho a implementação a seguir, mas estou pensando que deve haver uma maneira mais curta e agradável de fazer isso.

+ (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
fonte

Respostas:

206

Esta é uma categoria aplicada a NSData que escrevi. Ele retorna um NSString hexadecimal que representa o NSData, onde os dados podem ter qualquer comprimento. Retorna uma string vazia se NSData estiver vazio.

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

Uso:

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

Isso é "provavelmente" melhor do que chamar [someData description]e remover os espaços, <'s e>' s. Despir personagens parece muito "hacky". Além disso, você nunca sabe se a Apple mudará a formatação dos NSData -descriptionno futuro.

NOTA: algumas pessoas me procuraram sobre o licenciamento do código desta resposta. Eu, por meio deste, dedico meus direitos autorais do código que postei nesta resposta ao domínio público.

Dave
fonte
4
Legal, mas duas sugestões: (1) Acho que appendFormat é mais eficiente para dados grandes, pois evita a criação de um NSString intermediário e (2)% x representa um int sem sinal em vez de longo sem sinal, embora a diferença seja inofensiva.
svachalek
Não quero ser contestador, já que essa é uma boa solução fácil de usar, mas minha solução em 25 de janeiro é muito mais eficiente. Se você está procurando uma resposta com desempenho otimizado, veja essa resposta . Votar positivamente nesta resposta como uma solução agradável e fácil de entender.
NSProgrammer
5
Tive que remover o elenco (longo sem sinal) e usar @ "% 02hhx" como a string de formato para fazer este trabalho.
Anton,
1
Certo, por developer.apple.com/library/ios/documentation/cocoa/conceptual/… o formato deve ser "%02lx"com esse elenco, ou elenco para (unsigned int), ou elimine o elenco e use @"%02hhx":)
qix
1
[hexString appendFormat:@"%02x", (unsigned int)dataBuffer[i]];é muito melhor (pegada de memória menor)
Marek R
31

Aqui está um método de categoria NSData altamente otimizado para gerar uma string hexadecimal. Embora a resposta de @Dave Gallagher seja suficiente para um tamanho relativamente pequeno, o desempenho da memória e da CPU se deteriora para grandes quantidades de dados. Fiz o perfil disso com um arquivo de 2 MB no meu iPhone 5. A comparação de tempo foi de 0,05 contra 12 segundos. O consumo de memória é insignificante com este método, enquanto o outro método aumentou o heap para 70 MBs!

- (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
fonte
Legal, @Peter - há, no entanto, uma solução ainda mais rápida (não muito mais do que a sua) - logo abaixo;)
Moose
1
@Moose, por favor, mencione com mais precisão de qual resposta você está falando: votos e novas respostas podem afetar o posicionamento das respostas. [editar: oh, deixe-me adivinhar, você quer dizer sua própria resposta ...]
Cœur
1
Adicionada verificação de nulo de malloc. Obrigado @ Cœur.
Peter
17

Usar a propriedade de descrição de NSData não deve ser considerado um mecanismo aceitável para codificação HEX da string. Essa propriedade é apenas para descrição e pode ser alterada a qualquer momento. Como uma observação, pré-iOS, a propriedade de descrição NSData nem mesmo retornava seus dados em formato hexadecimal.

Desculpe por insistir na solução, mas é importante aproveitar a energia para serializá-la sem pegar carona em uma API que se destina a algo diferente da serialização de dados.

@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
fonte
entretanto, você tem que liberar (hexChars) antes do retorno.
karim
3
@karim, isso está incorreto. Usando initWithCharactersNoCopy: length: freeWhenDone: e tendo freeWhenDone como YES, o NSString assumirá o controle desse buffer de bytes. Chamar gratuitamente (hexChars) resultará em uma falha. O benefício aqui é substancial, já que NSString não terá que fazer uma chamada memcpy cara.
NSProgrammer
Obrigado @NSProgrammer. Não notei o inicializador NSSting.
karim
A documentação informa que descriptionretorna uma string codificada em hexadecimal, o que me parece razoável.
Incomum
não deveríamos verificar se o valor retornado de malloc é potencialmente nulo?
Cœur
9

Esta é uma maneira mais rápida de fazer a conversão:

BenchMark (tempo médio para uma conversão de dados de 1024 bytes repetida 100 vezes):

Dave Gallagher: ~
8,070 ms NSProgrammer: ~ 0,077 ms
Peter: ~ 0,031 ms
Este aqui: ~ 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
alce
fonte
1
Você pode ver como implementei a verificação de malloc aqui ( _hexStringmétodo): github.com/ZipArchive/ZipArchive/blob/master/SSZipArchive/…
Cœur
Obrigado pela referência - A propósito, eu gosto de 'muito extenso' - É verdade, mas agora que digitei, qualquer um pode copiar / colar - Estou brincando - Eu gerei - Você já sabia :) Você está certo o demorado, eu estava apenas tentando acertar em todos os lugares em que posso ganhar microssegundos! Ele divide as iterações do loop por 2. Mas admito que falta elegância. Tchau
Moose de
8

Versão funcional do Swift

Um liner:

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

Este é um formulário de extensão reutilizável e autodocumentável:

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

Alternativamente, use em reduce("", combine: +)vez de joinWithSeparator("")ser visto como um mestre funcional por seus colegas.


Edit: Eu mudei String ($ 0, radix: 16) para String (formato: "% 02x", $ 0), porque números de um dígito precisavam ter um zero de preenchimento

NiñoScript
fonte
7

A resposta de Peter portada para 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
fonte
4

Eu precisava resolver esse problema e achei as respostas aqui muito úteis, mas me preocupo com o desempenho. A maioria dessas respostas envolve a cópia de dados em massa de NSData, então escrevi o seguinte para fazer a conversão com baixa sobrecarga:

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

Isso pré-aloca espaço na string para todo o resultado e evita a cópia do conteúdo NSData usando enumerateByteRangesUsingBlock. Alterar o X para um x na string de formato usará dígitos hexadecimais minúsculos. Se você não quiser um separador entre os bytes, você pode reduzir a instrução

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

para baixo para apenas

[string appendFormat:@"%02X", byte];
John Stephen
fonte
2
Eu acredito que o índice para recuperar o valor do byte precisa de ajuste, porque o NSRangeindica o intervalo dentro da NSDatarepresentação maior , não dentro do buffer de bytes menores (aquele primeiro parâmetro do bloco fornecido para enumerateByteRangesUsingBlock) que representa uma única parte contígua do maior NSData. Assim, byteRange.lengthreflete o tamanho do buffer de bytes, mas byteRange.locationé a localização dentro do maior NSData. Portanto, você deseja usar simplesmente offset, não byteRange.location + offset, para recuperar o byte.
Rob
1
@Rob Obrigado, entendi o que você quis dizer e ajustei o código
John Stephen
1
Se você modificar a instrução para usar apenas o single appendFormat, provavelmente também deve alterar o self.length * 3paraself.length * 2
T. Colligan
1

Eu precisava de uma resposta que funcionasse com strings de comprimento variável, então aqui está o que fiz:

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

Funciona muito bem como uma extensão para a classe NSString.

BadPirate
fonte
1
e se a Apple mudar a maneira como eles representam a descrição?
Brenden,
1
no método de descrição iOS13 retorna um formato diferente.
nacho4d
1

Você sempre pode usar [yourString uppercaseString] para colocar letras maiúsculas na descrição dos dados

Rostyslav Bachyk
fonte
1

A melhor maneira de serializar / desserializar NSData em NSString é usar o codificador / decodificador Google Toolbox para Mac Base64. Basta arrastar para o seu projeto de aplicativo os arquivos GTMBase64.m, GTMBase64.he GTMDefines.h do pacote Foundation e fazer algo como

/**
 * 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
fonte
Olhando para o código - fonte , parece que a classe que fornece isso agora é GTMStringEncoding. Eu não tentei, mas parece uma ótima solução para essa questão.
sarfata de
1
A partir do Mac OS X 10.6 / iOS 4.0, o NSData faz a codificação Base-64. string = [data base64EncodedStringWithOptions:(NSDataBase64EncodingOptions)0]
jrc de
@jrc isso é verdade, mas considere codificar strings de trabalho reais em Base-64. Você tem que lidar com a codificação "web safe", que você não tem em iOS / MacOS, como em GTMBase64 # webSafeEncodeData. Também pode ser necessário adicionar / remover "preenchimento" Base64, então você também tem esta opção: GTMBase64 # stringByWebSafeEncodingData: (NSData *) dados preenchidos: (BOOL) preenchido;
Loretoparisi,
1

Aqui está uma solução usando 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
fonte
0
@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)
Ramesh
fonte
0

Mude %08xpara %08Xpara obter caracteres maiúsculos.

Dan Reese
fonte
6
seria melhor como um comentário, pois você não incluiu nenhum contexto. Apenas dizendo
Brenden,
0

Propriedade Swift +.

Eu prefiro ter uma representação hexadecimal como propriedade (o mesmo que bytese descriptionpropriedades):

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

A ideia é emprestada desta resposta

Avt
fonte
-4
[deviceToken description]

Você precisará remover os espaços.

Pessoalmente, base64codifico o deviceToken, mas é uma questão de gosto.

Eddie
fonte
Isso não obtém o mesmo resultado. a descrição retorna: <2cf56d5d 2fab0a47 ... 7738ce77 7e791759> Enquanto estou procurando: 2CF56D5D2FAB0A47 .... 7738CE777E791759
sarfata