class Set

Die Klasse Set implementiert eine Sammlung von ungeordneten Werten ohne Duplikate. Sie ist eine Mischung aus den intuitiven Interaktionsmöglichkeiten von Array und der schnellen Suche von Hash.

Set ist einfach mit Enumerable-Objekten (die each implementieren) zu verwenden. Die meisten Initialisierungsmethoden und binären Operatoren akzeptieren generische Enumerable-Objekte neben Sets und Arrays. Ein Enumerable-Objekt kann mit der Methode to_set in ein Set konvertiert werden.

Set verwendet eine Datenstruktur, die der von Hash ähnelt, für die Speicherung, außer dass sie nur Schlüssel und keine Werte hat.

Die Gleichheit von Elementen wird gemäß Object#eql? und Object#hash bestimmt. Verwenden Sie Set#compare_by_identity, um ein Set seine Elemente nach ihrer Identität vergleichen zu lassen.
Set geht davon aus, dass sich die Identität jedes Elements nicht ändert, während es gespeichert ist. Die Änderung eines Elements eines Sets kann das Set in einen unzuverlässigen Zustand versetzen.
Wenn ein String gespeichert werden soll, wird stattdessen eine eingefrorene Kopie des Strings gespeichert, es sei denn, der ursprüngliche String ist bereits eingefroren.

Vergleich

Die Vergleichsoperatoren <, >, <= und >= werden als Abkürzung für die Methoden {proper_,}{subset?,superset?} implementiert. Der Operator <=> spiegelt diese Reihenfolge wider oder gibt nil für Sets zurück, die beide unterschiedliche Elemente haben (z. B. {x, y} vs. {x, z}).

Beispiel

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

Kontakt

Akinori MUSHA <knu@iDaemons.org> (aktueller Betreuer)

Von Set erben

Vor Ruby 4.0 (veröffentlicht im Dezember 2025) hatte Set eine andere, weniger effiziente Implementierung. Es wurde in C neu implementiert und das Verhalten einiger Kernmethoden wurde angepasst.

Um die Abwärtskompatibilität zu gewährleisten, wird beim Erben einer Klasse von Set das zusätzliche Modul Set::SubclassCompatible eingebunden, das das Verhalten der geerbten Klasse sowie interne Methodennamen näher an das vor Ruby 4.0 heranbringt.

Dies ist zum Beispiel leicht an dem Verhalten der Methode inspect zu erkennen.

p Set[1, 2, 3]
# prints "Set[1, 2, 3]"

class MySet < Set
end
p MySet[1, 2, 3]
# prints "#<MySet: {1, 2, 3}>", like it was in Ruby 3.4

Für neuen Code, wenn Abwärtskompatibilität nicht erforderlich ist, wird empfohlen, stattdessen von Set::CoreSet zu erben, was die Einbindung der „Kompatibilitätsschicht“ vermeidet.

class MyCoreSet < Set::CoreSet
end
p MyCoreSet[1, 2, 3]
# prints "MyCoreSet[1, 2, 3]"

Methoden von Set

Zunächst, was woanders ist. Klasse Set

Erbt von Klasse Object.
Beinhaltet das Modul Enumerable, das Dutzende zusätzlicher Methoden bereitstellt.

Insbesondere hat die Klasse Set selbst nicht viele Methoden zum Abrufen oder Iterieren. Stattdessen verlässt sie sich auf die von Enumerable.

Hier stellt die Klasse Set nützliche Methoden bereit für

Methoden zum Erstellen eines Sets

::[]: Gibt ein neues Set zurück, das die angegebenen Objekte enthält.
::new: Gibt ein neues Set zurück, das entweder die angegebenen Objekte (wenn kein Block gegeben ist) oder die Rückgabewerte des aufgerufenen Blocks (wenn ein Block gegeben ist) enthält.

Methoden für Set-Operationen

| (alias für union und +): Gibt ein neues Set zurück, das alle Elemente aus self und alle Elemente aus einem gegebenen Enumerable (keine Duplikate) enthält.
& (alias für intersection): Gibt ein neues Set zurück, das alle Elemente enthält, die self und einem gegebenen Enumerable gemeinsam sind.
- (alias für difference): Gibt eine Kopie von self zurück, aus der alle Elemente eines gegebenen Enumerable entfernt wurden.
^: Gibt ein neues Set zurück, das alle Elemente aus self und einem gegebenen Enumerable enthält, außer denen, die beiden gemeinsam sind.

Methoden zum Vergleichen

<=>: Gibt -1, 0 oder 1 zurück, je nachdem, ob self kleiner als, gleich oder größer als ein gegebenes Objekt ist.
==: Gibt zurück, ob self und ein gegebenes Enumerable gleich sind, bestimmt durch Object#eql?.
compare_by_identity?: Gibt zurück, ob das Set beim Vergleichen von Elementen nur die Identität berücksichtigt.

Methoden zum Abfragen

length (alias für size): Gibt die Anzahl der Elemente zurück.
empty?: Gibt zurück, ob das Set keine Elemente hat.
include? (alias für member? und ===): Gibt zurück, ob ein gegebenes Objekt ein Element im Set ist.
subset? (alias für <=): Gibt zurück, ob ein gegebenes Objekt ein Subset des Sets ist.
proper_subset? (alias für <): Gibt zurück, ob ein gegebenes Enumerable ein echtes Subset des Sets ist.
superset? (alias für >=): Gibt zurück, ob ein gegebenes Enumerable ein Superset des Sets ist.
proper_superset? (alias für >): Gibt zurück, ob ein gegebenes Enumerable ein echtes Superset des Sets ist.
disjoint?: Gibt true zurück, wenn das Set und ein gegebenes Enumerable keine gemeinsamen Elemente haben, andernfalls false.
intersect?: Gibt true zurück, wenn das Set und ein gegebenes Enumerable gemeinsame Elemente haben, andernfalls false.
compare_by_identity?: Gibt zurück, ob das Set beim Vergleichen von Elementen nur die Identität berücksichtigt.

Methoden zum Zuweisen

add (alias für <<): Fügt ein gegebenes Objekt zum Set hinzu; gibt self zurück.
add?: Wenn das gegebene Objekt kein Element im Set ist, wird es hinzugefügt und self zurückgegeben; andernfalls wird nil zurückgegeben.
merge: Fügt die Elemente jedes gegebenen Enumerable-Objekts zum Set hinzu; gibt self zurück.
replace: Ersetzt den Inhalt des Sets durch den Inhalt eines gegebenen Enumerable.

Methoden zum Löschen

clear: Entfernt alle Elemente aus dem Set; gibt self zurück.
delete: Entfernt ein gegebenes Objekt aus dem Set; gibt self zurück.
delete?: Wenn das gegebene Objekt ein Element im Set ist, wird es entfernt und self zurückgegeben; andernfalls wird nil zurückgegeben.
subtract: Entfernt jedes gegebene Objekt aus dem Set; gibt self zurück.
delete_if - Entfernt Elemente, die durch einen gegebenen Block spezifiziert werden.
select! (alias für filter!): Entfernt Elemente, die nicht durch einen gegebenen Block spezifiziert werden.
keep_if: Entfernt Elemente, die nicht durch einen gegebenen Block spezifiziert werden.
reject! Entfernt Elemente, die durch einen gegebenen Block spezifiziert werden.

Methoden zur Konvertierung

classify: Gibt einen Hash zurück, der die Elemente klassifiziert, wie durch den gegebenen Block bestimmt.
collect! (alias für map!): Ersetzt jedes Element durch den Rückgabewert eines Blocks.
divide: Gibt einen Hash zurück, der die Elemente klassifiziert, wie durch den gegebenen Block bestimmt; unterscheidet sich von classify dadurch, dass der Block entweder ein oder zwei Argumente akzeptieren kann.
flatten: Gibt ein neues Set zurück, das eine rekursive Glättung von self ist.
flatten!: Ersetzt jedes verschachtelte Set in self durch die Elemente dieses Sets.
inspect (alias für to_s): Gibt eine Zeichenkette zurück, die die Elemente anzeigt.
join: Gibt eine Zeichenkette zurück, die alle Elemente, die bei Bedarf in Zeichenketten konvertiert wurden, und getrennt durch den angegebenen Aufzeichnungsseparator enthält.
to_a: Gibt ein Array zurück, das alle Set-Elemente enthält.
to_set: Gibt self zurück, wenn keine Argumente und kein Block übergeben werden; mit einem gegebenen Block gibt es ein neues Set zurück, das aus den Rückgabewerten des Blocks besteht.

Methoden zur Iteration

each: Ruft den Block mit jedem aufeinanderfolgenden Element auf; gibt self zurück.

Andere Methoden

reset: Setzt den internen Zustand zurück; nützlich, wenn ein Objekt modifiziert wurde, während es ein Element im Set war.

Öffentliche Klassenmethoden

Set[*objekte] → neues_set

Source

static VALUE
set_s_create(int argc, VALUE *argv, VALUE klass)
{
    VALUE set = set_alloc_with_size(klass, argc);
    set_table *table = RSET_TABLE(set);
    int i;

    for (i=0; i < argc; i++) {
        set_table_insert_wb(table, set, argv[i], NULL);
    }

    return set;
}

Gibt ein neues Set-Objekt zurück, das mit den angegebenen Objekten gefüllt ist. Siehe Set::new.

json_create (object)

Source

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

Siehe as_json.

new → neues_set

new(enum) → neues_set

new(enum) { |elem| ... } → neues_set

Source

static VALUE
set_i_initialize(int argc, VALUE *argv, VALUE set)
{
    if (RBASIC(set)->flags & RSET_INITIALIZED) {
        rb_raise(rb_eRuntimeError, "cannot reinitialize set");
    }
    RBASIC(set)->flags |= RSET_INITIALIZED;

    VALUE other;
    rb_check_arity(argc, 0, 1);

    if (argc > 0 && (other = argv[0]) != Qnil) {
        if (RB_TYPE_P(other, T_ARRAY)) {
            long i;
            int block_given = rb_block_given_p();
            set_table *into = RSET_TABLE(set);
            for (i=0; i<RARRAY_LEN(other); i++) {
                VALUE key = RARRAY_AREF(other, i);
                if (block_given) key = rb_yield(key);
                set_table_insert_wb(into, set, key, NULL);
            }
        }
        else {
            rb_block_call(other, enum_method_id(other), 0, 0,
                rb_block_given_p() ? set_initialize_with_block : set_initialize_without_block,
                set);
        }
    }

    return set;
}

Erstellt ein neues Set, das die Elemente des gegebenen Enumerable-Objekts enthält.

Wenn ein Block gegeben ist, werden die Elemente von enum vom gegebenen Block vorverarbeitet.

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]

Öffentliche Instanzmethoden

set & enum → neues_set

Source

static VALUE
set_i_intersection(VALUE set, VALUE other)
{
    VALUE new_set = set_s_alloc(rb_obj_class(set));
    set_table *stable = RSET_TABLE(set);
    set_table *ntable = RSET_TABLE(new_set);

    if (rb_obj_is_kind_of(other, rb_cSet)) {
        set_table *otable = RSET_TABLE(other);
        if (set_table_size(stable) >= set_table_size(otable)) {
            /* Swap so we iterate over the smaller set */
            otable = stable;
            set = other;
        }

        struct set_intersection_data data = {
            .set = new_set,
            .into = ntable,
            .other = otable
        };
        set_iter(set, set_intersection_i, (st_data_t)&data);
    }
    else {
        struct set_intersection_data data = {
            .set = new_set,
            .into = ntable,
            .other = stable
        };
        rb_block_call(other, enum_method_id(other), 0, 0, set_intersection_block, (VALUE)&data);
    }

    return new_set;
}

Gibt ein neues Set zurück, das die gemeinsamen Elemente des Sets und des gegebenen Enumerable-Objekts enthält.

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

Auch alias für: intersection

Alias für: |

set - enum → neues_set

Source

static VALUE
set_i_difference(VALUE set, VALUE other)
{
    return set_i_subtract(rb_obj_dup(set), other);
}

Gibt ein neues Set zurück, das durch Duplizieren des Sets erstellt und Entfernen jedes Elements, das im gegebenen Enumerable-Objekt vorkommt.

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

Auch alias für: difference

Alias für: proper_subset?

Alias für: add

Alias für: subset?

set <=> other → -1, 0, 1, oder nil

Source

static VALUE
set_i_compare(VALUE set, VALUE other)
{
    if (rb_obj_is_kind_of(other, rb_cSet)) {
        size_t set_size = RSET_SIZE(set);
        size_t other_size = RSET_SIZE(other);

        if (set_size < other_size) {
            if (set_le(set, other) == Qtrue) {
                return INT2NUM(-1);
            }
        }
        else if (set_size > other_size) {
            if (set_le(other, set) == Qtrue) {
                return INT2NUM(1);
            }
        }
        else if (set_le(set, other) == Qtrue) {
            return INT2NUM(0);
        }
    }

    return Qnil;
}

Gibt 0 zurück, wenn die Sets gleich sind, -1 / 1, wenn das Set ein echtes Subset / Superset des gegebenen Sets ist, oder nil, wenn beide eindeutige Elemente haben.

set == other → true oder false

Source

static VALUE
set_i_eq(VALUE set, VALUE other)
{
    if (!rb_obj_is_kind_of(other, rb_cSet)) return Qfalse;
    if (set == other) return Qtrue;

    set_table *stable = RSET_TABLE(set);
    set_table *otable = RSET_TABLE(other);
    size_t ssize = set_table_size(stable);
    size_t osize = set_table_size(otable);

    if (ssize != osize) return Qfalse;
    if (ssize == 0 && osize == 0) return Qtrue;
    if (stable->type != otable->type) return Qfalse;

    struct set_equal_data data;
    data.set = other;
    return rb_exec_recursive_paired(set_recursive_eql, set, other, (VALUE)&data);
}

Gibt true zurück, wenn zwei Sets gleich sind.

Auch alias für: eql?

===

Alias für: include?

Alias für: proper_superset?

Alias für: superset?

set ^ enum → neues_set

Source

static VALUE
set_i_xor(VALUE set, VALUE other)
{
    VALUE new_set = rb_obj_dup(set);

    if (rb_obj_is_kind_of(other, rb_cSet)) {
        set_iter(other, set_xor_i, (st_data_t)new_set);
    }
    else {
        VALUE tmp = set_s_alloc(rb_cSet);
        set_merge_enum_into(tmp, other);
        set_iter(tmp, set_xor_i, (st_data_t)new_set);
    }

    return new_set;
}

Gibt ein neues Set zurück, das die exklusiven Elemente zwischen dem Set und dem gegebenen Enumerable-Objekt enthält. (set ^ enum) ist äquivalent zu ((set | enum) - (set & enum)).

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

set | enum → neues_set

Source

static VALUE
set_i_union(VALUE set, VALUE other)
{
    set = rb_obj_dup(set);
    set_merge_enum_into(set, other);
    return set;
}

Gibt ein neues Set zurück, das durch Zusammenführen des Sets und der Elemente des gegebenen Enumerable-Objekts erstellt wurde.

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]

Auch alias für: +, union

add(obj) → self

Source

static VALUE
set_i_add(VALUE set, VALUE item)
{
    rb_check_frozen(set);
    if (set_iterating_p(set)) {
        if (!set_table_lookup(RSET_TABLE(set), (st_data_t)item)) {
            no_new_item();
        }
    }
    else {
        set_insert_wb(set, item, NULL);
    }
    return set;
}

Fügt das gegebene Objekt zum Set hinzu und gibt self zurück. Verwenden Sie Set#merge, um viele Elemente auf einmal hinzuzufügen.

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]

Auch alias für: <<

add?(obj) → self oder nil

Source

static VALUE
set_i_add_p(VALUE set, VALUE item)
{
    rb_check_frozen(set);
    if (set_iterating_p(set)) {
        if (!set_table_lookup(RSET_TABLE(set), (st_data_t)item)) {
            no_new_item();
        }
        return Qnil;
    }
    else {
        return set_insert_wb(set, item, NULL) ? Qnil : set;
    }
}

Fügt das gegebene Objekt zum Set hinzu und gibt self zurück. Wenn das Objekt bereits im Set vorhanden ist, wird nil zurückgegeben.

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 (*)

Source

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

Die Methoden Set#as_json und Set.json_create können verwendet werden, um ein Set-Objekt zu serialisieren und deserialisieren; siehe Marshal.

Die Methode Set#as_json serialisiert self und gibt einen 2-elementigen Hash zurück, der self repräsentiert.

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

Die Methode JSON.create deserialisiert einen solchen Hash und gibt ein Set-Objekt zurück.

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

classify { |o| ... } → hash

classify → enumerator

Source

static VALUE
set_i_classify(VALUE set)
{
    RETURN_SIZED_ENUMERATOR(set, 0, 0, set_enum_size);
    VALUE args[2];
    args[0] = rb_hash_new();
    args[1] = rb_obj_class(set);
    set_iter(set, set_classify_i, (st_data_t)args);
    return args[0];
}

Klassifiziert das Set nach dem Rückgabewert des gegebenen Blocks und gibt einen Hash von {wert => set von Elementen}-Paaren zurück. Der Block wird einmal für jedes Element des Sets aufgerufen und übergibt das Element als Parameter.

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"]}

Gibt einen Enumerator zurück, wenn kein Block gegeben wird.

clear → self

Source

static VALUE
set_i_clear(VALUE set)
{
    rb_check_frozen(set);
    if (RSET_SIZE(set) == 0) return set;
    if (set_iterating_p(set)) {
        set_iter(set, set_clear_i, 0);
    }
    else {
        set_table_clear(RSET_TABLE(set));
        set_compact_after_delete(set);
    }
    return set;
}

Entfernt alle Elemente und gibt self zurück.

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

collect! { |o| ... } → self

collect! → enumerator

Source

static VALUE
set_i_collect(VALUE set)
{
    RETURN_SIZED_ENUMERATOR(set, 0, 0, set_enum_size);
    rb_check_frozen(set);

    VALUE new_set = set_s_alloc(rb_obj_class(set));
    set_iter(set, set_collect_i, (st_data_t)new_set);
    set_i_initialize_copy(set, new_set);

    return set;
}

Ersetzt die Elemente durch die, die von collect zurückgegeben werden. Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

Auch alias für: map!

compare_by_identity → self

Source

static VALUE
set_i_compare_by_identity(VALUE set)
{
    if (RSET_COMPARE_BY_IDENTITY(set)) return set;

    if (set_iterating_p(set)) {
        rb_raise(rb_eRuntimeError, "compare_by_identity during iteration");
    }

    return set_reset_table_with_type(set, &identhash);
}

Lässt das Set seine Elemente nach ihrer Identität vergleichen und gibt self zurück.

compare_by_identity? → true oder false

Source

static VALUE
set_i_compare_by_identity_p(VALUE set)
{
    return RBOOL(RSET_COMPARE_BY_IDENTITY(set));
}

Gibt true zurück, wenn das Set seine Elemente nach ihrer Identität vergleichen wird. Siehe auch Set#compare_by_identity.

delete(obj) → self

Source

static VALUE
set_i_delete(VALUE set, VALUE item)
{
    rb_check_frozen(set);
    if (set_table_delete(RSET_TABLE(set), (st_data_t *)&item)) {
        set_compact_after_delete(set);
    }
    return set;
}

Löscht das gegebene Objekt aus dem Set und gibt self zurück. Verwenden Sie subtract, um viele Elemente auf einmal zu löschen.

delete?(obj) → self oder nil

Source

static VALUE
set_i_delete_p(VALUE set, VALUE item)
{
    rb_check_frozen(set);
    if (set_table_delete(RSET_TABLE(set), (st_data_t *)&item)) {
        set_compact_after_delete(set);
        return set;
    }
    return Qnil;
}

Löscht das gegebene Objekt aus dem Set und gibt self zurück. Wenn das Objekt nicht im Set ist, wird nil zurückgegeben.

delete_if { |o| ... } → self

delete_if → enumerator

Source

static VALUE
set_i_delete_if(VALUE set)
{
    RETURN_SIZED_ENUMERATOR(set, 0, 0, set_enum_size);
    rb_check_frozen(set);
    set_iter(set, set_delete_if_i, 0);
    set_compact_after_delete(set);
    return set;
}

Löscht jedes Element des Sets, für das der Block true ergibt, und gibt self zurück. Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

difference

Alias für: -

disjoint?(set) → true oder false

Source

static VALUE
set_i_disjoint(VALUE set, VALUE other)
{
    return RBOOL(!RTEST(set_i_intersect(set, other)));
}

Gibt true zurück, wenn das Set und das gegebene Enumerable kein gemeinsames Element haben. Diese Methode ist das Gegenteil von 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 { |o1, o2| ... } → set

divide { |o| ... } → set

divide → enumerator

Source

static VALUE
set_i_divide(VALUE set)
{
    RETURN_SIZED_ENUMERATOR(set, 0, 0, set_enum_size);

    if (rb_block_arity() == 2) {
        return set_divide_arity2(set);
    }

    VALUE values = rb_hash_values(set_i_classify(set));
    set = set_alloc_with_size(rb_cSet, RARRAY_LEN(values));
    set_merge_enum_into(set, values);
    return set;
}

Teilt das Set anhand der durch den gegebenen Block definierten Gemeinsamkeiten in eine Menge von Teilmengen auf.

Wenn die Arität des Blocks 2 ist, sind die Elemente o1 und o2 gemeinsam, wenn sowohl block.call(o1, o2) als auch block.call(o2, o1) true sind. Andernfalls sind die Elemente o1 und o2 gemeinsam, wenn block.call(o1) == block.call(o2).

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

Gibt einen Enumerator zurück, wenn kein Block gegeben wird.

each { |o| ... } → self

each → enumerator

Source

static VALUE
set_i_each(VALUE set)
{
    RETURN_SIZED_ENUMERATOR(set, 0, 0, set_enum_size);
    set_iter(set, set_each_i, 0);
    return set;
}

Ruft den gegebenen Block einmal für jedes Element im Set auf und übergibt das Element als Parameter. Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

empty? → true oder false

Source

static VALUE
set_i_empty(VALUE set)
{
    return RBOOL(RSET_EMPTY(set));
}

Gibt true zurück, wenn das Set keine Elemente enthält.

encode_with (coder)

Source

# File ext/psych/lib/psych/core_ext.rb, line 23
def encode_with(coder)
  hash = {}
  each do |m|
    hash[m] = true
  end
  coder["hash"] = hash
  coder
end

eql?

Alias für: ==

filter!

Alias für: select!

flatten → set

Source

static VALUE
set_i_flatten(VALUE set)
{
    VALUE new_set = set_s_alloc(rb_obj_class(set));
    set_flatten_merge(new_set, set, rb_hash_new());
    return new_set;
}

Gibt ein neues Set zurück, das eine Kopie des Sets ist und jedes enthaltene Set rekursiv glättet.

flatten! → self

Source

static VALUE
set_i_flatten_bang(VALUE set)
{
    bool contains_set = false;
    set_iter(set, set_contains_set_i, (st_data_t)&contains_set);
    if (!contains_set) return Qnil;
    rb_check_frozen(set);
    return set_i_replace(set, set_i_flatten(set));
}

Äquivalent zu Set#flatten, ersetzt aber den Empfänger durch das Ergebnis an Ort und Stelle. Gibt nil zurück, wenn keine Änderungen vorgenommen wurden.

hash → integer

Source

static VALUE
set_i_hash(VALUE set)
{
    st_index_t size = RSET_SIZE(set);
    st_index_t hval = rb_st_hash_start(size);
    hval = rb_hash_uint(hval, (st_index_t)set_i_hash);
    if (size) {
        set_iter(set, set_hash_i, (VALUE)&hval);
    }
    hval = rb_st_hash_end(hval);
    return ST2FIX(hval);
}

Gibt den Hash-Code für das Set zurück.

include?(item) → true oder false

Source

static VALUE
set_i_include(VALUE set, VALUE item)
{
    return RBOOL(RSET_IS_MEMBER(set, item));
}

Gibt true zurück, wenn das Set das gegebene Objekt enthält.

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

Beachten Sie, dass include? und member? die Elementgleichheit nicht mit == testen, wie es andere Enumerable tun.

Dies ist alias für ===, sodass es in case-Anweisungen verwendet werden kann.

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

Siehe auch Enumerable#include?

Auch alias für: member?, ===

init_with (coder)

Source

# File ext/psych/lib/psych/core_ext.rb, line 32
def init_with(coder)
  replace(coder["hash"].keys)
end

inspect → new_string

Source

static VALUE
set_i_inspect(VALUE set)
{
    return rb_exec_recursive(set_inspect, set, 0);
}

Gibt eine neue Zeichenkette zurück, die die Set-Einträge enthält.

s = Set.new
s.inspect # => "Set[]"
s.add(1)
s.inspect # => "Set[1]"
s.add(2)
s.inspect # => "Set[1, 2]"

Verwandt: siehe Methoden zur Konvertierung.

Auch alias für: to_s

intersect?(set) → true oder false

Source

static VALUE
set_i_intersect(VALUE set, VALUE other)
{
    if (rb_obj_is_kind_of(other, rb_cSet)) {
        size_t set_size = RSET_SIZE(set);
        size_t other_size = RSET_SIZE(other);
        VALUE args[2];
        args[1] = Qfalse;
        VALUE iter_arg;

        if (set_size < other_size) {
            iter_arg = set;
            args[0] = (VALUE)RSET_TABLE(other);
        }
        else {
            iter_arg = other;
            args[0] = (VALUE)RSET_TABLE(set);
        }
        set_iter(iter_arg, set_intersect_i, (st_data_t)args);
        return args[1];
    }
    else if (rb_obj_is_kind_of(other, rb_mEnumerable)) {
        return rb_funcall(other, id_any_p, 1, set);
    }
    else {
        rb_raise(rb_eArgError, "value must be enumerable");
    }
}

Gibt true zurück, wenn das Set und das gegebene Enumerable mindestens ein gemeinsames Element haben.

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

Alias für: &

join(separator=nil)→ new_string

Source

static VALUE
set_i_join(int argc, VALUE *argv, VALUE set)
{
    rb_check_arity(argc, 0, 1);
    return rb_ary_join(set_i_to_a(set), argc == 0 ? Qnil : argv[0]);
}

Gibt eine Zeichenkette zurück, die durch Konvertierung jedes Elements des Sets in eine Zeichenkette erstellt wird.

keep_if { |o| ... } → self

keep_if → enumerator

Source

static VALUE
set_i_keep_if(VALUE set)
{
    RETURN_SIZED_ENUMERATOR(set, 0, 0, set_enum_size);
    rb_check_frozen(set);

    set_iter(set, set_keep_if_i, (st_data_t)RSET_TABLE(set));

    return set;
}

Löscht jedes Element des Sets, für das der Block false ergibt, und gibt self zurück. Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

Länge

Alias für: size

map!

Alias für: collect!

member?

Alias für: include?

merge(*enums, **nil) → self

Source

static VALUE
set_i_merge(int argc, VALUE *argv, VALUE set)
{
    if (rb_keyword_given_p()) {
        rb_raise(rb_eArgError, "no keywords accepted");
    }

    if (set_iterating_p(set)) {
        rb_raise(rb_eRuntimeError, "cannot add to set during iteration");
    }

    rb_check_frozen(set);

    int i;

    for (i=0; i < argc; i++) {
        set_merge_enum_into(set, argv[i]);
    }

    return set;
}

Fügt die Elemente der gegebenen Enumerable-Objekte zum Set hinzu und gibt self zurück.

proper_subset?(set) → true oder false

Source

static VALUE
set_i_proper_subset(VALUE set, VALUE other)
{
    check_set(other);
    if (RSET_SIZE(set) >= RSET_SIZE(other)) return Qfalse;
    return set_le(set, other);
}

Gibt true zurück, wenn das Set ein echtes Subset des gegebenen Sets ist.

Auch alias für: <

proper_superset?(set) → true oder false

Source

static VALUE
set_i_proper_superset(VALUE set, VALUE other)
{
    check_set(other);
    if (RSET_SIZE(set) <= RSET_SIZE(other)) return Qfalse;
    return set_le(other, set);
}

Gibt true zurück, wenn das Set ein echtes Superset des gegebenen Sets ist.

Auch alias für: >

reject! { |o| ... } → self

reject! → enumerator

Source

static VALUE
set_i_reject(VALUE set)
{
    RETURN_SIZED_ENUMERATOR(set, 0, 0, set_enum_size);
    rb_check_frozen(set);

    set_table *table = RSET_TABLE(set);
    size_t n = set_table_size(table);
    set_iter(set, set_delete_if_i, 0);

    if (n == set_table_size(table)) return Qnil;

    set_compact_after_delete(set);
    return set;
}

Äquivalent zu Set#delete_if, gibt aber nil zurück, wenn keine Änderungen vorgenommen wurden. Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

replace(enum) → self

Source

static VALUE
set_i_replace(VALUE set, VALUE other)
{
    rb_check_frozen(set);

    if (rb_obj_is_kind_of(other, rb_cSet)) {
        set_i_initialize_copy(set, other);
    }
    else {
        if (set_iterating_p(set)) {
            rb_raise(rb_eRuntimeError, "cannot replace set during iteration");
        }

        // make sure enum is enumerable before calling clear
        enum_method_id(other);

        set_table_clear(RSET_TABLE(set));
        set_merge_enum_into(set, other);
    }

    return set;
}

Ersetzt den Inhalt des Sets durch den Inhalt des gegebenen Enumerable-Objekts und gibt self zurück.

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

reset → self

Source

static VALUE
set_i_reset(VALUE set)
{
    if (set_iterating_p(set)) {
        rb_raise(rb_eRuntimeError, "reset during iteration");
    }

    return set_reset_table_with_type(set, RSET_TABLE(set)->type);
}

Setzt den internen Zustand nach der Änderung bestehender Elemente zurück und gibt self zurück. Elemente werden neu indiziert und dedupliziert.

select! { |o| ... } → self

select! → enumerator

Source

static VALUE
set_i_select(VALUE set)
{
    RETURN_SIZED_ENUMERATOR(set, 0, 0, set_enum_size);
    rb_check_frozen(set);

    set_table *table = RSET_TABLE(set);
    size_t n = set_table_size(table);
    set_iter(set, set_keep_if_i, (st_data_t)table);

    return (n == set_table_size(table)) ? Qnil : set;
}

Äquivalent zu Set#keep_if, gibt aber nil zurück, wenn keine Änderungen vorgenommen wurden. Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

Auch alias für: filter!

size → integer

Source

static VALUE
set_i_size(VALUE set)
{
    return RSET_SIZE_NUM(set);
}

Gibt die Anzahl der Elemente zurück.

Auch alias für: length

subset?(set) → true oder false

Source

static VALUE
set_i_subset(VALUE set, VALUE other)
{
    check_set(other);
    if (RSET_SIZE(set) > RSET_SIZE(other)) return Qfalse;
    return set_le(set, other);
}

Gibt true zurück, wenn das Set ein Subset des gegebenen Sets ist.

Auch alias für: <=

subtract(enum) → self

Source

static VALUE
set_i_subtract(VALUE set, VALUE other)
{
    rb_check_frozen(set);
    set_remove_enum_from(set, other);
    return set;
}

Löscht jedes Element, das im gegebenen Enumerable-Objekt vorkommt, und gibt self zurück.

superset?(set) → true oder false

Source

static VALUE
set_i_superset(VALUE set, VALUE other)
{
    check_set(other);
    if (RSET_SIZE(set) < RSET_SIZE(other)) return Qfalse;
    return set_le(other, set);
}

Gibt true zurück, wenn das Set ein Superset des gegebenen Sets ist.

Auch alias für: >=

to_a → array

Source

static VALUE
set_i_to_a(VALUE set)
{
    st_index_t size = RSET_SIZE(set);
    VALUE ary = rb_ary_new_capa(size);

    if (size == 0) return ary;

    if (ST_DATA_COMPATIBLE_P(VALUE)) {
        RARRAY_PTR_USE(ary, ptr, {
            size = set_keys(RSET_TABLE(set), ptr, size);
        });
        rb_gc_writebarrier_remember(ary);
        rb_ary_set_len(ary, size);
    }
    else {
        set_iter(set, set_to_a_i, (st_data_t)ary);
    }
    return ary;
}

Gibt ein Array zurück, das alle Elemente im Set enthält.

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

to_json (*args)

Source

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

Gibt einen JSON-String zurück, der self repräsentiert

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

Ausgabe

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

to_s

Alias für: inspect

to_set(klass = Set, *args, &block) → self oder new_set

Source

static VALUE
set_i_to_set(int argc, VALUE *argv, VALUE set)
{
    VALUE klass;

    if (argc == 0) {
        klass = rb_cSet;
        argv = &set;
        argc = 1;
    }
    else {
        rb_warn_deprecated("passing arguments to Set#to_set", NULL);
        klass = argv[0];
        argv[0] = set;
    }

    if (klass == rb_cSet && rb_obj_is_instance_of(set, rb_cSet) &&
            argc == 1 && !rb_block_given_p()) {
        return set;
    }

    return rb_funcall_passing_block(klass, id_new, argc, argv);
}

Ohne Argumente gibt es self zurück (für Duck-Typing in Methoden, die „Set oder Set-konvertierbare“ Argumente akzeptieren).

Eine Form mit Argumenten ist *veraltet*. Sie konvertiert das Set in ein anderes mit klass.new(self, *args, &block).

union

Alias für: |