Is Ruby pass by reference or by value

Question

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  amp   user save end logger debug  --------------------LANG ERRORS-------------102----------                     lang errors full messages inspect  if lang errors full messages empty     user object adds errors to the lang errors variable in the update lanugages method  when I perform a save on the  user object I lose the errors that were initially stored in the lang errors variable   Though what I am attempting to do would be more of a hack  which does not seem to be working   I would like to understand why the variable values are washed out  I understand pass by reference so I would like to know how the value can be held in that variable without being washed out

User · Answer

Ruby is interpreted   Variables are references to data  but not the data itself  This facilitates using the same variable for data of different types   Assignment of lhs   rhs then copies the reference on the rhs  not the data   This differs in other languages  such as C  where assignment does a data copy to lhs from rhs     So for the function call  the variable passed  say x  is indeed copied into a local variable in the function  but x is a reference  There will then be two copies of the reference  both referencing the same data   One will be in the caller  one in the function    Assignment in the function would then copy a new reference to the function s version of x  After this the caller s version of x remains unchanged   It is still a reference to the original data   In contrast  using the  replace method on x will cause ruby to do a data copy   If replace is used before any new assignments then indeed the caller will see the data change in its version also   Similarly  as long as the original reference is in tact for the passed in variable  the instance variables will be the same that the caller sees   Within the framework of an object  the instance variables always have the most up to date reference values  whether those are provided by the caller or set in the function the class was passed in to   The  call by value  or  call by reference  is muddled here because of confusion over     In compiled languages     is a data copy   Here in this interpreted language     is a reference copy   In the example you have the reference passed in followed by a reference copy though     that clobbers the original passed in reference  and then people talking about it as though     were a data copy     To be consistent with definitions we must keep with   replace  as it is a data copy   From the perspective of   replace  we see that this is indeed pass by reference   Furthermore  if we walk through in the debugger  we see references being passed in  as variables are references     However if we must keep     as a frame of reference  then indeed we do get to see the passed in data up until an assignment  and then we don t get to see it anymore after assignment while the caller s data remains unchanged   At a behavioral level this is pass by value as long as we don t consider the passed in value to be composite - as we won t be able to keep part of it while changing the other part in a single assignment  as that assignment changes the reference and the original goes out of scope    There will also be a wart  in that instance variables in objects will be references  as are all variables   Hence we will be forced to talk about passing  references by value  and have to use related locutions

User · Answer

Is Ruby pass by reference or by value    Ruby is pass-by-reference  Always  No exceptions  No ifs  No buts   Here is a simple program which demonstrates that fact   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 is pass-by-reference 2279146940 because object id s  memory addresses  are always the same      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           some people don t realize it s reference because local assignment can take precedence  but it s clearly pass-by-reference

User · Answer

Is Ruby pass by reference or by value    Ruby is pass-by-value  Always  No exceptions  No ifs  No buts   Here is a simple program which demonstrates that fact   def foo bar    bar    reference  end  baz    value   foo baz   puts  Ruby is pass-by-  baz     Ruby is pass-by-value

User · Answer

In traditional terminology  Ruby is strictly pass-by-value  But that s not really what you re asking here   Ruby doesn t have any concept of a pure  non-reference value  so you certainly can t pass one to a method  Variables are always references to objects  In order to get an object that won t change out from under you  you need to dup or clone the object you re passed  thus giving an object that nobody else has a reference to   Even this isn t bulletproof  though     both of the standard cloning methods do a shallow copy  so the instance variables of the clone still point to the same objects that the originals did  If the objects referenced by the ivars mutate  that will still show up in the copy  since it s referencing the same objects

User · Answer

There are already some great answers  but I want to post the definition of a pair of authorities on the subject  but also hoping someone might explain what said authorities Matz  creator of Ruby  and David Flanagan meant in their excellent O Reilly book  The Ruby Programming Language    from 3 8 1  Object References  When you pass an object to a method in Ruby  it is an object reference that is passed to the  method  It is not the object itself  and it is not a reference to the reference to the  object  Another way to say this is that method arguments are passed by value rather than by reference  but that the values passed are object references  Because object references are passed to methods  methods can use those references to modify the underlying object  These modifications are then visible when the method returns   This all makes sense to me until that last paragraph  and especially that last sentence  This is at best misleading  and at worse confounding  How  in any way  could modifications to that passed-by-value reference change the underlying object

User · Answer

Two references refer to same object as long as there is no reassignment     Any updates in the same object won t make the references to new memory since it still is in same memory       Here are few examples         a    first string      b   a        b upcase         gt  FIRST STRING     a       gt  FIRST STRING      b    second string    a       gt  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       gt   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       gt    first sub hash   first key   first value   second key   second value   third key   third value

User · Answer

The other answerers are all correct  but a friend asked me to explain this to him and what it really boils down to is how Ruby handles variables  so I thought I would share some simple pictures   explanations I wrote for him  apologies for the length and probably some oversimplification      Q1  What happens when you assign a new variable str to a value of  foo    str    foo  str object id     gt  2000     A  A label called str is created that points at the object  foo   which for the state of this Ruby interpreter happens to be at memory location 2000     Q2  What happens when you assign the existing variable str to a new object using     str    bar  tap  b  puts  bar    b object id      bar  2002 str object id     gt  2002     A  The label str now points to a different object     Q3  What happens when you assign a new variable   to str   str2   str str2 object id     gt  2002     A  A new label called str2 is created that points at the same object as str     Q4  What happens if the object referenced by str and str2 gets changed   str2 replace  baz  str2     gt   baz  str      gt   baz  str object id     gt  2002 str2 object id     gt  2002     A  Both labels still point at the same object  but that object itself has mutated  its contents have changed to be something else      How does this relate to the original question   It s basically the same as what happens in Q3 Q4  the method gets its own private copy of the variable   label  str2  that gets passed in to it  str    It can t change which object the label str points to  but it can change the contents of the object that they both reference to contain else   str    foo   def mutate str2    puts  str2    str2 object id     str2 replace  bar    str2    baz    puts  str2    str2 object id   end  str object id     gt  2004 mutate str    str2  2004  str2  2006 str     gt   bar  str object id     gt  2004

User · Answer

It should be noted that you do not have to even use the  replace  method to change the value original value  If you assign one of the hash values for a hash  you are changing the original value    def my foo a hash    a hash  test    reference  end   hash     test   gt  value   my foo hash  puts  Ruby is pass-by-  hash  test

User · Answer

Ruby is pass-by-value in a strict sense  BUT the values are references    This could be called  pass-reference-by-value   This article has the best explanation I have read  http   robertheaton com 2014 07 22 is-ruby-pass-by-reference-or-pass-by-value   Pass-reference-by-value could briefly be explained as follows      A function receives a reference to  and will access  the same object in memory as used by the caller  However  it does not receive the box that the caller is storing this object in  as in pass-value-by-value  the function provides its own box and creates a new variable for itself     The resulting behavior is actually a combination of the classical definitions of pass-by-reference and pass-by-value

User · Answer

Try this --  1 object id    gt  3  2 object id    gt  5  a   1    gt  1 a object id    gt  3  b   2    gt  2 b object id    gt  5   identifier a contains object id 3 for value object 1 and identifier b contains object id 5 for value object 2   Now do this --  a object id   5    gt  error  a   b  value object id  at b copies itself as value object id  at a  value object 2 has object id 5    gt  2  a object id     gt  5   Now  a and b both contain same object id 5 which refers to value object 2  So  Ruby variable contains object ids to refer to value objects   Doing following also gives error --  c    gt  error   but doing this won t give error --  5 object id    gt  11  c   5    gt  value object 5 provides return type for variable c and saves 5 object id i e  11 at c    gt  5 c object id    gt  11   a   c object id    gt  object id of c as a value object changes value at a    gt  11 11 object id    gt  23 a object id    11 object id    gt  true  a    gt  Value at a    gt  11   Here identifier a returns value object 11 whose object id is 23 i e  object id 23 is at identifier a  Now we see an example by using method   def foo arg    p arg   p arg object id end    gt  nil 11 object id    gt  23 x   11    gt  11 x object id    gt  23 foo x     gt  11    gt  23   arg in foo is assigned with return value of x  It clearly shows that argument is passed by value 11  and value 11 being itself an object has unique object id 23    Now see this also --  def foo arg    p arg   p arg object id   arg   12   p arg   p arg object id end     gt  nil 11 object id    gt  23 x   11    gt  11 x object id    gt  23 foo x     gt  11    gt  23    gt  12    gt  25 x    gt  11 x object id    gt  23   Here  identifier arg first contains object id 23 to refer 11 and after internal assignment with value object 12  it contains object id 25  But it does not change value referenced by identifier x used in calling method   Hence  Ruby is pass by value and Ruby variables do not contain values but do contain reference to value object

User · Answer

Lots of great answers diving into the theory of how Ruby s  quot pass-reference-by-value quot  works  But I learn and understand everything much better by example  Hopefully  this will be helpful  def foo bar    puts  quot bar    bar   entering foo with object id   bar object id  quot    bar     quot reference quot    puts  quot bar    bar   leaving foo with object id   bar object id  quot  end  bar    quot value quot  puts  quot bar    bar   before foo with object id   bar object id  quot  foo bar  puts  quot bar    bar   after foo with object id   bar object id  quot     Output bar  value  before foo with object id 60 bar  value  entering foo with object id 60 bar  reference  leaving foo with object id 80    lt ----- bar  value  after foo with object id 60    lt -----  As you can see when we entered the method  our bar was still pointing to the string  quot value quot   But then we assigned a string object  quot reference quot  to  bar  which has a new object id   In this case bar inside of foo  has a different scope  and whatever we passed inside the method  is no longer accessed by bar as we re-assigned it and point it to a new place in memory that holds String  quot reference quot   Now consider this same method  The only difference is what with do inside the method def foo bar    puts  quot bar    bar   entering foo with object id   bar object id  quot    bar replace  quot reference quot    puts  quot bar    bar   leaving foo with object id   bar object id  quot  end  bar    quot value quot  puts  quot bar    bar   before foo with object id   bar object id  quot  foo bar  puts  quot bar    bar   after foo with object id   bar object id  quot     Output bar  value  before foo with object id 60 bar  value  entering foo with object id 60 bar  reference  leaving foo with object id 60    lt ----- bar  reference  after foo with object id 60    lt -----  Notice the difference  What we did here was   we modified the contents of the String object  that variable was pointing to   The scope of bar is still different inside of the method  So be careful how you treat the variable passed into methods  And if you modify passed-in variables-in-place  gsub   replace  etc   then indicate so in the name of the method with a bang    like so  quot def foo  quot  P S   It s important to keep in mind that the  quot bar quot s inside and outside of foo  are  quot different quot   quot bar quot   Their scope is different  Inside the method  you could rename  quot bar quot  to  quot club quot  and the result would be the same  I often see variables re-used inside and outside of methods  and while it s fine  it takes away from the readability of the code and is a code smell IMHO  I highly recommend not to do what I did in my example above    and rather do this def foo fiz    puts  quot fiz    fiz   entering foo with object id   fiz object id  quot    fiz     quot reference quot    puts  quot fiz    fiz   leaving foo with object id   fiz object id  quot  end  bar    quot value quot  puts  quot bar    bar   before foo with object id   bar object id  quot  foo bar  puts  quot bar    bar   after foo with object id   bar object id  quot     Output bar  value  before foo with object id 60 fiz  value  entering foo with object id 60 fiz  reference  leaving foo with object id 80 bar  value  after foo with object id 60

User · Answer

Ruby uses  pass by object reference    Using Python s terminology    To say Ruby uses  pass by value  or  pass by reference  isn t really descriptive enough to be helpful  I think as most people know it these days  that terminology   value  vs  reference   comes from C     In C     pass by value  means the function gets a copy of the variable and any changes to the copy don t change the original  That s true for objects too  If you pass an object variable by value then the whole object  including all of its members  get copied and any changes to the members don t change those members on the original object   It s different if you pass a pointer by value but Ruby doesn t have pointers anyway  AFAIK    class A     public      int x      void inc A arg      arg x      printf  in inc   d n   arg x        gt  6    void inc A  arg      arg- gt x      printf  in inc   d n   arg- gt x        gt  1    int main       A a    a x   5    inc a     printf  in main   d n   a x        gt  5    A  b   new A    b- gt x   0    inc b     printf  in main   d n   b- gt x        gt  1    return 0      Output   in inc  6 in main  5 in inc  1 in main  1   In C     pass by reference  means the function gets access to the original variable  It can assign a whole new literal integer and the original variable will then have that value too   void replace A  amp 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      Output   in replace  10 in main  10   Ruby uses pass by value  in the C   sense  if the argument is not an object  But in Ruby everything is an object  so there really is no pass by value in the C   sense in Ruby   In Ruby   pass by object reference   to use Python s terminology  is used    Inside the function  any of the object s members can have new values assigned to them and these changes will persist after the function returns   Inside the function  assigning a whole new object to the variable causes the variable to stop referencing the old object  But after the function returns  the original variable will still reference the old object    Therefore Ruby does not use  pass by reference  in the C   sense  If it did  then assigning a new object to a variable inside a function would cause the old object to be forgotten after the function returned   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   Output   1 2 2 3 2  1 2 1     This is why  in Ruby  if you want to modify an object inside a function but forget those changes when the function returns  then you must explicitly make a copy of the object before making your temporary changes to the copy

User · Answer

Parameters are a copy of the original reference  So  you can change values  but cannot change the original reference

User · Answer

Yes but       Ruby passes a reference to an object and since everything in ruby is an object  then you could say it s pass by reference   I don t agree with the postings here claiming it s pass by value  that seems like pedantic  symantic games to me   However  in effect it  hides  the behaviour because most of the operations ruby provides  out of the box  - for example string operations  produce a copy of the object    gt  astringobject    lowercase    gt  bstringobject   astringobject upcase  gt    bstringobject is a new object created by String upcase   gt  puts astringobject lowercase   gt  puts bstringobject LOWERCASE   This means that much of the time  the original object is left unchanged giving the appearance that ruby is  pass by value    Of course when designing your own classes  an understanding of the details of this behaviour is important for both functional behaviour  memory efficiency and performance

[ruby-on-rails] Is Ruby pass by reference or by value?

Examples related to ruby-on-rails

Examples related to ruby

Examples related to pass-by-reference