【问题标题】:Why is it considered a bad practice to omit curly braces? [closed]为什么省略花括号被认为是一种不好的做法? [关闭]
【发布时间】:2010-09-26 11:04:01
【问题描述】:

为什么每个人都告诉我这样写代码是一种不好的做法?

if (foo)
    Bar();

//or

for(int i = 0 i < count; i++)
    Bar(i);

我对省略花括号的最大理由是,有时它们的行数可能是它们的两倍。例如,下面是一些在 C# 中为标签绘制发光效果的代码。

using (Brush br = new SolidBrush(Color.FromArgb(15, GlowColor)))
{
    for (int x = 0; x <= GlowAmount; x++)
    {
        for (int y = 0; y <= GlowAmount; y++)
        {
            g.DrawString(Text, this.Font, br, new Point(IconOffset + x, y));
        }
     }
 }
 //versus
using (Brush br = new SolidBrush(Color.FromArgb(15, GlowColor)))
    for (int x = 0; x <= GlowAmount; x++)
        for (int y = 0; y <= GlowAmount; y++)
            g.DrawString(Text, this.Font, br, new Point(IconOffset + x, y));

您还可以获得将usings 链接在一起的额外好处,而无需缩进一百万次。

using (Graphics g = Graphics.FromImage(bmp))
{
    using (Brush brush = new SolidBrush(backgroundColor))
    {
        using (Pen pen = new Pen(Color.FromArgb(penColor)))
        {
            //do lots of work
        }
    }
 }
//versus
using (Graphics g = Graphics.FromImage(bmp))
using (Brush brush = new SolidBrush(backgroundColor))
using (Pen pen = new Pen(Color.FromArgb(penColor)))
{
    //do lots of work
}

花括号最常见的论点围绕维护编程,以及在原始 if 语句与其预期结果之间插入代码会产生的问题:

if (foo)
    Bar();
    Biz();

问题:

  1. 想要使用该语言提供的更紧凑的语法是错误的吗?设计这些语言的人很聪明,我无法想象他们会推出一个总是不好用的功能。
  2. 我们应该还是不应该编写代码,以便最低公分母能够理解并且使用它没有问题?
  3. 我还缺少另一个论点吗?

【问题讨论】:

  • 我同意你的看法。省略它们。期间。
  • 谁在乎它在 2010 年有多少行。显示器宽且便宜且分辨率高!我的显示器是 2048 X 1152,我有两个!当您很容易引入难以发现的细微错误时,可读性比节省 2 条垂直线更重要。
  • 显示器宽且便宜,但它们并不且便宜。垂直空间比水平空间更稀缺。
  • @AdamRuth 把它们转过来 :)
  • 所以你不会像 Apple 那样被 2014 年 2 月发现的 SSL 错误搞砸了,哈哈。

标签: java c# c++ c coding-style


【解决方案1】:

实际上,唯一一次真正让我感到痛苦的是我在调试时,并注释掉了 bar():

if(foo)
  // bar();
doSomethingElse();

除此之外,我倾向于使用:

if(foo) bar();

它负责处理上述情况。

编辑感谢您澄清问题,我同意,我们不应该按照最低公分母编写代码。

【讨论】:

  • 这当然很粗糙,但我认为维护者最大的问题是他们会添加第二行,并且没有意识到它不是条件语句的一部分,即使它看起来确实应该是.
  • 我不喜欢单线风格,因为我总是去寻找下面的循环体。
  • 我发现单行样式更令人恼火而不是有用,因为(尤其是在深度嵌套中——呃)该语句很容易被过度阅读并且可能随之而来的混乱。不过,我几乎只将此类单语句 ifs 用于输入验证(即提前返回)或循环控制(例如忽略文件系统遍历中不相关的文件名),其中空行有助于将它们与主代码隔离开来。
  • 单行样式也将 bar() 隐藏在测试覆盖范围之外。即使 foo 始终为 false,它也会看起来被覆盖。
  • 这是另一种说法,“如果源包含大括号,我就不会在调试时浪费时间。” - 添加牙套非常简单,并且避免给下一个人留下陷阱。唯一反对的论点是“可读性”,这是相当脆弱的,因为在这种情况下,如果你忽略它们,就会隐含地发生一些事情。
【解决方案2】:

阅读速度...

除了已经提到的。在这一点上,我已经习惯于解析带有大括号和空格的 if 语句。于是我读了:

if (condition)
{
    DoSomething();
}

DoSomethingElse();

比我读的要快一点:

if (condition) DoSomething();

DoSomethingElse();

如果它看起来像这样,我读起来会慢一点:

if (condition) DoSomething();
DoSomethingElse();

我读这个比以前慢得多:

if (condition) 
    DoSomething();
DoSomethingElse();

因为我忍不住再读一遍,以防万一,想知道作者是否有意:

if (condition)
{
    DoSomething();
    DoSomethingElse();
}

已经概括地介绍了,但是当涉及到阅读下面的内容时,我会研究很长一段时间以确保作者的意图。我什至可能会去找原作者确认。

if (condition) 
    DoSomething();
    DoSomethingElse();

【讨论】:

  • 问题解决了,在您的第 4 个示例中,您只需在 if 语句后放置一个空行以将其与 DoSomethingElse() 分开这就是我所做的,并且可读性与第一个示例几乎相同(如果不是更好;-P)另一件事是,将行分成 2 或 3 行可以显着提高可读性,您只需更快地浏览代码。
  • 也许是因为我习惯了 Python,但是把第一个花括号和 if 语句放在同一行可以让我更快地阅读和理解它。
  • 无牙套样式的问题,它让你浪费宝贵的注意力去思考积木是否有牙套,而不是更重要的事情。仅此一项就足以有理由使用最简单的约定,即始终使用大括号。
  • 大括号本质上是显式的。我会坚持下去,谢谢。
  • 在最后一种情况下,追捕原作者并打他... ;)
【解决方案3】:

如果是小东西,写成这样:

if(foo()) bar();

如果足够长可以分成两行,请使用大括号。

【讨论】:

  • 是的,我也是这样做的。如果您添加另一行,它会强制您添加大括号,并且很明显 bar() 实际上是 if 的一部分,所以如果您将其注释掉,就会发生不好的事情。
  • 虽然对调试器不太友好。如何在“bar”部分设置断点?
  • @Nemanja:只需将光标放在 bar() 上;并按 F9。 VS2005 和 VS2008 都处理行内断点,如果它们是单独的“语句”。
  • GalanticCowboy:环境比你知道的要多。 :-)
  • 当然,但由于上下文是 C#,因此应该涵盖绝大多数用户...
【解决方案4】:

我也曾经认为最好只在真正需要时使用大括号。但现在不是了,主要原因是,当你有很多代码时,它确实使它更具可读性,并且当你有一致的大括号样式时,你可以更快地解析代码。

除了有人在 if 中添加第二条语句之外,总是使用大括号的另一个很好的理由是可能会发生这样的事情:

if(a)
   if(b)
     c();
else
   d();

您是否注意到 else 子句实际上是“if(b)”的子句?您可能做过,但您会相信任何人都熟悉这个问题吗?

所以,如果只是为了保持一致性,并且因为你永远不知道当其他人(总是愚蠢的总是其他人)更改代码时会发生什么意想不到的事情,我总是放大括号,因为它使源代码更具可读性,您的大脑可以更快地解析。仅对于最简单的 if 语句,例如进行委托或类似于 switch 的 if 语句,您知道该子句永远不会被扩展,我会省略大括号。

【讨论】:

  • 这是我使用大括号的两种情况之一。否则不行。
  • 这应该写成好像 (a && b) ... 首先我认为。
  • @alexander.biskop:当然不是,因为这给 else 块赋予了不同的含义(!a || !b),与添加大括号(!a)或不添加大括号(a &amp;&amp; !b)的情况不同。跨度>
  • @Ben Voigt:没错!喜欢它;-) 半年和两次投票后,有人意识到我所做的陈述是错误的......我猜我没有足够关注细节,主要是因为我评论背后的意图与指出的意图不同该 if 子句的技术上正确的转换。我的意思是嵌套的内联 if 语句通常会显着降低可读性(尤其是控制流的可追溯性),因此应该将其组合成一个语句(或完全规避)。干杯
  • @alexander.biskop:同时,嵌套的 if 条件更简单,调试更容易,因为您可以单步执行每个条件。
【解决方案5】:

线路很便宜。处理器功率便宜。开发人员的时间非常昂贵。

作为一般规则,除非我正在开发一些绝对资源/速度关键的应用程序,否则我总是会在编写代码方面犯错

(a) 任何其他开发人员都可以轻松了解我正在做的事情

(b) 注释代码中可能需要的特定部分

(c) 如果出现问题,易于调试

(d) 如果将来需要,易于修改(即添加/删除代码)

从业务角度来看,代码的速度或学术优雅次于这些因素。这并不是说我开始编写笨拙或丑陋的代码,但这是我的优先顺序。

通过在大多数情况下省略花括号,这对我来说使 (b)、(c) 和 (d) 变得更加困难(但请注意并非不可能)。我会说是否使用花括号对 (a) 没有影响。

【讨论】:

  • 您关于 (a) 的最后陈述是许多开发人员(包括此处的其他发帖人)会争论的观点。
【解决方案6】:

这并不总是被认为是一种不好的做法。 Mono Project Coding Guidelines 建议在没有必要的情况下不要使用花括号。 GNU Coding Standards 也是如此。我认为与编码标准一样,这是个人品味的问题。

【讨论】:

  • 在阅读了整个指南之后,我对 Mono 代码的看法似乎很陌生
【解决方案7】:

我更喜欢花括号提供的清晰度。您确切地知道是什么意思,并且不必猜测是否有人只是犯了错误并离开了他们(并引入了一个错误)。我唯一一次省略它们是当我将 if 和 action 放在同一行时。我也不经常这样做。我实际上更喜欢通过将花括号放在自己的行中引入的空格,尽管从多年的 K&R C 类编程中,如果 IDE 不强制执行它,用大括号结束行是我必须努力克服的一种做法我。

if (condition) action();  // ok by me

if (condition) // normal/standard for me
{
   action();
}

【讨论】:

    【解决方案8】:

    我认为这是您正在从事的项目的指导方针和个人品味的问题。

    我通常在不需要它们时省略它们,除了以下某些情况:

    if (something)
        just one statement; // i find this ugly
    else
    {
        // many
        // lines
        // of code
    }
    

    我更喜欢

    if (something)
    {
        just one statement; // looks better:)
    }
    else
    {
        // many
        // lines
        // of code
    }
    

    【讨论】:

      【解决方案9】:

      在过去的 C/C++ 宏时代,这可能会让您感到厌烦。我知道这是一个 C# 问题,但编码标准通常会在没有最初创建该标准的原因的情况下延续。

      如果您在创建宏时不够小心,最终可能会导致不使用 {} 的 if 语句出现问题。

      #define BADLY_MADE_MACRO(x) function1(x); function2(x);
      
      if (myCondition) BADLY_MADE_MACRO(myValue)
      

      现在,不要误会我的意思,我并不是说你应该总是这样做 {} 只是为了避免 C/C++ 中的这个问题,但我不得不处理一些非常奇怪的错误,因此。

      【讨论】:

      • 如果所有代码都这样声明自己... sigh
      【解决方案10】:

      坦率地说,我认为它是:

      优秀的程序员会进行防御性编程,而糟糕的程序员则不会。

      由于上面有几个示例以及我自己与忘记大括号相关的错误的类似经历,因此我学会了始终放置大括号的艰难方法。

      其他任何事情都是选择个人风格而不是安全,这显然是糟糕的编程。

      Joel 甚至在 Making Wrong Code Look Wrong 中提到了这一点

      一旦你因为缺少大括号而被一个 bug 咬住,你就会发现缺少大括号看起来不对,因为你知道这可能是另一个 bug 发生的地方。

      【讨论】:

      • 如果大括号自己放在行上,那么任何有两行或多行缩进而没有大括号对的地方都会看起来不对,任何不匹配的大括号对也是如此。在if 语句控制块的情况下,这种用法将花费一个空行,但在if 语句控制单个操作而不是块的情况下避免需要块。
      【解决方案11】:

      我以前也是这么想的。

      直到有一天(为什么总有那个“一天”永远改变你的生活?)我们连续 24 到 36 小时不睡觉地调试生产代码,结果发现有人没有放大括号并结合搜索/替换更改。

      是这样的。

       if( debugEnabled ) 
            println( "About to save 1 day of work to some very important place.");
       saveDayData();
      

      接下来是

       if( debugEnabled ) 
       //     println( "About to save 1 day of work to some very important place.");
       saveDayData();
      

      事实证明,系统每天生成 500 mb 的日志,我们被要求停止它。调试标志是不够的,所以搜索和替换 println 是为了。

      当应用程序投入生产时,调试标志仍处于关闭状态,并且从未调用过重要的“saveDayData”。

      编辑

      现在我唯一不使用大括号的地方是 if/try 构造。

      if( object != null ) try { 
           object.close();
      } catch( .....
      

      在看过一位超级明星开发者这样做之后。

      【讨论】:

      • 我不明白。您有一个控制调试的变量(debugEnabled),您仍然使用cmets来禁用调试???为什么不直接将 debugEnabled 设置为 false?
      • 这不完全是场景,但你说得很好。愚蠢的事情(比如不将 debug 设置为 false )确实会产生比“明显”错误更难找到的微妙和愚蠢的错误。在这种情况下,不使用大括号并没有太大帮助。
      • @igor 怎么样,因为他们只是想删除一行日志而不是所有日志行?
      【解决方案12】:

      我很高兴:

      foreach (Foo f in foos)
        foreach (Bar b in bars)
          if (f.Equals(b))
            return true;
      
      return false;
      

      我个人不明白为什么

      foreach (Foo f in foos)
      {
        foreach (Bar b in bars)
        {
          if (f.Equals(b))
          {
            return true;
          }
        }
      }
      
      return false;
      

      更具可读性。

      是的,行是免费的,但是为什么我必须滚动页面和代码页面,因为它可能只有一半大小?

      如果在可读性或可维护性方面存在差异,那么,当然,放大括号......但在这种情况下,我看不出有任何理由。

      另外,我会总是在嵌套了 else 的地方为嵌套的 if 放置大括号

      if (condition1)
        if (condition2)
          doSomething();
        else (condition2)
          doSomethingElse();
      

      if (condition1)
        if (condition2)
          doSomething();
      else (condition2)
        doSomethingElse();
      

      非常混乱,所以我总是这样写:

      if (condition1)
      {
        if (condition2)
          doSomething();
        else (condition2)
          doSomethingElse();
      }
      

      我尽可能使用三元运算符,但我从不nest them

      【讨论】:

      • 刚刚看到这几乎发生在我的代码中 :) 想我会环顾四周,瞧……它已经在那里了 :)
      【解决方案13】:

      我同意“如果你足够聪明,可以让别人付钱给你写代码,那么你应该足够聪明,不要仅仅依靠缩进来查看代码的流程。”

      但是......可能会犯错误,而且这个调试起来很痛苦......尤其是如果您要查看其他人的代码。

      【讨论】:

        【解决方案14】:

        当您跳过单行块上的大括号时,我的计算机编程领域的同行(你们很多)不会被潜在错误的前景吓倒,这给我留下了深刻的印象和谦卑。

        我想这意味着我不聪明。我在这方面犯了很多次错误。我已经调试了其他人的错误。由于这个原因,我看到软件发布时存在错误(RDP 到运行 VS2002 的机器,您的监视窗口字体会变得不稳定)。

        如果我看看我所犯的所有错误,这些错误本可以通过改变编码风格来避免,这个列表很长。如果我没有在这些情况下改变我的方法,我可能永远不会成为一名程序员。再说一次,我想我不聪明。作为补偿,我长期以来一直是单行块上大括号的忠实用户。

        也就是说,世界上有些事情已经发生了变化,使得“你应该在单行块上使用大括号”规则在今天的相关性不如摩西带给我们的时候:

        • 一些流行的语言通过让计算机读取缩进来解决问题,就像程序员一样(例如 Python)。

        • 我的编辑器为我自动格式化,因此我被缩进误导的可能性大大降低。

        • TDD 意味着如果我因为对单行代码块感到困惑而引入了一个错误,我更有可能很快发现这个错误。

        • 重构和语言表达能力意味着我的代码块要短得多,单行代码块比以前更频繁地出现。假设,通过无情地应用 ExtractMethod,我的整个程序中可能只有 个单行块。 (我想知道那会是什么样子?)

        事实上,无情地重构和省略单行块上的大括号可以带来明显的好处:当你看到大括号时,你的脑海中会响起一个小警报,说“这里很复杂!小心!”。想象一下,如果这是常态:

        if (condition) Foo();   // normal, everyday code
        
        if (condition) 
        {
            // something non-trivial hapening; pay attention!
            Foo();
            Bar();
        }
        

        我正在接受将我的编码约定更改为“单行块可能永远不会有大括号”或“如果您可以将块与条件放在同一行,并且所有内容都符合80 个字符,省略大括号”。我们拭目以待。

        【讨论】:

        • 作为一名前 Java 程序员,我必须完全同意自动格式化是问题的真正答案。你甚至不必让你的编辑器自动添加大括号——单独的自动缩进可以帮助避免歧义。当然,现在我已经切换到 Python,我已经习惯于首先正确地格式化我的代码。
        • 我对牙套也有同感。这一切都与复杂性有关。理想情况下,我们只有一个行块。这就是我所说的可读性,而不是不必要的大括号。
        【解决方案15】:

        我的理念是,如果它使代码更具可读性,为什么不这样做呢?

        显然,您必须在某处划清界限,例如在简洁和过度描述的变量名称之间找到合适的媒介。但是括号确实可以避免错误并提高代码的可读性。

        您可以争辩说,足够聪明成为编码员的人将足够聪明,可以避免导致无括号语句的错误。但是你能诚实地说你从来没有被拼写错误这样简单的事情绊倒吗?在查看大型项目时,这样的细节可能会让人不知所措。

        【讨论】:

        • 当然这是非常主观的。有时不使用它们可以提高可读性。
        • 没错,如果我把括号去掉,我会保留一行,就像其他人提到的那样。我被咬了太多次,但多行无括号声明。即使您知道要注意它,它仍然偶尔会吸引您。
        【解决方案16】:

        总有例外,但我反对仅在其中一种形式时才省略大括号:

        if(x == y)
           for(/* loop */)
           {
              //200 lines
           }
        
        //rampion's example:
        for(/* loop */)
        {
           for(/* loop */)
              for(/* loop */)
              {
                 //several lines
              }
        }
        

        否则,我没有问题。

        【讨论】:

        • 不好的例子。在这两种情况下,我都会将 200 行 for 循环考虑到它自己的方法中,或者最好是几种方法。
        • 没错,但它确实发生了。另外,任何时候一个块比阅读器的屏幕高,你都会遇到这个问题。而且您无法控制代码阅读器的屏幕高度。他们可能只会在每一侧看到几行。
        • 确实会发生。这并不意味着它应该发生。
        • @AdamJaskiewicz 对。它确实发生了。我们必须考虑会发生什么,而不是应该发生什么。如果我们可以将自己限制在应该发生的事情上,我们就不必担心错误。
        【解决方案17】:

        我偶尔会使用最底层的代码(多个 using 语句),但除此之外,我总是把大括号放进去。我只是发现它使代码更清晰。从不仅仅是缩进中可以明显看出语句是块的一部分(因此可能是 if 等的一部分)。

        我看过

        if (...)
            foo();
            bar();
        

        bug 咬了我(或者更确切地说是“我和同事”——我实际上并没有介绍这个 bug)一次。尽管我们当时的编码标准建议在任何地方都使用大括号,但这仍然是事实。我花了很长时间才发现——因为你看到了你想看到的。 (这是大约 10 年前的事了。也许我现在会发现它更快。)

        当然,如果您使用“行尾大括号”,它会减少产生的额外行,但我个人还是不喜欢这种风格。 (我在工作中使用它,发现它没有我想象的那么不愉快,但还是有点不愉快。)

        【讨论】:

        • 我一直认为一致性比实际风格更重要,为什么我们只在使用的情况下例外?
        • @Bob:很好,我只是偶尔这样做。我不想假装我在这里有实际的理由:) 实际上,有一个合理的理由 - 像这样嵌套 usings(和唯一的 usings)是相当明显的,你仍然会得到 a堵塞。我无法立即看到危险。
        • 当然,这并不是说没有任何危险。
        • 这个错误的最佳解决方案:使用 Python。 (当然是在开玩笑。)
        【解决方案18】:

        三种约定中的一种:

        if(addCurleyBraces()) bugFreeSofware.hooray();
        

        和:

        if(addCurleyBraces())
            bugFreeSofware.hooray();
        

        and(使用左大括号和右大括号表示任何缩进样式):

        if(addCurleyBraces()) {
            bugFreeSofware.hooray();
        }
        

        我更喜欢最后一个:

        • 我发现如果所有 if 语句都以统一的方式编写,则更易于阅读。
        • 它可能会使软件更加健壮且无错误。然而,所有现代 IDE 和高级文本编辑器都具有很好的自动缩进功能,我认为每个人都应该使用它们,只要它不会弄乱评论格式或违反团队标准(在很多情况下,可以创建自定义格式方案并与团队分享)。我的观点是,如果缩进操作正确,引入错误的风险会降低一点。
        • 我更喜欢布尔表达式和语句在不同的行上执行。我喜欢能够标记一行以进行调试。即使我使用的是可以标记语句并单步执行的 IDE,它也是一个交互式操作,我可能会忘记我从哪里开始调试,或者至少我需要多一点时间来单步调试代码次(因为我必须在每次调试期间手动标记位置)。

        【讨论】:

          【解决方案19】:

          您反对使用大括号的主要论据是它们使用了额外的行并且需要额外的缩进。

          行(几乎)是免费的,尽量减少代码中的行数不应该是一个目标。

          缩进独立于大括号的使用。在您的级联“使用”示例中,即使您省略了大括号,我仍然认为您应该缩进它们。

          【讨论】:

            【解决方案20】:

            我坚信编写整洁简洁的代码,但我总是使用花括号。我发现它们是一种快速查看特定代码行存在范围的便捷方式。没有歧义,只是明确地摆在你面前。

            有人可能会说这是一种偏好,但我发现如果程序的逻辑流程内部一致,则更容易遵循,而且我不认为像这样编写一个 IF 语句是一致的;

            if(x < y)
                x = y;
            else
                y = x;
            

            还有一个这样的;

            if(x < y)
            {
                x = y;
                x++;
            }
            else
            {
                y = x;
                y++;
            }
            

            我更喜欢只选择一种通用风格并坚持下去:)

            【讨论】:

              【解决方案21】:

              主要问题之一是当您有单线和非单线区域时, 以及与控制语句的分离(forif,你有什么)和语句的结尾。

              例如:

              for (...)
              {
                for (...)
                  for (...) 
                  {
                    // a couple pages of code
                  }
                // which for block is ending here?  A good text editor will tell you, 
                // but it's not obvious when you're reading the code
              }
              

              【讨论】:

              • 为什么你的 for 循环中有几页代码?
              • b/c 我是个麻木不仁的笨蛋,我痴迷于摆脱函数调用的“成本”。 :)
              • 这几页代码通常应该在一个单独的函数中。
              • 对不起,我的意思是我在扮演这样一个笨蛋的角色。但是,我认为通过小视口查看时,较短的区域也会出现同样的问题。这不在编码员的控制范围内。
              【解决方案22】:

              我曾经是“大括号是必须的!”的坚定支持者,但自从采用单元测试后,我发现我的单元测试可以保护无大括号语句免受以下场景的影响:

              if (foo)
                  snafu();
                  bar();
              

              通过良好的单元测试,我可以自信地省略简单语句的花括号以提高可读性(是的,这可能是主观的)。

              或者,对于像上面这样的东西,我可能会内联它看起来像:

              if (foo) snafu();
              

              这样,需要在条件中添加 bar() 的开发人员会更容易识别出缺少花括号并添加它们。

              【讨论】:

              • 你说“我不需要它”然后给出了使用它的理由:可读性!
              • 我不会依赖单元测试来找到它。 LINT 也许,单元测试没有!
              • @Kristen - 单元测试的想法是断言方法的行为。如果行为发生变化(如上所述),单元测试将失败。我看不出问题所在。
              • 但是为什么要依赖单元测试来找出在去 UT 之前应该解决的明显问题呢?
              【解决方案23】:

              好的,这是一个老问题,已经回答得要死了。我有话要补充。

              首先我不得不说使用大括号。它们只能提高可读性,并且可读性(对您自己和他人!)应该在您的优先级列表中非常高,除非您正在编写程序集。不可读的代码总是会导致错误。如果您发现大括号使您的代码占用了太多空间,那么您的方法可能太长了。如果你做得对,任何方法的大部分或全部都应该适合一个屏幕高度,而 Find (F3) 是你的朋友。

              现在补充一下:这里有一个问题:

              if (foo) bar();
              

              尝试设置一个只有在 bar() 运行时才会触发的断点。您可以在 C# 中通过将光标放在代码的后半部分来执行此操作,但这并不明显并且有点痛苦。在 C++ 中你根本做不到。出于这个原因,我们从事 C++ 代码工作的一位最资深的开发人员坚持将“if”语句分成两行。我同意他的看法。

              这样做:

              if (foo)
              {
                  bar(); //It is easy to put a breakpoint here, and that is useful.
              }
              

              【讨论】:

              • 右键单击栏并选择插入断点...一点也不难。了解你的工具。
              • 右击指示条没有任何作用;你的意思是右键单击文本?无论如何,如果您只想在“if”语句为真时触发断点,并且“bar()”在它自己的行上,您可以将光标放在该行的任意位置并按 F9,或左键单击指标保证金。但是,如果所有代码都在一行上,则必须将光标定位在“bar()”上或在按 F9 之前准确地单击那里,并且单击指示器边距将不起作用(将断点放在 '如果')。这并不“难”,但当代码为两行时,它需要较少的注意力。
              • 哦,哈哈,右键“bar()”。你的意思是文字。明白了。当然可以,或者直接按 F9...
              • >>您必须将光标定位在“bar()”上或在按 F9 之前准确地单击那里,(我的意思是在按 F9 或右键单击之前将光标准确地定位在那里)
              【解决方案24】:

              为了避免带大括号的代码占用大量空间,我使用了Code Complete一书中推荐的技术:

              if (...) {
                  foo();
                  bar();
              }
              else {
                  ...
              }
              

              【讨论】:

              • 我不明白为什么它被降级了它为我一直使用的每一对括号保存一行
              • 这更通俗地称为 K&R 风格。基于 Kernighan 和 Ritchie 所著的《C 编程语言》一书:en.wikipedia.org/wiki/The_C_Programming_Language_(book)。而且它不应该让你被改装。
              • 谢谢!我认为这只是个人口味。我曾经觉得这种语法让我自己很烦,但是在阅读了 Code Complete 之后我就采用了它,现在真的很喜欢它。
              • 我正在阅读上面的所有答案,并在想“为什么还没有人提出这个建议???”它使右括号与它正在关闭的块对齐,即“if”或“while”等,而不是无意义的“{”。 +1。
              • 如果大括号总是单独放在行上,那么if 后面跟一个缩进的行可能会被视觉识别为控制单个语句而不需要任何大括号。因此,在if 语句控制语义上是单个操作的某些东西(与恰好仅包含单个步骤的步骤序列不同)的情况下,open-brace-by-itself 样式可以节省空格。例如,if (someCondition) / ` throw new SomeException(...)`。
              【解决方案25】:

              假设你有一些代码:

              if (foo)
                  bar();
              

              然后其他人过来并补充说:

              if (foo)
                  snafu();
                  bar();
              

              根据它的写法,bar();现在无条件执行。通过包含花括号,可以防止这种意外错误。代码的编写方式应使此类错误难以或不可能发生。如果我在进行代码审查并看到缺少​​的大括号,特别是分布在多行中,我会创建一个缺陷。在合理的情况下,将其保留在一行中,以便再次将犯此类错误的机会降至最低。

              【讨论】:

              • 问题中已经说明了这一点。
              • 实际上并不完全。是的,他提到了这种错误的可能性,但我说的是使您的代码能够防止错误并消除潜在的错误,作为最佳实践的一部分。
              • 真的有bug证明代码这种东西吗?
              • 不,但你可以让它变得更难。阅读 Jason Cohen 的“同行代码审查的最佳保密”(请参阅​​此处某些页面旁边的链接),以更好地了解您为什么这样做。
              • 这个 Mike Scott 是谁?为什么他是警察?人们必须陈述显而易见的事情,这总是让我感到震惊。那么为什么 Mike 不继续评论用户发布的关于此问题的附加描述。不是所有答案都指向问题吗?
              【解决方案26】:

              我总是在适当的时候省略它们,例如在您的第一个示例中。我可以通过浏览来查看和理解的干净、简洁的代码比我必须逐行滚动和阅读的代码更容易维护、调试和理解。我想大多数程序员都会同意这一点。

              如果你开始做多重嵌套,if/else 子句等等,它很容易失控,但我认为大多数程序员应该能够知道在哪里划线。

              我认为这有点像 if ( foo == 0 )if ( 0 == foo ) 的论点。后者可以防止新程序员(甚至可能偶尔为老手)的错误,而前者在您维护代码时更容易快速阅读和理解。

              【讨论】:

                【解决方案27】:

                减少行并不是删除大括号的好理由。如果您的方法太大,它可能应该被重构为更小的部分或重组。这样做无疑会比简单地去掉大括号更能提高可读性。

                【讨论】:

                  【解决方案28】:

                  使用一些个人判断。

                  if (foo)
                    bar();
                  

                  本身就很好。除非你真的担心白痴以后会做这样的事情:

                  if (foo)
                    bar();
                    baz();
                  

                  如果你不担心白痴,那你很好(我不担心——如果他们不能正确掌握基本的代码语法,这是他们最不关心的问题)>

                  作为交换,它更具可读性。

                  其余时间:

                  if (foo) {
                    bar();
                    baz();
                  }
                  

                  从我记事起,这就是我的最爱。另外:

                  if (foo) {
                    bar();
                    baz();
                  } else {
                    qux();
                  }
                  

                  为我工作。

                  垂直空间本身并不是非常相关,可读性是。一行上的左大括号本身只是停止了一个句法元素的对话,直到你的眼睛向下移动到下一行。不是我喜欢的。

                  【讨论】:

                  • 我更喜欢第一种样式的唯一情况是当我必须立即返回或抛出错误以防出现问题时。喜欢if (parameter == null) return null;
                  【解决方案29】:

                  大多数时候,无论是对于公司还是 FOSS 项目,它都作为一种编码标准根深蒂固。

                  最终,其他人将需要深入了解您的代码,而对于每个开发人员来说,必须弄清楚他们正在处理的代码部分的特定样式是一个很大的时间消耗。

                  另外,假设有人每天不止一次地在 Python 和 Cish 语言之间切换……在 Python 中,缩进是该语言块语义的一部分,很容易犯像你这样的错误引用。

                  【讨论】:

                  • +1 对 python 的评论。在不断切换语言时,我总是很“愚蠢”。
                  【解决方案30】:

                  错误在于更安全 - 只是多了一个您可能不需要修复的错误。

                  如果我所有的积木都包裹在卷曲中,我个人会觉得更安全。即使对于单行,这些都是很容易防止错误的简单符号。它使代码更具可读性,因为您可以清楚地看到块中的内容,以免将块的主体与块外的以下语句混淆。

                  如果我有一个单行,我通常将其格式化如下:

                  if( some_condition ) { do_some_operation; }
                  

                  如果线路太麻烦,请使用以下内容:

                  if( some_condition )
                  {
                      do_some_operation;
                  }
                  

                  【讨论】:

                    猜你喜欢
                    • 1970-01-01
                    • 2013-09-13
                    • 2010-11-09
                    • 2010-10-22
                    • 2011-11-20
                    • 2010-10-15
                    • 2011-01-08
                    相关资源
                    最近更新 更多