InhaltsverzeichnisKlicke auf den Link, um zur gewünschten Stelle zu navigieren
Dieser Inhalt wurde automatisch aus dem Ukrainischen übersetzt.
Zuerst müssen wir klären, was immediate value und reference in Ruby sind.
Unmittelbarer Wert (immediate value) in der Programmiersprache ist ein Wert, der direkt in einer Variablen oder einem Objekt gespeichert wird, ohne auf einen anderen Speicherbereich zu verweisen. Das kann eine Zahl, ein Symbol, true, false oder nil sein. Zum Beispiel, wenn Sie einer Variablen eine Zahl zuweisen, ist das ein unmittelbarer Wert.
Referenz (reference) verweist auf den Speicherbereich, in dem ein Objekt gespeichert ist. Objekte, die normalerweise über Referenzen gespeichert werden, umfassen Strings, Arrays, Hashes und Objekte von Klassen. Wenn Sie mit einem Objekt über eine Referenz arbeiten, arbeiten Sie tatsächlich mit dem Speicherbereich, in dem das Objekt selbst gespeichert ist.
In dem Beitrag über die Zuweisung einer Variablen in ruby haben wir das Konzept der Referenz (reference) behandelt. Aber wir haben die unmittelbaren Werte nicht betrachtet.
Unmittelbare Werte in Ruby
Unmittelbarer Wert - das ist ein Wert, der direkt in einer Variablen gespeichert wird, und nicht über eine Referenz auf ein Objekt. Aber es gibt einen Punkt, der mich persönlich ein wenig verwirrt hat. In Ruby haben sogar für unmittelbare Werte Variablen eine object_id, aber sie verweisen auf einen bestimmten Ort im Speicher, an dem der Wert gespeichert ist, und nicht auf ein Objekt, wie es bei Referenzen der Fall ist. Das bedeutet, dass im Fall von unmittelbarem Wert die object_id nicht auf ein Objekt im Speicher verweist, sondern einfach einen bestimmten Wert identifiziert, der direkt in der Variablen gespeichert ist. Ja, in Ruby ist nicht alles ein Objekt.
Zitat von apidock:
object_id() öffentlich Gibt einen ganzzahligen Identifikator für obj zurück. Die gleiche Zahl wird bei allen Aufrufen von object_id für ein gegebenes Objekt zurückgegeben, und keine zwei aktiven Objekte teilen sich eine ID. Hinweis: Einige Objekte von eingebauten Klassen werden zur Optimierung wiederverwendet. Dies ist der Fall für unmittelbare Werte und gefrorene String-Literale. Unmittelbare Werte werden nicht durch Referenz übergeben, sondern durch Wert: nil, true, false, Fixnums, Symbole und einige Floats.
Diese Werte werden direkt in Variablen gespeichert und können nicht über eine Referenz auf ein Objekt geändert werden. Sie sind die effizienteste Möglichkeit, Daten im Speicher zu speichern, da sie keine Speicherzuweisung für ein Objekt benötigen. Dies wurde zur Optimierung des Speichers getan. Es macht keinen Sinn, für jedes nil neue Objekte zu erstellen. Lassen Sie uns also ein wenig mit IRB spielen.
Ein String ist ein Objekt.
a = 'hehe' b = 'hehe' a == b => true # Die Strings sind tatsächlich gleich a.object_id == b.object_id => false # Wir haben zwei verschiedene Objekte zur Speicherung des gleichen Inhalts
Symbole - unmittelbare Werte
a = :test => :test b = :test => :test a.object_id == b.object_id => true # Wir haben einen Wert im Speicher und zwei Variablen, die darauf verweisen
Das Gleiche gilt für true, false und nil
a = true b = true a.object_id == b.object_id => true a = false b = false a.object_id == b.object_id => true a = nil b = nil a.object_id == b.object_id => true
Ruby reserviert bestimmte object IDs für diese Objekte unmittelbaren Werte, da jede Variable, die einem unmittelbaren Wert zugewiesen wird, auf denselben Speicherort verweist. Überprüfen wir:
true.object_id => 20 false.object_id => 0 nil.object_id => 4 a = true => true b = false => false c = nil => nil a.object_id => 20 b.object_id => 0 c.object_id => 4
Und besser - wir schreiben rspec:
require 'rspec'
describe "Unmittelbare Werte und Referenzen in Ruby" do
it "demonstriert unmittelbare Werte vs Referenzen" do
# Unmittelbare Werte
a = 5
b = a
expect(a.object_id).to eq(b.object_id)
# Referenz
a = [1, 2, 3]
b = a
expect(a.object_id).to eq(b.object_id)
end
it "demonstriert object_id für unmittelbare Werte" do
# True
a = true
b = true
expect(a.object_id).to eq(b.object_id)
# False
a = false
b = false
expect(a.object_id).to eq(b.object_id)
# Nil
a = nil
b = nil
expect(a.object_id).to eq(b.object_id)
end
it "demonstriert object_id für Symbole" do
a = :test
b = :test
expect(a.object_id).to eq(b.object_id)
end
it "demonstriert object_id für gefrorene Literale" do
a = 'test'.freeze
b = 'test'.freeze
expect(a.object_id).to eq(b.object_id)
end
it "demonstriert statische object_id für true, false, nil" do
expect(true.object_id).to eq(20)
expect(false.object_id).to eq(0)
expect(nil.object_id).to eq(4)
end
end
Fertig in 0.01952 Sekunden (Dateien benötigten 0.27884 Sekunden zum Laden) 5 Beispiele, 0 Fehler
Ich hoffe, diese Informationen helfen jemandem, ein wenig über unmittelbare Werte und Referenzen in Ruby zu verstehen.
Dieser Beitrag hat noch keine Ergänzungen vom Autor.
