class Struct

Die Klasse Struct bietet eine praktische Möglichkeit, eine einfache Klasse zu erstellen, die Werte speichern und abrufen kann.

Dieses Beispiel erstellt eine Unterklasse von Struct, Struct::Customer; das erste Argument, ein String, ist der Name der Unterklasse; die anderen Argumente, Symbole, bestimmen die Mitglieder der neuen Unterklasse.

Customer = Struct.new('Customer', :name, :address, :zip)
Customer.name       # => "Struct::Customer"
Customer.class      # => Class
Customer.superclass # => Struct

Jedem Mitglied entsprechen zwei Methoden, eine Writer- und eine Reader-Methode, die Werte speichern und abrufen.

methods = Customer.instance_methods false
methods # => [:zip, :address=, :zip=, :address, :name, :name=]

Eine Instanz der Unterklasse kann erstellt und ihre Mitglieder mit Werten zugewiesen werden, über die Methode ::new.

joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe # => #<struct Struct::Customer name="Joe Smith", address="123 Maple, Anytown NC", zip=12345>

Die Mitgliedswerte können so verwaltet werden:

joe.name    # => "Joe Smith"
joe.name = 'Joseph Smith'
joe.name    # => "Joseph Smith"

Und so; beachten Sie, dass der Mitgliedername entweder als String oder als Symbol angegeben werden kann.

joe[:name]  # => "Joseph Smith"
joe[:name] = 'Joseph Smith, Jr.'
joe['name'] # => "Joseph Smith, Jr."

Siehe Struct::new.

Was gibt es hier

Zuerst, was ist sonst noch. Klasse Struct

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

Siehe auch Data, ein etwas ähnliches, aber strengeres Konzept zur Definition unveränderlicher Wertobjekte.

Hier bietet die Klasse Struct Methoden, die nützlich sind für

Methoden zum Erstellen einer `Struct`-Unterklasse

::new: Gibt eine neue Unterklasse von Struct zurück.

Methoden zum Abfragen

hash: Gibt den ganzzahligen Hash-Code zurück.
size (aliased as length): Gibt die Anzahl der Mitglieder zurück.

Methoden zum Vergleichen

==: Gibt zurück, ob ein gegebenes Objekt gleich self ist, wobei == zum Vergleichen von Mitgliedswerten verwendet wird.
eql?: Gibt zurück, ob ein gegebenes Objekt gleich self ist, wobei eql? zum Vergleichen von Mitgliedswerten verwendet wird.

Methoden zum Abrufen

[]: Gibt den Wert zurück, der einem gegebenen Mitgliedsnamen zugeordnet ist.
to_a (aliased as values, deconstruct): Gibt die Mitgliedswerte in self als Array zurück.
deconstruct_keys: Gibt einen Hash der Namen/Wert-Paare für gegebene Mitgliedsnamen zurück.
dig: Gibt das Objekt in verschachtelten Objekten zurück, das durch einen gegebenen Mitgliedsnamen und zusätzliche Argumente spezifiziert wird.
members: Gibt ein Array der Mitgliedsnamen zurück.
select (aliased as filter): Gibt ein Array von Mitgliedswerten aus self zurück, wie durch den gegebenen Block ausgewählt.
values_at: Gibt ein Array zurück, das Werte für gegebene Mitgliedsnamen enthält.

Methoden zum Zuweisen

[]=: Weist einem gegebenen Mitgliedsnamen einen gegebenen Wert zu.

Methoden zur Iteration

each: Ruft einen gegebenen Block mit jedem Mitgliedsnamen auf.
each_pair: Ruft einen gegebenen Block mit jedem Mitgliedsnamen/Wert-Paar auf.

Methoden zur Konvertierung

inspect (aliased as to_s): Gibt eine String-Darstellung von self zurück.
to_h: Gibt einen Hash der Mitgliedsnamen/Wert-Paare in self zurück.

Öffentliche Klassenmethoden

json_create (object)

Source

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

Siehe as_json.

StructClass::keyword_init? → true oder falsy Wert

Source

static VALUE
rb_struct_s_keyword_init_p(VALUE obj)
{
}

Gibt true zurück, wenn die Klasse mit keyword_init: true initialisiert wurde. Andernfalls gibt nil oder false zurück.

Beispiele

Foo = Struct.new(:a)
Foo.keyword_init? # => nil
Bar = Struct.new(:a, keyword_init: true)
Bar.keyword_init? # => true
Baz = Struct.new(:a, keyword_init: false)
Baz.keyword_init? # => false

StructClass::members → array_of_symbols

Source

static VALUE
rb_struct_s_members_m(VALUE klass)
{
    VALUE members = rb_struct_s_members(klass);

    return rb_ary_dup(members);
}

Gibt die Mitgliedsnamen des Struct-Nachfahren als Array zurück.

Customer = Struct.new(:name, :address, :zip)
Customer.members # => [:name, :address, :zip]

new(*member_names, keyword_init: nil){|Struct_subclass| ... } → Struct_subclass

new(class_name, *member_names, keyword_init: nil){|Struct_subclass| ... } → Struct_subclass

new(*member_names) → Struct_subclass_instance

new(**member_names) → Struct_subclass_instance

Source

static VALUE
rb_struct_s_def(int argc, VALUE *argv, VALUE klass)
{
    VALUE name = Qnil, rest, keyword_init = Qnil;
    long i;
    VALUE st;
    VALUE opt;

    argc = rb_scan_args(argc, argv, "0*:", NULL, &opt);
    if (argc >= 1 && !SYMBOL_P(argv[0])) {
        name = argv[0];
        --argc;
        ++argv;
    }

    if (!NIL_P(opt)) {
        static ID keyword_ids[1];

        if (!keyword_ids[0]) {
            keyword_ids[0] = rb_intern("keyword_init");
        }
        rb_get_kwargs(opt, keyword_ids, 0, 1, &keyword_init);
        if (UNDEF_P(keyword_init)) {
            keyword_init = Qnil;
        }
        else if (RTEST(keyword_init)) {
            keyword_init = Qtrue;
        }
    }

    rest = rb_ident_hash_new();
    RBASIC_CLEAR_CLASS(rest);
    for (i=0; i<argc; i++) {
        VALUE mem = rb_to_symbol(argv[i]);
        if (rb_is_attrset_sym(mem)) {
            rb_raise(rb_eArgError, "invalid struct member: %"PRIsVALUE, mem);
        }
        if (RTEST(rb_hash_has_key(rest, mem))) {
            rb_raise(rb_eArgError, "duplicate member: %"PRIsVALUE, mem);
        }
        rb_hash_aset(rest, mem, Qtrue);
    }
    rest = rb_hash_keys(rest);
    RBASIC_CLEAR_CLASS(rest);
    OBJ_FREEZE(rest);
    if (NIL_P(name)) {
        st = anonymous_struct(klass);
    }
    else {
        st = new_struct(name, klass);
    }
    setup_struct(st, rest);
    rb_ivar_set(st, id_keyword_init, keyword_init);
    if (rb_block_given_p()) {
        rb_mod_module_eval(0, 0, st);
    }

    return st;
}

Struct.new gibt eine neue Unterklasse von Struct zurück. Die neue Unterklasse

Kann anonym sein oder den von class_name angegebenen Namen haben.
Kann Mitglieder haben, wie von member_names angegeben.
Kann eine Initialisierung über normale Argumente oder über Schlüsselwortargumente haben.

Die neue Unterklasse hat ihre eigene Methode ::new; somit

Foo = Struct.new('Foo', :foo, :bar) # => Struct::Foo
f = Foo.new(0, 1)                   # => #<struct Struct::Foo foo=0, bar=1>

Klassenname

Mit dem String-Argument class_name wird eine neue Unterklasse von Struct mit dem Namen Struct::class_name zurückgegeben.

Foo = Struct.new('Foo', :foo, :bar) # => Struct::Foo
Foo.name                            # => "Struct::Foo"
Foo.superclass                      # => Struct

Ohne das String-Argument class_name wird eine neue anonyme Unterklasse von Struct zurückgegeben.

Struct.new(:foo, :bar).name # => nil

Block

Wenn ein Block angegeben ist, wird die erstellte Unterklasse an den Block übergeben.

Customer = Struct.new('Customer', :name, :address) do |new_class|
  p "The new subclass is #{new_class}"
  def greeting
    "Hello #{name} at #{address}"
  end
end           # => Struct::Customer
dave = Customer.new('Dave', '123 Main')
dave # =>     #<struct Struct::Customer name="Dave", address="123 Main">
dave.greeting # => "Hello Dave at 123 Main"

Ausgabe von Struct.new

"The new subclass is Struct::Customer"

Mitgliedsnamen

Symbol-Argumente member_names bestimmen die Mitglieder der neuen Unterklasse.

Struct.new(:foo, :bar).members        # => [:foo, :bar]
Struct.new('Foo', :foo, :bar).members # => [:foo, :bar]

Die neue Unterklasse hat Instanzmethoden, die den member_names entsprechen.

Foo = Struct.new('Foo', :foo, :bar)
Foo.instance_methods(false) # => [:foo, :bar, :foo=, :bar=]
f = Foo.new                 # => #<struct Struct::Foo foo=nil, bar=nil>
f.foo                       # => nil
f.foo = 0                   # => 0
f.bar                       # => nil
f.bar = 1                   # => 1
f                           # => #<struct Struct::Foo foo=0, bar=1>

Singleton-Methoden

Eine Unterklasse, die von Struct.new zurückgegeben wird, hat diese Singleton-Methoden.

Methode ::new erstellt eine Instanz der Unterklasse.

Foo.new          # => #<struct Struct::Foo foo=nil, bar=nil>
Foo.new(0)       # => #<struct Struct::Foo foo=0, bar=nil>
Foo.new(0, 1)    # => #<struct Struct::Foo foo=0, bar=1>
Foo.new(0, 1, 2) # Raises ArgumentError: struct size differs

# Initialization with keyword arguments:
Foo.new(foo: 0)         # => #<struct Struct::Foo foo=0, bar=nil>
Foo.new(foo: 0, bar: 1) # => #<struct Struct::Foo foo=0, bar=1>
Foo.new(foo: 0, bar: 1, baz: 2)
# Raises ArgumentError: unknown keywords: baz

Methode :inspect gibt eine String-Darstellung der Unterklasse zurück.
```
Foo.inspect
# => "Struct::Foo"
```
Methode ::members gibt ein Array der Mitgliedsnamen zurück.
```
Foo.members # => [:foo, :bar]
```

Schlüsselwortargument

Standardmäßig können die Argumente zur Initialisierung einer Instanz der neuen Unterklasse sowohl Positions- als auch Schlüsselwortargumente sein.

Das optionale Schlüsselwortargument keyword_init: ermöglicht die Erzwingung der Akzeptanz nur eines Argumenttyps.

KeywordsOnly = Struct.new(:foo, :bar, keyword_init: true)
KeywordsOnly.new(bar: 1, foo: 0)
# => #<struct KeywordsOnly foo=0, bar=1>
KeywordsOnly.new(0, 1)
# Raises ArgumentError: wrong number of arguments

PositionalOnly = Struct.new(:foo, :bar, keyword_init: false)
PositionalOnly.new(0, 1)
# => #<struct PositionalOnly foo=0, bar=1>
PositionalOnly.new(bar: 1, foo: 0)
# => #<struct PositionalOnly foo={:foo=>1, :bar=>2}, bar=nil>
# Note that no error is raised, but arguments treated as one hash value

# Same as not providing keyword_init:
Any = Struct.new(:foo, :bar, keyword_init: nil)
Any.new(foo: 1, bar: 2)
# => #<struct Any foo=1, bar=2>
Any.new(1, 2)
# => #<struct Any foo=1, bar=2>

Öffentliche Instanzmethoden

self == other → true oder false

Source

static VALUE
rb_struct_equal(VALUE s, VALUE s2)
{
    if (s == s2) return Qtrue;
    if (!RB_TYPE_P(s2, T_STRUCT)) return Qfalse;
    if (rb_obj_class(s) != rb_obj_class(s2)) return Qfalse;
    if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
        rb_bug("inconsistent struct"); /* should never happen */
    }

    return rb_exec_recursive_paired(recursive_equal, s, s2, s2);
}

Gibt true zurück, wenn und nur wenn die folgenden Bedingungen erfüllt sind; andernfalls gibt false zurück.

other.class == self.class.
Für jeden Mitgliedsnamen name gilt other.name == self.name.

Beispiele

Customer = Struct.new(:name, :address, :zip)
joe    = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe_jr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe_jr == joe # => true
joe_jr[:name] = 'Joe Smith, Jr.'
# => "Joe Smith, Jr."
joe_jr == joe # => false

struct[name] → object

struct[n] → object

Source

VALUE
rb_struct_aref(VALUE s, VALUE idx)
{
    int i = rb_struct_pos(s, &idx);
    if (i < 0) invalid_struct_pos(s, idx);
    return RSTRUCT_GET(s, i);
}

Gibt einen Wert von self zurück.

Mit dem Symbol- oder String-Argument name wird der Wert für das benannte Mitglied zurückgegeben.

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe[:zip] # => 12345

Löst NameError aus, wenn name nicht der Name eines Mitglieds ist.

Mit dem Integer-Argument n wird self.values[n] zurückgegeben, wenn n im Bereich liegt; siehe Array-Indizes in Array.

joe[2]  # => 12345
joe[-2] # => "123 Maple, Anytown NC"

Löst IndexError aus, wenn n außerhalb des Bereichs liegt.

struct[name] = value → value

struct[n] = value → value

Source

VALUE
rb_struct_aset(VALUE s, VALUE idx, VALUE val)
{
    int i = rb_struct_pos(s, &idx);
    if (i < 0) invalid_struct_pos(s, idx);
    rb_struct_modify(s);
    RSTRUCT_SET(s, i, val);
    return val;
}

Weist einem Mitglied einen Wert zu.

Mit dem Symbol- oder String-Argument name wird der gegebene value dem benannten Mitglied zugewiesen; gibt value zurück.

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe[:zip] = 54321 # => 54321
joe # => #<struct Customer name="Joe Smith", address="123 Maple, Anytown NC", zip=54321>

Löst NameError aus, wenn name nicht der Name eines Mitglieds ist.

Mit dem Integer-Argument n wird der gegebene value dem n-ten Mitglied zugewiesen, wenn n im Bereich liegt; siehe Array-Indizes in Array.

joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe[2] = 54321           # => 54321
joe[-3] = 'Joseph Smith' # => "Joseph Smith"
joe # => #<struct Customer name="Joseph Smith", address="123 Maple, Anytown NC", zip=54321>

Löst IndexError aus, wenn n außerhalb des Bereichs liegt.

as_json (*)

Source

# File ext/json/lib/json/add/struct.rb, line 30
def as_json(*)
  klass = self.class.name
  klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
  {
    JSON.create_id => klass,
    'v'            => values,
  }
end

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

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

require 'json/add/struct'
Customer = Struct.new('Customer', :name, :address, :zip)
x = Struct::Customer.new.as_json
# => {"json_class"=>"Struct::Customer", "v"=>[nil, nil, nil]}

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

Struct::Customer.json_create(x)
# => #<struct Struct::Customer name=nil, address=nil, zip=nil>

deconstruct

Alias für: to_a

deconstruct_keys(array_of_names) → hash

Source

static VALUE
rb_struct_deconstruct_keys(VALUE s, VALUE keys)
{
    VALUE h;
    long i;

    if (NIL_P(keys)) {
        return rb_struct_to_h(s);
    }
    if (UNLIKELY(!RB_TYPE_P(keys, T_ARRAY))) {
        rb_raise(rb_eTypeError,
                 "wrong argument type %"PRIsVALUE" (expected Array or nil)",
                 rb_obj_class(keys));

    }
    if (RSTRUCT_LEN(s) < RARRAY_LEN(keys)) {
        return rb_hash_new_with_size(0);
    }
    h = rb_hash_new_with_size(RARRAY_LEN(keys));
    for (i=0; i<RARRAY_LEN(keys); i++) {
        VALUE key = RARRAY_AREF(keys, i);
        int i = rb_struct_pos(s, &key);
        if (i < 0) {
            return h;
        }
        rb_hash_aset(h, key, RSTRUCT_GET(s, i));
    }
    return h;
}

Gibt einen Hash der Namen/Wert-Paare für die gegebenen Mitgliedsnamen zurück.

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
h = joe.deconstruct_keys([:zip, :address])
h # => {:zip=>12345, :address=>"123 Maple, Anytown NC"}

Gibt alle Namen und Werte zurück, wenn array_of_names nil ist.

h = joe.deconstruct_keys(nil)
h # => {:name=>"Joseph Smith, Jr.", :address=>"123 Maple, Anytown NC", :zip=>12345}

dig(name, *identifiers) → object

dig(n, *identifiers) → object

Source

static VALUE
rb_struct_dig(int argc, VALUE *argv, VALUE self)
{
    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
    self = rb_struct_lookup(self, *argv);
    if (!--argc) return self;
    ++argv;
    return rb_obj_dig(argc, argv, self, Qnil);
}

Findet und gibt ein Objekt unter verschachtelten Objekten zurück. Die verschachtelten Objekte können Instanzen verschiedener Klassen sein. Siehe Dig-Methoden.

Mit dem Symbol- oder String-Argument name wird das Objekt zurückgegeben, das durch name und identifiers spezifiziert wird.

Foo = Struct.new(:a)
f = Foo.new(Foo.new({b: [1, 2, 3]}))
f.dig(:a) # => #<struct Foo a={:b=>[1, 2, 3]}>
f.dig(:a, :a) # => {:b=>[1, 2, 3]}
f.dig(:a, :a, :b) # => [1, 2, 3]
f.dig(:a, :a, :b, 0) # => 1
f.dig(:b, 0) # => nil

Mit dem Integer-Argument n wird das Objekt zurückgegeben, das durch n und identifiers spezifiziert wird.

f.dig(0) # => #<struct Foo a={:b=>[1, 2, 3]}>
f.dig(0, 0) # => {:b=>[1, 2, 3]}
f.dig(0, 0, :b) # => [1, 2, 3]
f.dig(0, 0, :b, 0) # => 1
f.dig(:b, 0) # => nil

each {|value| ... } → self

each → enumerator

Source

static VALUE
rb_struct_each(VALUE s)
{
    long i;

    RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
    for (i=0; i<RSTRUCT_LEN(s); i++) {
        rb_yield(RSTRUCT_GET(s, i));
    }
    return s;
}

Ruft den gegebenen Block mit dem Wert jedes Mitglieds auf; gibt self zurück.

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.each {|value| p value }

Ausgabe

"Joe Smith"
"123 Maple, Anytown NC"
12345

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

Verwandt: each_pair.

each_pair {|(name, value)| ... } → self

each_pair → enumerator

Source

static VALUE
rb_struct_each_pair(VALUE s)
{
    VALUE members;
    long i;

    RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
    members = rb_struct_members(s);
    if (rb_block_pair_yield_optimizable()) {
        for (i=0; i<RSTRUCT_LEN(s); i++) {
            VALUE key = rb_ary_entry(members, i);
            VALUE value = RSTRUCT_GET(s, i);
            rb_yield_values(2, key, value);
        }
    }
    else {
        for (i=0; i<RSTRUCT_LEN(s); i++) {
            VALUE key = rb_ary_entry(members, i);
            VALUE value = RSTRUCT_GET(s, i);
            rb_yield(rb_assoc_new(key, value));
        }
    }
    return s;
}

Ruft den gegebenen Block mit jedem Mitgliedsnamen/Wert-Paar auf; gibt self zurück.

Customer = Struct.new(:name, :address, :zip) # => Customer
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.each_pair {|(name, value)| p "#{name} => #{value}" }

Ausgabe

"name => Joe Smith"
"address => 123 Maple, Anytown NC"
"zip => 12345"

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

Verwandt: each.

eql?(other) → true oder false

Source

static VALUE
rb_struct_eql(VALUE s, VALUE s2)
{
    if (s == s2) return Qtrue;
    if (!RB_TYPE_P(s2, T_STRUCT)) return Qfalse;
    if (rb_obj_class(s) != rb_obj_class(s2)) return Qfalse;
    if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
        rb_bug("inconsistent struct"); /* should never happen */
    }

    return rb_exec_recursive_paired(recursive_eql, s, s2, s2);
}

Gibt true zurück, wenn und nur wenn die folgenden Bedingungen erfüllt sind; andernfalls gibt false zurück.

other.class == self.class.

Für jeden Mitgliedsnamen name gilt other.name.eql?(self.name).

Customer = Struct.new(:name, :address, :zip)
joe    = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe_jr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe_jr.eql?(joe) # => true
joe_jr[:name] = 'Joe Smith, Jr.'
joe_jr.eql?(joe) # => false

Verwandt: Object#==.

filter

Alias für: select

hash → integer

Source

static VALUE
rb_struct_hash(VALUE s)
{
    long i, len;
    st_index_t h;
    VALUE n;

    h = rb_hash_start(rb_hash(rb_obj_class(s)));
    len = RSTRUCT_LEN(s);
    for (i = 0; i < len; i++) {
        n = rb_hash(RSTRUCT_GET(s, i));
        h = rb_hash_uint(h, NUM2LONG(n));
    }
    h = rb_hash_end(h);
    return ST2FIX(h);
}

Gibt den ganzzahligen Hash-Wert für self zurück.

Zwei Structs derselben Klasse und mit demselben Inhalt haben denselben Hash-Code (und werden mit Struct#eql? verglichen).

Customer = Struct.new(:name, :address, :zip)
joe    = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe_jr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.hash == joe_jr.hash # => true
joe_jr[:name] = 'Joe Smith, Jr.'
joe.hash == joe_jr.hash # => false

Verwandt: Object#hash.

inspect → String

Source

static VALUE
rb_struct_inspect(VALUE s)
{
    return rb_exec_recursive(inspect_struct, s, rb_str_new2("#<struct "));
}

Gibt eine String-Repräsentation von self zurück.

Customer = Struct.new(:name, :address, :zip) # => Customer
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.inspect # => "#<struct Customer name=\"Joe Smith\", address=\"123 Maple, Anytown NC\", zip=12345>"

Auch aliased als: to_s

Länge

Alias für: size

members → array_of_symbols

Source

static VALUE
rb_struct_members_m(VALUE obj)
{
    return rb_struct_s_members_m(rb_obj_class(obj));
}

Gibt die Mitgliedsnamen von self als Array zurück.

Customer = Struct.new(:name, :address, :zip)
Customer.new.members # => [:name, :address, :zip]

Verwandt: to_a.

select {|value| ... } → array

select → enumerator

Source

static VALUE
rb_struct_select(int argc, VALUE *argv, VALUE s)
{
    VALUE result;
    long i;

    rb_check_arity(argc, 0, 0);
    RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
    result = rb_ary_new();
    for (i = 0; i < RSTRUCT_LEN(s); i++) {
        if (RTEST(rb_yield(RSTRUCT_GET(s, i)))) {
            rb_ary_push(result, RSTRUCT_GET(s, i));
        }
    }

    return result;
}

Mit einem gegebenen Block wird ein Array von Werten aus self zurückgegeben, für die der Block einen wahrheitsgemäßen Wert zurückgibt.

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
a = joe.select {|value| value.is_a?(String) }
a # => ["Joe Smith", "123 Maple, Anytown NC"]
a = joe.select {|value| value.is_a?(Integer) }
a # => [12345]

Ohne Block wird ein Enumerator zurückgegeben.

Auch aliased als: filter

size → integer

Source

VALUE
rb_struct_size(VALUE s)
{
    return LONG2FIX(RSTRUCT_LEN(s));
}

Gibt die Anzahl der Mitglieder zurück.

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.size #=> 3

Auch aliased als: length

to_a → array

Source

static VALUE
rb_struct_to_a(VALUE s)
{
    return rb_ary_new4(RSTRUCT_LEN(s), RSTRUCT_CONST_PTR(s));
}

Gibt die Werte in self als Array zurück.

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.to_a # => ["Joe Smith", "123 Maple, Anytown NC", 12345]

Verwandt: members.

Auch aliased als: values, deconstruct

to_h → hash

to_h {|name, value| ... } → hash

Source

static VALUE
rb_struct_to_h(VALUE s)
{
    VALUE h = rb_hash_new_with_size(RSTRUCT_LEN(s));
    VALUE members = rb_struct_members(s);
    long i;
    int block_given = rb_block_given_p();

    for (i=0; i<RSTRUCT_LEN(s); i++) {
        VALUE k = rb_ary_entry(members, i), v = RSTRUCT_GET(s, i);
        if (block_given)
            rb_hash_set_pair(h, rb_yield_values(2, k, v));
        else
            rb_hash_aset(h, k, v);
    }
    return h;
}

Gibt einen Hash zurück, der den Namen und Wert für jedes Mitglied enthält.

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
h = joe.to_h
h # => {:name=>"Joe Smith", :address=>"123 Maple, Anytown NC", :zip=>12345}

Wenn ein Block gegeben ist, wird er mit jedem Namen/Wert-Paar aufgerufen; der Block sollte ein 2-elementiges Array zurückgeben, dessen Elemente ein Schlüssel/Wert-Paar im zurückgegebenen Hash bilden.

h = joe.to_h{|name, value| [name.upcase, value.to_s.upcase]}
h # => {:NAME=>"JOE SMITH", :ADDRESS=>"123 MAPLE, ANYTOWN NC", :ZIP=>"12345"}

Löst ArgumentError aus, wenn der Block einen ungeeigneten Wert zurückgibt.

to_json (*args)

Source

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

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

require 'json/add/struct'
Customer = Struct.new('Customer', :name, :address, :zip)
puts Struct::Customer.new.to_json

Ausgabe

{"json_class":"Struct","t":{'name':'Rowdy',"age":null}}

to_s

Alias für: inspect

values

Alias für: to_a

values_at(*integers) → array

values_at(integer_range) → array

Source

static VALUE
rb_struct_values_at(int argc, VALUE *argv, VALUE s)
{
    return rb_get_values_at(s, RSTRUCT_LEN(s), argc, argv, struct_entry);
}

Gibt ein Array von Werten aus self zurück.

Mit den Integer-Argumenten integers wird ein Array zurückgegeben, das jeden Wert enthält, der durch eine der integers gegeben ist.

Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.values_at(0, 2)    # => ["Joe Smith", 12345]
joe.values_at(2, 0)    # => [12345, "Joe Smith"]
joe.values_at(2, 1, 0) # => [12345, "123 Maple, Anytown NC", "Joe Smith"]
joe.values_at(0, -3)   # => ["Joe Smith", "Joe Smith"]

Löst IndexError aus, wenn eine der integers außerhalb des Bereichs liegt; siehe Array-Indizes in Array.

Mit dem Integer-Range-Argument integer_range wird ein Array zurückgegeben, das jeden Wert enthält, der durch die Elemente des Bereichs gegeben ist; füllt mit nil-Werten für Bereichselemente, die größer als die Struktur sind.

joe.values_at(0..2)
# => ["Joe Smith", "123 Maple, Anytown NC", 12345]
joe.values_at(-3..-1)
# => ["Joe Smith", "123 Maple, Anytown NC", 12345]
joe.values_at(1..4) # => ["123 Maple, Anytown NC", 12345, nil, nil]

Löst RangeError aus, wenn ein Element des Bereichs negativ und außerhalb des Bereichs liegt; siehe Array-Indizes in Array.

class Struct

Methoden zum Erstellen einer Struct-Unterklasse

Methoden zum Erstellen einer `Struct`-Unterklasse