ruby将映射和压缩放在一起_Ruby

ruby将映射和压缩放在一起

ruby

ruby将映射和压缩放在一起,ruby,Ruby,我是ruby新手，这看起来不对，但效果很好 def get_internal_deps self.internal_dependencies = self.sources.map do |f| s = File.open(File.join(self.dir, f)).grep(/\d{8}-\w{5}/) if s.length > 0 {:file => f, :line => s} end end.compact #how

我是ruby新手，这看起来不对，但效果很好

def get_internal_deps
  self.internal_dependencies = self.sources.map do |f| 
    s = File.open(File.join(self.dir, f)).grep(/\d{8}-\w{5}/)
    if s.length > 0
      {:file => f, :line => s}
    end
  end.compact
  #how crazy does that look?
end

那么，如何在不使用

end.compact

的情况下执行此操作？

为了避免

compact

，可以使用

reduce

（在这种特殊情况下）而不是

map

：

def get_internal_deps
  self.internal_dependencies = sources.each_with_object do |f, acc|
    s = File.open(File.join(self.dir, f)).grep(/\d{8}-\w{5}/)
    acc << {:file => f, :line => s} if s.length > 0
  end
end

def get_internal_deps
self.internal_dependencies=sources.each_with_object do | f，acc|
s=File.open（File.join（self.dir，f））.grep（/\d{8}-\w{5}/）
acc f，：line=>s}如果s.length>0
结束
结束

另外，请注意，显式的

self

接收者在赋值的情况下可能是有意义的，但在RHO中它是完全冗余的（

源代码

）

您的方法名为
```
get\u internal\u deps
```
，但看起来它实际上设置了一个实例变量
您可以定义
```
内部依赖项
```
并使用缓存

在这种情况下，您需要删除

@internal\u dependencies

的所有

attr\u reader/writer/accessor

```
File.open（f）
```
不是很干净
在
```
self.dir
```
或
```
self.sources
```
```
：行
```
是一个数组。它不应该被称为：线吗
两个单独的、简短的方法可能比一个更大的方法更好

重构代码

internal\u dependencies

是实例变量吗？

可以有多行吗？您也可以用大括号替换

do end

。我还认为，

结束。一些方法看起来weird@cobaltsoda：在Ruby中，实例变量以@
符号开头，因此它不可能是实例变量。理论上，它可以是局部变量，也可以是不带参数列表的无接收者消息发送。这两种方法中的哪一种取决于对该名称的局部变量的赋值是否在所讨论的行之前被解析。但是请注意，内部依赖项
实际上并不出现在OP的代码中。只有一条消息发送到internal\u dependencies=
方法。我知道实例变量是如何工作的。我是专门问这个问题的，如果@internal\u dependencies
已经在其他地方定义了，你可以返回@internal\u dependencies，如果定义了@在方法的开头使用内部依赖项，然后使用每个在一个循环中构建数组（而不是.map.reject
）。除此之外，回答得很好。@Cobaltsoad:谢谢你的反馈。不过，我不确定自己是否理解这样做的好处。我通常更喜欢链接专门的可枚举方法，而不是使用每个方法，只要它不会导致更多的迭代。对不起，很难通过注释框解释。我的意思是像@internal_dependencies=[]；sources.each{s|p=parse_dependency（s）；@internal_dependencies谢谢。我想这是一个品味问题。顺便说一句，你调用parse_dependency两次；）只有当存在大量依赖时才会真正受益，我喜欢挑剔。
def internal_dependencies
  @internal_dependencies ||= sources.map{|s| parse_dependency(s) }
                                    .reject{|h| h[:line].empty? }
end

private

def parse_dependency(source)
  {
    file: source,
    line: File.readlines(File.join(dir, source)).grep(/\d{8}-\w{5}/)
  }
end