Ruby 为什么阵法要洗牌！不使用嵌套数组？

在这里，我想看看

Array#shuffle用于数组对象。所以我开始在我的
IRB
中使用它：

在上面的代码中，我理解了它是如何工作的。下面我试着用更难的方式从每个角落看到它

[1,2,5]
#=> [1, 2, 5]
[1,2,5]<<[1,2,5]
#=> [1, 2, 5, [1, 2, 5]]

对于上面的代码，我感到困惑。因此，我脑海中出现了以下问题：


（a） 为什么
洗牌不是递归工作的吗？正如我所预料的，内部数组
[1，2，5]
的输出也将被洗牌。但事实并非如此

（b） 为什么
洗牌
不洗牌元素数组
[1，2，5]
，而只对数组
[1，2，5，
元素
[1，2，5，[1，2，5]
？我认为输出应该是
[[1,2,5]，5,1,2]
。那么为什么元素数组没有改变它的位置，而只是普通元素改变了它的位置呢


编辑：

它表现出非常有趣的行为：

a=[1,2,4]
#=> [1, 2, 4]
a<<[7,8]
#=> [1, 2, 4, [7, 8]]
a.shuffle!
#=> [[7, 8], 1, 4, 2]
a.shuffle!
#=> [4, 1, [7, 8], 2]
a.shuffle!
#=> [[7, 8], 2, 1, 4]
irb(main):006:0>

a=[1,2,4]
#=> [1, 2, 4]
a[[7,8]，1,4,2]
a、 洗牌！
#=> [4, 1, [7, 8], 2]
a、 洗牌！
#=> [[7, 8], 2, 1, 4]
irb（主要）：006:0>

洗牌真的遵循任何顺序还是随机洗牌
 a）
洗牌更改数组中对象的顺序，这可以是任何内容的集合，因此该方法不能假设数组中的内容也可以或应该被洗牌

b） 我真的不明白这个问题与a有什么不同。你能解释一下你认为什么让人困惑吗？
a）
shuffle更改数组中对象的顺序，这可以是任何内容的集合，因此该方法不能假设数组中的内容也可以或应该被洗牌

b） 我真的不明白这个问题与a有什么不同。你能解释一下你认为什么是令人困惑的吗？
a）为什么要
洗牌递归行为？它作用于它所传递的对象，在您的示例中，该对象是一个由4项组成的数组——它将它们洗牌。其中一个是数组的事实不在这里也不在那里，其中一个可能是一头驴

b） 它会洗牌数组元素，你应该多次尝试你的小IRB测试，你会发现数组只是没有按机会移动

关于你的编辑，你到底想在这里展示什么，我看不到任何有趣的行为？没有模式，洗牌是伪随机的。
a）为什么要
洗牌递归行为？它作用于它所传递的对象，在您的示例中，该对象是一个由4项组成的数组——它将它们洗牌。其中一个是数组的事实不在这里也不在那里，其中一个可能是一头驴

b） 它会洗牌数组元素，你应该多次尝试你的小IRB测试，你会发现数组只是没有按机会移动

关于你的编辑，你到底想在这里展示什么，我看不到任何有趣的行为？没有模式，洗牌是伪随机的。
如果确实希望递归洗牌数组，则没有问题：

# encoding: utf-8

a = [1,2,3]
a << [6,7,8]

class Array
  alias shuffle_orig shuffle
  def shuffle
    self.shuffle_orig.map { |e| e.respond_to?(:shuffle) ? e.shuffle : e }
  end
end


3.times do
  p a.shuffle
end

bang版本也可能是monckey补丁。
如果确实希望递归地洗牌数组，则没有问题：

# encoding: utf-8

a = [1,2,3]
a << [6,7,8]

class Array
  alias shuffle_orig shuffle
  def shuffle
    self.shuffle_orig.map { |e| e.respond_to?(:shuffle) ? e.shuffle : e }
  end
end


3.times do
  p a.shuffle
end

a=[1,2,4]
#=> [1, 2, 4]
a<<[7,8]

a.each_with_index do |element, index|

  puts "Index: #{index} element: #{element}"
end

bang版本也可能是monckey补丁

a=[1,2,4]
#=> [1, 2, 4]
a<<[7,8]

a.each_with_index do |element, index|

  puts "Index: #{index} element: #{element}"
end

附加数组
[7,8]
被视为1个对象，因此其内部的元素不会像数组
a
中的元素那样被洗牌

附加数组
[7,8]
被视为1个对象，因此其内部的元素不会像数组
a
中的元素那样被洗牌
 我相信您可以想象这样一种情况：需要对一组数组的顺序进行洗牌，这些数组的顺序很重要。在这种情况下，shuffle非常方便，如果您需要更改，可以使用shuffle方法轻松实现递归shuffle。但是，如果Ruby只包含一个递归洗牌，那么您就必须编写原始的非递归洗牌方法的逻辑，并且不能用递归洗牌方法优雅地实现一个解决方案。我认为大多数语言都喜欢使用简单、通用的方法，而不是更复杂的方法。
我相信您可以想象这样一种情况，即需要对顺序非常重要的一组数组的顺序进行无序排列。在这种情况下，shuffle非常方便，如果您需要更改，可以使用shuffle方法轻松实现递归shuffle。但是，如果Ruby只包含一个递归洗牌，那么您就必须编写原始的非递归洗牌方法的逻辑，并且不能用递归洗牌方法优雅地实现一个解决方案。我认为与更复杂的方法相比，大多数语言更喜欢简单、多功能的方法。
查看文档和源代码（），它表明这种混乱是随机的。您希望它是什么？查看文档和源代码（），它表明洗牌是随机的。你希望它是什么？
a=[1,2,4]
#=> [1, 2, 4]
a<<[7,8]

a.each_with_index do |element, index|

  puts "Index: #{index} element: #{element}"
end

Index: 0 element: 1
Index: 1 element: 2
Index: 2 element: 4
Index: 3 element: [7, 8]