Objective-C può accendere NSString?

C'è un modo più intelligente per riscriverlo?

if ([cardName isEqualToString:@"Six"]) {
    [self setValue:6];
} else if ([cardName isEqualToString:@"Seven"]) {
    [self setValue:7];
} else if ([cardName isEqualToString:@"Eight"]) {
    [self setValue:8];
} else if ([cardName isEqualToString:@"Nine"]) {
    [self setValue:9];
} 

Sfortunatamente non possono. Questo è uno degli utilizzi migliori e più ricercati delle istruzioni switch, quindi speriamo che saltino sul carro (ora) Java (e altri)!

Se stai facendo nomi di carte, forse assegna a ciascun oggetto carta un valore intero e accendilo. O forse un enum, che è considerato come un numero e può quindi essere attivato.

per esempio

typedef enum{
  Ace, Two, Three, Four, Five ... Jack, Queen, King

} CardType;

Fatto in questo modo, l'asso sarebbe uguale al caso 0, due al caso 1, ecc.

È possibile impostare un dizionario di blocchi, in questo modo:

NSString *lookup = @"Hearts"; // The value you want to switch on

typedef void (^CaseBlock)();

// Squint and this looks like a proper switch!
NSDictionary *d = @{
    @"Diamonds": 
    ^{ 
        NSLog(@"Riches!"); 
    },
    @"Hearts":
    ^{ 
        self.hearts++;
        NSLog(@"Hearts!"); 
    },
    @"Clubs":
    ^{ 
        NSLog(@"Late night coding > late night dancing"); 
    },
    @"Spades":
    ^{ 
        NSLog(@"I'm digging it"); 
    }
};

((CaseBlock)d[lookup])(); // invoke the correct block of code

Per avere una sezione "predefinita", sostituisci l'ultima riga con:

CaseBlock c = d[lookup];
if (c) c(); else { NSLog(@"Joker"); }

Speriamo che Apple insegnerà a "cambiare" alcuni nuovi trucchi.

Per me, un bel modo semplice:

NSString *theString = @"item3";   // The one we want to switch on
NSArray *items = @[@"item1", @"item2", @"item3"];
int item = [items indexOfObject:theString];
switch (item) {
    case 0:
       // Item 1
       break;
    case 1:
       // Item 2
       break;
    case 2:
       // Item 3
       break;
    default:
       break;
}

Sfortunatamente, le istruzioni switch possono essere utilizzate solo su tipi primitivi. Tuttavia, hai alcune opzioni usando le raccolte.

Probabilmente l'opzione migliore sarebbe quella di memorizzare ogni valore come voce in un NSDictionary.

NSDictionary *stringToNumber = [NSDictionary dictionaryWithObjectsAndKeys:
                                              [NSNumber numberWithInt:6],@"Six",
                                              [NSNumber numberWithInt:7],@"Seven",
                                              [NSNumber numberWithInt:8],@"Eight",
                                              [NSNumber numberWithInt:9],@"Nine",
                                              nil];
NSNumber *number = [stringToNumber objectForKey:cardName];
if(number) [self setValue:[number intValue]];

Un po 'in ritardo, ma per chiunque in futuro sono stato in grado di farlo funzionare per me

#define CASE(str) if ([__s__ isEqualToString:(str)])
#define SWITCH(s) for (NSString *__s__ = (s); ; )
#define DEFAULT

Ecco il modo più intelligente di scriverlo. E 'di utilizzare un NSNumberFormatternello "stile spell-out" :

NSString *cardName = ...;

NSNumberFormatter *nf = [[NSNumberFormatter alloc] init];
[nf setNumberStyle:NSNumberFormatterSpellOutStyle];
NSNumber *n = [nf numberFromString:[cardName lowercaseString]];
[self setValue:[n intValue]];
[nf release];

Nota che il formattatore dei numeri vuole che la stringa sia minuscola, quindi dobbiamo farlo da soli prima di passarla al formatter.

Ci sono altri modi per farlo, ma switchnon è uno di questi.

Se hai solo poche stringhe, come nel tuo esempio, il codice che hai va bene. Se hai molti casi, puoi archiviare le stringhe come chiavi in ​​un dizionario e cercare il valore corrispondente:

NSDictionary *cases = @{@"Six" : @6,
                        @"Seven" : @7,
                        //...
                       };

NSNumber *value = [cases objectForKey:cardName];
if (value != nil) {
    [self setValue:[value intValue]];
}

DI FAR .. il mio componente aggiuntivo "ObjC" PREFERITO èObjectMatcher

objswitch(someObject)
    objcase(@"one") { // Nesting works.
        objswitch(@"b")
            objcase(@"a") printf("one/a");
            objcase(@"b") printf("one/b");
            endswitch // Any code can go here, including break/continue/return.
    }
    objcase(@"two") printf("It's TWO.");  // Can omit braces.
    objcase(@"three",     // Can have multiple values in one case.
        nil,              // nil can be a "case" value.
        [self self],      // "Case" values don't have to be constants.
        @"tres", @"trois") { printf("It's a THREE."); }
    defaultcase printf("None of the above."); // Optional default must be at end.
endswitch

E funziona anche con non stringhe, TROPPO ... anche in loop!

for (id ifNumericWhatIsIt in @[@99, @0, @"shnitzel"])
    objswitch(ifNumericWhatIsIt)
        objkind(NSNumber)  printf("It's a NUMBER.... "); 
        objswitch([ifNumericWhatIsIt stringValue])
            objcase(@"3")   printf("It's THREE.\n"); 
            objcase(@"99")  printf("It's NINETY-NINE.\n"); 
            defaultcase     printf("some other Number.\n");
       endswitch
    defaultcase printf("It's something else entirely.\n");
endswitch

It's a NUMBER.... It's NINETY-NINE.
It's a NUMBER.... some other Number.
It's something else entirely.

Soprattutto, ci sono così pochi {...}", :" e ()"s"

Objective-c non è diverso da c in questo aspetto, può solo accendere ciò che c può (e il def di preproc è come NSInteger, NSUInteger, dato che alla fine sono semplicemente scritti in un tipo integrale).

Wikipedia:

sintassi c :

L'istruzione switch fa sì che il controllo venga trasferito a una delle diverse istruzioni in base al valore di un'espressione, che deve avere un tipo integrale .

Tipi integrali :

Nell'informatica, un numero intero è un dato del tipo di dati integrale, un tipo di dati che rappresenta un sottoinsieme finito degli interi matematici. I tipi di dati integrali possono avere dimensioni diverse e possono contenere o meno valori negativi.

Sono un po 'in ritardo alla festa, ma per rispondere alla domanda come indicato , c'è un modo più intelligente:

NSInteger index = [@[@"Six", @"Seven", @"Eight", @"Nine"] indexOfObject:cardName];
if (index != NSNotFound) [self setValue: index + 6];

Nota che indexOfObjectcercherà la partita usando isEqual:, esattamente come nella domanda.

Basandosi sull'idea di @Graham Perks pubblicata in precedenza, ho progettato una classe semplice per rendere l'accensione delle stringhe abbastanza semplice e pulita.

@interface Switcher : NSObject

+ (void)switchOnString:(NSString *)tString
                 using:(NSDictionary<NSString *, CaseBlock> *)tCases
           withDefault:(CaseBlock)tDefaultBlock;

@end

@implementation Switcher

+ (void)switchOnString:(NSString *)tString
                 using:(NSDictionary<NSString *, CaseBlock> *)tCases
           withDefault:(CaseBlock)tDefaultBlock
{
    CaseBlock blockToExecute = tCases[tString];
    if (blockToExecute) {
        blockToExecute();
    } else {
        tDefaultBlock();
    }
}

@end

Lo useresti così:

[Switcher switchOnString:someString
                   using:@{
                               @"Spades":
                               ^{
                                   NSLog(@"Spades block");
                               },
                               @"Hearts":
                               ^{
                                   NSLog(@"Hearts block");
                               },
                               @"Clubs":
                               ^{
                                   NSLog(@"Clubs block");
                               },
                               @"Diamonds":
                               ^{
                                   NSLog(@"Diamonds block");
                               }
                           } withDefault:
                               ^{
                                   NSLog(@"Default block");
                               }
 ];

Il blocco corretto verrà eseguito in base alla stringa.

Saggia per questa soluzione

Non posso commentare la risposta di cris sulla risposta di @Cris, ma vorrei dire che:

C'è una LIMITAZIONE per il metodo di @ cris:

typedef enum non prenderà valori alfanumerici

typedef enum
{
  12Ace, 23Two, 23Three, 23Four, F22ive ... Jack, Queen, King

} CardType;

Quindi eccone un altro:

Link Stack over flow Vai a questa risposta per l'utente "user1717750"

typedef enum
{
    Six,
    Seven,
    Eight
} cardName;

- (void) switchcardName:(NSString *) param {
    switch([[cases objectForKey:param] intValue]) {
        case Six:
            NSLog(@"Six");
            break;
        case Seven:
            NSLog(@"Seven");
            break;
        case Eight:
            NSLog(@"Eight");
            break;
        default: 
            NSLog(@"Default");
            break;
    }
}

Goditi la programmazione .....