Ruby 中的冒号运算符是什么？

Question

当我说 { :bla =>; 1、:bloop => 2 }，: 到底是做什么的？我在某处读到它与字符串相似，但在某种程度上是一个符号。

我对这个概念不是很清楚，有人可以启发我吗？

Answer 1

:foo 是一个名为“foo”的符号。符号具有一个独特的特征，即任何两个名称相同的符号都将是相同的：

"foo".equal? "foo"  # false
:foo.equal? :foo    # true

这使得比较两个符号非常快（因为只涉及指针比较，而不是像字符串中那样比较所有字符），而且您还赢了不会有无数相同符号的副本漂浮在周围。

此外，与字符串不同，符号是不可变的。

Answer 2

只是为了演示答案中提到的一些内容：

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 秒的差异，所以我想说这是使用的一次清洗。

Answer 3

符号是 ruby​​ 中表示字符串和名称的一种方式。

符号和字符串之间的主要区别在于，同名符号在 ruby​​ 会话期间仅被初始化并在内存中仅存在一次。

当您需要使用相同的单词来表示不同的事物时，它们非常有用

Answer 4

有一些引自名著Agile Web Development with Rails的内容，可能也有助于理解符号：

Rails 使用符号来识别事物。特别是，在命名方法参数和在哈希中查找内容时，它使用它们作为键。

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

您可以将符号视为字符串文字，它们被神奇地制成常量。或者，您可以将冒号视为“名为的事物”，因此 :id 是“名为 id 的事物”。

Answer 5

在 ruby​​ 中，每个对象都有一个唯一的对象标识符，如果您在 irb 中写入 puts "hello".object_id 并按回车键 2 次不同的时间，您将获得 2 个不同的返回值，但是如果您写入 < code>:hello.object_id 2次你只会得到相同的返回值。
这应该可以解释其中的差异。

Answer 6

如果您使用 :foo =>; bar, foo 将是一个符号。符号的好处是它们是独一无二的。当您调用哈希中的某个项目时，您会执行hash[:foo]。

符号比字符串需要更少的内存，如果你想让你的程序更快一点，这也使得它们很有用。

Answer 7

所有这些答案都忽略了一个额外的诱人细节..如果你将符号 :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 程序员来说，这是 Ruby 对“裸词”的回答。

Answer 8

这是一个象征。基本上，您是说散列的两个元素具有键 bla 和 bloop，就像您使用了字符串 "bla"和“bloop”。然而，它们比字符串占用更少的内存并且更容易输入。

Answer 9

如果您熟悉 Java，您可能会知道 Java 中的字符串是不可变的。 Ruby 中的符号在这个意义上是相似的。它们是不可变的，即，特定符号 :symbol 出现任意次数都将仅映射到单个内存地址。因此，建议尽可能使用符号，因为它可以优化内存使用。