Was ist der Doppelpunktoperator in Ruby?

Wenn ich sage { :bla => 1, :bloop => 2 }, was genau macht das :? Ich habe irgendwo darüber gelesen, wie ähnlich es einer Zeichenfolge ist, aber irgendwie ein Symbol.

Ich bin nicht ganz klar über das Konzept, könnte mich jemand aufklären?

:fooist ein Symbol namens "foo". Symbole haben die Besonderheit, dass zwei beliebige gleichnamige Symbole identisch sind:

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

Dies macht das Vergleichen von zwei Symbolen sehr schnell (da nur ein Zeigervergleich erforderlich ist, im Gegensatz zum Vergleichen aller Zeichen wie in einer Zeichenfolge), und Sie haben nicht zig Kopien desselben Symbols im Umlauf.

Im Gegensatz zu Zeichenfolgen sind Symbole auch unveränderlich.

Nur um einige der in den Antworten genannten Dinge zu demonstrieren:

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

Beim Ausführen werden folgende Ausgaben ausgeführt:

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

Der Vergleich einer Zeichenfolge mit einer Zeichenfolge unter Verwendung equal?schlägt fehl, da es sich um unterschiedliche Objekte handelt, auch wenn sie den gleichen Inhalt haben. ==vergleicht den Inhalt und die entsprechenden Überprüfungen mit Symbolen sind viel schneller.

                 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)

Beide Symboltests sind grundsätzlich hinsichtlich der Geschwindigkeit gleich. Nach 1.000.000 Iterationen gibt es nur einen Unterschied von 0,004733 Sekunden. Ich würde also sagen, es ist eine Wäsche, zwischen der verwendet werden muss.

Symbole sind eine Möglichkeit, Zeichenfolgen und Namen in Rubin darzustellen.

Der Hauptunterschied zwischen Symbolen und Zeichenfolgen besteht darin, dass gleichnamige Symbole initialisiert werden und während einer Rubinsitzung nur einmal im Speicher vorhanden sind.

Sie sind nützlich, wenn Sie dasselbe Wort verwenden müssen, um verschiedene Dinge darzustellen

Es gibt einige Zitate aus dem berühmten Buch Agile Web Development with Rails , die hilfreich sein können, um das Symbol ebenfalls zu verstehen :

Rails verwendet Symbole, um Dinge zu identifizieren. Insbesondere werden sie als Schlüssel verwendet, wenn Methodenparameter benannt und in Hashes nachgeschlagen werden.

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

Sie können sich Symbole als Zeichenfolgenliterale vorstellen, die auf magische Weise zu Konstanten gemacht werden. Alternativ können Sie den Doppelpunkt als "das benannte Ding" betrachten, also: id ist "das Ding mit dem Namen id".

In Ruby hat jedes Objekt eine eindeutige Objektkennung. Wenn Sie puts "hello".object_idin Ihren irb schreiben und zweimal auf die Eingabetaste drücken, erhalten Sie zwei verschiedene Rückgabewerte. Wenn Sie jedoch :hello.object_idzwei Mal schreiben, erhalten Sie nur denselben Rückgabewert. Das hätte den Unterschied erklären sollen.

Wenn Sie verwenden :foo => bar, wird foo ein Symbol sein. Symbole haben den Vorteil, dass sie einzigartig sind. Wenn Sie ein Element im Hash aufrufen, tun Sie dies hash[:foo].

Symbole benötigen weniger Speicher als Zeichenfolgen, was sie auch nützlich macht, wenn Sie Ihr Programm etwas schneller machen möchten.

Es ist ein Symbol. Grundsätzlich sagen Sie, dass die beiden Elemente des Hash Schlüssel haben blaund bloop, als hätten Sie die Zeichenfolgen "bla"und verwendet "bloop". Sie benötigen jedoch weniger Speicher als Zeichenfolgen und sind einfacher zu tippen.

Alle diese Antworten lassen ein zusätzliches verlockendes Detail aus. Wenn Sie das Symbol stringieren: foo, erhalten Sie ... raten Sie mal ... die Zeichenfolge "foo". Daher

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>

Daher ist es für Perl-Programmierer Rubys Antwort auf das "bloße Wort".

Wenn Sie mit Java vertraut sind, wissen Sie möglicherweise, dass Strings in Java unveränderlich sind. Symbole sind in diesem Sinne in Ruby ähnlich. Sie sind unveränderlich, dh eine beliebige Anzahl von Vorkommen eines bestimmten Symbols :symbolwird nur einer einzigen Speicheradresse zugeordnet. Daher wird empfohlen, wo immer möglich Symbole zu verwenden, da dies die Speichernutzung optimiert.