在 Ruby 中用 Hash 总结对象区域

Question

require 'sketchup'

entities = Sketchup.active_model.entities
summa = Hash.new

for face in entities
  next unless face.kind_of? Sketchup::Face
  if (face.material)
    summa[face.material.display_name] += face.area
  end
end

我正在尝试获取数组中的结构，如下所示：

summa { "Bricks" => 500, "Planks" => 4000 }

顺便说一句，我正在为 Google Sketchup 制作 ruby​​ 脚本，

但是如果我运行此代码，我只会得到

Error: #<NoMethodError: undefined method `+' for nil:NilClass>
C:\Program Files (x86)\Google\Google SketchUp 7\Plugins\test.rb:17
C:\Program Files (x86)\Google\Google SketchUp 7\Plugins\test.rb:14:in `each'
C:\Program Files (x86)\Google\Google SketchUp 7\Plugins\test.rb:14
C:\Program Files (x86)\Google\Google SketchUp 7\Plugins\test.rb:8:in `call'

As I'm used to using PHP and just do $array['myownassoc'] += bignumber; 但我想这在使用 Ruby 时不是正确的方法吗？

所以任何关于我需要如何去的帮助都会很好。

Answer 1

问题是这样的：

summa[face.material.display_name] += face.area

这（大致）相当于

summa[face.material.display_name] = summa[face.material.display_name] + face.area

然而，你从 summa 作为一个空散列开始：

summa = Hash.new

这意味着每当你第一次遇到特定的材料时（显然，这是在循环的第一次迭代中就已经是这种情况了），summa[face.material.display_name]根本不存在。所以，你试图将一个数字添加到不存在的东西上，这显然是行不通的。

快速修复方法是使用默认值初始化哈希，以便它返回一些有用的内容，而不是对于不存在的键返回 nil：

summa = Hash.new(0)

但是，还有许多其他改进可以被写入代码。我会这样做：

require 'sketchup'

Sketchup.active_model.entities.grep(Sketchup::Face).select(&:material).
reduce(Hash.new(0)) {|h, face|
  h.tap {|h| h[face.material.display_name] += face.area }
}

我发现更更容易阅读，而不是“对此进行循环，但如果发生这种情况则跳过一次迭代，并且如果发生这种情况也不要这样做”。

这实际上是一种常见的模式，几乎每个 Rubyist 都已经编写了十几次，所以我实际上有一个代码片段，我只需要稍微调整一下。不过，我将向您展示，如果我还没有解决方案，我可以如何逐步重构您的原始代码。

首先，让我们从编码风格开始。我知道这很无聊，但它很重要。实际的编码风格是什么并不重要，重要的是代码是一致的，这意味着一段代码应该与其他代码看起来相同的代码。在这个特定的例子中，您要求 Ruby 社区为您提供无偿支持，因此至少以该社区成员习惯的风格格式化代码是有礼貌的。这意味着标准的 Ruby 编码风格：2 个空格用于缩进，snake_case 用于方法和变量名称，CamelCase 用于引用模块或类的常量，ALL_CAPS 用于常量，等等。不要使用括号，除非它们消除了优先级。

例如，在您的代码中，您有时使用 3 个空格，有时使用 4 个空格，有时使用 5 个空格，有时使用 6 个空格进行缩进，而所有这些都只用了 9 行非空代码！你的编码风格不仅与社区的其他人不一致，甚至与自己的下一行不一致！

让我们先解决这个问题：

require 'sketchup'
entities = Sketchup.active_model.entities
summa = {}

for face in entities
  next unless face.kind_of? Sketchup::Face
  if face.material
    summa[face.material.display_name] += face.area
  end
end

啊，好多了。

正如我已经提到的，我们需要做的第一件事是解决明显的问题：用 summa = Hash 替换 summa = {} （顺便说一句，这是惯用的编写方式） .new(0)。现在，代码至少可以工作了。

下一步，我将切换两个局部变量的分配：首先分配 entities，然后分配 summa，然后对 entities< 执行某些操作/code> 并且您必须查看三行才能找出实体是什么。如果切换两者，实体的使用和分配将彼此相邻。

结果，我们看到实体被分配，然后立即使用，然后再也没有使用过。我认为这并不能提高可读性，所以我们可以完全摆脱它：

for face in Sketchup.active_model.entities

接下来是 for 循环。这些在 Ruby 中是非常不惯用的； Rubyists 强烈喜欢内部迭代器。那么，让我们切换到一个：

Sketchup.active_model.entities.each {|face|
  next unless face.kind_of? Sketchup::Face
  if face.material
    summa[face.material.display_name] += face.area
  end
}

它的一个优点是，现在 face 是循环体的本地变量，而之前，它会泄漏到周围的作用域中。 （在 Ruby 中，只有模块体、类体、方法体、块体和脚本体有自己的作用域；for 和 while 循环体以及 if/unless/case 表达式没有。）

让我们进入循环体。

第一行是一个保护子句。很好，我喜欢保护子句 :-)

第二行是，如果 face.material 是 true-ish，它会执行某些操作，否则它不会执行任何操作，这意味着循环结束。所以，这是另一个保护条款！然而，它的编写风格与第一个保护子句完全不同，就在它上面一行！同样，一致性很重要：

Sketchup.active_model.entities.each {|face|
  next unless face.kind_of? Sketchup::Face
  next unless face.material
  summa[face.material.display_name] += face.area
}

现在我们有两个相邻的保护子句。让我们简化一下逻辑：

Sketchup.active_model.entities.each {|face|
  next unless face.kind_of? Sketchup::Face && face.material
  summa[face.material.display_name] += face.area
}

但是现在只有一个保护子句只保护一个表达式。因此，我们可以将整个表达式本身设置为有条件的：

Sketchup.active_model.entities.each {|face|
  summa[face.material.display_name] += face.area if
    face.kind_of? Sketchup::Face && face.material
}

但是，这仍然有点难看：我们正在循环某个集合，然后在循环内我们跳过所有我们不想循环的项目。那么，如果我们不想循环它们，我们首先要循环它们吗？我们不是先选择“有趣”的项目，然后循环它们吗？

Sketchup.active_model.entities.select {|e|
  e.kind_of? Sketchup::Face && e.material
}.each {|face|
  summa[face.material.display_name] += face.area
}

我们可以对此做一些简化。如果我们意识到o.kind_of？ C 与 C === o 相同，那么我们可以使用 grep 过滤器，该过滤器使用 === 进行模式化match，而不是 select：

Sketchup.active_model.entities.grep(Sketchup::Face).select {|e| e.material
}.each { … }

我们的 select 过滤器可以通过使用 Symbol#to_proc 进一步简化：

Sketchup.active_model.entities.grep(Sketchup::Face).select(&:material).each { … }

现在让我们回到循环。任何具有高阶语言经验的人，例如 Ruby、JavaScript、Python、C++ STL、C#、Visual Basic.NET、Smalltalk、Lisp、Scheme、Clojure、Haskell、Erlang、F#、Scala……基本上任何现代语言无论如何，都会立即将此模式识别为变形，reduce、fold、inject:into:、inject或者无论您选择的语言碰巧如何称呼它。

reduce 的作用基本上是将几件事“减少”为一件事。最明显的例子是一列数字的总和：它将几个数字减少为一个数字：

[4, 8, 15, 16, 23, 42].reduce(0) {|accumulator, number| accumulator += number }

[注意：在惯用的 Ruby 中，这将被写为 [4, 8, 15, 16, 23, 42 ].reduce(:+).]

发现潜伏在循环后面的 reduce 的一种方法是查找以下模式：

accumulator = something # create an accumulator before the loop

collection.each {|element|
  # do something with the accumulator
}

# now, accumulator contains the result of what we were looking for

在本例中，累加器 > 是 summa 哈希值。

Sketchup.active_model.entities.grep(Sketchup::Face).select(&:material).
reduce(Hash.new(0)) {|h, face|
  h[face.material.display_name] += face.area
  h
}

最后但并非最不重要的一点是，我不喜欢在块末尾显式返回 h 。显然我们可以将其写在同一行上：

h[face.material.display_name] += face.area; h

但我更喜欢使用 Object#tap （又名 K-combinator）：

Sketchup.active_model.entities.grep(Sketchup::Face).select(&:material).
reduce(Hash.new(0)) {|h, face|
  h.tap {|h| h[face.material.display_name] += face.area }
}

而且，就是这样！

Answer 2

当face.material.display_name不是现有键时，summa[face.material.display_name]默认返回nil。创建哈希时，您可以指定要返回的不同默认值。像这样的东西：

summa = Hash.new(0)

Answer 3

只需注意您的面部区域摘要 - 您还必须考虑到可能会缩放的组/组件，因此您需要利用包含您检查的面部的组/组件的整个层次结构的转换。请记住，组/组件也可能会倾斜 - 因此也必须考虑到这一点。