相关疑难解决方法(0)

我不时会用一个while(1)块来压扁一连串if..else不成比例的东西.它沿着这些方向发展.

而不是做:

// process 
if (success) {
  // process 
  if (success) {
    //process
    if (success) {
      // etc
    }
  }
}

我做:

while (1) {
  // process
  if (!success) break;
  // process
  if (!success) break;
  // process
  if (!success) break;
  // etc
  break;
}

我对这个结尾的隐含跳跃感到有些恼火while.我能用更精简的构造逃脱(即最后没有break)吗？

我可以break用变量(或寄存器？)来交易最终结果.这不是更精简或更清晰.

int once = 1;
while (once--) {
  // process
  if (!success) break;
  // process
  if (!success) break;
  // process
  if (!success) break;
  // etc …

有时我必须编写代码,在执行操作和检查错误条件之间交替(例如,调用库函数,检查其返回值,继续).这通常导致长期运行,其中实际工作发生在if语句的条件下,例如

if(! (data = (big_struct *) malloc(sizeof(*data)))){
    //report allocation error
} else if(init_big_struct(data)){
    //handle initialization error
} else ...

你们是怎么写这种代码的？我检查了一些样式指南,但他们似乎更关心变量命名和空格.

风格指南的链接欢迎.

编辑:如果不清楚,我不满意这种风格的易读性,并寻找更好的东西.

假设脚本中没有任何特定的内存优化问题，那么我的问题是关于Python编码风格的。这还意味着：最好尽快使用Python取消引用对象，这是一种好习惯吗？情况如下。

Class A实例化一个对象，self.foo并要求其class B存储并与其他对象共享。在某个时候A决定self.foo不再共享，并将其从中删除B。

Class A仍然有对foo的引用，但我们知道此对象从现在开始就没有用。由于foo是一个相对较大的对象，您会麻烦从A删除引用吗？（例如delvs设置self.foo = None）这个决定如何影响垃圾收集器？

如何在没有得到的情况下干净利落地做到这一点？

loop:
  if(condition1){
    something();
  } else if (condition2) {
    somethingDifferent();
  } else {
    mostOfTheWork();
    goto loop;
  }

我也不想使用休息时间.此外,在做其他事情之前,预计会循环几次(adv 40次),因此即使只是为了可读性,最多的工作部分很可能会尽可能高.提前致谢.

编辑:这是在错误的观念下发布的,编译器优化器在休息时效果很差,虽然开始时通常很愚蠢,但我通过实验(性能)证明我自己是不正确的.另一方面,谢谢你的答案; 他们对各种风格的阅读都很有趣.

就像如何避免"如果"链？,这个问题是关于保持异步程序清洁应该做些什么.

异步编程是一种完全不同于程序编程的范例,当你了解它时它真的很有趣.但是,当您有多个异步调用时,它可能会变得混乱.

考虑这个例子(这是我遇到的现实场景的抽象):

1. 读取文件 a.txt
2. 将内容提交a.txt给服务器X进行处理并检索输出.
3. 读取文件b.txt.
4. 将b.txt服务器的内容和响应X(步骤2)发送到服务器Y,并获取输出.
5. 将服务器的响应Y(步骤4)保存到c.txt.

使用异步调用,我的JavaScript看起来与此类似(函数名称组成.所有函数都是带回调的异步调用.省略了错误参数以提高清晰度.带有错误参数和错误处理的实际代码比这更麻烦):

readFile('a.txt', function (file_a_data) {
    requestToServer('http://xserver.com/', file_a_data, function (server_x_response) {
        readFile('b.txt', function (file_b_data) {
            var request_params = server_x_response + file_b_data;
            requestToServer('http://yserver.com/', request_params, function (server_y_reponse) {
                writeFile('c.txt', server_y_response);
            });
        });
    });
});

正如您所看到的,已经有四个级别的缩进,并且正在构建一个代码箭头.我们如何避免这种回调嵌套,并编写一些干净的代码？

到目前为止我尝试了什么:

• 这样做的一种方法是尽可能编写函数的同步,无回调版本.返回一个值并抛出错误异常.

  try {
      var file_content = readFile('a.txt');
      // do stuff with file_content
  } catch (ex) {
      // an error …

  Run Code Online (Sandbox Code Playgroud)

举个例子:

function()
{
    calculation1();

    while(1)
    {
        if (test1() == FAIL) { break; }

        calculation2();

        if (test2() == FAIL) { break; }

        calculation3();

        if (test3() == FAIL) { break; }

        calculation4();

        break;
    }

    final_calculation();

    return;
}

每个测试取决于从它之前的所有计算中获得的结果.但是,如果测试失败,则应跳过其余计算.

另一种方法是使用一系列嵌套的if()语句:

function()
{
    calculation1();

    if (test1() == SUCCESS)
    {
        calculation2();

        if (test2() == SUCCESS)
        {
            calculation3();

            if (test3() == SUCCESS)
            {
                    calculation4();
            }
        }
    }

    final_calculation();

    return;
}

然而,后一种方法开始看起来非常混乱,除了像上面这样的高度抽象的例子.我相信前一种方法可以更好地扩展到更长,更复杂的代码.有没有理由不采用第一种方法？

(以下与微控制器编程有关)

我想测试IF句子中的几个条件

if(variable) {            // fastest check
  if(register) {          // a bit slower
    if(read_peripheral) { // very slow check
      // [do something]
    }
  }
}

很明显,我想从最快的检查开始,然后转移到较慢的检查,如果上述错误,可能会避免检查它们.

既然我需要检查很多条件,我想知道以下内容是否相同,或者是否在做出决定之前评估所有条件？

if(variable && register && read_peripheral) {
  // [do something]
}

例如，有 5 个（或更多）任务（方法）返回true或false；如果任何连续的方法返回false，我正在使用算法语法来打破链，否则继续向内。目前，我已经构建了一堆 if 块，它们相互链接；然而，对我来说似乎很难看，并且很难通过一堆论点阅读。

if (Method_1_Returns(String manyArgs, ...) == true) {
    if (Method_2_Returns(String manyArgs, ...) == true) {
        if (Method_3_Returns(String manyArgs, ...) == true) {
            if (Method_4_Returns(String manyArgs, ...) == true) {
                ...
            }
            else {
                MethodToShowError(someString_4);
            }
        }
        else {
            MethodToShowError(someString_3);
        }
    }
    else {
        MethodToShowError(someString_2);
    }
}
else {
    MethodToShowError(someString_1);
}

我打算将其转换为一个switch块，但除了讨厌该goto指令外，这似乎不符合编码标准（或者，是吗？）。

String temp = "1";

switch (temp) {
    case "1":
        if (Method_1_Returns(String manyArgs, ...)) goto case …