类 Set

这个库提供了 Set 类，它实现了一个不含重复项的无序值集合。它是 Array 直观的互操作功能和 Hash 的快速查找的混合体。

为了方便起见，方法 to_set 被添加到 Enumerable 中。

Set 可以很容易地与 Enumerable 对象（实现 each）一起使用。大多数初始化方法和二元运算符除了集合和数组之外，还接受通用的 Enumerable 对象。可以使用 to_set 方法将 Enumerable 对象转换为 Set。

Set 使用 Hash 作为存储，因此您必须注意以下几点

元素的相等性根据 Object#eql? 和 Object#hash 确定。使用 Set#compare_by_identity 使集合通过其标识比较其元素。
Set 假定每个元素的标识在存储时不会更改。修改集合的元素将使集合处于不可靠的状态。
如果要存储字符串，则会存储该字符串的冻结副本，除非原始字符串已冻结。

比较¶ ↑

比较运算符 <、>、<= 和 >= 实现为 {proper_,}{subset?,superset?} 方法的简写。<=> 运算符反映此顺序，或者对于都具有不同元素的集合（例如 {x, y} 与 {x, z}）返回 nil。

示例¶ ↑

require 'set'
s1 = Set[1, 2]                        #=> #<Set: {1, 2}>
s2 = [1, 2].to_set                    #=> #<Set: {1, 2}>
s1 == s2                              #=> true
s1.add("foo")                         #=> #<Set: {1, 2, "foo"}>
s1.merge([2, 6])                      #=> #<Set: {1, 2, "foo", 6}>
s1.subset?(s2)                        #=> false
s2.subset?(s1)                        #=> true

联系方式¶ ↑

Akinori MUSHA <knu@iDaemons.org>（当前维护者）

这里有什么¶ ↑

首先，其他地方有什么。类 Set

继承自类 Object。
包含模块 Enumerable，它提供了数十种附加方法。

特别是，类 Set 没有很多自己的方法用于获取或迭代。相反，它依赖于 Enumerable 中的方法。

在这里，类 Set 提供了对以下内容有用的方法

创建 Set
Set 操作
比较
查询
赋值
删除
转换
迭代
等等……

创建 Set 的方法¶ ↑

::[]：返回一个包含给定对象的新集合。
::new：返回一个新的集合，该集合包含给定对象（如果没有给出块）或来自调用块的返回值（如果给出了块）。

Set 操作的方法¶ ↑

| （别名为 union 和 +）：返回一个新集合，其中包含 self 的所有元素以及给定可枚举的所有元素（无重复项）。
& （别名为 intersection）：返回一个新集合，其中包含 self 和给定可枚举中所有共同的元素。
- （别名为 difference）：返回 self 的副本，其中删除了给定可枚举中的所有元素。
^：返回一个新集合，其中包含 self 和给定可枚举中的所有元素，除了两者共有的元素。

比较的方法¶ ↑

<=>：如果 self 小于、等于或大于给定对象，则返回 -1、0 或 1。
==：返回 self 和给定可枚举是否相等，由 Object#eql? 确定。
compare_by_identity?：返回集合在比较元素时是否只考虑标识。

查询的方法¶ ↑

length （别名为 size）：返回元素的计数。
empty?：返回集合是否没有元素。
include? （别名为 member? 和 ===）：返回给定对象是否为集合中的元素。
subset? （别名为 <=）：返回给定对象是否为该集合的子集。
proper_subset? （别名为 <）：返回给定可枚举是否为该集合的真子集。
superset? （别名为 >=）：返回给定可枚举是否为该集合的超集。
proper_superset? （别名为 >）：返回给定可枚举是否为该集合的真超集。
disjoint?：如果该集合和给定可枚举没有共同元素，则返回 true，否则返回 false。
intersect?：如果该集合和给定可枚举有任何共同元素，则返回 true，否则返回 false。
compare_by_identity?：返回集合在比较元素时是否只考虑标识。

赋值的方法¶ ↑

add （别名为 <<）：将给定对象添加到集合；返回 self。
add?：如果给定对象不是集合中的元素，则添加它并返回 self；否则，返回 nil。
merge：将每个给定可枚举对象的元素合并到集合中；返回 self。
replace：用给定可枚举的内容替换集合的内容。

删除的方法¶ ↑

clear：删除集合中的所有元素；返回 self。
delete：从集合中删除给定对象；返回 self。
delete?：如果给定对象是集合中的元素，则删除它并返回 self；否则，返回 nil。
subtract：从集合中删除每个给定对象；返回 self。
delete_if - 删除由给定块指定的元素。
select! （别名为 filter!）：删除由给定块未指定的元素。
keep_if：删除由给定块未指定的元素。
reject! 删除由给定块指定的元素。

转换的方法¶ ↑

classify：返回一个哈希，该哈希根据给定的块对元素进行分类。
collect! （别名为 map!）：将每个元素替换为块返回值。
divide：返回一个哈希，该哈希根据给定的块对元素进行分类；与 classify 的不同之处在于，该块可以接受一个或两个参数。
flatten：返回一个新集合，该集合是 self 的递归扁平化。flatten!：用该集合中的元素替换 self 中的每个嵌套集合。
inspect （别名为 to_s）：返回显示元素的字符串。
join：返回一个包含所有元素的字符串，根据需要转换为字符串，并由给定的记录分隔符连接。
to_a：返回一个包含所有集合元素的数组。
to_set：如果未给定任何参数且没有块，则返回 self；如果给定块，则返回一个由块返回值组成的新集合。

迭代的方法¶ ↑

each：使用每个连续元素调用块；返回 self。

其他方法¶ ↑

reset：重置内部状态；如果对象在作为集合中的元素时被修改过，则很有用。

常量

VERSION

公共类方法

[] (*ary)

源代码

# File lib/set.rb, line 228
def self.[](*ary)
  new(ary)
end

创建一个包含给定对象的新集合。

Set[1, 2]                   # => #<Set: {1, 2}>
Set[1, 2, 1]                # => #<Set: {1, 2}>
Set[1, 'c', :s]             # => #<Set: {1, "c", :s}>

json_create (object)

源代码

# File ext/json/lib/json/add/set.rb, line 9
def self.json_create(object)
  new object['a']
end

请参阅 as_json。

new (enum = nil) { |o| ... }

源代码

# File lib/set.rb, line 243
def initialize(enum = nil, &block) # :yields: o
  @hash ||= Hash.new(false)

  enum.nil? and return

  if block
    do_with_enum(enum) { |o| add(block[o]) }
  else
    merge(enum)
  end
end

创建一个包含给定可枚举对象的元素的新集合。

如果给出了一个块，则给定块将预处理 enum 的元素。

Set.new([1, 2])                       #=> #<Set: {1, 2}>
Set.new([1, 2, 1])                    #=> #<Set: {1, 2}>
Set.new([1, 'c', :s])                 #=> #<Set: {1, "c", :s}>
Set.new(1..5)                         #=> #<Set: {1, 2, 3, 4, 5}>
Set.new([1, 2, 3]) { |x| x * x }      #=> #<Set: {1, 4, 9}>

公共实例方法

& (enum)

源代码

# File lib/set.rb, line 643
def &(enum)
  n = self.class.new
  if enum.is_a?(Set)
    if enum.size > size
      each { |o| n.add(o) if enum.include?(o) }
    else
      enum.each { |o| n.add(o) if include?(o) }
    end
  else
    do_with_enum(enum) { |o| n.add(o) if include?(o) }
  end
  n
end

返回一个新集合，其中包含该集合和给定可枚举对象共有的元素。

Set[1, 3, 5] & Set[3, 2, 1]             #=> #<Set: {3, 1}>
Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> #<Set: {"a", "b"}>

也称为别名：intersection

+ (enum)

别名：|

- (enum)

源代码

# File lib/set.rb, line 633
def -(enum)
  dup.subtract(enum)
end

返回一个新集合，该集合通过复制原集合构建，并移除所有在给定可枚举对象中出现的元素。

Set[1, 3, 5] - Set[1, 5]                #=> #<Set: {3}>
Set['a', 'b', 'z'] - ['a', 'c']         #=> #<Set: {"b", "z"}>

也称为别名：difference

< (set)

别名：proper_subset?

<< (o)

别名：add

<= (set)

别名：subset?

<=> (set)

源代码

# File lib/set.rb, line 456
def <=>(set)
  return unless set.is_a?(Set)

  case size <=> set.size
  when -1 then -1 if proper_subset?(set)
  when +1 then +1 if proper_superset?(set)
  else 0 if self.==(set)
  end
end

如果两个集合相等，则返回 0；如果该集合是给定集合的真子集/超集，则返回 -1/+1；如果它们都具有唯一元素，则返回 nil。

== (other)

源代码

# File lib/set.rb, line 677
def ==(other)
  if self.equal?(other)
    true
  elsif other.instance_of?(self.class)
    @hash == other.instance_variable_get(:@hash)
  elsif other.is_a?(Set) && self.size == other.size
    other.all? { |o| @hash.include?(o) }
  else
    false
  end
end

如果两个集合相等，则返回 true。每对元素的相等性根据 Object#eql? 定义。

Set[1, 2] == Set[2, 1]                       #=> true
Set[1, 3, 5] == Set[1, 5]                    #=> false
Set['a', 'b', 'c'] == Set['a', 'c', 'b']     #=> true
Set['a', 'b', 'c'] == ['a', 'c', 'b']        #=> false

=== (o)

如果给定对象是该集合的成员，则返回 true，否则返回 false。

用于 case 语句中

require 'set'

case :apple
when Set[:potato, :carrot]
  "vegetable"
when Set[:apple, :banana]
  "fruit"
end
# => "fruit"

或者单独使用

Set[1, 2, 3] === 2   #=> true
Set[1, 2, 3] === 4   #=> false

别名：include?

> (set)

别名：proper_superset?

>= (set)

别名：superset?

^ (enum)

源代码

# File lib/set.rb, line 664
def ^(enum)
  n = self.class.new(enum)
  each { |o| n.add(o) unless n.delete?(o) }
  n
end

返回一个新集合，其中包含该集合和给定可枚举对象之间独有的元素。(set ^ enum) 等效于 ((set | enum) - (set & enum))。

Set[1, 2] ^ Set[2, 3]                   #=> #<Set: {3, 1}>
Set[1, 'b', 'c'] ^ ['b', 'd']           #=> #<Set: {"d", 1, "c"}>

| (enum)

源代码

# File lib/set.rb, line 622
def |(enum)
  dup.merge(enum)
end

返回一个新集合，该集合通过合并该集合和给定可枚举对象的元素构建。

Set[1, 2, 3] | Set[2, 4, 5]         #=> #<Set: {1, 2, 3, 4, 5}>
Set[1, 5, 'z'] | (1..6)             #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>

也称为别名：+、union

add (o)

源代码

# File lib/set.rb, line 514
def add(o)
  @hash[o] = true
  self
end

将给定对象添加到集合并返回 self。使用 merge 一次添加多个元素。

Set[1, 2].add(3)                    #=> #<Set: {1, 2, 3}>
Set[1, 2].add([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
Set[1, 2].add(2)                    #=> #<Set: {1, 2}>

也称为别名：<<

add? (o)

源代码

# File lib/set.rb, line 526
def add?(o)
  add(o) unless include?(o)
end

将给定对象添加到集合并返回 self。如果对象已在集合中，则返回 nil。

Set[1, 2].add?(3)                    #=> #<Set: {1, 2, 3}>
Set[1, 2].add?([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
Set[1, 2].add?(2)                    #=> nil

as_json (*)

源代码

# File ext/json/lib/json/add/set.rb, line 28
def as_json(*)
  {
    JSON.create_id => self.class.name,
    'a'            => to_a,
  }
end

方法 Set#as_json 和 Set.json_create 可用于序列化和反序列化 Set 对象；请参阅 Marshal。

方法 Set#as_json 序列化 self，返回一个表示 self 的 2 元素哈希

require 'json/add/set'
x = Set.new(%w/foo bar baz/).as_json
# => {"json_class"=>"Set", "a"=>["foo", "bar", "baz"]}

方法 JSON.create 反序列化此类哈希，返回一个 Set 对象

Set.json_create(x) # => #<Set: {"foo", "bar", "baz"}>

classify () { |o| ... }

源代码

# File lib/set.rb, line 746
def classify # :yields: o
  block_given? or return enum_for(__method__) { size }

  h = {}

  each { |i|
    (h[yield(i)] ||= self.class.new).add(i)
  }

  h
end

通过给定块的返回值对集合进行分类，并返回 {值 => 元素集合} 对的哈希。该块为集合的每个元素调用一次，并将该元素作为参数传递。

require 'set'
files = Set.new(Dir.glob("*.rb"))
hash = files.classify { |f| File.mtime(f).year }
hash       #=> {2000=>#<Set: {"a.rb", "b.rb"}>,
           #    2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
           #    2002=>#<Set: {"f.rb"}>}

如果没有给出块，则返回枚举器。

clear ()

源代码

# File lib/set.rb, line 316
def clear
  @hash.clear
  self
end

移除所有元素并返回 self。

set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
set.clear                         #=> #<Set: {}>
set                               #=> #<Set: {}>

collect! () { |o| ... }

源代码

# File lib/set.rb, line 567
def collect!
  block_given? or return enum_for(__method__) { size }
  set = self.class.new
  each { |o| set << yield(o) }
  replace(set)
end

用 collect() 返回的元素替换现有元素。如果没有给出块，则返回枚举器。

也称为别名：map!

compare_by_identity ()

源代码

# File lib/set.rb, line 257
def compare_by_identity
  if @hash.respond_to?(:compare_by_identity)
    @hash.compare_by_identity
    self
  else
    raise NotImplementedError, "#{self.class.name}\##{__method__} is not implemented"
  end
end

使集合通过元素的标识进行比较并返回 self。并非 Set 的所有子类都可能支持此方法。

compare_by_identity? ()

源代码

# File lib/set.rb, line 268
def compare_by_identity?
  @hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity?
end

如果集合将通过元素的标识进行比较，则返回 true。另请参阅 Set#compare_by_identity。

delete (o)

源代码

# File lib/set.rb, line 532
def delete(o)
  @hash.delete(o)
  self
end

从集合中删除给定对象并返回 self。使用 subtract 一次删除多个项目。

delete? (o)

源代码

# File lib/set.rb, line 539
def delete?(o)
  delete(o) if include?(o)
end

从集合中删除给定对象并返回 self。如果对象不在集合中，则返回 nil。

delete_if (&block)

源代码

# File lib/set.rb, line 546
def delete_if(&block)
  block_given? or return enum_for(__method__) { size }
  # Instead of directly using @hash.delete_if, perform enumeration
  # using self.each that subclasses may override.
  select(&block).each { |o| @hash.delete(o) }
  self
end

删除集合中每个块求值为 true 的元素，并返回 self。如果没有给出块，则返回枚举器。

difference (enum)

别名：-

disjoint? (set)

源代码

# File lib/set.rb, line 495
def disjoint?(set)
  !intersect?(set)
end

如果集合和给定可枚举对象没有共同元素，则返回 true。此方法与 intersect? 相反。

Set[1, 2, 3].disjoint? Set[3, 4]   #=> false
Set[1, 2, 3].disjoint? Set[4, 5]   #=> true
Set[1, 2, 3].disjoint? [3, 4]      #=> false
Set[1, 2, 3].disjoint? 4..5        #=> true

divide (&func)

源代码

# File lib/set.rb, line 774
def divide(&func)
  func or return enum_for(__method__) { size }

  if func.arity == 2
    require 'tsort'

    class << dig = {}         # :nodoc:
      include TSort

      alias tsort_each_node each_key
      def tsort_each_child(node, &block)
        fetch(node).each(&block)
      end
    end

    each { |u|
      dig[u] = a = []
      each{ |v| func.call(u, v) and a << v }
    }

    set = Set.new()
    dig.each_strongly_connected_component { |css|
      set.add(self.class.new(css))
    }
    set
  else
    Set.new(classify(&func).values)
  end
end

根据给定块定义的公共性将集合划分为子集集合。

如果块的参数数量为 2，则当 block.call(o1, o2) 为 true 时，元素 o1 和 o2 是公共的。否则，当 block.call(o1) == block.call(o2) 时，元素 o1 和 o2 是公共的。

require 'set'
numbers = Set[1, 3, 4, 6, 9, 10, 11]
set = numbers.divide { |i,j| (i - j).abs == 1 }
set        #=> #<Set: {#<Set: {1}>,
           #           #<Set: {11, 9, 10}>,
           #           #<Set: {3, 4}>,
           #           #<Set: {6}>}>

如果没有给出块，则返回枚举器。

each (&block)

源代码

# File lib/set.rb, line 502
def each(&block)
  block_given? or return enum_for(__method__) { size }
  @hash.each_key(&block)
  self
end

为集合中的每个元素调用给定的块一次，并将该元素作为参数传递。如果没有给出块，则返回枚举器。

empty? ()

源代码

# File lib/set.rb, line 307
def empty?
  @hash.empty?
end

如果集合不包含任何元素，则返回 true。

filter! (&block)

等效于 Set#select!

别名：select!

flatten ()

源代码

# File lib/set.rb, line 380
def flatten
  self.class.new.flatten_merge(self)
end

返回一个新的集合，该集合是该集合的副本，递归地展平每个包含的集合。

flatten! ()

源代码

# File lib/set.rb, line 386
def flatten!
  replace(flatten()) if any?(Set)
end

等效于 Set#flatten，但用结果就地替换接收者。如果没有进行任何修改，则返回 nil。

include? (o)

源代码

# File lib/set.rb, line 396
def include?(o)
  @hash[o]
end

如果集合包含给定对象，则返回 true。

请注意，与其他的 Enumerables 不同，include? 和 member? 不使用 == 测试成员的相等性。

另请参阅 Enumerable#include?

也称为别名：member?、===

initialize_clone (orig, **options)

源代码

# File lib/set.rb, line 290
def initialize_clone(orig, **options)
  super
  @hash = orig.instance_variable_get(:@hash).clone(**options)
end

克隆内部哈希。

调用超类方法

initialize_dup (orig)

源代码

# File lib/set.rb, line 284
def initialize_dup(orig)
  super
  @hash = orig.instance_variable_get(:@hash).dup
end

复制内部哈希。

调用超类方法

inspect ()

源代码

# File lib/set.rb, line 814
def inspect
  ids = (Thread.current[InspectKey] ||= [])

  if ids.include?(object_id)
    return sprintf('#<%s: {...}>', self.class.name)
  end

  ids << object_id
  begin
    return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
  ensure
    ids.pop
  end
end

返回一个字符串，其中包含该集合的易读表示形式（“#<Set: {element1, element2, …}>”）。

也称为别名：to_s

intersect? (set)

源代码

# File lib/set.rb, line 473
def intersect?(set)
  case set
  when Set
    if size < set.size
      any?(set)
    else
      set.any?(self)
    end
  when Enumerable
    set.any?(self)
  else
    raise ArgumentError, "value must be enumerable"
  end
end

如果集合和给定可枚举对象至少有一个共同元素，则返回 true。

Set[1, 2, 3].intersect? Set[4, 5]   #=> false
Set[1, 2, 3].intersect? Set[3, 4]   #=> true
Set[1, 2, 3].intersect? 4..5        #=> false
Set[1, 2, 3].intersect? [3, 4]      #=> true

intersection (enum)

别名：&

join (separator=nil)

源代码

# File lib/set.rb, line 806
def join(separator=nil)
  to_a.join(separator)
end

返回一个字符串，该字符串是通过将集合的每个元素转换为字符串而创建的。另请参阅：Array#join

keep_if (&block)

源代码

# File lib/set.rb, line 557
def keep_if(&block)
  block_given? or return enum_for(__method__) { size }
  # Instead of directly using @hash.keep_if, perform enumeration
  # using self.each that subclasses may override.
  reject(&block).each { |o| @hash.delete(o) }
  self
end

删除集合中每个块求值为 false 的元素，并返回 self。如果没有给出块，则返回枚举器。

length ()

别名：size

map! ()

别名：collect!

member? (o)

别名：include?

merge (*enums, **nil)

源代码

# File lib/set.rb, line 598
def merge(*enums, **nil)
  enums.each do |enum|
    if enum.instance_of?(self.class)
      @hash.update(enum.instance_variable_get(:@hash))
    else
      do_with_enum(enum) { |o| add(o) }
    end
  end

  self
end

将给定可枚举对象的元素合并到集合并返回 self。

proper_subset? (set)

源代码

# File lib/set.rb, line 441
def proper_subset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:<)
    @hash < set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size < set.size && all?(set)
  else
    raise ArgumentError, "value must be a set"
  end
end

如果该集合是给定集合的真子集，则返回 true。

也称为别名：<

proper_superset? (set)

源代码

# File lib/set.rb, line 415
def proper_superset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:>)
    @hash > set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size > set.size && set.all?(self)
  else
    raise ArgumentError, "value must be a set"
  end
end

如果该集合是给定集合的真超集，则返回 true。

也称为别名：>

reject! (&block)

源代码

# File lib/set.rb, line 577
def reject!(&block)
  block_given? or return enum_for(__method__) { size }
  n = size
  delete_if(&block)
  self if size != n
end

等效于 Set#delete_if，但如果没有进行任何更改，则返回 nil。如果没有给出块，则返回枚举器。

replace (enum)

源代码

# File lib/set.rb, line 327
def replace(enum)
  if enum.instance_of?(self.class)
    @hash.replace(enum.instance_variable_get(:@hash))
    self
  else
    do_with_enum(enum)  # make sure enum is enumerable before calling clear
    clear
    merge(enum)
  end
end

用给定可枚举对象的内容替换集合的内容并返回 self。

set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
set.replace([1, 2])               #=> #<Set: {1, 2}>
set                               #=> #<Set: {1, 2}>

reset ()

源代码

# File lib/set.rb, line 702
def reset
  if @hash.respond_to?(:rehash)
    @hash.rehash # This should perform frozenness check.
  else
    raise FrozenError, "can't modify frozen #{self.class.name}" if frozen?
  end
  self
end

修改现有元素后重置内部状态并返回 self。

元素将被重新索引和去重。

select! (&block)

源代码

# File lib/set.rb, line 586
def select!(&block)
  block_given? or return enum_for(__method__) { size }
  n = size
  keep_if(&block)
  self if size != n
end

等效于 Set#keep_if，但如果没有进行任何更改，则返回 nil。如果没有给出块，则返回枚举器。

也称为别名：filter!

size ()

源代码

# File lib/set.rb, line 301
def size
  @hash.size
end

返回元素的数量。

也称为别名：length

subset? (set)

源代码

# File lib/set.rb, line 428
def subset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:<=)
    @hash <= set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size <= set.size && all?(set)
  else
    raise ArgumentError, "value must be a set"
  end
end

如果该集合是给定集合的子集，则返回 true。

也称为别名：<=

subtract (enum)

源代码

# File lib/set.rb, line 612
def subtract(enum)
  do_with_enum(enum) { |o| delete(o) }
  self
end

删除给定可枚举对象中出现的每个元素并返回 self。

superset? (set)

源代码

# File lib/set.rb, line 402
def superset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:>=)
    @hash >= set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size >= set.size && set.all?(self)
  else
    raise ArgumentError, "value must be a set"
  end
end

如果该集合是给定集合的超集，则返回 true。

也称为别名：>=

to_a ()

源代码

# File lib/set.rb, line 342
def to_a
  @hash.keys
end

返回一个包含集合中所有元素的数组。

Set[1, 2].to_a                    #=> [1, 2]
Set[1, 'c', :s].to_a              #=> [1, "c", :s]

to_json (*args)

源代码

# File ext/json/lib/json/add/set.rb, line 44
def to_json(*args)
  as_json.to_json(*args)
end

返回一个表示 self 的 JSON 字符串

require 'json/add/set'
puts Set.new(%w/foo bar baz/).to_json

输出

{"json_class":"Set","a":["foo","bar","baz"]}

to_s ()

别名：inspect

to_set (klass = Set, *args, &block)

源代码

# File lib/set.rb, line 351
def to_set(klass = Set, *args, &block)
  return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
  klass.new(self, *args, &block)
end

如果没有给出参数，则返回 self。否则，使用 klass.new(self, *args, &block) 将集合转换为另一个集合。

在子类中，除非被覆盖，否则返回 klass.new(self, *args, &block)。

union (enum)

别名：|