标签: code-readability

对于if语句,我有相当复杂的逻辑.我目前正在使用:

if(numerical_evaluation) {

    if ((!boolOne && boolTwo) || !boolThree){
        //do stuff
    }
}

boolOne,boolTwo和boolThree是逻辑操作(可能是x < y'myObject-> getBool'等).

我不知道更好的方法是在不将||条件嵌套在第三个if语句中的情况下使其易于阅读.

我遇到困难的原因是or操作员认为if可能有必要保证第三种说法.

一种选择是这样做.

或者,我可以做类似的事情

if(x <= y) {

    bool boolFour = false;
    if ((!boolOne && boolTwo))
        boolFour = true;

    if (boolFour || !boolThree){
        //do stuff
    }
}

甚至可以创建一个单独的函数来尝试将所有内容或组合验证为单个返回值？

或者,我可以尝试以不需要的方式重构代码,这可能需要大量的时间.

我的问题:格式化复杂if问题的最佳方法是什么- 包括更复杂的评估而不仅仅是if (!A && B && C)变化？当你将||语句与&&语句组合成一行时,似乎事情变得无可救药(尤其是当你对boolOne,boolTwo等进行复杂的评估时).做同样的原则 - 格式化if语句的多种条件的最佳方法 - 在这里也适用,或者在使用各种逻辑运算符时存在根本差异吗？

我想知道是否有更美观/更容易阅读的方式来编写以下内容:

for (int i = 0; i < 100; i++)
{ 
    // If m.GetString(i) throws an exception, continue.
    // Otherwise, do stuff.       
    try
    {
        string s = m.GetString(i);
        continue;
    }           
    catch (InvalidCastException) 
    { 
    }

    // do stuff with the message that you know is not a string.
}

这是m看起来像:

msg[0] = 10
msg[1] = "string"
msg[2] = 2.224574743
// Etc.
// Assume it's different every time.

因此,当我m.GetString(0)在这个例子中,它抛出一个异常,就像msg[0]a uint而不是a string.这是我用来获取类型的,因为m它不包含GetType而我无法编辑m.

m是Message库中的类的实例,我无法编辑. …

我目前正在寻找整齐的方式,我可以迭代这个元组的向量..

这就是我目前正在做的事情？

#include <experimental/filesystems>
#include <tuple>
#include <iostream>
#include <vector>


std::tuple<std::experimental::filesystem::path, std::experimental::filesystem::file_status, std::size_t>
file_info(const std::experimental::filesystem::directory_entry &entry)
{

    const std::experimental::filesystem::file_status fs(std::experimental::filesystem::status(entry));
    return {entry.path(),
                fs,
                std::experimental::filesystem::is_regular_file(fs) ? std::experimental::filesystem::file_size(entry.path()) : 0u};

}



int main ()
{
    std::experimental::filesystem::path _path(string_dir_to_test_files);  // string_dir_to_test_files is just a string 
    std::experimental::filesystem::directory_entry dir_path(_path);
    if (std::experimental::filesystem::exists(_path))
    {
        std::cout << "exists() = " << std::experimental::filesystem::exists(_path) << std::endl;
        std::cout << "Number of files in directory: " << number_of_files(_path) << std::endl;
        std::vector<std::tuple<std::experimental::filesystem::path,std::experimental::filesystem::file_status, std::size_t>> items;
        std::transform(std::experimental::filesystem::directory_iterator(_path),{},back_inserter(items),file_info);
        for( auto const& index : items)
        {
            std::cout << …

我有时需要使用多行字符串，但在嵌套块中。这有效，但可读性真的很差：

CONDITION1 = CONDITION2 = CONDITION3 = True

if CONDITION1:
    if CONDITION2:
        s = """jkljkj
dfkjslfds
sqjdlqkj"""
    elif CONDITION3:
        s = """azeazea
azeoiuaez
azeytzae
azetzae"""

使用：

if CONDITION1:
    if CONDITION2:
        s = """jkljkj
               dfkjslfds
               sqjdlqkj"""

（如Pythonic way to create a long multi-line string所建议的那样）不是一个选项，因为该字符串s将是：

jkljkj
               dfkjslfds
               sqjdlqkj

带有不需要的左侧空格。

问题：如何在可读性好的嵌套块中使用多行字符串？

大多数人在用 C++ 或大多数其他语言声明字符串时，都会这样做：

std::string example = "example";

但是我见过一些代码示例，其完成方式如下：

std::string example("example");

对我来说，它似乎不必要地混淆了代码，特别是如果using std::string代码中的声明上方隐藏着一条语句，使其看起来像

string example("example");

对于一些可能是代码库新手或来自其他语言的人来说，它几乎看起来像是一个方法或函数。

使用构造函数而不是赋值运算符是否有任何实际或基于性能的原因，或者是否只是个人喜好？

每个人都知道更易读的代码的优点.因此,为了使我的代码更具可读性,我通常在该类的实现文件中包含注释类声明.
这样我就不必浏览各种include目录来定义.
那么,这是一个很好的做法还是只是过度记录？
如果有一些标准技术,请告诉我.
编辑:
有没有办法从Vim中的实现迁移到类声明？
除了在新缓冲区中打开它.

谢谢

if (false == x) { ...}

而不是:

if (!x) { ... }

和

if (false == f1()) { ...}

而不是:

if (!f1()) { ... }

我认为if(假= = ......版本更具可读性.你同意,或者你可以提出另一个技巧吗？它会一样快吗？谢谢.

这就是我不喜欢的原因!x:

if (25 == a->function1(12345, 6789) &&
    45 == b->function1(12345, 6789) &&
    !c->someOtherFunction(123)) { ... }

以下似乎更好:

if (25 == a->function1(12345, 6789) &&
    45 == b->function1(12345, 6789) &&
    false == c->someOtherFunction(123)) { ... }

我想知道我应该把它放在哪里.

$b =& $a;
or
$b = &$a;

以下哪一项是更好地构建嵌套的方法If.

if (x && y)
   doXY();
else if (x)
   doX();
else if (y)
   doY();

(要么)

if(x)
   if(y)
     doXY();
   else
     doX();       
else if(Y)
   doY();

程序员A喜欢一些三元运算符,尤其是嵌套运算符.更好的是,他声称它们使代码更易于阅读和维护,因为它们可以适应更少的线路.程序员B认为,当三元嵌套时可读性会丢失,反过来代码变得难以维护.

看看下面的块:

private int MyFunction(bool condA, bool condB)
{
  // Programmer A says:
  // Nested ternary --> This is easier to read and maintain because it is on one line.  Ternaries can be nested 4 or 5 deep and it is no problem.
  return condA ? condB ? 20 : -10 : -20;

  // Programmer B says:
  // Unwrapped --> This is more readable as it better describes the step by step evaluation of the conditions and their results.
  if …

我有一个项目愿意创建这样的结构文件:

js
css
images
core
--- dblayer.class.php
--- user.class.php
--- comments.class.php
--- etc.class.php
index.php
users.php 

在DBLayer类继承自PDO这样的:

class DBLayer extends PDO
{
    public function __construct()
    {
        $options = array(
            PDO::ATTR_PERSISTENT => true,
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
        );

        $dsn = DB_DRIVER . ":host=" . DB_HOST . ";dbname=" . DB_NAME;
        parent::__construct($dsn, DB_USER, DB_PASSWORD, $options);
    }

    public function getLastId()
    {
    }

    public function getLastError()
    {
    }

    // Other general methods used frequently by other classes
}

其他类将继承自DBLayer类:

class User …

您有多少次在代码深处遇到过带有return语句的函数？或者没有注意到循环中的中断或继续？虽然我最近没有被return打得措手不及，但我仍然对continue和break感到措手不及。

本科毕业后不久，我向 Dennis Ritchie 建议更改 C\xe2\x80\x99s 的中断语句。虽然我不再希望做出改变，但 Dennis\xe2\x80\x99s 的回应包含了更广泛适用的智慧：

您的建议是 \xe2\x80\x98break\xe2\x80\x99 语句应该用一个数字来表示要逃脱的级别数，这一建议之前已经出现过。这是我和 X3J11 委员会仔细考虑的一个想法，它在几个方面都很有吸引力。然而，语言标准化委员会决定拒绝它。这个想法的固有问题之一是它加剧了 \xe2\x80\x98break\xe2\x80\x99 已经存在的困难，即很难确定控制权的去向。源程序中非常小的变化会导致控制流发生巨大的变化，并且混乱程度随着中断级别的数量而增加。[强调我的]

我相信问题不在于break和其他控制流语句。问题是我们如何缩进这些陈述。缩进不应位于控件所在的位置。相反，缩进应该达到控件所在的水平。所以，而不是

func(....) {\n    \xe2\x80\xa6\n    for (...) {\n        \xe2\x80\xa6\n        if (...) {\n            break;\n        }\n       \xe2\x80\xa6\n    }\n    \xe2\x80\xa6\n}\n

我建议我们缩进如下

func(....) {\n    \xe2\x80\xa6\n    for (...) {\n        \xe2\x80\xa6\n        if (...) {\n    break;\n        }\n       \xe2\x80\xa6\n    }\n    \xe2\x80\xa6\n}\n

上面的代码看起来很难看，但这正是重点。

通过像往常一样缩进，我们可能会掩盖意外的行为。通过按建议缩进，我们使意想不到的事情成为了预期。这将有助于更好地理解代码，并让所有人获得更好的睡眠。

我不知道丹尼斯对此有何感想。可悲的是我从来没有由他来管理它。然而，如果你喜欢这个想法，作为对丹尼斯的致敬，我希望以他的名字命名它。K&R的缩进风格已经归功于他。称此为Ritchie 缩进会令人困惑。因此，我建议我们将其称为Ritchie …