在Ruby中使用元组？

有人在Ruby中使用元组吗？如果是这样，如何实现元组？Ruby哈希很好，几乎也可以工作，但我真的希望看到类似Python中的Tuple类的东西，您可以使用

表示法来查找要查找的值。我想要这个，这样我就可以创建的实现，类似于Python

简要示例：

require 'ostruct'

person = OpenStruct.new
person.name    = "John Smith"
person.age     = 70
person.pension = 300

puts person.name     # -> "John Smith"
puts person.age      # -> 70
puts person.address  # -> nil

---

基于您谈论哈希和。符号我假设你指的是一种不同于

（1.“a”）

排序的元组。您可能正在寻找

Struct

类。例如：

Person = Struct.new(:name, :age)
me = Person.new
me.name = "Guy"
me.age =  30

---

虽然这不是严格意义上的元组（不能用点表示成员），但您可以从列表中分配变量列表，这通常可以解决ruby在处理返回值列表时通过值传递的问题

例如

---

你可以做一些类似于解构的事情：

def something((a, b))
  a + b
end

p something([1, 2])

2.2.5 :012 > a, b = t
 => {:_1=>"a", :_2=>"b"}
2.2.5 :013 > a
 => {:_1=>"a", :_2=>"b"}
2.2.5 :014 > b
 => nil

这将按预期打印出

3

。

我是这本书的作者

您将获得两个类：

• 元组

  一般

• 尤其是配对

您可以用不同的方式初始化它们：

Tuple.new(1, 2)
Tuple.new([1, 2])
Tuple(1, 2)
Tuple([1, 2])
Tuple[1, 2]

这两个类都有一些辅助方法：

• length

  /

  arity

  -返回元组中的值数

• 第一个

  /

  最后一个

  /

  第二个

  （仅对）-返回相应的元素

• []

  允许您访问特定元素的

---

您可以使用以下技巧模拟Scala元组：

Tuple = Struct.new(:_1, :_2)

2.2.5 :003 > t = Tuple.new("a", "b")
 => #<struct Tuple _1="a", _2="b">
2.2.5 :004 > t._1
 => "a"
2.2.5 :005 > t._2
 => "b"

但多亏了这个技巧： 分解结构将起作用：

2.2.5 :001 > Tuple = Struct.new(:_1, :_2)
 => Tuple
2.2.5 :002 > t = Tuple.new("a", "b")
 => #<struct Tuple _1="a", _2="b">
2.2.5 :003 > t._1
 => "a"
2.2.5 :004 > class Tuple ; def to_ary ; to_a ; end ; end
 => :to_ary
2.2.5 :005 > a, b = t
 => #<struct Tuple _1="a", _2="b">
2.2.5 :006 > a
 => "a"
2.2.5 :007 > b
 => "b"

2.2.5:001>Tuple=Struct.new（：_1，：_2）
=>元组
2.2.5:002>t=Tuple.new（“a”、“b”）
=> #
2.2.5:003>t.\U 1
=>“a”
2.2.5:004>类元组；定义为"ary",；到a；结束；结束
=>：至
2.2.5:005>a，b=t
=> #
2.2.5:006>a
=>“a”
2.2.5:007>b
=>“b”

由于解构，数组很适合用作元组

a=[[1,2]，[2,3]，[3,4]]
a、 映射{a，b{a+b}

结构为您提供方便的

访问器

Person=Struct.new（：first\u name，：last\u name）
ppl=Person.new（'John'、'Connor'）
第一名
ppl.姓

您可以通过

to\u ary

Person=Struct.new（：first\u name，：last\u name）do
def至ary
[名字，姓氏]
结束
结束
# =>
[
Person.new（'John'，'Connor'），
Person.new（'John'，'Conway'）
].map{a，b{a+''+b}
#=>[“约翰·康纳”、“约翰·康威”]

这正是我想要的。谢谢np:）回答你们的问题：不，我不在ruby中使用元组，作为openstructs或其他。我在高端使用类，在低端使用散列：）这是一个糟糕的答案，只是一个链接？认真地如果/当链接断开时会发生什么？这甚至不是您在这里公开的元组概念。只是一个数据结构。无法理解您的解决方案是如何最有效的upvoted@JulesIvanic有效的评论，但有时一个OP不知道如何正确地为一个问题制定一个标题，在这种情况下，这实际上是OP寻找的答案：）很接近，但不得不命名它让我感到困扰。我在寻找类似于（1。“a”）排序的东西，但使用您描述的属性get/set符号。@panesofglass，无需命名任何东西：a=Struct.new（：name，：age）.new；a、 name=“Guy”我可以设置

a=Struct.new（：name，：age）

然后说a.new吗？我想是的。我得检查一下。关于我想要什么，这将更加明确。几年后发现，我可以确认

Person.new（“Guy”，30）

除了单独设置字段外，还可以工作。你曾经在Ruby中实现过D吗？如果有，你有它的链接吗？我最近一直在做类似的事情，我很想看看你到目前为止都做了些什么；我从来没有走那么远。我一直在绕着其他几件事转，试图回到过去。我确实找到了几个似乎有用的图书馆：LazyList和arel。我基本上得出结论，LINQ在.NET中几乎就在那里，然后找到了arel，这也很接近。使用LazyList并删除直接到SQL的转换（后者也是项目的目标）几乎可以实现这一目标。也就是说，我很想看看你们到目前为止都做了些什么。野心是另一个看起来很有趣的图书馆，但它已经有一段时间没有更新了。那是我第一个找到的。阿雷尔似乎延续了同样的传统。我刚刚开始了一个名为veritas的项目来研究这一点：现在还为时过早。如果情况良好，我可以更新DATAMAPER来使用它作为基础。我对在核心中支持雄心勃勃的语法并不感兴趣，因为您只能在1.8中使用ParseTree，但我为DataMapper编写的插件不会有问题：我应该补充一点，我正在考虑更新底层实现，以使用元组的结构对象来优化内存使用，但目前我更关心的是正确性和指定公共API。只需在传递给

Struct.new

之类的块中定义destructing accessor方法，就可以稍微减少混淆

2.2.5 :001 > Tuple = Struct.new(:_1, :_2)
 => Tuple
2.2.5 :002 > t = Tuple.new("a", "b")
 => #<struct Tuple _1="a", _2="b">
2.2.5 :003 > t._1
 => "a"
2.2.5 :004 > class Tuple ; def to_ary ; to_a ; end ; end
 => :to_ary
2.2.5 :005 > a, b = t
 => #<struct Tuple _1="a", _2="b">
2.2.5 :006 > a
 => "a"
2.2.5 :007 > b
 => "b"