ios - 如果语句没有调用所有返回 BOOL 的方法

Question

我有这样的代码：

-(IBAction)send {        
    if ([self isCorrect1] && [self isCorrect2] && ...) {
        [self sendRequest];
    }
}

-(BOOL)isCorrect1 {
     ...
}

-(BOOL)isCorrect2 {
     ...
}

每个isCorrect方法都在检查一些条件，在视图中显示一些消息并返回检查结果。我注意到，如果第一个条件为假，它只会显示第一个方法的错误消息（我需要检查所有这些），并且在这些方法中不会触发断点。我认为这是某种 LLVM 优化，所以我创建了这样的代码：

-(IBAction)send {
    BOOL correct = [self isCorrect1];
    correct = correct && [self isCorrect2];
    ...

    if (correct) {
        [self sendRequest];
    }
}

并且仍然无法正常工作。我必须创建新的 BOOL 变量来存储检查结果还是有其他方法？

Answer 1

由于第一个条件被评估为false，它不会检查其余条件，而是else直接进入该部分。

试试这个。

BOOL finalResult = [self isCorrect1];
finalResult = [self isCorrect2] && finalResult;
finalResult = [self isCorrect3] && finalResult;
finalResult = [self isCorrect4] && finalResult;
...

if (finalResult) {

}

这将通过所有isCorrect测试，并让您知道它最终是否通过了所有测试。

Answer 2

您看到的行为是 的预期行为&&，即，如果它可以在评估所有条件之前提前确定结果，它会“短路”评估：

expression-yielding-false && something-else

以上结果完全由第一部分决定；无论第二个操作数产生什么，最终结果都是错误的。这使您可以编写如下内容：

if (obj != null && obj->count == 3) 
{
    ...
}

如果&&没有短路行为，你必须写

if (obj != null) 
{
    if (obj->count == 3)
    {
       ...
    }
}

||具有类似的行为。的情况下

something-yielding-true || anything

右侧不会影响结果值，因为左侧已经返回 true。

一种可能的解决方法是：

int succeeses = 0;

succeesses += [self isCorrect1]? 1 : 0;
succeesses += [self isCorrect2]? 1 : 0;
succeesses += [self isCorrect3]? 1 : 0;

if (successes == 3) 
{
    // All tests did succeed
}
else
{
    // At least one failed.
}

如果您需要知道哪些测试通过了，哪些测试失败了，您可以尝试：

BOOL passed1 = [self isCorrect1];
BOOL passed2 = [self isCorrect2];
BOOL passed3 = [self isCorrect3];

if (passed1 && passed2 && passed3) 
{
    // All tests did succeed
}
else
{
    // At least one failed.
}

上面的一个更密集的版本将是

int passed = 0;

passed |= [self isCorrect1]? (1 << 0) : 0;
passed |= [self isCorrect2]? (1 << 1) : 0;
passed |= [self isCorrect3]? (1 << 2) : 0;

if (passed == 7) 
{
    // All tests did succeed
}
else
{
    if (passed & (1 << 0)) 
    {
        // First test passed
    }
    else 
    {
        // First test failed
    }
    if (passed & (1 << 1)) 
    {
        // Second test passed
    }
    else 
    {
        // Second test failed
    }
    if (passed & (1 << 2)) 
    {
        // Third test passed
    }
    else 
    {
        // Third test failed
    }
}

这只是一个更神秘的版本，每次测试都有一个布尔变量。