Как понимать символы в Ruby

Учти это:

x = :sym
y = :sym
(x.__id__ == y.__id__ ) && ( :sym.__id__ == x.__id__) # => true

x = "string"
y = "string"
(x.__id__ == y.__id__ ) || ( "string".__id__ == x.__id__) # => false

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

(В ответ на комментарий ниже)

В исходной статье значение не хранится в символе, оно хранится в хэше. Учти это:

hash1 = { "string" => "value"}
hash2 = { "string" => "value"}

Это создает шесть объектов в памяти - четыре строковых объекта и два хэш-объекта.

hash1 = { :symbol => "value"}
hash2 = { :symbol => "value"}

Это создает в памяти только пять объектов - один символ, две строки и два хеш-объекта.

Когда я думал об этом вот так, я мог гробить символы. Строка Ruby - это объект, у которого есть набор методов и свойств. Людям нравится использовать строки для ключей, а когда строка используется для ключа, все эти дополнительные методы не используются. Поэтому они создали символы, которые представляют собой строковые объекты, из которых удалены все функции, за исключением того, что необходимо для того, чтобы он был хорошим ключом.

Просто думайте о символах как о постоянных строках.

Символ :ruby не содержит "red" или "programming". Символ :ruby - это просто символ :ruby. Это ваши хэши, patient1 и patient2, каждый из которых содержит эти значения, в каждом случае на которые указывает один и тот же ключ.

Подумайте об этом так: если вы войдете в гостиную в рождественское утро и увидите две коробки с биркой, на которой написано «Кеззер». У одного есть носки, а у другого - уголь. Вы не запутаетесь и не спросите, как «Кеззер» может содержать и носки, и уголь, хотя это одно и то же название. Потому что в названии нет (дерьмовых) подарков. Он просто указывает на них. Точно так же :ruby не содержит значений в вашем хэше, он просто указывает на них.

Вы можете предположить, что сделанное вами объявление определяет значение символа как нечто иное, чем то, что оно есть на самом деле. Фактически, символ - это просто «внутреннее» строковое значение, которое остается постоянным. Поскольку они хранятся с использованием простого целочисленного идентификатора, они часто используются, поскольку это более эффективно, чем управление большим количеством строк переменной длины.

Рассмотрим ваш пример:

patient1 = { :ruby => "red" }

Это следует читать как: «объявить переменную пациента1 и определить ее как хэш, и в этом хранилище значение« красный »под ключом (символ« рубин »)»

Другой способ написать это:

patient1 = Hash.new
patient1[:ruby] = 'red'

puts patient1[:ruby]
# 'red'

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

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

Каждый объект String отличается, даже если значения идентичны:

[ "foo", "foo", "foo", "bar", "bar", "bar" ].each do |v|
  puts v.inspect + ' ' + v.object_id.to_s
end

# "foo" 2148099960
# "foo" 2148099940
# "foo" 2148099920
# "bar" 2148099900
# "bar" 2148099880
# "bar" 2148099860

Каждый символ с одинаковым значением относится к одному и тому же объекту:

[ :foo, :foo, :foo, :bar, :bar, :bar ].each do |v|
  puts v.inspect + ' ' + v.object_id.to_s
end

# :foo 228508
# :foo 228508
# :foo 228508
# :bar 228668
# :bar 228668
# :bar 228668

Преобразование строк в символы сопоставляет одинаковые значения с одним и тем же уникальным символом:

[ "foo", "foo", "foo", "bar", "bar", "bar" ].each do |v|
  v = v.to_sym
  puts v.inspect + ' ' + v.object_id.to_s
end

# :foo 228508
# :foo 228508
# :foo 228508
# :bar 228668
# :bar 228668
# :bar 228668

Точно так же преобразование из символа в строку создает каждый раз отдельную строку:

[ :foo, :foo, :foo, :bar, :bar, :bar ].each do |v|
  v = v.to_s
  puts v.inspect + ' ' + v.object_id.to_s
end

# "foo" 2148097820
# "foo" 2148097700
# "foo" 2148097580
# "bar" 2148097460
# "bar" 2148097340
# "bar" 2148097220

Вы можете думать о значениях символов как о взятых из внутренней хеш-таблицы, и вы можете видеть все значения, которые были закодированы в символы, используя простой вызов метода:

Symbol.all_values

# => [:RUBY_PATCHLEVEL, :vi_editing_mode, :Separator, :TkLSHFT, :one?, :setuid?, :auto_indent_mode, :setregid, :back, :Fail, :RET, :member?, :TkOp, :AP_NAME, :readbyte, :suspend_context, :oct, :store, :WNOHANG, :@seek, :autoload, :rest, :IN_INPUT, :close_read, :type, :filename_quote_characters=, ...

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

Символы - это не указатели. Они не содержат значений. Символы просто есть. :ruby - это символ :ruby, и это все, что ему нужно. Он не содержит значения, он ничего не делает, он просто существует как символ :ruby. Символ :ruby - это такое же значение, как и число 1. Оно не указывает на другое значение больше, чем число 1.

patient1.each_key {|key| puts key.to_s}

Тогда что будет на выходе? «красный» или «программирование»?

И "рубин" тоже не будет.

Вы путаете символы и хеши. Они не связаны между собой, но вместе полезны. Рассматриваемый символ - :ruby; он не имеет ничего общего со значениями в хэше, и его внутреннее целочисленное представление всегда будет одним и тем же, и его «значение» (при преобразовании в строку) всегда будет «рубиновым».

Короче

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

Почему: красный лучше, чем красный

В динамических объектно-ориентированных языках вы создаете сложные вложенные структуры данных с читаемыми ссылками. Обычно используется хеш , где вы сопоставляете значения с уникальными ключами - уникальными, по крайней мере, для каждого экземпляра. У вас не может быть более одного «красного» ключа на хеш.