Ruby 组合多个“elsif”语句

我尝试用Ruby编程蛇。为了让自己更熟悉Ruby。我通过将蛇的X和Y值保存在两个1D数组（一个用于X值，一个用于Y值）中来定义蛇的每个部分的位置

 $x = [2,...]
 $y = [2,...]

我忘了告诉你的是，蛇头在用户输入中移动，而其他蛇头只是从前面的部分继承它的位置，就像这样

def length(f)
if $length >= f
    $y[f] = $y[f-1]
    $x[f] = $x[f-1]
end
end

为了给蛇提供一个活动的空间，我编写了这个程序

for a in (1..20)  
  for b in (1..20)
    print " X "
  end  
  puts" "  
end

这给了我一个20*20的字段

然后我试着在场地上展示蛇的每一部分，同时在场地周围画一个寄宿者

for a in (1..20)
for b in (1..20)
    if a == 1 || a == 20
        if b == 1 || b == 20
            print " + "
        else
            print " - "
        end
    elsif b == 1 || b == 20
        print " | "
    elsif a == $x[0] && b == $y[0]
        body
    elsif a == $x[1] && b == $y[1]
        body
    elsif a == $x[2] && b == $y[2]
        body
    elsif a == $x[3] && b == $y[3]
        body
    elsif a == $x[4] && b == $y[4]
        body
    else
        print "   "  
    end

end
puts""
end

这是可行的，但是如果用户真的很好/有很多空闲时间，我需要分配elsif，因为每个人都代表蛇的一部分，如果蛇的长度限制为100，我需要做100个elsif声明。正文如下：

def body
print " # ".green
end

我试着用这样的for循环来修复它：

for c in (1..100)
  if a == $x[c] && b == $y[c]
    body
  end
end

(1..20).each do |a|
  (1..20).each do |b|
    if [1, 20].include?(a)
      print([1, 20].include?(b) ? ' + ' : ' - ')

    elsif (1..100).any? { |i| a == $x[i] && b == $y[i] }
      body

    else
      print('   ')
    end

    puts('')
  end
end

还有这个

 loop do  
    $x.size.times do |index|
        if $x[index] == a && $y[index] == b
            body
        end
    end
    break
 end

但令人遗憾的是，这并没有给出预期的结果，因为这干扰了吸引球场边界的IFT

for a in (1..20)
for b in (1..20)
    if a == 1 || a == 20
        if b == 1 || b == 20
            print " + "
        else
            print " - "
        end
    elsif b == 1 || b == 20
        print " | "
    elsif a == $x[0] && b == $y[0]
        body
    elsif a == $x[1] && b == $y[1]
        body
    elsif a == $x[2] && b == $y[2]
        body
    elsif a == $x[3] && b == $y[3]
        body
    elsif a == $x[4] && b == $y[4]
        body
    else
        print "   "  
    end

end
puts""
end

有没有办法组合这些多个elsif语句

---

我们将不胜感激。很抱歉在初稿中含糊不清。

我将从以下内容开始：

for c in (1..100)
  if a == $x[c] && b == $y[c]
    body
  end
end

(1..20).each do |a|
  (1..20).each do |b|
    if [1, 20].include?(a)
      print([1, 20].include?(b) ? ' + ' : ' - ')

    elsif (1..100).any? { |i| a == $x[i] && b == $y[i] }
      body

    else
      print('   ')
    end

    puts('')
  end
end

---

我将从以下内容开始：

for c in (1..100)
  if a == $x[c] && b == $y[c]
    body
  end
end

(1..20).each do |a|
  (1..20).each do |b|
    if [1, 20].include?(a)
      print([1, 20].include?(b) ? ' + ' : ' - ')

    elsif (1..100).any? { |i| a == $x[i] && b == $y[i] }
      body

    else
      print('   ')
    end

    puts('')
  end
end

建议的重构 注意：您在原始帖子中没有包含任何样本数据，因此您的答案里程会有所不同

你有很多问题，而不仅仅是一个。除了不枯燥之外，您的代码也不是很容易测试，因为它没有分解成离散的操作。您可以而且可能应该做很多事情：

将你的身体材料分解成离散的方法。 使用数组或枚举器方法简化数据。 使用动态方法在数组上循环，而不是固定范围或循环。 在循环中使用case/when语句处理同一变量的多个条件。 简言之，您需要将代码重构为更模块化的代码，并利用该语言对数据对象进行迭代，而不是像目前这样对每个元素使用一个条件

简化数据集并按程序处理

作为一个例子，考虑如下：

def handle_matched_values array
end

def handle_mismatched_values array
end

paired_array = a.zip b

matched_pairs   = paired_array.select { |subarray| subarray[0] == subarray[1] }
unmatched_pairs = paired_array.reject { |subarray| subarray[0] == subarray[1] }

matched_pairs.each { |pair| handle_matched_values pair }
matched_pairs.each { |pair| handle_mismatched_values pair }

在本例中，您甚至可能不需要if语句。相反，您可以使用或查找与所需条件匹配的索引，然后调用相关的处理程序以获得结果。这具有非常程序化的优点，并且可以非常清楚地显示哪些数据集和处理程序是成对的。它的可读性也很强，这一点非常重要

动态循环和Case语句 如果您确实需要在单个循环中处理数据，请使用case语句来清理您的条件。例如：

# Extract methods to handle each case.
def do_something_with data; end
def do_something_else_with data; end
def handle_borders data; end

# Construct your data any way you want.
paired_array  = a.zip b

# Loop over your data to evaluate each pair of values.
paired_array.each do |pair|
  case pair
  when a == b
    do_something_with pair
  when a == paired_array.first || paired_array.last
     handle_borders pair
  else
     do_something_else_with pair
  end
end

当然，还有很多其他方法可以两两处理大型数据集。目标是为您提供重构代码的基本结构。剩下的就看你了

建议的重构 注意：您在原始帖子中没有包含任何样本数据，因此您的答案里程会有所不同

你有很多问题，而不仅仅是一个。除了不枯燥之外，您的代码也不是很容易测试，因为它没有分解成离散的操作。您可以而且可能应该做很多事情：

将你的身体材料分解成离散的方法。 使用数组或枚举器方法简化数据。 使用动态方法在数组上循环，而不是固定范围或循环。 在循环中使用case/when语句处理同一变量的多个条件。 简言之，您需要将代码重构为更模块化的代码，并利用该语言对数据对象进行迭代，而不是像目前这样对每个元素使用一个条件

简化数据集并按程序处理

作为一个例子，考虑如下：

def handle_matched_values array
end

def handle_mismatched_values array
end

paired_array = a.zip b

matched_pairs   = paired_array.select { |subarray| subarray[0] == subarray[1] }
unmatched_pairs = paired_array.reject { |subarray| subarray[0] == subarray[1] }

matched_pairs.each { |pair| handle_matched_values pair }
matched_pairs.each { |pair| handle_mismatched_values pair }

在本例中，您甚至可能不需要if语句。相反，您可以使用或查找与所需条件匹配的索引，然后调用相关的处理程序以获得结果。这具有非常程序化的优点，并且可以非常清楚地显示哪些数据集和处理程序是成对的。它的可读性也很强，这一点非常重要

动态循环和Case语句 如果您确实需要在单个循环中处理数据，请使用case语句来清理您的条件。例如：

# Extract methods to handle each case.
def do_something_with data; end
def do_something_else_with data; end
def handle_borders data; end

# Construct your data any way you want.
paired_array  = a.zip b

# Loop over your data to evaluate each pair of values.
paired_array.each do |pair|
  case pair
  when a == b
    do_something_with pair
  when a == paired_array.first || paired_array.last
     handle_borders pair
  else
     do_something_else_with pair
  end
end

---

当然，还有很多其他方法可以两两处理大型数据集。目标是为您提供重构代码的基本结构。剩下的就看你了

我想这将是一个解决方案，即使它不是那么先进

 loop do  
    $x.size.times do |index|
        if $x[index] == a && $y[index] == b
            body
        end
    end
    break
 end

---

我想这将是一个解决方案，即使它不是那么先进

 loop do  
    $x.size.times do |index|
        if $x[index] == a && $y[index] == b
            body
        end
    end
    break
 end

---

在Ruby中，尽可能避免使用全局变量，如$x，这一点很重要。$prefix与Perl或PHP不同，Perl或PHP表示变量。@tadman我使用$x

---

因为我需要在函数中引用它。我添加了这一部分是为了更容易理解。这就是为什么函数采用参数，或者如果这仍然不方便的话，对象具有至少包含在作用域中的@x之类的实例变量。关于实例变量的新内容是否适用于定义函数？例如，它们是类上下文中的实例方法。只要对象实例存在，它们就会一直存在。在Ruby中，尽可能避免使用全局变量，如$x，这一点很重要。$prefix与Perl或PHP不同，Perl或PHP表示变量。@tadman我使用$x是因为我需要在函数中引用它。我添加了这一部分是为了更容易理解。这就是为什么函数采用参数，或者如果这仍然不方便的话，对象具有至少包含在作用域中的@x之类的实例变量。关于实例变量的新内容是否适用于定义函数？例如，它们是类上下文中的实例方法。只要对象实例存在，它们就会一直存在。这有助于保存从一个方法调用到另一个方法调用的数据。这是一个很好的进步，但隔离装箱代码以环绕任意字符串列表可能会更清楚。这是一个很好的进步，但是，隔离装箱代码来包装任意的字符串列表可能会更清楚。我试图修复我的帖子，使其更具体、更容易理解。在第一个版本中，我忘了告诉他们我只是为了好玩而编写代码，我在蛇的游戏中使用了这些代码。非常感谢你的回答，我一直在努力改进你指出的问题，非常感谢。我试图修改我的帖子，使它更具体，更容易理解。在第一个版本中，我忘了告诉他们我只是为了好玩而编写代码，我在蛇的游戏中使用了这些代码。非常感谢你的回答，我一直在努力改进你指出的问题，非常感谢。