在Ruby核心类的自定义属性中保存数据（编程风格建议）

在编写Ruby方法以生成非重复字符字符串的排列时偶然发现了这一点：

类字符串
def置换
@结果_数组=[]
递归（“，self.each\u char.to\u a）
@结果数组
结束
def递归（前置字符、子数组）
子数组。每个{124; c|
递归（前置字符+c，子数组-[c]）
}
@结果\u array如果您不知道自己的工具，则不应更改核心类。只有那些确切知道发生了什么事情的人才能做到这一点

因此，我的建议是：在你真的必须这样做之前不要这样做

core Ruby中几乎所有的东西都有解决方案：

"abc".split('').permutation.map(&:join)
=> ["abc", "acb", "bac", "bca", "cab", "cba"]

如果您不了解自己的工具，则不应更改核心类。只有那些确切知道发生了什么事情的人才能做到这一点

因此，我的建议是：在你真的必须这样做之前不要这样做

core Ruby中几乎所有的东西都有解决方案：

"abc".split('').permutation.map(&:join)
=> ["abc", "acb", "bac", "bca", "cab", "cba"]

如果您不了解自己的工具，则不应更改核心类。只有那些确切知道发生了什么事情的人才能做到这一点

因此，我的建议是：在你真的必须这样做之前不要这样做

core Ruby中几乎所有的东西都有解决方案：

"abc".split('').permutation.map(&:join)
=> ["abc", "acb", "bac", "bca", "cab", "cba"]

如果您不了解自己的工具，则不应更改核心类。只有那些确切知道发生了什么事情的人才能做到这一点

因此，我的建议是：在你真的必须这样做之前不要这样做

core Ruby中几乎所有的东西都有解决方案：

"abc".split('').permutation.map(&:join)
=> ["abc", "acb", "bac", "bca", "cab", "cba"]

忽略可以对逻辑进行的改进，下面是如何重写逻辑，而不向类中添加不必要的实例变量或函数：

class String
    def permutations
        result = []
        recurse = lambda do |pre, sub|
            sub.each { |c| recurse[pre + c, sub - [c]] }
            result << pre if sub.empty?
        end
        recurse['', each_char.to_a]
        result
    end
end

'abc'.permutations

类字符串
def置换
结果=[]
递归=lambda do | pre，sub|
sub.each{c |递归[pre+c，sub-[c]}
结果忽略可以对逻辑进行的改进，下面是如何在不向类中添加不必要的实例变量或函数的情况下重写它：

class String
    def permutations
        result = []
        recurse = lambda do |pre, sub|
            sub.each { |c| recurse[pre + c, sub - [c]] }
            result << pre if sub.empty?
        end
        recurse['', each_char.to_a]
        result
    end
end

'abc'.permutations

类字符串
def置换
结果=[]
递归=lambda do | pre，sub|
sub.each{c |递归[pre+c，sub-[c]}
结果忽略可以对逻辑进行的改进，下面是如何在不向类中添加不必要的实例变量或函数的情况下重写它：

class String
    def permutations
        result = []
        recurse = lambda do |pre, sub|
            sub.each { |c| recurse[pre + c, sub - [c]] }
            result << pre if sub.empty?
        end
        recurse['', each_char.to_a]
        result
    end
end

'abc'.permutations

类字符串
def置换
结果=[]
递归=lambda do | pre，sub|
sub.each{c |递归[pre+c，sub-[c]}
结果忽略可以对逻辑进行的改进，下面是如何在不向类中添加不必要的实例变量或函数的情况下重写它：

class String
    def permutations
        result = []
        recurse = lambda do |pre, sub|
            sub.each { |c| recurse[pre + c, sub - [c]] }
            result << pre if sub.empty?
        end
        recurse['', each_char.to_a]
        result
    end
end

'abc'.permutations

类字符串
def置换
结果=[]
递归=lambda do | pre，sub|
sub.each{c |递归[pre+c，sub-[c]}
结果一般来说，如果您正在打开现有代码，添加一个属性并不一定不好，但在这种情况下，它不是必需的。您应该能够编写一个实际返回结果的递归函数；研究使用
inject
而不是
each
。@JacobM我试图用inject重写它；不知怎的，我就是不能，也许我还不足以把它翻译成注射剂。你能推荐一些指针吗？一般来说，如果你正在打开现有的代码，添加一个属性并不一定不好，但是在这种情况下，它不是必需的。您应该能够编写一个实际返回结果的递归函数；研究使用
inject
而不是
each
。@JacobM我试图用inject重写它；不知怎的，我就是不能，也许我还不足以把它翻译成注射剂。你能推荐一些指针吗？一般来说，如果你正在打开现有的代码，添加一个属性并不一定不好，但是在这种情况下，它不是必需的。您应该能够编写一个实际返回结果的递归函数；研究使用
inject
而不是
each
。@JacobM我试图用inject重写它；不知怎的，我就是不能，也许我还不足以把它翻译成注射剂。你能推荐一些指针吗？一般来说，如果你正在打开现有的代码，添加一个属性并不一定不好，但是在这种情况下，它不是必需的。您应该能够编写一个实际返回结果的递归函数；研究使用
inject
而不是
each
。@JacobM我试图用inject重写它；不知怎的，我就是不能，也许我还不足以把它翻译成注射剂。你能给我一些建议吗？哦，我真的不知道lambda可以这样使用！非常感谢，在看到这段代码之前，我一直对它的作用域感到困惑。毕竟，它的代码可以被视为在其定义的同一范围内，只是它被封闭并有一个名称，以便可以调用它！出于好奇，你能解释一下如何改进我共享的代码吗？我似乎遗漏了一些明显的东西？（注意：我是Ruby的新手，所以如果它的代码太傻，请原谅）如果您的目标是创建置换算法，那么您的代码就可以了。如果你只是想置换一些东西，那么不要重新发明轮子：使用Ruby的内置方法，就像phoet的回答一样。是的，我的目的只是创建置换算法。性能和优雅是我非常珍视的东西，所以我一直在思考通过这个实现是否有我忽略的东西，我可以改进它。无论如何，谢谢你的时间。哦，我真的不知道lambda's可以这样使用！非常感谢，在看到这段代码之前，我一直对它的作用域感到困惑。毕竟，它的代码可以被视为在其定义的同一范围内，只是它被封闭并有一个名称，以便可以调用它！出于好奇，你能解释一下如何改进我共享的代码吗？我似乎遗漏了一些明显的东西？（注意：我是Ruby的新手，所以如果它的代码太傻，请原谅）如果您的目标是创建置换算法