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

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

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

Создание подкласса 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.

Константы

Group

Group

Group это Struct, доступный только при компиляции с HAVE_GETGRENT.

Структура содержит следующие члены:

name

содержит имя группы в виде String.

passwd

содержит зашифрованный пароль в виде String. Возвращает ‘x’, если доступ к паролю группы отсутствует; возвращает пустую строку, если пароль не требуется для получения членства в группе.

Требуется компиляция с HAVE_STRUCT_GROUP_GR_PASSWD.

gid

содержит числовой идентификатор группы в виде целого числа.

mem

является Array строк, содержащих короткие логины членов группы.

Passwd

Passwd

Passwd это Struct, содержащий следующие члены:

name: содержит короткое имя входа пользователя в виде String.
passwd: содержит зашифрованный пароль пользователя в виде String. Возвращает ‘x’, если используются теневые пароли. Возвращает ‘*’, если пользователь не может войти с помощью пароля.
uid: содержит целочисленный идентификатор пользователя (uid).
gid: содержит целочисленный идентификатор группы (gid) основной группы пользователя.
dir: содержит путь к домашнему каталогу пользователя в виде String.
shell: содержит путь к входной оболочке пользователя в виде String.

Следующие члены ниже являются необязательными и должны быть скомпилированы со специальными флагами:

gecos: содержит более подробное описание пользователя в виде String, например, полное имя. Некоторые системы Unix предоставляют структурированную информацию в поле gecos, но это зависит от системы. Требуется компиляция с HAVE_STRUCT_PASSWD_PW_GECOS
change: время изменения пароля (целое число). Требуется компиляция с HAVE_STRUCT_PASSWD_PW_CHANGE
quota: значение квоты (целое число). Требуется компиляция с HAVE_STRUCT_PASSWD_PW_QUOTA
age: возраст пароля (целое число). Требуется компиляция с HAVE_STRUCT_PASSWD_PW_AGE
class: класс доступа пользователя (строка). Требуется компиляция с HAVE_STRUCT_PASSWD_PW_CLASS
comment: комментарий (строка). Требуется компиляция с HAVE_STRUCT_PASSWD_PW_COMMENT
expire: время истечения срока действия учетной записи (целое число). Требуется компиляция с HAVE_STRUCT_PASSWD_PW_EXPIRE

Методы публичного класса

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

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

    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
    name = argv[0];
    if (SYMBOL_P(name)) {
        name = Qnil;
    }
    else {
        --argc;
        ++argv;
    }

    if (RB_TYPE_P(argv[argc-1], T_HASH)) {
        static ID keyword_ids[1];

        if (!keyword_ids[0]) {
            keyword_ids[0] = rb_intern("keyword_init");
        }
        rb_get_kwargs(argv[argc-1], keyword_ids, 0, 1, &keyword_init);
        if (keyword_init == Qundef) {
            keyword_init = Qnil;
        }
        else if (RTEST(keyword_init)) {
            keyword_init = Qtrue;
        }
        --argc;
    }

    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.
Может быть инициализирован обычными аргументами (по умолчанию) или ключевыми аргументами (если задан keyword_init: true).

Новый подкласс имеет свой собственный метод ::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

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

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

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

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

# Without keyword_init: true.
Foo = Struct.new('Foo', :foo, :bar)
Foo                     # => Struct::Foo
Foo.new(0, 1)           # => #<struct Struct::Foo foo=0, bar=1>
# With keyword_init: true.
Bar = Struct.new(:foo, :bar, keyword_init: true)
Bar # =>                # => Bar(keyword_init: true)
Bar.new(bar: 1, foo: 0) # => #<struct Bar foo=0, bar=1>

Общедоступные методы экземпляров

self == other → true или 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 находится в допустимом диапазоне; см. Индексы массивов:

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 находится в допустимом диапазоне; см. Индексы массивов:

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

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

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

При использовании символьного или строкового аргумента 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 или 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).

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

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

static VALUE
rb_struct_inspect(VALUE s)
{
    return rb_exec_recursive(inspect_struct, s, 0);
}

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

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}

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

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

values_at(integer_range) → массив

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 находится за пределами диапазона; см. Индексы массива.

При целочисленном аргументе диапазона 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, если какой-либо элемент диапазона отрицательный и выходит за пределы диапазона; см. Индексы массива.

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

класс Struct

Что здесь

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

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

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

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

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

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

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

Следующие члены ниже являются необязательными и должны быть скомпилированы со специальными флагами:

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