Ruby 使用initialize定义带参数的类方法

我是ruby的新手。我为一个问题编写了以下代码。我相信这个代码是正确的

class Array 
  def sum
    result = 0
    self.each do |x|
      result += x
    end
    result
  end
end

我想知道的是如何在不使用

sum

方法中的

self

方法的情况下编写准确的代码。这就是我要做的…我知道下面的代码是不正确的，但它会告诉你我想得到什么

class Array
  def initialize
    @array = []
  end

  def sum (@array)
    result = 0
    @array.each do |x|
      result += x
    end
    result
  end
end

所以我要做的是通过在

sum

方法中传递一个参数，而不是使用

.self

方法来让这段代码工作。有什么帮助吗？谢谢

下面的情况如何

class Array
  def sum
    inject(0,:+)
  end
end
[2,9].sum # => 11

---

没有self：（不是一个好代码，而是使用上面的代码）

---

在Ruby中，如果不使用self，那么self就是隐含的。我将以您的代码为例

在代码中，键入self.each。如果您只需编写

每个
，它也会工作。您的代码片段如下所示：

def sum
  result = 0
  each do |x|
    result += x
  end
  result
end

class Array
  def sum
    total = 0.0
    self.each {|x| total += x if ["Fixnum", "Float"].include?(x.class.name)}
    total%1==0 ? total.to_i : total
  end
end

a = [1, 2, 3, "y"]
b = [2, "z", 4.3]

puts a.sum #=> 6
puts b.sum #=> 6.3

def sum(array)
    array.reduce(:+)
end

这将以同样的方式工作

[1,2,3,4].sum
#=> 10

为什么?？在这种情况下，
[1,2,3,4]
是
self
，并且因为
每一个
，一个方法，没有被任何东西调用，那么
self
就被暗示了，你的代码被解释为好像你说的是
self.each
。请注意，在这种情况下，与许多人一样，您可能希望键入self.each
，因为这对读者来说更有意义。因此，你在上面写的方式最好。


如果我是你，我现在会探索
inject
。您可以通过调用inject方法来执行方法的操作：

[1,2,3,4].inject { |accum, elem| accum + elem }
#=> 10

更好的是

[1,2,3,4].inject(:+)
#=> 10

我将留给您来探索Ruby的深度，这个非常有趣的方法，以及
inject（：+）
是如何工作的。注意：在互联网上阅读时，
：inject
和
：reduce
是相同的。就像数组的
：count
和
：length
一样。我把
：
放在他们前面，作为关于
注入（：+）
的提示
 我不得不说，你实际上想使用self，而不是排除self。据我所知，在实例中使用self-in-instance方法是首选做法。至于你的求和方法，我可能会这样写：

def sum
  result = 0
  each do |x|
    result += x
  end
  result
end

class Array
  def sum
    total = 0.0
    self.each {|x| total += x if ["Fixnum", "Float"].include?(x.class.name)}
    total%1==0 ? total.to_i : total
  end
end

a = [1, 2, 3, "y"]
b = [2, "z", 4.3]

puts a.sum #=> 6
puts b.sum #=> 6.3

def sum(array)
    array.reduce(:+)
end

所以我要做的是通过在sum方法中传递一个参数，而不是使用.self方法，让这段代码正常工作。有什么帮助吗

我相信你真的很困惑。至少有两种方法（我希望您关注）：


实例方法
自由方法（在
内核
类中定义的方法）


在您的情况下，您真正想要的是一个自由方法（不受
数组
类的限制），可以这样定义：

def sum
  result = 0
  each do |x|
    result += x
  end
  result
end

class Array
  def sum
    total = 0.0
    self.each {|x| total += x if ["Fixnum", "Float"].include?(x.class.name)}
    total%1==0 ? total.to_i : total
  end
end

a = [1, 2, 3, "y"]
b = [2, "z", 4.3]

puts a.sum #=> 6
puts b.sum #=> 6.3

def sum(array)
    array.reduce(:+)
end

用起来像：

sum([1, 2, 3])
# => 6

我建议您改为使用实例方法版本：

class Array
    def sum
        reduce(:+)
    end
end

然后像这样使用它：

[1, 2, 3].sum
# => 6

你为什么要那样做？使用self是首选方法。请注意，sum不是class方法。这是一个实例方法。（不想学究气，只是不想让提问者感到困惑）。我看到你实际上只对固定数和浮动数求和。我认为，该方法最好不要让用户对数组中的内容过于随意。只对数字求和很酷，但你可能需要另一种方法。不过我可能错了。