Apakah Ruby lulus dengan referensi atau berdasarkan nilai?

@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?

@userobjek menambahkan kesalahan ke lang_errorsvariabel dalam update_lanugagesmetode. ketika saya melakukan save pada @userobjek saya kehilangan kesalahan yang awalnya disimpan dalam lang_errorsvariabel.

Meskipun apa yang saya coba lakukan akan lebih merupakan peretasan (yang sepertinya tidak berfungsi). Saya ingin memahami mengapa nilai variabel terhapus. Saya mengerti lewat referensi jadi saya ingin tahu bagaimana nilai dapat disimpan dalam variabel itu tanpa terhapus.

Dalam terminologi tradisional, Ruby benar-benar merupakan nilai tambah . Tapi bukan itu yang sebenarnya kamu tanyakan di sini.

Ruby tidak memiliki konsep nilai murni, non-referensi, jadi Anda tentu tidak dapat meneruskannya ke suatu metode. Variabel selalu referensi ke objek. Untuk mendapatkan objek yang tidak akan berubah dari bawah Anda, Anda perlu menggandakan atau mengkloning objek yang Anda lewati, sehingga memberikan objek yang tidak memiliki referensi orang lain. (Meskipun ini bukan anti peluru) - kedua metode kloning standar melakukan salinan dangkal, jadi variabel instance dari klon masih menunjuk ke objek yang sama dengan yang asli lakukan. Jika objek yang dirujuk oleh ivars bermutasi, itu akan masih muncul dalam salinan, karena itu merujuk objek yang sama.)

Penjawab lainnya semuanya benar, tetapi seorang teman meminta saya untuk menjelaskan ini kepadanya dan apa yang sebenarnya menjadi intinya adalah bagaimana Ruby menangani variabel, jadi saya pikir saya akan membagikan beberapa gambar / penjelasan sederhana yang saya tulis untuknya (permintaan maaf untuk panjangnya) dan mungkin beberapa penyederhanaan berlebihan):

T1: Apa yang terjadi ketika Anda menetapkan variabel baru strke nilai 'foo'?

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

A: Label yang dipanggil strdibuat yang menunjuk ke objek 'foo', yang untuk keadaan interpreter Ruby ini berada di lokasi memori 2000.

T2: Apa yang terjadi ketika Anda menetapkan variabel yang ada strke objek baru menggunakan =?

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

A: Label strsekarang menunjuk ke objek yang berbeda.

Q3: Apa yang terjadi ketika Anda menetapkan variabel baru =ke str?

str2 = str
str2.object_id # => 2002

A: Label baru bernama str2dibuat yang menunjuk pada objek yang sama dengan str.

T4: Apa yang terjadi jika objek direferensikan oleh strdan str2diubah?

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

A: Kedua label masih menunjuk pada objek yang sama, tetapi objek itu sendiri telah bermutasi (isinya telah berubah menjadi sesuatu yang lain).

Bagaimana ini berhubungan dengan pertanyaan awal?

Ini pada dasarnya sama dengan apa yang terjadi di Q3 / Q4; metode mendapatkan salinan pribadi dari variabel / label ( str2) yang diteruskan ke sana ( str). Itu tidak dapat mengubah objek yang str ditunjuk label , tetapi itu dapat mengubah konten objek yang keduanya rujuk mengandung yang lain:

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 menggunakan "referensi objek lewat"

(Menggunakan terminologi Python.)

Untuk mengatakan Ruby menggunakan "pass by value" atau "pass by reference" tidak cukup deskriptif untuk membantu. Saya pikir karena kebanyakan orang tahu hari ini, bahwa terminologi ("nilai" vs "referensi") berasal dari C ++.

Dalam C ++, "pass by value" berarti fungsi mendapatkan salinan variabel dan setiap perubahan pada salinan tidak mengubah yang asli. Itu juga berlaku untuk objek. Jika Anda melewatkan variabel objek berdasarkan nilai, maka seluruh objek (termasuk semua anggotanya) akan disalin dan perubahan apa pun pada anggota tidak mengubah anggota tersebut pada objek asli. (Ini berbeda jika Anda melewatkan pointer dengan nilai tetapi Ruby tetap tidak memiliki pointer, 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;
}

Keluaran:

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

Dalam C ++, "lulus dengan referensi" berarti fungsi mendapatkan akses ke variabel asli. Itu dapat menetapkan integer literal baru dan variabel asli kemudian akan memiliki nilai itu juga.

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;
}

Keluaran:

in replace: 10
in main: 10

Ruby menggunakan pass by value (dalam pengertian C ++) jika argumennya bukan objek. Tapi di Ruby semuanya adalah objek, jadi benar-benar tidak ada nilai yang lewat dalam pengertian C ++ di Ruby.

Di Ruby, "lewat referensi objek" (untuk menggunakan terminologi Python) digunakan:

• Di dalam fungsi, anggota objek mana pun dapat memiliki nilai baru yang ditugaskan kepadanya dan perubahan ini akan bertahan setelah fungsi kembali. *
• Di dalam fungsi, menugaskan objek yang sama sekali baru ke variabel menyebabkan variabel berhenti referensi objek lama. Tetapi setelah fungsi kembali, variabel asli masih akan merujuk objek lama.

Karenanya Ruby tidak menggunakan "pass by reference" dalam pengertian C ++. Jika ya, maka menetapkan objek baru ke variabel di dalam fungsi akan menyebabkan objek lama dilupakan setelah fungsi kembali.

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

Keluaran:

1
2
2
3
2

1
2
1

* Inilah sebabnya, di Ruby, jika Anda ingin memodifikasi objek di dalam suatu fungsi tetapi melupakan perubahan itu ketika fungsi kembali, maka Anda harus secara eksplisit membuat salinan objek sebelum membuat perubahan sementara pada salinan.

Apakah Ruby lulus dengan referensi atau berdasarkan nilai?

Ruby adalah nilai per nilai. Selalu. Tidak ada pengecualian. Tidak ada seandainya. Tidak ada tapi

Berikut ini adalah program sederhana yang menunjukkan fakta itu:

def foo(bar)
  bar = 'reference'
end

baz = 'value'

foo(baz)

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

Ruby adalah pass-by-value dalam arti yang ketat, TETAPI nilainya adalah referensi.

Ini bisa disebut " pass-reference-by-value ". Artikel ini memiliki penjelasan terbaik yang pernah saya baca: http://robertheaton.com/2014/07/22/is-ruby-pass-by-reference-or-pass-by-value/

Pass-reference-by-value secara singkat dapat dijelaskan sebagai berikut:

Suatu fungsi menerima referensi ke (dan akan mengakses) objek yang sama dalam memori seperti yang digunakan oleh pemanggil. Namun, itu tidak menerima kotak di mana pemanggil menyimpan objek ini di; seperti pada pass-value-by-value, fungsi menyediakan kotaknya sendiri dan membuat variabel baru untuk dirinya sendiri.

Perilaku yang dihasilkan sebenarnya merupakan kombinasi dari definisi klasik pass-by-reference dan pass-by-value.

Sudah ada beberapa jawaban yang bagus, tetapi saya ingin memposting definisi sepasang otoritas pada subjek, tetapi juga berharap seseorang dapat menjelaskan apa yang dimaksud otoritas Matz (pencipta Ruby) dan David Flanagan dalam buku O'Reilly mereka yang sangat bagus, Bahasa Pemrograman Ruby .

[dari 3.8.1: Referensi Obyek]

Saat Anda meneruskan objek ke metode di Ruby, itu adalah referensi objek yang diteruskan ke metode. Ini bukan objek itu sendiri, dan itu bukan referensi ke referensi ke objek. Cara lain untuk mengatakan ini adalah bahwa argumen metode dilewatkan oleh nilai daripada oleh referensi , tetapi nilai yang dikirimkan adalah referensi objek.

Karena referensi objek diteruskan ke metode, metode dapat menggunakan referensi tersebut untuk memodifikasi objek yang mendasarinya. Modifikasi ini kemudian terlihat ketika metode kembali.

Ini semua masuk akal bagi saya sampai paragraf terakhir, dan terutama kalimat terakhir itu. Ini paling menyesatkan, dan lebih buruk lagi membingungkan. Bagaimana, dengan cara apa pun, modifikasi terhadap referensi yang dilewatkan oleh nilai dapat mengubah objek yang mendasarinya?

Apakah Ruby lulus dengan referensi atau berdasarkan nilai?

Ruby adalah pass-by-reference. Selalu. Tidak ada pengecualian. Tidak ada seandainya. Tidak ada tapi

Berikut ini adalah program sederhana yang menunjukkan fakta itu:

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 adalah pass-by-reference 2279146940 karena object_id (alamat memori) selalu sama;)

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}"

=> beberapa orang tidak menyadari itu referensi karena tugas lokal dapat diutamakan, tapi itu jelas lewat-referensi

Parameter adalah salinan dari referensi asli. Jadi, Anda dapat mengubah nilai, tetapi tidak dapat mengubah referensi asli.

Coba ini:--

1.object_id
#=> 3

2.object_id
#=> 5

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

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

identifier a berisi object_id 3 untuk value object 1 dan identifier b berisi object_id 5 untuk value object 2.

Sekarang lakukan ini: -

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

Sekarang, a dan b keduanya berisi object_id 5 yang sama yang merujuk ke objek nilai 2. Jadi, variabel Ruby berisi object_ids untuk merujuk ke objek nilai.

Melakukan hal berikut juga memberikan kesalahan: -

c
#=> error

tetapi melakukan ini tidak akan memberikan kesalahan: -

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

Berikut identifier objek nilai pengembalian 11 yang id objeknya 23 yaitu object_id 23 berada di identifier a, Sekarang kita melihat contoh dengan menggunakan metode.

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 in foo ditugaskan dengan nilai balik x. Ini jelas menunjukkan bahwa argumen dilewatkan oleh nilai 11, dan nilai 11 menjadi objek sendiri memiliki id objek unik 23.

Sekarang lihat ini juga: -

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

Di sini, identifier arg pertama berisi object_id 23 untuk merujuk 11 dan setelah penugasan internal dengan nilai objek 12, itu berisi object_id 25. Tapi itu tidak mengubah nilai yang dirujuk oleh pengidentifikasi x yang digunakan dalam metode pemanggilan.

Oleh karena itu, Ruby diteruskan oleh nilai dan variabel Ruby tidak mengandung nilai tetapi berisi referensi ke objek nilai.

Ruby ditafsirkan. Variabel adalah referensi ke data, tetapi bukan data itu sendiri. Ini memfasilitasi menggunakan variabel yang sama untuk data dari berbagai jenis.

Penugasan lhs = rhs kemudian menyalin referensi pada rhs, bukan data. Ini berbeda dalam bahasa lain, seperti C, di mana tugas tidak menyalin data ke lhs dari rhs.

Jadi untuk pemanggilan fungsi, variabel yang dikirimkan, misalkan x, memang disalin ke variabel lokal dalam fungsi, tetapi x adalah referensi. Kemudian akan ada dua salinan referensi, keduanya merujuk data yang sama. Satu akan berada di pemanggil, satu di fungsi.

Tugas dalam fungsi kemudian akan menyalin referensi baru ke versi fungsi x. Setelah ini, versi x penelepon tetap tidak berubah. Itu masih referensi ke data asli.

Sebaliknya, menggunakan metode .replace pada x akan menyebabkan ruby ​​melakukan salinan data. Jika ganti digunakan sebelum penugasan baru maka penelepon memang akan melihat perubahan data dalam versinya juga.

Demikian pula, selama referensi asli sesuai dengan variabel yang diteruskan, variabel instan akan sama dengan yang dilihat pemanggil. Dalam kerangka suatu objek, variabel instan selalu memiliki nilai referensi yang paling terkini, baik yang disediakan oleh pemanggil atau diatur dalam fungsi kelas yang diteruskan.

'Panggilan berdasarkan nilai' atau 'panggilan dengan referensi' kacau di sini karena kebingungan mengenai '=' Dalam bahasa yang dikompilasi '=' adalah salinan data. Di sini, dalam bahasa yang ditafsirkan ini '=' adalah salinan referensi. Dalam contoh Anda memiliki referensi yang diteruskan diikuti oleh salinan referensi meskipun '=' yang clobbers yang asli lulus dalam referensi, dan kemudian orang-orang membicarakannya seolah-olah '=' adalah salinan data.

Agar konsisten dengan definisi, kita harus tetap menggunakan '.replace' karena ini adalah salinan data. Dari perspektif '. Ganti' kita melihat bahwa ini memang lulus dengan referensi. Lebih jauh, jika kita berjalan di debugger, kita melihat referensi dilewatkan, karena variabel adalah referensi.

Namun jika kita harus menjaga '=' sebagai kerangka referensi, maka memang kita bisa melihat data yang diteruskan hingga tugas, dan kemudian kita tidak bisa melihatnya lagi setelah penugasan sementara data pemanggil tetap tidak berubah. Pada tingkat perilaku, ini dilewati oleh nilai selama kami tidak menganggap nilai yang diteruskan sebagai komposit - karena kami tidak akan dapat menyimpan bagian darinya sambil mengubah bagian lainnya dalam satu tugas tunggal (karena tugas itu mengubah referensi dan yang asli keluar dari ruang lingkup). Juga akan ada kutil, dalam hal variabel variabel dalam objek akan menjadi referensi, seperti semua variabel. Karenanya kita akan dipaksa untuk berbicara tentang melewati 'referensi berdasarkan nilai' dan harus menggunakan lokasi terkait.

Perlu dicatat bahwa Anda bahkan tidak perlu menggunakan metode "ganti" untuk mengubah nilai nilai asli. Jika Anda menetapkan salah satu nilai hash untuk hash, Anda mengubah nilai aslinya.

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. 

Pembaruan di objek yang sama tidak akan membuat referensi ke memori baru karena masih di memori yang sama. Berikut ini beberapa contoh:

    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"}}

Ya tapi ....

Ruby memberikan referensi ke sebuah objek dan karena semua yang ada di ruby ​​adalah sebuah objek, maka Anda bisa mengatakan itu lewat referensi.

Saya tidak setuju dengan posting di sini yang mengklaim itu lewat nilai, yang tampak seperti permainan yang simpatik dan simpatik bagi saya.

Namun, efeknya "menyembunyikan" perilaku karena sebagian besar operasi ruby ​​menyediakan "di luar kotak" - misalnya operasi string, menghasilkan salinan objek:

> astringobject = "lowercase"

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

> puts astringobject
lowercase

> puts bstringobject
LOWERCASE

Ini berarti bahwa sebagian besar waktu, objek asli dibiarkan tidak berubah memberikan penampilan yang ruby ​​adalah "lewat nilai".

Tentu saja ketika merancang kelas Anda sendiri, pemahaman tentang detail perilaku ini penting untuk perilaku fungsional, efisiensi memori dan kinerja.