Question

我正在写一个Befunge翻译。我很好奇这种方法的风格有多糟糕。

def adv(r, c, dir, torus)
  case dir
  when 0; r == 0 ? (return torus.n_o_l - 1, c) : (return r - 1, c)
  when 1; c == torus.r_l - 1 ? (return r, 0) : (return r, c + 1)
  when 2; r == torus.n_o_l - 1 ? (return 0, c) : (return r + 1, c)
  when 3; c == 0 ? (return r, torus.r_l - 1) : (return r, c - 1)
  end
end

如果我只需要使用更标准的if / else结构，我知道如何重新格式化它，但我很好奇这在源代码中看起来有多糟糕。

Answer 1

你的代码很糟糕。我会这样做：

def adv(r, c, dir, torus)
  case dir
  when 0
    r = torus.n_o_l if r.zero?
    [r - 1, c]
  when 1
    c = -1 if c == torus.r_l - 1
    [r, c + 1]
  when 2
    r = -1 if r == torus.n_o_l - 1
    [r + 1, c]
  when 3
    c = torus.r_l if c.zero?
    [r, c - 1]
  end
end

Answer 2

我的尝试：

def adv(r, c, dir, torus)
  case dir
  when 0; r == 0 ? [torus.n_o_l - 1, c] : [r - 1, c]
  when 1; c == torus.r_l - 1 ? [r, 0] : [r, c + 1]
  when 2; r == torus.n_o_l - 1 ? [0, c] : [r + 1, c]
  when 3; c == 0 ? [r, torus.r_l - 1] : [r, c - 1]
  end
end

忽略return因为case默认会返回一些内容。

Answer 3

我个人至少将每个操作都删除到自己的方法中。暂时忽略简洁论证，我的主要原因是我可以独立于case语句测试每个操作。

def adv(r, c, dir, torus)
  case dir
  when 0; op1(r, c, torus)
  when 1; op2(r, c, torus)
  when 2; op3(r, c, torus)
  when 3; op4(r, c, torus)
  end
end

def op0(r, c, torus)
  r == 0 ? [torus.n_o_l - 1, c] : [r - 1, c]
end

def op1(r, c, torus)
  c == torus.r_l - 1 ? [r, 0] : [r, c + 1]
end

def op2(r, c, torus)
  r == torus.n_o_l - 1 ? [0, c] : [r + 1, c]
end

def op3(r, c, torus)
  c == 0 ? [r, torus.r_l - 1] : [r, c - 1]
end

至于＆＃34;我个人喜欢我的代码尽可能短＆＃34;，你显然还没知道你应该code like the next developer looking at your code is a psychopath who knows where you live。

不要担心 - 你会学习。

Answer 4

你是在征求意见，所以你的问题对这个世界来说可能不长，但这是我的建议：

def adv(r, c, dir, torus)
  case dir
  when 0
    case r
    when 0 then             [torus.n_o_l-1, c]
    else                    [r-1, c]  
    end
  when 1
    case c     
    when torus.r_l-1 then   [r, 0]
    else                    [r, c+1]
  when 2
    case r
    when torus.n_o_l-1 then [0, c]
    else                    [r+1, c]
  when 3
    case c
    when 0 then             [r, torus.r_l-1]
    else                    [r, c-1]
  end
end

有时候想做的事情不能简化。我希望这就是这种情况。如果你不能把它分解成碎片，你至少可以考虑我们人类如何处理我们阅读的信息。我发现你的代码难以理解，因为返回值在视觉上与条件语句混合在一起。我通过将所有返回值放在一列中来解决这个问题。对于案例陈述中dir的每个值，您可以拥有if ... else ... end或... ? ... : ...或次要案例陈述。我之所以选择最后一个，只是因为我认为它最容易阅读并导致最少的注意力分散＃34;代码混乱＆＃34;。

Answer 5

我建议为变量使用更好的名称 - 什么是r，什么是c？

我最近写了一篇'readable' Befunge interpreter，其中我为方向添加了一个人性友好常数。看起来like this。

DIRECTIONS = {
  right: { x: 1, y: 0 },
  down:  { x: 0, y: 1 },
  left:  { x: -1, y: 0 },
  up:    { x: 0, y: -1 }
}

鉴于该常量，计算指令的下一个位置（下面称为code_pointer）就像这样简单：

# Moves the `code_pointer` in the specified `code_direction`, and returns the modified
# `code_pointer`
#
# @param code_pointer [Hash] the current +code_pointer+, in the form: `{x: 0, y: 3}`
# @param code_direction [Hash] the current +code_direction+, in the form: `{x: 0, y: 1}`
# @return [Hash] the modified `code_pointer`
def move_pointer(code_pointer, code_direction)
  code_pointer[:x] += code_direction[:x]
  code_pointer[:y] += code_direction[:y]

  code_pointer
end

这太令人费解了吗？

5 个答案: