Czy Ruby przechodzi przez referencję czy wartość?

@user.update_languages(params[:language][:language1], 
                       params[:language][:language2], 
                       params[:language][:language3])
lang_errors = @user.errors
logger.debug "--------------------LANG_ERRORS----------101-------------" 
                + lang_errors.full_messages.inspect

if params[:user]
  @user.state = params[:user][:state]
  success = success & @user.save
end
logger.debug "--------------------LANG_ERRORS-------------102----------" 
                + lang_errors.full_messages.inspect

if lang_errors.full_messages.empty?

@userobiekt dodaje błędy do lang_errorszmiennej w update_lanugagesmetodzie. kiedy wykonuję zapis @userobiektu, tracę błędy, które początkowo były przechowywane w lang_errorszmiennej.

Chociaż to, co próbuję zrobić, byłoby bardziej włamaniem (co wydaje się nie działać). Chciałbym zrozumieć, dlaczego wartości zmiennych są wypłukiwane. Rozumiem przekazanie przez odniesienie, więc chciałbym wiedzieć, jak wartość może być utrzymywana w tej zmiennej bez wymywania.

W tradycyjnej terminologii Ruby jest ściśle przekazywana według wartości . Ale tak naprawdę nie o to tu pytasz.

Ruby nie ma pojęcia o wartości czystej, bez odniesienia, więc z pewnością nie można przekazać żadnej metody. Zmienne są zawsze odniesieniami do obiektów. Aby uzyskać obiekt, który nie zmieni się spod ciebie, musisz zduplikować lub sklonować przekazany obiekt, dając w ten sposób obiekt, do którego nikt inny nie ma odniesienia. (Nawet to nie jest kuloodporne - obie standardowe metody klonowania wykonują płytką kopię, więc zmienne instancji klonu nadal wskazują na te same obiekty, które zrobiły oryginały. Jeśli obiekty, do których odwołują się ivars, mutują, to będzie nadal pojawiają się w kopii, ponieważ odnoszą się do tych samych obiektów).

Pozostałe odpowiedzi są prawidłowe, ale przyjaciel poprosił mnie, żebym mu to wytłumaczył, a tak naprawdę sprowadza się to do tego, jak Ruby obsługuje zmienne, więc pomyślałem, że podzielę się kilkoma prostymi zdjęciami / wyjaśnieniami, które dla niego napisałem (przepraszam za długość i prawdopodobnie pewne uproszczenia):

P1: Co się stanie, gdy przypiszesz nową zmienną strdo wartości 'foo'?

str = 'foo'
str.object_id # => 2000

Odp .: Wywoływana strjest etykieta wskazująca obiekt 'foo', który dla stanu tego interpretera języka Ruby znajduje się w miejscu pamięci 2000.

P2: Co się stanie, gdy przypiszesz istniejącą zmienną strdo nowego obiektu za pomocą =?

str = 'bar'.tap{|b| puts "bar: #{b.object_id}"} # bar: 2002
str.object_id # => 2002

Odp .: Etykieta strwskazuje teraz na inny obiekt.

Q3: Co się dzieje, kiedy przypisać nową zmienną =do str?

str2 = str
str2.object_id # => 2002

Odp .: Tworzona jest nowa etykieta o nazwie, str2która wskazuje na ten sam obiekt co str.

P4: Co się stanie, jeśli obiekt odwołuje się do str i str2zostanie zmieniony?

str2.replace 'baz'
str2 # => 'baz'
str  # => 'baz'
str.object_id # => 2002
str2.object_id # => 2002

Odp .: Obie etykiety nadal wskazują ten sam obiekt, ale sam obiekt zmutował (jego zawartość zmieniła się na coś innego).

Jak to się ma do pierwotnego pytania?

Jest to w zasadzie to samo, co dzieje się w Q3 / Q4; metoda otrzymuje własną prywatną kopię zmiennej / label ( str2), która jest do niej przekazywana ( str). Nie może zmienić obiektu, na który str wskazuje etykieta , ale może zmienić zawartość obiektu, do którego odwołują się oboje, aby zawierał jeszcze:

str = 'foo'

def mutate(str2)
  puts "str2: #{str2.object_id}"
  str2.replace 'bar'
  str2 = 'baz'
  puts "str2: #{str2.object_id}"
end

str.object_id # => 2004
mutate(str) # str2: 2004, str2: 2006
str # => "bar"
str.object_id # => 2004

Ruby używa „przekaż odniesienie do obiektu”

(Korzystanie z terminologii Python.)

Powiedzenie, że Ruby używa „przekaż przez wartość” lub „przekaż przez referencję”, nie jest tak naprawdę wystarczająco opisowe, aby było pomocne. Myślę, że jak większość ludzi wie to w dzisiejszych czasach, terminologia („wartość” vs „referencja”) pochodzi z C ++.

W C ++ „przekazanie przez wartość” oznacza, że ​​funkcja pobiera kopię zmiennej, a wszelkie zmiany w kopii nie zmieniają oryginału. Dotyczy to również obiektów. Jeśli przekażesz zmienną obiektową według wartości, cały obiekt (w tym wszystkie jego elementy) zostanie skopiowany, a wszelkie zmiany w elementach członkowskich nie zmienią tych elementów w oryginalnym obiekcie. (Jest inaczej, jeśli przekażesz wskaźnik wartości, ale Ruby i tak nie ma wskaźników, AFAIK.)

class A {
  public:
    int x;
};

void inc(A arg) {
  arg.x++;
  printf("in inc: %d\n", arg.x); // => 6
}

void inc(A* arg) {
  arg->x++;
  printf("in inc: %d\n", arg->x); // => 1
}

int main() {
  A a;
  a.x = 5;
  inc(a);
  printf("in main: %d\n", a.x); // => 5

  A* b = new A;
  b->x = 0;
  inc(b);
  printf("in main: %d\n", b->x); // => 1

  return 0;
}

Wynik:

in inc: 6
in main: 5
in inc: 1
in main: 1

W C ++ „przekazanie przez odniesienie” oznacza, że ​​funkcja uzyskuje dostęp do oryginalnej zmiennej. Może przypisać zupełnie nową literalną liczbę całkowitą, a oryginalna zmienna również będzie miała tę wartość.

void replace(A &arg) {
  A newA;
  newA.x = 10;
  arg = newA;
  printf("in replace: %d\n", arg.x);
}

int main() {
  A a;
  a.x = 5;
  replace(a);
  printf("in main: %d\n", a.x);

  return 0;
}

Wynik:

in replace: 10
in main: 10

Ruby używa przekazywania przez wartość (w sensie C ++), jeśli argument nie jest obiektem. Ale w Ruby wszystko jest przedmiotem, więc tak naprawdę w Ruby nie ma przekazywania wartości w sensie C ++.

W Ruby używa się „pass by object reference” (w celu użycia terminologii Pythona):

• Wewnątrz funkcji każdemu członkowi obiektu można przypisać nowe wartości, a zmiany te zostaną zachowane po powrocie funkcji. *
• Wewnątrz funkcji przypisanie całego nowego obiektu do zmiennej powoduje, że zmienna przestaje odwoływać się do starego obiektu. Ale po powrocie funkcji oryginalna zmienna nadal będzie odwoływać się do starego obiektu.

Dlatego Ruby nie używa „przekaż przez referencję” w sensie C ++. Jeśli tak, to przypisanie nowego obiektu do zmiennej wewnątrz funkcji spowoduje, że stary obiekt zostanie zapomniany po powrocie funkcji.

class A
  attr_accessor :x
end

def inc(arg)
  arg.x += 1
  puts arg.x
end

def replace(arg)
  arg = A.new
  arg.x = 3
  puts arg.x
end

a = A.new
a.x = 1
puts a.x  # 1

inc a     # 2
puts a.x  # 2

replace a # 3
puts a.x  # 2

puts ''

def inc_var(arg)
  arg += 1
  puts arg
end

b = 1     # Even integers are objects in Ruby
puts b    # 1
inc_var b # 2
puts b    # 1

Wynik:

1
2
2
3
2

1
2
1

* Dlatego w Rubim, jeśli chcesz zmodyfikować obiekt wewnątrz funkcji, ale zapominasz o tych zmianach po powrocie funkcji, musisz jawnie wykonać kopię obiektu przed dokonaniem tymczasowych zmian w kopii.

Czy Ruby przechodzi przez referencję czy wartość?

Ruby jest wartością przekazywaną. Zawsze. Bez wyjątków. Nie, jeśli. Żadnych ale.

Oto prosty program, który pokazuje ten fakt:

def foo(bar)
  bar = 'reference'
end

baz = 'value'

foo(baz)

puts "Ruby is pass-by-#{baz}"
# Ruby is pass-by-value

Ruby jest wartością przekazywaną w ścisłym tego słowa znaczeniu, ALE wartości są referencjami.

Można to nazwać „ pass-reference-by-value ”. Ten artykuł ma najlepsze wyjaśnienie, jakie przeczytałem: http://robertheaton.com/2014/07/22/is-ruby-pass-by-reference-or-pass-by-value/

Przekazywanie według wartości można krótko wyjaśnić w następujący sposób:

Funkcja otrzymuje odniesienie do (i uzyskuje dostęp) tego samego obiektu w pamięci, z którego korzysta osoba wywołująca. Jednak nie otrzymuje skrzynki, w której dzwoniący przechowuje ten obiekt; podobnie jak w przypadku przekazywania wartości po wartości, funkcja zapewnia własne pole i tworzy dla siebie nową zmienną.

Wynikowe zachowanie jest w rzeczywistości kombinacją klasycznych definicji pass-by-reference i pass-by-value.

Istnieją już świetne odpowiedzi, ale chcę opublikować definicję pary autorytetów na ten temat, ale mam również nadzieję, że ktoś może wyjaśnić, co autorytety Matz (twórca Ruby) i David Flanagan mieli na myśli w swojej doskonałej książce O'Reilly, Język programowania Ruby .

[z 3.8.1: Odwołania do obiektów]

Gdy przekazujesz obiekt do metody w Ruby, jest to odwołanie do obiektu przekazywane do metody. To nie jest sam obiekt i nie jest odniesieniem do odniesienia do obiektu. Innym sposobem na powiedzenie tego jest to, że argumenty metody są przekazywane raczej przez wartość niż przez referencję , ale przekazywane wartości są referencjami obiektowymi.

Ponieważ odwołania do obiektów są przekazywane do metod, metody mogą je wykorzystywać do modyfikowania obiektu bazowego. Te modyfikacje są następnie widoczne po powrocie metody.

To wszystko ma dla mnie sens aż do ostatniego akapitu, a zwłaszcza do ostatniego zdania. Jest to co najmniej wprowadzające w błąd, a co gorsza. W jaki sposób modyfikacje odwołania do wartości przekazywanej przez wartość mogłyby zmienić obiekt leżący u podstaw?

Czy Ruby przechodzi przez referencję czy wartość?

Ruby jest przekazywany przez odniesienie. Zawsze. Bez wyjątków. Nie, jeśli. Żadnych ale.

Oto prosty program, który pokazuje ten fakt:

def foo(bar)
  bar.object_id
end

baz = 'value'

puts "#{baz.object_id} Ruby is pass-by-reference #{foo(baz)} because object_id's (memory addresses) are always the same ;)"

=> 2279146940 Ruby jest referencją 2279146940, ponieważ identyfikator_obiektu (adresy pamięci) jest zawsze taki sam;)

def bar(babar)
  babar.replace("reference")
end

bar(baz)

puts "some people don't realize it's reference because local assignment can take precedence, but it's clearly pass-by-#{baz}"

=> niektórzy ludzie nie zdają sobie sprawy, że jest to odniesienie, ponieważ przypisanie lokalne może mieć pierwszeństwo, ale wyraźnie jest to przejście przez odniesienie

Parametry są kopią oryginalnego odwołania. Możesz więc zmieniać wartości, ale nie możesz zmienić oryginalnego odwołania.

Spróbuj tego:--

1.object_id
#=> 3

2.object_id
#=> 5

a = 1
#=> 1
a.object_id
#=> 3

b = 2
#=> 2
b.object_id
#=> 5

identyfikator a zawiera identyfikator_obiektu 3 dla obiektu wartości 1, a identyfikator b zawiera identyfikator_obiektu 5 dla obiektu wartości 2.

Zrób to teraz:--

a.object_id = 5
#=> error

a = b
#value(object_id) at b copies itself as value(object_id) at a. value object 2 has object_id 5
#=> 2

a.object_id 
#=> 5

Teraz oba a i b zawierają ten sam identyfikator_obiektu 5, który odnosi się do obiektu wartości 2. Tak więc zmienna Ruby zawiera identyfikatory obiektu, które odnoszą się do obiektów wartości.

Wykonanie następujących czynności powoduje również błąd: -

c
#=> error

ale zrobienie tego nie spowoduje błędu: -

5.object_id
#=> 11

c = 5
#=> value object 5 provides return type for variable c and saves 5.object_id i.e. 11 at c
#=> 5
c.object_id
#=> 11 

a = c.object_id
#=> object_id of c as a value object changes value at a
#=> 11
11.object_id
#=> 23
a.object_id == 11.object_id
#=> true

a
#=> Value at a
#=> 11

Tutaj identyfikator zwraca wartość obiektu 11, którego identyfikator obiektu to 23, tj. ID_obiektu 23 znajduje się w identyfikatorze a, Teraz widzimy przykład za pomocą metody.

def foo(arg)
  p arg
  p arg.object_id
end
#=> nil
11.object_id
#=> 23
x = 11
#=> 11
x.object_id
#=> 23
foo(x)
#=> 11
#=> 23

arg w foo ma przypisaną wartość x. Wyraźnie pokazuje, że argument jest przekazywany przez wartość 11, a sama wartość 11 będąca obiektem ma unikalny identyfikator obiektu 23.

Zobacz teraz także: -

def foo(arg)
  p arg
  p arg.object_id
  arg = 12
  p arg
  p arg.object_id
end

#=> nil
11.object_id
#=> 23
x = 11
#=> 11
x.object_id
#=> 23
foo(x)
#=> 11
#=> 23
#=> 12
#=> 25
x
#=> 11
x.object_id
#=> 23

W tym przypadku identyfikator arg najpierw zawiera identyfikator_obiektu 23 do odwołania 11, a po wewnętrznym przypisaniu do obiektu wartości 12 zawiera identyfikator_obiektu 25. Ale nie zmienia wartości, do której odwołuje się identyfikator x używany w metodzie wywoływania.

Dlatego Ruby jest przekazywany przez wartość, a zmienne Ruby nie zawierają wartości, ale zawierają odwołanie do obiektu wartości.

Ruby jest interpretowany. Zmienne są odniesieniami do danych, ale nie do samych danych. Ułatwia to użycie tej samej zmiennej dla danych różnych typów.

Przypisanie lhs = rhs następnie kopiuje odwołanie do rhs, a nie danych. Różni się to w innych językach, takich jak C, gdzie przypisanie kopiuje dane do lhs z rhs.

Tak więc dla wywołania funkcji przekazana zmienna, powiedzmy x, jest rzeczywiście kopiowana do zmiennej lokalnej w funkcji, ale x jest referencją. Będą wtedy dwie kopie referencji, obie odwołujące się do tych samych danych. Jeden będzie w dzwoniącym, jeden w funkcji.

Przypisanie funkcji spowoduje skopiowanie nowego odwołania do wersji x funkcji. Po tym wersja x dzwoniącego pozostaje niezmieniona. Jest to nadal odniesienie do oryginalnych danych.

Natomiast użycie metody .replace na x spowoduje, że Ruby wykona kopię danych. Jeśli zastąpi się przed nowymi przypisaniami, to rzeczywiście dzwoniący zobaczy zmiany danych również w swojej wersji.

Podobnie, dopóki oryginalne odwołanie jest taktowane dla przekazywanej zmiennej, zmienne instancji będą takie same, jak wywołujący. W ramach obiektu zmienne instancji zawsze mają najbardziej aktualne wartości referencyjne, niezależnie od tego, czy są one dostarczane przez obiekt wywołujący, czy ustawione w funkcji, do której klasa została przekazana.

„Call by value” lub „call by reference” jest tu mętne z powodu zamieszania związanego z „=” W językach kompilowanych „=” to kopia danych. Tutaj w tym tłumaczonym języku „=” jest kopią referencyjną. W tym przykładzie przekazano referencję, a następnie kopię referencyjną „=”, która blokuje oryginał przekazany w referencji, a następnie ludzie mówią o tym, jakby „=” była kopią danych.

Aby zachować zgodność z definicjami, musimy zachować „.replace”, ponieważ jest to kopia danych. Z perspektywy „.replace” widzimy, że tak naprawdę jest to odniesienie. Ponadto, jeśli przejdziemy przez debugger, zobaczymy, że przekazywane są referencje, ponieważ zmienne są referencjami.

Jeśli jednak musimy zachować wartość „=” jako odniesienie, wówczas rzeczywiście widzimy przekazane dane aż do przypisania, a następnie nie widzimy go już po przypisaniu, podczas gdy dane dzwoniącego pozostają niezmienione. Na poziomie behawioralnym jest to przekazywanie wartości, o ile nie uważamy, że przekazana wartość jest złożona - ponieważ nie będziemy w stanie zachować jej części, zmieniając drugą część w jednym przydziale (jak to przydział) zmienia odniesienie, a oryginał wychodzi poza zakres). Będzie też brodawka, w tym przypadku zmienne w obiektach będą referencjami, podobnie jak wszystkie zmienne. W związku z tym będziemy zmuszeni mówić o przekazywaniu „referencji według wartości” i musimy używać powiązanych lokalizacji.

Należy zauważyć, że nie trzeba nawet używać metody „zamień”, aby zmienić pierwotną wartość wartości. Jeśli przypiszesz jedną z wartości skrótu do skrótu, zmienisz oryginalną wartość.

def my_foo(a_hash)
  a_hash["test"]="reference"
end;

hash = {"test"=>"value"}
my_foo(hash)
puts "Ruby is pass-by-#{hash["test"]}"

Two references refer to same object as long as there is no reassignment. 

Wszelkie aktualizacje w tym samym obiekcie nie będą zawierać odniesień do nowej pamięci, ponieważ nadal znajduje się ona w tej samej pamięci. Oto kilka przykładów:

    a = "first string"
    b = a



    b.upcase! 
    => FIRST STRING
    a
    => FIRST STRING

    b = "second string"


a
    => FIRST STRING
    hash = {first_sub_hash: {first_key: "first_value"}}
first_sub_hash = hash[:first_sub_hash]
first_sub_hash[:second_key] = "second_value"

    hash
    => {first_sub_hash: {first_key: "first_value", second_key: "second_value"}}

    def change(first_sub_hash)
    first_sub_hash[:third_key] = "third_value"
    end

    change(first_sub_hash)

    hash
    =>  {first_sub_hash: {first_key: "first_value", second_key: "second_value", third_key: "third_value"}}

Tak ale ....

Ruby przekazuje odwołanie do obiektu, a ponieważ wszystko w Rubim jest obiektem, można powiedzieć, że przekazuje je przez odwołanie.

Nie zgadzam się z zamieszczonymi tutaj postami, które twierdzą, że przekazuje wartość, co wydaje mi się pedantycznymi, sympatycznymi grami.

Jednak w efekcie „ukrywa” to zachowanie, ponieważ większość operacji ruby ​​zapewnia „po wyjęciu z pudełka” - na przykład operacje łańcuchowe tworzą kopię obiektu:

> astringobject = "lowercase"

> bstringobject = astringobject.upcase
> # bstringobject is a new object created by String.upcase

> puts astringobject
lowercase

> puts bstringobject
LOWERCASE

Oznacza to, że przez większość czasu oryginalny obiekt pozostaje niezmieniony, co sprawia, że ​​rubin jest „przekazywany przez wartość”.

Oczywiście przy projektowaniu własnych klas zrozumienie szczegółów tego zachowania jest ważne zarówno dla zachowania funkcjonalnego, wydajności pamięci, jak i wydajności.