класс Struct

Родитель:: Объект
Включенные модули:: Перечисляемый

Класс Struct предоставляет удобный способ создания простого класса, который может хранить и извлекать значения.

Этот пример создаёт подкласс Struct, Struct::Customer; первый аргумент, строка, — имя подкласса; другие аргументы, символы, определяют члены нового подкласса.

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

Каждому члену соответствуют два метода, записывающий и считывающий значения:

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

Экземпляр подкласса может быть создан, и его члены могут получить значения с помощью метода ::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>

Значения членов могут быть обработаны так:

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

И так; обратите внимание, что имя члена может быть выражено либо как строка, либо как символ:

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

См. Struct::new.

Что здесь

Сначала, что где-то ещё. Класс Struct:

Наследуется от класса Объект.
Включает модуль Перечисляемый, который предоставляет десятки дополнительных методов.

См. также Data, что является несколько похожим, но более строгим понятием для определения неизменяемых объектов значений.

Здесь класс Struct предоставляет методы, которые полезны для:

Методы для создания подкласса `Struct`

::new: Возвращает новый подкласс Struct.

Методы для запросов

hash: Возвращает целое число хеш-код.
length, size: Возвращает количество членов.

Методы для сравнения

==: Возвращает, равен ли заданный объект self, используя == для сравнения значений членов.
eql?: Возвращает, равен ли заданный объект self, используя eql? для сравнения значений членов.

Методы для извлечения

[]: Возвращает значение, связанное с заданным именем члена.
to_a, values, deconstruct: Возвращает значения членов в self в виде массива.
deconstruct_keys: Возвращает хеш пар имя/значение для заданных имён членов.
dig: Возвращает объект во вложенных объектах, который задаётся данным именем члена и дополнительными аргументами.
members: Возвращает массив имён членов.
select, filter: Возвращает массив значений членов из self, отобранных с помощью заданного блока.
values_at: Возвращает массив, содержащий значения для заданных имён членов.

Методы для присвоения

[]=: Присваивает заданное значение заданному имени члена.

Методы для итерации

each: Вызывает заданный блок с каждым именем члена.
each_pair: Вызывает заданный блок с каждой парой имя/значение члена.

Методы для преобразования

inspect, to_s: Возвращает строковое представление self.
to_h: Возвращает хеш пар имя/значение членов в self.

Публичные методы класса

json_create(object) Показать исходный код

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

См. as_json.

StructClass::keyword_init? → true or falsy value Показать исходный код

static VALUE
rb_struct_s_keyword_init_p(VALUE obj)
{
}

Возвращает true если класс был инициализирован с keyword_init: true. В противном случае возвращает nil или false.

Примеры:

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 Показать исходный код

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

    return rb_ary_dup(members);
}

Возвращает имена членов потомка Struct в виде массива:

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

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_RAW(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 возвращает новый подкласс Struct. Новый подкласс:

Может быть анонимным или иметь имя, заданное class_name.
Может иметь члены, заданные member_names.
Может иметь инициализацию через обычные аргументы или через ключевые аргументы

Новый подкласс имеет свой собственный метод ::new; таким образом:

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

Имя класса

Со строковым аргументом class_name, возвращает новый подкласс Struct с именем Struct::class_name:

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

Без строкового аргумента class_name, возвращает новый анонимный подкласс Struct:

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

Блок

С заданным блоком, созданный подкласс передаётся в блок:

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"

Вывод, из Struct.new:

"The new subclass is Struct::Customer"

Имена членов

Symbol аргументы member_names определяют члены нового подкласса:

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

Новый подкласс имеет методы экземпляра, соответствующие member_names:

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>

Методы одиночки

Подкласс, возвращённый Struct.new, имеет следующие методы одиночки:

Метод ::new создаёт экземпляр подкласса:

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

Метод :inspect возвращает строковое представление подкласса:
```
Foo.inspect
# => "Struct::Foo"
```
Метод ::members возвращает массив имён членов:
```
Foo.members # => [:foo, :bar]
```

Ключевой аргумент

По умолчанию, аргументы для инициализации экземпляра нового подкласса могут быть как позиционными, так и ключевыми аргументами.

Необязательный ключевой аргумент keyword_init: позволяет принудительно принять только один тип аргументов:

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>

Публичные методы экземпляра

self == other → true or false Показать исходный код

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);
}

Возвращает true тогда и только тогда, когда истинны следующие условия; в противном случае возвращает false:

other.class == self.class.
Для каждого имени члена name, other.name == 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 == joe # => true
joe_jr[:name] = 'Joe Smith, Jr.'
# => "Joe Smith, Jr."
joe_jr == joe # => false

struct[name] → object Показать исходный код

struct[n] → object

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);
}

Возвращает значение из self.

С аргументом-символом или строкой name возвращает значение для именованного члена:

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

Вызывает NameError, если name не является именем члена.

С целочисленным аргументом n возвращает self.values[n], если n находится в диапазоне; см. Индексы массива в Array:

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

Вызывает IndexError, если n находится вне диапазона.

struct[name] = value → value Показать исходный код

struct[n] = value → value

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;
}

Присваивает значение члену.

С аргументом-символом или строкой name присваивает заданное value именованному члену; возвращает value:

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>

Вызывает NameError, если name не является именем члена.

С целочисленным аргументом n присваивает заданное value n-му члену, если n находится в диапазоне; см. Индексы массива в 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>

Вызывает IndexError, если n находится вне диапазона.

as_json(*) Показать исходный код

# 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

Методы Struct#as_json и Struct.json_create могут использоваться для сериализации и десериализации объекта Struct; см. Marshal.

Метод Struct#as_json сериализует self, возвращая 2-элементный хэш, представляющий self:

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

Метод JSON.create десериализует такой хэш, возвращая объект Struct:

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

deconstruct

Псевдоним для: to_a

deconstruct_keys(array_of_names) → hash Показать исходный код

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;
}

Возвращает хэш пар имя/значение для заданных имен членов.

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

Возвращает все имена и значения, если array_of_names является nil:

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

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);
}

Находит и возвращает объект среди вложенных объектов. Вложенные объекты могут быть экземплярами различных классов. См. Методы Dig.

С аргументом-символом или строкой name, возвращает объект, указанный name и identifiers:

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

С целочисленным аргументом n, возвращает объект, указанный n и identifiers:

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

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;
}

Вызывает данный блок со значением каждого члена; возвращает self:

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

Вывод:

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

Возвращает Enumerator, если блок не задан.

Связанный метод: each_pair.

each_pair {|(name, value)| ... } → self Показать исходный код

each_pair → enumerator

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;
}

Вызывает данный блок с каждой парой имя/значение члена; возвращает self:

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

Вывод:

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

Возвращает Enumerator, если блок не задан.

Связанный метод: each.

eql?(other) → true or false Показать исходный код

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);
}

Возвращает true тогда и только тогда, когда истинны следующие условия; в противном случае возвращает false:

other.class == self.class.

Для каждого имени члена name, 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

Связанный метод: Object#==.

filter

Псевдоним для: select

hash → integer Показать исходный код

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);
}

Возвращает целочисленное значение хэша для self.

Два struct одного класса и с одинаковым содержимым будут иметь одинаковый хэш-код (и будут сравниваться с использованием Struct#eql?):

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

Связанный метод: Object#hash.

inspect → string Показать исходный код

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

Возвращает строковое представление self:

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

Также имеет псевдоним: to_s

length

Псевдоним для: size

members → array_of_symbols Показать исходный код

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

Возвращает имена членов из self в виде массива:

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

Связанный метод: to_a.

select {|value| ... } → array Показать исходный код

select → enumerator

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;
}

С заданным блоком возвращает массив значений из self, для которых блок возвращает истинное значение:

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]

Без блока возвращает Enumerator.

Также имеет псевдоним: filter

size → целое Показать исходный код

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

Возвращает количество элементов.

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

Также алиасируется как: length

to_a → массив Показать исходный код

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

Возвращает значения из self в виде массива:

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]

Связанно с: members.

Также алиасируется как: values, deconstruct

to_h → хэш Показать исходный код

to_h {|name, value| ... } → хэш

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;
}

Возвращает хэш, содержащий имя и значение для каждого элемента:

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}

Если задан блок, он вызывается с каждой парой имя/значение; блок должен вернуть массив из 2 элементов, которые станут парой ключ/значение в возвращаемом хэше:

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

Вызывает ArgumentError, если блок возвращает неподходящее значение.

to_json(*args) Показать исходный код

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

Возвращает строку JSON, представляющую self:

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

Вывод:

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

to_s

Псевдоним для: inspect

values

Псевдоним для: to_a

values_at(*целые) → массив

values_at(диапазон_целых) → массив

Показать исходный код

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);
}

Возвращает массив значений из self.

При целочисленных аргументах integers возвращает массив, содержащий каждое значение, заданное одним из integers:

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

Вызывает IndexError, если какой-либо из integers находится за пределами диапазона; см. Индексы массивов в Array.

При целочисленном аргументе диапазона integer_range возвращает массив, содержащий каждое значение, заданное элементами диапазона; заполняет nil значениями для элементов диапазона, больших, чем структура:

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]

Вызывает RangeError, если какой-либо элемент диапазона отрицательный и находится за пределами диапазона; см. Индексы массивов в Array.

Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

класс Struct

Что здесь

Методы для создания подкласса Struct

Методы для запросов

Методы для сравнения

Методы для извлечения

Методы для присвоения

Методы для итерации

Методы для преобразования

Методы для создания подкласса `Struct`