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

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

См. также 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 10
def self.json_create(object)
  new(*object['v'])
end

Десериализует строку JSON, создавая новый объект Struct со значениями v сериализованными с помощью to_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: false){|Struct_subclass| ... } → Struct_subclass Показать исходный код

new(class_name, *member_names, keyword_init: false){|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, rest, keyword_init = Qnil;
    long i;
    VALUE st;
    st_table *tbl;
    VALUE opt;

    argc = rb_scan_args(argc, argv, "1*:", NULL, NULL, &opt);
    name = argv[0];
    if (SYMBOL_P(name)) {
        name = Qnil;
    }
    else {
        --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);
    OBJ_WB_UNPROTECT(rest);
    tbl = RHASH_TBL_RAW(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 (st_insert(tbl, mem, Qtrue)) {
            rb_raise(rb_eArgError, "duplicate member: %"PRIsVALUE, mem);
        }
    }
    rest = rb_hash_keys(rest);
    st_clear(tbl);
    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"

Имена членов

Символьные аргументы 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

Метод ::[] — псевдоним метода ::new.

Метод :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 Show 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);
}

Возвращает 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 Show source

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 Show source

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

# File ext/json/lib/json/add/struct.rb, line 16
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

Возвращает хеш, который будет преобразован в объект JSON и будет представлять этот объект.

deconstruct()

Возвращает значения в 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]

Struct#values и Struct#deconstruct являются псевдонимами для Struct#to_a.

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

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

deconstruct_keys(array_of_names) → hash Show 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;
}

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

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 Show source

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 Show source

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 Show source

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

Возвращает 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(*args)

Если блок задан, возвращает массив значений из 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.

Struct#filter является псевдонимом для Struct#select.

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

hash → integer Show 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);
}

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

Две структуры одного класса и с одинаковым содержимым будут иметь один и тот же хэш-код (и будут сравниваться с помощью 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 Show source

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

Struct#to_s является псевдонимом для Struct#inspect.

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

length()

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

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

Struct#length является псевдонимом для Struct#size.

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

members → array_of_symbols Show source

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

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.

Struct#filter — псевдоним для Struct#select.

Также алиасируется как: 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

Struct#length — псевдоним для Struct#size.

Также алиасируется как: 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]

Struct#values и Struct#deconstruct — псевдонимы для Struct#to_a.

Связанные: 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 27
def to_json(*args)
  as_json.to_json(*args)
end

Сохраняет имя класса (Struct) со значениями Struct v в виде строки JSON. Поддерживаются только именованные структуры.

to_s()

Возвращает строковое представление 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>"

Struct#to_s — псевдоним для Struct#inspect.

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

values()

Возвращает значения в 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]

Struct#values и Struct#deconstruct — псевдонимы для Struct#to_a.

Связанные: members.

Псевдоним для: 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.