标签: readability

在Douglas Crockford 所着的Javascript:The Good Parts一书中,这是作者对继续声明所说的全部内容:

该continue声明跳转到循环的顶部.我从未见过一段没有通过重构来删除continue语句而得到改进的代码.

这真让我困惑.我知道Crockford对JavaScript有一些非常自以为是的看法,但这对我来说听起来完全错了.

首先,continue不仅仅是跳到循环的顶部.默认情况下,它也会进入下一次迭代.那么克罗克福德的陈述是不是完全虚假的信息呢？

更重要的是,我并不完全理解为什么continue甚至会被认为是坏事.这篇文章提供了似乎一般的假设: 为什么在循环中继续一个坏主意？

虽然我理解continue在某些情况下如何使代码难以阅读,但我认为它可以使代码更具可读性.例如:

var someArray=['blah',5,'stuff',7];
for(var i=0;i<someArray.length;i++){
    if(typeof someArray[i]==='number'){
        for(var j=0;j<someArray[i];j++){
            console.log(j);
        }
    }
}

这可以重构为:

var someArray=['blah',5,'stuff',7];
for(var i=0;i<someArray.length;i++){
    if(typeof someArray[i]!=='number'){
        continue;
    }
    for(var j=0;j<someArray[i];j++){
        console.log(j);
    }
}

continue在这个具体的例子中并不是特别有益,但它确实证明了它减少了嵌套深度的事实.在更复杂的代码中,这可能会提高可读性.

Crockford没有解释为什么continue不应该使用,所以这个意见背后有一些更深层次的意义,我错过了吗？

我已经在我的第一个编程工作大约8个月了,到目前为止我已经学到了不可思议的数量.

不幸的是,我是一家内部应用程序的小型初创公司的唯一开发人员.

有史以来第一次,当我离开这份工作时,我会把我的一些项目交给其他人.我已经彻底记录了我的所有项目(至少我是这么认为的),但我仍然对其他人阅读我的代码感到紧张.

例如,我总是做这种事情.

for (int i = 0; i < blah.length; i++)
{
//Do stuff
}

我应该将'i'命名为描述性的吗？它只是一个临时变量,并且只存在于该循环中,并且看起来循环对"i"的作用非常明显.

这只是一个例子.另一个是我以不同的方式命名变量...除了使用下划线启动所有私有成员之外,我并不真正符合命名标准.

是否有任何资源可以告诉我如何让下一个开发人员更容易？这种类型的东西有标准吗？

我经常使用这个代码模式:

while(true) {

    //do something

    if(<some condition>) {
        break;
    }

}   

另一位程序员告诉我,这是不好的做法,我应该用更标准的替换它:

while(!<some condition>) {

    //do something

}   

他的理由是你可以"轻易地忘记休息"并拥有无限循环.我告诉他,在第二个例子中你可以很容易地放入一个永远不会返回真实的条件,因此很容易有一个无限循环,所以两者都是同样有效的做法.

此外,我经常更喜欢前者,因为当你有多个断点时,即当多个条件退出循环时,它使代码更容易阅读.

任何人都可以通过为一方或另一方添加证据来丰富这一论点吗？

我已经看到使用显式编号重复的正则表达式模式而不是?,*和+,即:

Explicit            Shorthand
(something){0,1}    (something)?
(something){1}      (something)
(something){0,}     (something)*
(something){1,}     (something)+

问题是:

• 这两种形式是否相同？如果添加占有/不情愿修饰符怎么办？
• 如果它们相同,哪一个更惯用？更具可读性？只是"更好"？

在Perl代码中最好使用ifvs的一些指导原则是什么unless？在某些情况下是否有充分理由偏好其中一种？

我总是按照这种风格进行编码if not value,然而,一些指南引起了我的注意,虽然这种风格有效但似乎有两个潜在的问题:

1. 它不完全可读; if value is None肯定更容易理解.
2. 这可能影响后(并导致微妙的错误),因为像[],并0会评估为False也.

我也开始将这个想法应用于其他比较,例如:

• if not value VS if value is False
• if not value VS if value is []

列表也是如此......

问题是,你对这个原则有多远？在哪里划线,同时保持代码安全？

我应该总是使用这种if value is None风格吗？

关于PHP函数声明关键字一个小点:如果你有一类方法是静态的,应在static关键字的知名度关键字之前或之后都(public,protected,private)？假设您的所有方法(静态或其他方法)都有可见性关键字,那么您希望visibility关键字与关键字保持在同一位置function:

public function foo() {}

public function bar() {}

protected function baz() {}

private function quux() {}

现在假装一对夫妇是静态的:

public function foo() {}

static public function bar() {}

protected function baz() {}

static private function quux() {}

此外,如果某个方法是静态的,那么您希望这是第一个看到的方法,因为这对于它甚至是可见性关键字所做的方法有更多的影响.

这严格来说是一个可读性问题,因为它显然没有功能或设计后果.(我能想到的.)

我开始觉得使用正则表达式会降低代码的可维护性.正则表达式的简洁性和强大功能有些恶意.Perl将其与副作用(如默认运算符)相结合.

我有习惯记录正则表达式,至少有一个句子给出基本意图,至少有一个匹配的例子.

因为构建了正则表达式,所以我觉得对表达式中每个元素的最大组件进行注释是绝对必要的.尽管如此,即便是我自己的正则表达式让我摸不着头脑,好像我在读克林贡一样.

你故意愚弄你的正则表达式吗？你是否将可能更短,更强大的那些分解成更简单的步骤？我放弃了嵌套正则表达式.是否存在由于可维护性问题而避免的正则表达式构造？

不要让这个例子覆盖这个问题.

如果迈克尔·艾什的下面有一些错误,你会有什么可以做任何事情,但完全扔掉它？

^(?:(?:(?:0?[13578]|1[02])(\/|-|\.)31)\1|(?:(?:0?[13-9]|1[0-2])(\/|-|\.)(?:29|30)\2))(?:(?:1[6-9]|[2-9]\d)?\d{2})$|^(?:0?2(\/|-|\.)29\3(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:(?:0?[1-9])|(?:1[0-2]))(\/|-|\.)(?:0?[1-9]|1\d|2[0-8])\4(?:(?:1[6-9]|[2-9]\d)?\d{2})$

根据请求,可以使用上面的Ash先生的链接找到确切的目的.

比赛 01.1.02 | 11-30-2001 | 2000年2月29日

非比赛 02/29/01 | 13/01/2002 | 11/00/02

我被告知使用Java try-catch机制会有一些开销.因此,虽然有必要在try块中放置抛出checked异常的方法来处理可能的异常,但是在性能方面优化的做法是限制try块的大小以仅包含那些可能抛出异常的操作.

我不太确定这是一个明智的结论.

考虑以下两个实现处理指定文本文件的实现.

即使第一个产生一些不必要的开销是正确的,我发现它更容易遵循.通过查看语句来确定异常的确切位置尚不清楚,但评论清楚地表明哪些陈述是负责任的.

第二个比第一个更长更复杂.特别是,第一个很好的读行成语必须被修改以使readLine调用适合try块.

在函数中处理异常的最佳实践是什么？在定义中可能抛出多个异常？

这个包含try块中的所有处理代码:

void processFile(File f)
{
  try
  {
    // construction of FileReader can throw FileNotFoundException
    BufferedReader in = new BufferedReader(new FileReader(f));

    // call of readLine can throw IOException
    String line;
    while ((line = in.readLine()) != null)
    {
      process(line);
    }
  }
  catch (FileNotFoundException ex)
  {
    handle(ex);
  }
  catch (IOException ex)
  {
    handle(ex);
  }
}

这个只包含在try块中抛出异常的方法:

void processFile(File f)
{
  FileReader reader;
  try
  {
    reader = new FileReader(f);
  }
  catch (FileNotFoundException ex)
  {
    handle(ex); …

我在学习之后做了一些研究new,不像malloc()我习惯的那样,对于失败的分配没有返回NULL,并且发现有两种不同的方法来检查new是否成功.这两种方式是:

try
{
    ptr = new int[1024];
}
catch(std::bad_alloc& exc)
{
    assert();
};

和

ptr = new (std::nothrow) int[1024];
if(ptr == NULL) 
    assert();

我相信这两种方式可以实现相同的目标,(如果我当然错了,请纠正我!),所以我的问题是:

这是new完全基于可读性,可维护性和性能检查是否成功的更好选择,同时忽略了事实上的c ++编程约定.