Ändern des Werts von ruby-Variablen/Referenzen

Ich stolperte über etwas, was ich nicht ganz verstehen. Ich weiß, dass die Variablen in ruby sind Referenzen. So genial, dass Zeug ist möglich. Aber wenn ich übergeben Sie eine variable an eine Methode, es verhält sich seltsam:

my_var_a = "nothing happend to me"
my_var_b = "nothing happend to me"

def parse_set(my_var_set)
  my_var_set = "my value changed"
end

def parse_sub(my_var_sub)
  my_var_sub.sub! /(.*)/, "my value changed"
end

parse_set(my_var_a)
parse_sub(my_var_b)

my_var_a # => "nothing happend to me"
my_var_b # => "my value changed"

Können Sie mir erklären, warum es funktioniert mit sub! und = lässt das Objekt unverändert? Wie kann ich vermeiden, um sub! aber mit dem gleichen Ergebnis?

InformationsquelleAutor Nils Riedemann | 2010-01-28

12

my_var_a und my_var_set sind unterschiedliche Referenzen, aber Sie zeigen auf das gleiche Objekt. Wenn Sie das Objekt ändern in my_var_set, die änderung zeigt sich in my_var_a. Allerdings, wenn Sie repoint my_var_set auf ein neues Objekt, das ändert nichts, was my_var_a Punkte an.

Edit: Klärung...

Was Ruby tut, ist aufgerufen, die übergabe von Referenzen von Wert. Wenn Sie sagen,
```
my_var_a = "nothing happend to me"
```
Ruby speichert den string "nothing happend to me" in einem Speicherplatz (sagen wir 1000), und speichert die my_var_a Referenz in einem anderen Speicher-Ort (sagen wir, 2000). Wenn Ihr code verwendet my_var_a, der interpreter sucht am Standort 2000, zu sehen, dass es Punkte auf 1000, dann wird der eigentliche string-Wert von 1000.

Beim Aufruf parse_set(my_var_a) Ruby tatsächlich erstellt eine neue Referenz namens my_var_set und verweist auf die Zeichenfolge, die my_var_a war deutete auf (memory-Position 1000). Allerdings my_var_set ist eine Kopie der my_var_a Referenz-sagen wir my_var_set wurde Speicheradresse 3000. my_var_a und my_var_set sind 2 völlig verschiedene Referenzen im Speicher, Sie passieren einfach-Punkt in der gleichen genaue Position im Speicher hält, die die string-Wert.

Die Aussage my_var_set = "my value changed" im parse_set erstellt eine neue Zeichenfolge, die im Speicher und Punkte my_var_set an, die neue memory location. Dies bedeutet jedoch nicht ändern, was die ursprüngliche my_var_a Referenz Punkte an! Nun, dass my_var_set Punkte an eine andere Position im Speicher, nichts, was Sie tun, um diese variable beeinflussen my_var_a.

Die gleiche Referenz kopieren passiert parse_sub als gut. Aber der Grund, dass parse_sub Veränderungen der string ist, weil Sie den Aufruf der Methode direkt auf die my_var_sub Referenz. Wenn Sie dies tun, wird der interpreter bekommt das Objekt, das my_var_sub gerichtet ist und dann ändert es. So dass der Wandel in der my_var_a Referenz, weil es noch Punkte auf die gleiche Zeichenfolge.
- Kann man irgendwie anders formulieren? Ich wirklich nicht bekommen, das Teil über repointing 🙂 (auch ich änderte den Namen von Variablen, für die weniger Mehrdeutigkeit) Und wie kann ich den Wert ändern, ohne einen lächerlich sub! und regex?
- Ich habe ein wenig mehr Informationen, hoffe, dass macht die Dinge klarer. Verweis durch Wert ist kompliziert und dauert eine Weile, um zu realisieren, was Los ist. Auch, um den Wert zu ändern, ohne Verwendung von sub, nur haben Sie Ihre parse Methode einen Wert zurückgeben, und weisen Sie es auf die ursprüngliche variable: my_var_a = some_parse_method(my_var_a).
- Wow, das ist eine wirklich gute und einfache Erklärung. Danke!!!
- "Pass Referenz-Wert" ist der Genaueste Weg, um zu beschreiben, wie Ruby arbeitet.
InformationsquelleAutor Kaleb Brasee
5
```
irb(main):008:0* a = 'abc'
=> "abc"
irb(main):009:0> a.replace('def')
=> "def"
irb(main):010:0> a
=> "def"
```
Habe ich in Benutzung hatte replace genau null mal in all den Jahren, ich habe die Programmierung in Ruby. Ich Frage mich, ob es ein besseres design für Ihren code.

Meisten string-Methoden, die sich ändern, die Empfänger werden mit dem Suffix ! (sub!, Kapital!, chomp!, etc.) Einige, ändern Sie den Empfänger nicht mit dem Suffix ! (ersetzen ist). Wenn Sie eine Methode aufrufen, die änderungen der Empfänger, und alle Verweise auf das Objekt wird die änderung sehen. wenn Sie eine Methode aufrufen, die sich nicht ändert-Empfänger, die Methode gibt eine neuen string.

gsub, ändert sich nicht der Empfänger, sondern liefert eine neue Instanz von String:
```
a = "foo"
b = a
p a.sub(/o/, '#')     # "f##"
p a                   # => "foo"
p b                   # => "foo"
```
gsub! ändern Sie die Empfänger:
```
a = "foo"
b = a
p a.sub!(/o/, '#')    # => "f#o"
p a                   # => "f#o"
p b                   # => "f#o"
```
- Danke für den Hinweis auf die replace-Methode. Aber die Antwort von Kaleb erklärte mir die Interna, so dass ich verstehen konnte, was Los ist, sonst hätte ich das akzeptiert habe, Ihre Antwort 😀
InformationsquelleAutor Wayne Conrad
0

"Wie kann ich vermeiden, um sub! aber mit dem gleichen Ergebnis?"
```
def parse_set()
  "my value changed"
end

a = parse_set()
```
Legen Sie es als eine Instanzvariable eines Objekts (obwohl dies funktioniert nur in Ihrem Haupt-Skript, ich empfehle das erstellen Ihrer eigenen Klasse, wenn Sie möchten, verwenden Sie die Instanz-Variablen-Ansatz).
```
@my_var_a = "nothing happend to me"

def parse_set()
  @my_var_a = "my value changed"
end
```
InformationsquelleAutor Beanish

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.