NSString (hex) d'octets

Est il une méthode Objective-C qui convertit une chaîne hexadécimale d'octets? Par exemple @"1156FFCD3430AA22" à un unsigned char array {0x11, 0x56, 0xFF, ...}.

InformationsquelleAutor AOO | 2010-03-23

Plus rapide NSString implémentation de la catégorie que je pouvais penser (cocktail de quelques exemples):

- (NSData *)dataFromHexString {
    const char *chars = [self UTF8String];
    int i = 0, len = self.length;

    NSMutableData *data = [NSMutableData dataWithCapacity:len / 2];
    char byteChars[3] = {'- (NSData *)dataFromHexString {
const char *chars = [self UTF8String];
int i = 0, len = self.length;
NSMutableData *data = [NSMutableData dataWithCapacity:len / 2];
char byteChars[3] = {'\0','\0','\0'};
unsigned long wholeByte;
while (i < len) {
byteChars[0] = chars[i++];
byteChars[1] = chars[i++];
wholeByte = strtoul(byteChars, NULL, 16);
[data appendBytes:&wholeByte length:1];
}
return data;
}
','- (NSData *)dataFromHexString {
const char *chars = [self UTF8String];
int i = 0, len = self.length;
NSMutableData *data = [NSMutableData dataWithCapacity:len / 2];
char byteChars[3] = {'\0','\0','\0'};
unsigned long wholeByte;
while (i < len) {
byteChars[0] = chars[i++];
byteChars[1] = chars[i++];
wholeByte = strtoul(byteChars, NULL, 16);
[data appendBytes:&wholeByte length:1];
}
return data;
}
','- (NSData *)dataFromHexString {
const char *chars = [self UTF8String];
int i = 0, len = self.length;
NSMutableData *data = [NSMutableData dataWithCapacity:len / 2];
char byteChars[3] = {'\0','\0','\0'};
unsigned long wholeByte;
while (i < len) {
byteChars[0] = chars[i++];
byteChars[1] = chars[i++];
wholeByte = strtoul(byteChars, NULL, 16);
[data appendBytes:&wholeByte length:1];
}
return data;
}
'};
    unsigned long wholeByte;

    while (i < len) {
        byteChars[0] = chars[i++];
        byteChars[1] = chars[i++];
        wholeByte = strtoul(byteChars, NULL, 16);
        [data appendBytes:&wholeByte length:1];
    }

    return data;
}

Il est près de 8 fois plus rapide que wookay de la solution. NSScanner est assez lent.

+1 ce qui semble être de meilleure qualité, non seulement plus rapide, mais c'est effectivement correcte.
Très bonne mise en œuvre.
La bonne mise en œuvre, mais si vous avez besoin d'une vérification d'erreur, vous devez définir le errno à 0 avant d'appeler strtoul et de la lecture par la suite.
Pourquoi faites-vous de byteChars taille 3 au lieu de la taille 2?
Nvm mon C était rouillé oublié chaînes C sont censés être null.

InformationsquelleAutor Zyphrax

@interface NSString (NSStringHexToBytes)
-(NSData*) hexToBytes ;
@end



@implementation NSString (NSStringHexToBytes)
-(NSData*) hexToBytes {
  NSMutableData* data = [NSMutableData data];
  int idx;
  for (idx = 0; idx+2 <= self.length; idx+=2) {
    NSRange range = NSMakeRange(idx, 2);
    NSString* hexStr = [self substringWithRange:range];
    NSScanner* scanner = [NSScanner scannerWithString:hexStr];
    unsigned int intValue;
    [scanner scanHexInt:&intValue];
    [data appendBytes:&intValue length:1];
  }
  return data;
}
@end



///example
unsigned char bytes[] = { 0x11, 0x56, 0xFF, 0xCD, 0x34, 0x30, 0xAA, 0x22 };
NSData* expectedData = [NSData dataWithBytes:bytes length:sizeof(bytes)];
NSLog(@"data %@", [@"1156FFCD3430AA22" hexToBytes]);
NSLog(@"expectedData isEqual:%d", [expectedData isEqual:[@"1156FFCD3430AA22" hexToBytes]]);

Corrigez-moi si je me trompe, mais je pense que les [données appendBytes:&intValue longueur:1] a un peu de difficulté. Type unsigned int est d'au moins quatre caractères de large (détenant au moins 32 bits). &intValue est un pointeur vers le premier des quatre. Cela signifie que sur little endian système de la &intValue va justement être un pointeur sur le caractère que vous venez de numériser. Mais sur big endian architectures, il pointe toujours à zéro de la valeur, car la valeur est stockée comme la dernière des quatre personnages. Fondamentalement, cela signifie que ce code fonctionne sur Mac et de la pause sur iOS.
Cette réponse a beaucoup de défauts. Non seulement il traite la int comme si c'était un octet (ce qui est impossible selon la norme C), mais il ne superfluously génère beaucoup de sous-chaînes, au lieu de marcher à travers la const char * l'on peut obtenir à l'aide de UTF8String...

InformationsquelleAutor wookay

3

La scanHexInt: et les mêmes méthodes de NSScanner pourrait être utile de faire ce que vous voulez, mais vous auriez probablement besoin de briser la chaîne, jusqu'en petits morceaux, auquel cas la conversion manuellement peut-être plus simple que d'utiliser NSScanner.

InformationsquelleAutor Isaac
2

Pas dans la façon dont vous le faites. Vous aurez besoin d'écrire votre propre méthode pour prendre tous les deux des personnages, de les interpréter comme un int, et de les stocker dans un tableau.

InformationsquelleAutor Marc W

Approche modifiée,

/* Converts a hex string to bytes.
Precondition:
. The hex string can be separated by space or not.
. the string length without space or 0x, must be even. 2 symbols for one byte/char
. sample input: 23 3A F1 OR 233AF1, 0x23 0X231f 2B
*/
+ (NSData *) dataFromHexString:(NSString*)hexString
{
NSString * cleanString = [Util cleanNonHexCharsFromHexString:hexString];
if (cleanString == nil) {
return nil;
}
NSMutableData *result = [[NSMutableData alloc] init];
int i = 0;
for (i = 0; i+2 <= cleanString.length; i+=2) {
NSRange range = NSMakeRange(i, 2);
NSString* hexStr = [cleanString substringWithRange:range];
NSScanner* scanner = [NSScanner scannerWithString:hexStr];
unsigned int intValue;
[scanner scanHexInt:&intValue];
unsigned char uc = (unsigned char) intValue;
[result appendBytes:&uc length:1];
}
NSData * data = [NSData dataWithData:result];
[result release];
return data;
}
/* Clean a hex string by removing spaces and 0x chars.
. The hex string can be separated by space or not.
. sample input: 23 3A F1; 233AF1; 0x23 0x3A 0xf1
*/
+ (NSString *) cleanNonHexCharsFromHexString:(NSString *)input
{
if (input == nil) {
return nil;
}
NSString * output = [input stringByReplacingOccurrencesOfString:@"0x" withString:@""
options:NSCaseInsensitiveSearch range:NSMakeRange(0, input.length)];
NSString * hexChars = @"0123456789abcdefABCDEF";
NSCharacterSet *hexc = [NSCharacterSet characterSetWithCharactersInString:hexChars];
NSCharacterSet *invalidHexc = [hexc invertedSet];
NSString * allHex = [[output componentsSeparatedByCharactersInSet:invalidHexc] componentsJoinedByString:@""];
return allHex;
}

InformationsquelleAutor karim

Première tentative de Swift 2.2:

func hexStringToBytes(hexString: String) -> NSData? {
guard let chars = hexString.cStringUsingEncoding(NSUTF8StringEncoding) else { return nil}
var i = 0
let length = hexString.characters.count
let data = NSMutableData(capacity: length/2)
var byteChars: [CChar] = [0, 0, 0]
var wholeByte: CUnsignedLong = 0
while i < length {
byteChars[0] = chars[i]
i+=1
byteChars[1] = chars[i]
i+=1
wholeByte = strtoul(byteChars, nil, 16)
data?.appendBytes(&wholeByte, length: 1)
}
return data
}

Ou, comme une extension de la Chaîne:

extension String {
func dataFromHexString() -> NSData? {
guard let chars = cStringUsingEncoding(NSUTF8StringEncoding) else { return nil}
var i = 0
let length = characters.count
let data = NSMutableData(capacity: length/2)
var byteChars: [CChar] = [0, 0, 0]
var wholeByte: CUnsignedLong = 0
while i < length {
byteChars[0] = chars[i]
i+=1
byteChars[1] = chars[i]
i+=1
wholeByte = strtoul(byteChars, nil, 16)
data?.appendBytes(&wholeByte, length: 1)
}
return data
}
}

C'est un travail continu en cours, mais semble bien fonctionner jusqu'à présent.

D'autres optimisations et une discussion plus approfondie peut être trouvée sur L'Examen Du Code.

N'est-ce pas juste une rapide traduction de cette réponse?

InformationsquelleAutor JAL

Plusieurs solution est renvoyée valeur faux si la chaîne de caractères comme ceci
"DBA"

Les données correctes pour "DBA" chaîne est "\x0D\xBA" (int valeur : 3514)

si vous avez des données n'est pas comme cela "\x0D\xBA" cela signifie que vous avez un mauvais parce que la valeur sera différente, par exemple vous obtenu des données de cette "\xDB\x0A" la valeur int est 56074

Ici est de réécrire la solution:

+ (NSData *)dataFromHexString:(NSString *) string {
if([string length] % 2 == 1){
string = [@"0"stringByAppendingString:string];
}
const char *chars = [string UTF8String];
int i = 0, len = (int)[string length];
NSMutableData *data = [NSMutableData dataWithCapacity:len / 2];
char byteChars[3] = {'\0','\0','\0'};
unsigned long wholeByte;
while (i < len) {
byteChars[0] = chars[i++];
byteChars[1] = chars[i++];
wholeByte = strtoul(byteChars, NULL, 16);
[data appendBytes:&wholeByte length:1];
}
return data;
}

InformationsquelleAutor jefry jacky

Vous devez vous connecter pour publier un commentaire.