那么,至少有两种低级方法可以确定给定的数字是否是偶数:

 1. if (num%2 == 0) { /* even */ } 
 2. if ((num&1) == 0) { /* even */ }

我认为第二种选择更加优雅和有意义,而这正是我经常使用的选择.但这不仅仅是品味问题; 实际性能可能会有所不同:通常按位操作(例如logial和here)比mod(或div)操作更有效.当然,你可能会争辩说有些编译器无论如何都能优化它,我同意......但有些人不会.

另一点是,对于经验不足的程序员来说,第二个可能有点难以理解.关于这一点,我回答说,如果这些程序员花很短的时间来理解这种语句,它可能只会让每个人受益.

你怎么看？

只有当num无符号整数或具有二进制补码表示的负数时,给定的两个片段才是正确的. - 正如一些评论所说的那样.

字符串类的接口通常具有名为IsEmpty(VCL)或empty(STL)的方法.这是绝对合理的,因为它是一个特殊情况,但使用这些方法的代码通常必须否定这个谓词,这导致"光学(甚至心理)开销"(感叹号不是很明显,特别是在一个左括号后) ).例如,请参阅此(简化)代码:

/// format an optional time specification for output
std::string fmtTime(const std::string& start, const std::string& end)
{
    std::string time;
    if (!start.empty() || !end.empty()) {
        if (!start.empty() && !end.empty()) {
            time = "from "+start+" to "+end;
        } else {
            if (end.empty()) {
                time = "since "+start;
            } else {
                time = "until "+end;
            }
        }
    }
    return time;
}

它有四个否定,因为空案例是要跳过的.在设计界面时,我经常会观察到这种否定,这不是一个大问题,但它很烦人.我只想支持编写易于理解且易于阅读的代码.我希望你能理解我的观点.

也许我只是失明了:你如何解决上述问题？

编辑:在阅读了一些评论后,我认为原始代码使用System::AnsiString …

使用该object.ReferenceEquals方法使用时会有额外的开销((object)obj1 == (object)obj2)吗？

在第一种情况下,将涉及静态方法调用,并且在两种情况下都涉及到对象的某种形式的转换.

即使编译器平衡了那些方法,那么不等式呢？

(object)obj != null

相比于...

!object.ReferenceEquals(obj,null)

我想在某些时候,会在!=运算符内或者应用于ReferenceEquals方法的结果时发生逻辑否定.你怎么看？

还有可读性问题需要考虑.在检查相等性时,ReferenceEquals似乎更清晰,但是对于不平等,可能会错过!前面的内容object.ReferenceEquals,而!=第一个变体中很难忽略.

我正在尝试为新的网站项目挑选出最佳的颜色集.

我想做一个传统的黑色白色外观和主要内容的感觉.但是我的项目合作伙伴想要做一个更像传统Windows窗体外观的颜色组合.

有没有关于最佳颜色组合的研究可用于可读性,易用性和减少眼睛疲劳？

我有一个函数User::func()(回调),它将由模板类(Library<T>)调用.

在开发的第一次迭代中,每个人都知道func()只为这个目的服务.
几个月后,大多数成员忘记了什么func().
经过一些重构后,func()有时会被一些程序员删除.

起初,我认为这根本不是问题.
但是,在我多次重新遇到这种模式之后,我想我需要一些反制措施.

题

如何优雅地记录它？(可爱&&简洁&&没有额外的CPU成本)

例

这是一个简化的代码: -
(现实世界的问题是散布10个以上的库文件和20多个用户文件以及40多个函数.)

Library.h

template<class T> class Library{
    public: T* node=nullptr;
    public: void utility(){
        node->func();  //#1
    }
};

User.h

class User{
    public: void func(){/** some code*/} //#1
    //... a lot of other functions  ...
    // some of them are also callback of other libraries
};

main.cpp中

int main(){
    Library<User> li; .... ;  li.utility();
}

我糟糕的解决方案

1.评论/文件

作为第一个解决方法,我倾向于添加这样的评论: -

class …

我对Ruby有点新鲜,虽然我发现它是一种非常直观的语言,但我很难理解隐式返回值的行为方式.

我正在开发一个小程序来grep Tomcat日志并从相关数据生成管道分隔的CSV文件.这是我用来从日志条目生成行的简化示例.

class LineMatcher
  class << self
    def match(line, regex)
      output = ""
      line.scan(regex).each do |matched|
        output << matched.join("|") << "\n"
      end
      return output
    end        
  end
end


puts LineMatcher.match("00:00:13,207 06/18 INFO  stateLogger - TerminationRequest[accountId=AccountId@66679198[accountNumber=0951714636005,srNumber=20]",
                       /^(\d{2}:\d{2}:\d{2},\d{3}).*?(\d{2}\/\d{2}).*?\[accountNumber=(\d*?),srNumber=(\d*?)\]/)

当我运行这段代码时,我得到了以下内容,这是显式返回输出值时的预期结果.

00:00:13,207|06/18|0951714636005|20

但是,如果我将LineMatcher更改为以下内容并且不显式返回输出:

    class LineMatcher
      class << self
        def match(line, regex)
          output = ""
          line.scan(regex).each do |matched|
            output << matched.join("|") << "\n"
          end
        end        
      end
    end

然后我得到以下结果:

00:00:13,207
06/18
0951714636005
20

显然,这不是理想的结果.感觉我应该能够摆脱输出变量,但不清楚返回值的来源.此外,欢迎任何其他可读性的建议/改进.

我正在维护一些代码,并且发现了以下模式:

var isMale = (row["Gender"].ToString() == "M") ? true : false;

而不是这个:

var isMale = (row["Gender"].ToString() == "M");

是否有任何理由为什么会有人这样做？有人认为前者更具可读性或更清晰吗？是否有某种旧的C"陷阱",这是一个保留吗？

使用相同的查询但不同的参数查询数据库时,最好是:

• 一次性使用,
• 或者创建两个单独的查询？

使用单个示例:

using (SqlCommand addProduct = new SqlCommand(@"insert into [Products].[Products] ([Name], [Price]) values (@name, @price)", sqlConnection))
{
    // Insert the first product.
    addProduct.Parameters.AddWithValue("@name", "Product 1");
    addProduct.Parameters.AddWithValue("@price", 41F);
    int countAffectedRows = addProduct.ExecuteNonQuery();
    Debug.Assert(countAffectedRows == 1, "Wrong number of rows affected.");

    addProduct.Parameters.Clear();

    // Insert the second product.
    addProduct.Parameters.AddWithValue("@name", "Product 2");
    addProduct.Parameters.AddWithValue("@price", 49.9);
    countAffectedRows = addProduct.ExecuteNonQuery();
    Debug.Assert(countAffectedRows == 1, "Wrong number of rows affected.");
}

使用两个单独查询的相同代码示例:

// Insert the first product.
using (SqlCommand addProduct = new SqlCommand(@"insert into [Products].[Products] ([Name], [Price]) …

当您在SQL查询中有一个长字段时,如何使其更具可读性？

例如:

public function findSomethingByFieldNameId($Id) {
        $sql = "SELECT field1, field2, field3 as Field3_Something, field4, field5, field6, field7, field8, field9
                      FROM table
               JOIN table2 AS TNS ON TNS.id = table.id
                      WHERE something = 1";
 return $this->db->fetchData($sql, null, 'all');
    }

可能重复:
C#foreach vs functional each

这是关于编码可读性的问题.

我有一个XDocument和一个List<string>包含我需要屏蔽的敏感信息的元素的名称(在本例中用下划线替换).

XDocument xDoc;
List<string> propertiesToMask;

这可以用两种方式编写,使用传统foreach循环,或使用.ForEachlamba语法的方法.

foreach (string propertyToMask in propertiesToMask)
{
    foreach (XElement element in xDoc.Descendants(propertyToMask))
    {
        element.SetValue(new string('_', element.Value.Length));
    }
}

要么

propertiesToMask
    .ForEach(propertyToMask => xDoc.Descendants(propertyToMask).ToList()
        .ForEach(element => element.SetValue(new string('_', element.Value.Length))));

您认为哪种方法最具可读性？为什么？如果您更喜欢第二个示例,您将如何呈现它以获得最大可读性？