Что такое оператор двоеточия в Ruby?

просто чтобы продемонстрировать некоторые из вещей, упомянутых в ответах:

require 'benchmark'

n = 1_000_000

print '"foo".equal? "foo" -> ', ("foo".equal? "foo"), "\n"
print '"foo" == "foo"     -> ', ("foo" == "foo"    ), "\n"
print ':foo.equal? :foo   -> ', (:foo.equal? :foo  ), "\n"
print ':foo == :foo       -> ', (:foo == :foo      ), "\n"

Benchmark.bm(10) do |b|
  b.report('string')     { n.times { "foo".equal? "foo" }}
  b.report('str == str') { n.times { "foo" == "foo"     }}
  b.report('symbol')     { n.times { :foo.equal? :foo   }}
  b.report('sym == sym') { n.times { :foo == :foo       }}
end

запуск он выдает:

"foo".equal? "foo" -> false
"foo" == "foo"     -> true
:foo.equal? :foo   -> true
:foo == :foo       -> true

Итак, сравнивая строку со строкой с помощью equal? не удается, потому что они разные объекты, даже если они равны по содержанию. == сравнивает содержимое, и эквивалентные проверки с символами намного быстрее.

                 user     system      total        real
string       0.370000   0.000000   0.370000 (  0.371700)
str == str   0.330000   0.000000   0.330000 (  0.326368)
symbol       0.170000   0.000000   0.170000 (  0.174641)
sym == sym   0.180000   0.000000   0.180000 (  0.179374)

оба символа тесты в основном то же самое, что и скорость. После 1,000,000 итераций есть только 0.004733 второе отличие, поэтому я бы сказал, что это стирка, между которой можно использовать.

символы-это способ представления строк и имен в ruby.

основное различие между символами и строками заключается в том, что символы с одинаковым именем инициализируются и существуют в памяти только один раз во время сеанса ruby.

Они полезны, когда вам нужно использовать одно и то же слово для представления разных вещей

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

Rails использует символы для идентификации вещей. В частности, он использует их в качестве ключей при именовании параметров метода и поиске вещей в хэшах.

redirect_to :action => "edit", :id => params[:id]

вы можете думать о символах как о строковых литералах, которые волшебным образом превращаются в константы. Кроме того, вы можете рассмотрим двоеточие в значении "вещь по имени", так :идентификатор-это "вещь, которая называется ID".

в Ruby каждый объект имеет уникальный идентификатор объекта, если вы пишите puts "hello".object_id в вашем irb и нажмите return для 2 разных раз, вы получите 2 разных возвращаемых значения,но если вы пишете :hello.object_id 2 раза вы получите только одно возвращаемое значение. Это должно было объяснить разницу.

Если вы используете :foo => bar, foo будет символом. Преимущество символов в том, что они уникальны. Когда вы вызываете элемент в хэше, вы делаете hash[:foo].

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

это символ. В принципе, вы говорите, что два элемента хэша имеют ключи bla и bloop, как если бы вы использовали строки "bla" и "bloop". Однако они занимают меньше памяти, чем строки, и их легче вводить.

все эти ответы опускают одну дополнительную мучительную деталь.. если вы строчите символ: foo, вы получаете.. угадай, что.. строка "foo". Отсюда

irb(main):025:0>
irb(main):026:0> :foo
=> :foo
irb(main):027:0> "#{:foo}"
=> "foo"
irb(main):028:0>
irb(main):029:0> 'foo' <=> :foo
=> nil
irb(main):030:0> 'foo' <=> :foo.to_s
=> 0
irb(main):031:0>

отсюда.. для Perl-программистов.. это ответ Руби на "голое слово".

Если вы знакомы с Java, вы можете знать, что строки в Java являются неизменяемыми. Символы похожи в этом смысле в Ruby. Они неизменны, т. е. любое количество вхождений определенного символа :symbol будет отображаться только на один адрес памяти. И, следовательно, рекомендуется использовать символы везде, где это возможно, так как это оптимизирует использование памяти.