Question

我已经将很多范围映射到0-300 = 10,300-600 = 20,600-900 = 30 ... 2500000-2700000 = 7000的值....所以我可以做一个真正的大的switch-statement / if-block但是我想知道是否有更优雅的方法来解决这个小问题。

好的，这是表格的一小部分，包含真实数据：

0-300 : 25
301-600.  : 45
601-900 : 65
901-1200. : 85
1201-1500: 105

1501-2000 : 133
2001-2500 : 161
2501-3000: 189
3001-3500:217
3501-4000:245

4001-4500:273
4501-5000:301
5001-6000:338

Answer 1

摆脱switch语句最常见的模式是使用字典。在您的情况下，由于您是映射范围，因此您将使用NSArray范围截止值。如果您正在处理整数，那就是它的样子：

NSArray *rangeCutoffs = [NSArray arrayWithObjects:[NSNumber numberWithInt:300],[NSNumberWithInt:600],...,nil];
NSArray *values = [NSArray arrayWithObjects:[NSNumber numberWithInt:10], [NSNumber numberWithInt:20],...,nil];

int mappedInt;
for (int index=0; index <= [rangeCutoffs count]; index++) {
    if (intToMap < [[rangeCutoffs objectAtIndex:index] intValue]) {
        mappedInt = [[values objectAtIndex:index] intValue];
    }
}
if (mappedInt == 0) {
    mappedInt = [[values lastObject] intValue];
}

实际上，您需要从plist加载rangeCutoffs和values，而不是硬编码。

Answer 2

您可以使用表格。 e.g。

struct Lookup
{
    int min;
    int max;
    int value;
};

struct Lookup table[] =
{
    {       0,     300,   10 },
    {     301,     600,   20 },
    {     601,     900,   30 },
    // other ranges
    { 2500000, 2700000, 7000 },
    { -1, -1, -1 } // marks the end of the table
};

然后简单地遍历它以找到正确的范围

int result = -1;
for (int i = 0 ; table[i].min != -1 && result == -1 ; ++i)
{
     if (table[i].min <= value && value <= table[i].max)
     {
         result = table[i].value;
     }
}

如果它是一个非常大的表，你可以使用二进制搜索。

Answer 3

你可以这样做（C例）：

#include <stdio.h>
#include <stdlib.h>

typedef int range_type;
typedef int value_type;

typedef struct {
    range_type min;
    range_type max;
    value_type value;
} range_t;

const range_t *find_range(const range_t *ranges, size_t rangesSize,
    value_type valueToFind)
{
    for (size_t i = 0; i < rangesSize; ++i) {
        if (ranges[i].min <= valueToFind && valueToFind <= ranges[i].max)
            return &ranges[i];
    }
    return NULL;
}

int main() {
    const range_t ranges[] = {
        {   0,  300, 10 },
        { 301,  600, 20 },
        { 601,  900, 30 },
        { 901, 1200, 40 }
        // And so on...
    };

    value_type testValues[] = {
          -1,                   // None
           0, 299,  300,    // [  0,  300]
         301, 599,  600,    // [301,  600]
         601, 899,  900,    // [601,  900]
         901, 1199, 1200,   // [901, 1200]
         // And so on...
    };

    for (size_t i = 0; i < sizeof(testValues) / sizeof(testValues[0]); ++i) {
        const range_t *match = find_range(
            ranges, sizeof(ranges) / sizeof(ranges[0]), testValues[i]);
        if (match != NULL)
            printf("%d found at [%d..%d]\n", testValues[i], match->min,
                match->max);
        else
            printf("%d not found\n", testValues[i]);
    }
    return EXIT_SUCCESS;
}

应输出：

-1 not found
0 found at [0..300]
299 found at [0..300]
300 found at [0..300]
301 found at [301..600]
599 found at [301..600]
600 found at [301..600]
601 found at [601..900]
899 found at [601..900]
900 found at [601..900]
901 found at [901..1200]
1199 found at [901..1200]
1200 found at [901..1200]

对于大型switch语句，是否有更优雅的解决方案？

3 个答案: