Arrays 在这种情况下如何使用Ruby数组？

下面是一个ruby数组：

array=['x'，3,0,4,4,7]

我想通过

array

进行映射，将数组中的每个整数（除了

0

）减去2，然后返回一个新数组

如果有字母，则不会对字母进行更改

示例输出：

['x', 1, 0, 2, 2, 5]

这就是我所拥有的，但我收到的错误消息是“undefined method integer？”有人能告诉我问题出在哪里吗

    def minusNumber(array)
     array.map do |e|
      if e.integer? && e !== 0
      e - 2
      end
     end
    end

---

如上所述，您应该使用

is\u？

方法检查元素的数据类型。以下代码应按预期工作：

 def minusNumber(array)
   array.map do |e|
     if e.is_a?(String) || e == 0
       e
     else
       e - 2
     end
   end
 end

除了if语句，您还可以执行以下操作：

(e.is_a?(String) || e == 0 ) ? e : e-2

---

请注意，原始对象是不变的，除非您使用

map

正如上面的评论中所提到的，您应该使用

是一种？

方法来检查元素的数据类型。以下代码应按预期工作：

 def minusNumber(array)
   array.map do |e|
     if e.is_a?(String) || e == 0
       e
     else
       e - 2
     end
   end
 end

除了if语句，您还可以执行以下操作：

(e.is_a?(String) || e == 0 ) ? e : e-2

---

请注意，原始对象是不变的，除非您使用

map
这是另一种观点：

array = ['x', 3, 0, 4, 4, 7]

transformed = array.map do |e|
  case e
  when 0, String
    e
  when Integer
    e - 2
  else
    fail 'unexpected input'
  end
end

transformed # => ["x", 1, 0, 2, 2, 5]


遗憾的是，你必须保留你没有减去2的元素。我真的很想做这样的事情

array.grep(Integer).reject(&:zero?).map{|i| i - 2 } # => [1, 2, 2, 5]

还找不到保存未处理项目的方法。
下面是另一种方法：

array = ['x', 3, 0, 4, 4, 7]

transformed = array.map do |e|
  case e
  when 0, String
    e
  when Integer
    e - 2
  else
    fail 'unexpected input'
  end
end

transformed # => ["x", 1, 0, 2, 2, 5]


遗憾的是，你必须保留你没有减去2的元素。我真的很想做这样的事情

array.grep(Integer).reject(&:zero?).map{|i| i - 2 } # => [1, 2, 2, 5]

还找不到保存未处理项目的方法。
又短又甜

array.map { |v| v.is_a?(Integer) && !v.zero? ? v - 2 : v }

这消除了所有不必要的
case
语句、多次迭代和转换。只要取每个元素，如果它是整数且大于0，则减去2，否则什么也不做。
简短而甜蜜

array.map { |v| v.is_a?(Integer) && !v.zero? ? v - 2 : v }

这消除了所有不必要的
case
语句、多次迭代和转换。只需获取每个元素，如果它是整数且大于0，则减去2，否则什么也不做。
此处的其他答案将适用于您当前的输入。比如：

def minusNumber(array)
  array.map do |e|
    if e.is_a?(Integer) && e != 0
      e - 2
    else
      e
    end
  end
end

但这里有一个更灵活的解决方案。这对你现在的处境来说可能有点太高级了，但所有的学习都是好的学习：-）

Ruby是一种允许变量具有多态性的语言。使用方法的示例输入，您可以看到变量
e
可能包含
字符串
对象或
整数
对象。但它实际上可能包含任何类型的对象，Ruby一点也不在乎，除非它在使用变量时遇到错误

所以。在您的示例中，需要在输出中保持
整数
s。但是如果将来您需要传入一个包含一些
Score
对象的数组，并且您的输出中也需要这些对象，该怎么办？这是一个全新的类，你甚至还没有写过，但你知道你以后会写的。有一种方法可以让你重新编写你的方法来预测这个未来的类，以及你将来可能编写的所有其他
Integer
类型的类

不要使用
#is#a？
检查对象的类型，而要使用
#respond#u to？
检查它实现了哪些方法

可以用作整数的任何类
Integer
当然会，你未来的
分数会，但
String
不会。任何其他不能被视为整数的类也是如此。因此，这将适用于所有类型的值，正确区分响应
#to_int
的值和不响应的值

def minusNumber(array)
  array.map do |e|
    if e.respond_to?(:to_int) && e != 0
      e - 2
    else
      e
    end
  end
end

同样，这些东西可能有点先进，但最好养成习惯，尽早根据变量的方法而不是类型来思考变量。这种思维方式将真正帮助您以后解决问题。
这里的其他答案将与您当前的输入配合使用。比如：

def minusNumber(array)
  array.map do |e|
    if e.is_a?(Integer) && e != 0
      e - 2
    else
      e
    end
  end
end

但这里有一个更灵活的解决方案。这对你现在的处境来说可能有点太高级了，但所有的学习都是好的学习：-）

Ruby是一种允许变量具有多态性的语言。使用方法的示例输入，您可以看到变量
e
可能包含
字符串
对象或
整数
对象。但它实际上可能包含任何类型的对象，Ruby一点也不在乎，除非它在使用变量时遇到错误

所以。在您的示例中，需要在输出中保持
整数
s。但是如果将来您需要传入一个包含一些
Score
对象的数组，并且您的输出中也需要这些对象，该怎么办？这是一个全新的类，你甚至还没有写过，但你知道你以后会写的。有一种方法可以让你重新编写你的方法来预测这个未来的类，以及你将来可能编写的所有其他
Integer
类型的类

不要使用
#is#a？
检查对象的类型，而要使用
#respond#u to？
检查它实现了哪些方法

可以用作整数的任何类
Integer
当然会，你未来的
分数会，但
String
不会。任何其他不能被视为整数的类也是如此。因此，这将适用于所有类型的值，正确区分响应
#to_int
的值和不响应的值

def minusNumber(array)
  array.map do |e|
    if e.respond_to?(:to_int) && e != 0
      e - 2
    else
      e
    end
  end
end

同样，这些东西可能有点先进，但最好养成习惯，尽早根据变量的方法而不是类型来思考变量。这种思维方式在以后会对你有很大帮助。
你可以不用检查类型就可以做到这一点

使用什么样的？是一种代码味道，它表明您的代码是过程性的，而不是面向对象的…

您可以在不检查类型的情况下执行此操作

使用什么样的？是一种代码味道，它表明您的代码是过程性的，而不是面向对象的…

我想