Does JavaScript pass by reference

Question

Does JavaScript pass by references or pass by values  Here is an example from JavaScript  The Good Parts  I am very confused about the my parameter for the rectangle function  It is actually undefined  and redefined inside the function  There are no original reference  If I remove it from the function parameter  the inside area function is not able to access it  Is it a closure  But no function is returned  var shape   function  config        var that           that name   config name     quot  quot       that area   function              return 0             return that      var rectangle   function  config  my        my   my            my l   config length    1      my w   config width    1      var that   shape config       that area   function              return my l   my w             return that      myShape   shape       name   quot Unhnown quot       myRec   rectangle       name   quot Rectangle quot       length  4      width  6      console log myShape name    quot  area is  quot    myShape area      quot   quot    myRec name    quot  area is  quot    myRec area

User · Answer

I can t see pass-by-reference in the examples where people try to demonstrate such  I only see pass-by-value  In the case of variables that hold a reference to an object  the reference is the value of those variables  and therefore the reference is passed  which is then pass-by-value  In a statement like this  var a       b   quot foo quot     c   quot bar quot      the value of the  a  is not the Object  but the  so far only  reference to it  In other words  the object is not in the variable a - a reference to it is  I think this is something that seems difficult for programmers who are mainly only familiar with JavaScript  But it is easy for people who know also e g  Java  C   and C

User · Answer

My two cents     It s irrelevant whether JavaScript passes parameters by reference or value  What really matters is assignment vs  mutation  I wrote a longer  more detailed explanation in this link  When you pass anything  whether that be an object or a primitive   all JavaScript does is assign a new variable while inside the function    just like using the equal sign      How that parameter behaves inside the function is exactly the same as it would behave if you just assigned a new variable using the equal sign    Take these simple examples   x000D   x000D  var myString    Test string 1       Assignment - A link to the same place as myString var sameString   myString      If I change sameString  it will not modify myString     it just re-assigns it to a whole new string sameString    New string    console log myString      Logs  Test string 1   console log sameString      Logs  New string   x000D   x000D   x000D   If I were to pass myString as a parameter to a function  it behaves as if I simply assigned it to a new variable  Now  let s do the same thing  but with a function instead of a simple assignment  x000D   x000D  function myFunc sameString          Reassignment    Again  it will not modify myString   sameString    New string      var myString    Test string 1       This behaves the same as if we said sameString   myString myFunc myString    console log myString      Again  logs  Test string 1   x000D   x000D   x000D   The only reason that you can modify objects when you pass them to a function is because you are not reassigning    Instead  objects can be changed or mutated     Again  it works the same way  var myObject     name   Joe         Assignment - We simply link to the same object var sameObject   myObject      This time  we can mutate it  So a change to myObject affects sameObject and visa versa myObject name    Jack   console log sameObject name      Logs  Jack   sameObject name    Jill   console log myObject name      Logs  Jill      If we re-assign it  the link is lost sameObject     name   Howard     console log myObject name      Logs  Jill   If I were to pass myObject as a parameter to a function  it behaves as if I simply assigned it to a new variable  Again  the same thing with the exact same behavior but with a function   x000D   x000D  function myFunc sameObject         We mutate the object  so the myObject gets the change too    just like before    sameObject name    Jill         But  if we re-assign it  the link is lost   sameObject         name   Howard          var myObject       name   Joe         This behaves the same as if we said sameObject   myObject  myFunc myObject   console log myObject name      Logs  Jill  x000D   x000D   x000D   Every time you pass a variable to a function  you are  quot assigning quot  to whatever the name of the parameter is  just like if you used the equal   sign  Always remember that the equals sign   means assignment  And passing a parameter to a function also means assignment  They are the same and the two variables are connected in exactly the same way  The only time that modifying a variable affects a different variable is when the underlying object is mutated  There is no point in making a distinction between objects and primitives  because it works the same exact way as if you didn t have a function and just used the equal sign to assign to a new variable

User · Answer

In the interest of creating a simple example that uses const     const myRef     foo   bar     const myVal   true   function passes r  v      r foo    baz     v   false     passes myRef  myVal    console log myRef  myVal      Object  foo   baz   true

User · Answer

In practical terms  Alnitak is correct and makes it easy to understand  but ultimately in JavaScript  everything is passed by value  What is the  quot value quot  of an object  It is the object reference  When you pass in an object  you get a copy of this value  hence the  copy of a reference  that Alnitak described   If you change this value  you do not change the original object  you are changing your copy of that reference

User · Answer

Objects are always pass by reference and primitives by value  Just keep that parameter at the same address for objects  Here s some code to illustrate what I mean  try it in a JavaScript sandbox such as https   js do    Unfortunately you can t only retain the address of the parameter  you retain all the original member values as well  a     key   bevmo     testRetain a   document write   after function     document write a key     function testRetain  b        document write   arg0 is         document write arguments 0  key       b key    passed by reference       var retain   b     Retaining the original address of the parameter         Address of left set to address of right  changes address of parameter     b    key   vons       Right is a new object with a new address     document write   arg0 is         document write arguments 0  key           Now retrieve the original address of the parameter for pass by reference     b   retain      document write   arg0 is         document write arguments 0  key      Result   arg0 is bevmo arg0 is vons arg0 is passed by reference after function passed by reference

User · Answer

Primitives are passed by value  and Objects are passed by  quot copy of a reference quot   Specifically  when you pass an object  or array  you are  invisibly  passing a reference to that object  and it is possible to modify the contents of that object  but if you attempt to overwrite the reference it will not affect the copy of the reference held by the caller - i e  the reference itself is passed by value  function replace ref        ref                    this code does  not  affect the object passed    function update ref        ref key    newvalue       this code  does  affect the  contents  of the object    var a     key   value     replace a       a still has its original value - it s unmodfied update a        the  contents  of  a  are changed

User · Answer

Without purisms  I think that the best way to emulate scalar argument by reference in JavaScript is using object  like previous an answer tells  However  I do a little bit different  I ve made the object assignment inside function call  so one can see the reference parameters near the function call  It increases the source readability  In function declaration  I put the properties like a comment  for the very same reason  readability  var r   funcWithRefScalars r    amount 200  message null     console log r amount    quot  -  quot    r message     function funcWithRefScalars o        o amount  message    o amount     1 2    o message    quot 20  increase quot      In the above example  null indicates clearly an output reference parameter  The exit  240 - 20  Increase  On the client-side  console log should be replaced by alert        Another method that can be even more readable  var amount  message   funcWithRefScalars amount    200   message    null     console log amount 0     quot  -  quot    message 0     function funcWithRefScalars amount  message        o amount  message     amount 0      1 2     message 0     quot 20  increase quot      Here you don t even need to create new dummy names  like r above

User · Answer

Function arguments are passed either by-value or by-sharing  but never ever by reference in JavaScript  Call-by-Value Primitive types are passed by-value   x000D   x000D  var num   123  str    foo    function f num  str      num    1    str     bar     console log  inside of f    num  str      f num  str   console log  outside of f    num  str   x000D   x000D   x000D   Reassignments inside a function scope are not visible in the surrounding scope  This also applies to Strings  which are a composite data type and yet immutable   x000D   x000D  var str    foo    function f str      str 0     b      doesn t work  because strings are immutable   console log  inside of f    str      f str   console log  outside of f    str   x000D   x000D   x000D   Call-by-Sharing Objects  that is to say all types that are not primitives  are passed by-sharing  A variable that holds a reference to an object actually holds merely a copy of this reference  If JavaScript would pursue a call-by-reference evaluation strategy  the variable would hold the original reference  This is the crucial difference between by-sharing and by-reference  What are the practical consequences of this distinction   x000D   x000D  var o    x   foo    p    y  123    function f o  p      o x    bar      Mutation   p    x  456      Reassignment   console log  o inside of f    o     console log  p inside of f    p      f o  p    console log  o outside of f    o   console log  p outside of f    p   x000D   x000D   x000D   Mutating means to modify certain properties of an existing Object  The reference copy that a variable is bound to and that refers to this object remains the same  Mutations are thus visible in the caller s scope  Reassigning means to replace the reference copy bound to a variable  Since it is only a copy  other variables holding a copy of the same reference remain unaffected  Reassignments are thus not visible in the caller s scope like they would be with a call-by-reference evaluation strategy  Further information on evaluation strategies in ECMAScript

User · Answer

JavaScript is pass by value  For primitives  primitive s value is passed  For Objects  Object s reference  quot value quot  is passed  Example with Object  var f1   function inputObject       inputObject a   2     var f2   function        var inputObject     quot a quot   1       f1 inputObject       console log inputObject a      Calling f2 results in printing out  quot a quot  value as 2 instead of 1  as the reference is passed and the  quot a quot  value in reference is updated  Example with primitive  var f1   function a       a   2    var f2   function        var a   1      f1 a       console log a      Calling f2 results in printing out  quot a quot  value as 1

User · Answer

As with C  ultimately  everything is passed by value   Unlike C  you can t actually back up and pass the location of a variable  because it doesn t have pointers  just references  And the references it has are all to objects  not variables   There are several ways of achieving the same result  but they have to be done by hand  not just adding a keyword at either the call or declaration site

User · Answer

quot Global quot  JavaScript variables are members of the window object  You could access the reference as a member of the window object  var v    quot initialized quot    function byref ref      window ref     quot changed by ref quot      byref  function   for r in window  if window r    v  return r              It could also be called like    byref  v    console log v      outputs changed by ref  Note  the above example will not work for variables declared within a function

User · Answer

Think of it like this   Whenever you create an object in ECMAscript  this object is formed in a mystique ECMAscript universal place where no man will ever be able to get  All you get back is a reference to that object in this mystique place   var obj          Even obj is only a reference to the object  which is located in that special wonderful place  and hence  you can only pass this reference around  Effectively  any piece of code which accesses obj will modify the object which is far  far away

User · Answer

Primitives are passed by value  But in case you only need to read the value of a primitve  and value is not known at the time when function is called  you can pass function which retrieves the value at the moment you need it   function test value      console log  retrieve value      console log value           call the function like this var value   1  test      gt  value

[javascript] Does JavaScript pass by reference?

Examples related to javascript

Examples related to reference

Examples related to pass-by-reference

Examples related to pass-by-value