класс Struct

Родитель:: Объект
Включенные модули:: Enumerable

Класс 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:

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

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

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

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

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

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

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

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

==: Возвращает, является ли заданный объект равным 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 или ложное значение

Исходный код

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 → массив_символов

Исходный код

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(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 → строка

Исходный код

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 → массив_символов

Исходный код

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 {|значение| ... } → массив

select → перечислитель

Исходный код

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 {|имя, значение| ... } → хэш

Исходный код

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–2024 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

класс Struct

Что здесь

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

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

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

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

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

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

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

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