Pass Variables by Reference in Javascript

Pass Variables by Reference in Javascript

How do I pass variables by reference in JS? I have 3 variables that I want to perform several operations to so I want to put them in a for loop and perform the operations to each one.
pseudo code:
myArray = new Array(var1, var2, var3);
for (var x = 0; x < myArray.length; x++){ //do stuff to the array makePretty(myArray[x]); } //now do stuff to the updated vars What is the best way to do this?


Solution 1:

There is no “pass by reference” available in JavaScript. You can pass an object (which is to say, you can pass-by-value a reference to an object) and then have a function modify the object contents:

function alterObject(obj) { = "goodbye";

var myObj = { foo: "hello world" };


alert(; // "goodbye" instead of "hello world"

Now, in your case, you’re not passing anything anyway, as far as I can tell. You can iterate over the properties of an array with a numeric index and modify each cell of the array, if you want.

It’s important to note that “pass-by-reference” is a very specific term. It does not mean simply that it’s possible to pass a reference to a modifiable object. Instead, it means that it’s possible to pass a simple variable in such a way as to allow a function to modify that value in the calling context. So:

 function swap(a, b) {
   var tmp = a;
   a = b;
   b = tmp; //assign tmp to b

 var x = 1, y = 2;
 swap(x, y);

 alert("x is " + x + " y is " + y); // "x is 1 y is 2"

In a language like C++, it’s possible to do that because that language does (sort-of) have pass-by-reference.

edit — this recently (March 2015) blew up on Reddit again over a blog post similar to mine mentioned below, though in this case about Java. It occurred to me while reading the back-and-forth in the Reddit comments that a big part of the confusion stems from the unfortunate collision involving the word “reference”. The terminology “pass by reference” and “pass by value” predates the concept of having “objects” to work with in programming languages. It’s really not about objects at all; it’s about function parameters, and specifically how function parameters are “connected” (or not) to the calling environment. In particular, note that in a true pass-by-reference language — one that does involve objects — one would still have the ability to modify object contents, and it would look pretty much exactly like it does in JavaScript. However, one would also be able to modify the object reference in the calling environment, and that’s the key thing that you can’t do in JavaScript. A pass-by-reference language would pass not the reference itself, but a reference to the reference.

edithere is a blog post on the topic. (Note the comment to that post that explains that C++ doesn’t really have pass-by-reference. That is true. What C++ does have, however, is the ability to create references to plain variables, either explicitly at the point of function invocation to create a pointer, or implicitly when calling functions whose argument type signature calls for that to be done. Those are the key things JavaScript doesn’t support.)

Related:  What does “publicPath” in Webpack do?

Solution 2:

  1. primitive type variables like strings and numbers are always passed by value.
  2. Arrays and Objects are passed by reference or by value based on these conditions:

    • if you are setting the value of an object or array it is Pass by Value.

      object1 = {prop: "car"};
      array1 = [1,2,3];

    • if you are changing a property value of an object or array then it is Pass by Reference.

      object1.prop = "car";
      array1[0] = 9;


function passVar(obj1, obj2, num) {
    obj1.prop = "laptop"; // will CHANGE original
    obj2 = { prop: "computer" }; //will NOT affect original
    num = num + 1; // will NOT affect original

var object1 = {
    prop: "car"
var object2 = {
    prop: "bike"
var number1 = 10;

passVar(object1, object2, number1);
console.log(object1); //output: Object {item:"laptop"}
console.log(object2); //output: Object {item:"bike"}
console.log(number1); //ouput: 10

Solution 3:

Workaround to pass variable like by reference:

var a = 1;
inc = function(variableName) {
  window[variableName] += 1;


alert(a); // 2


yup, actually you can do it without access global

inc = (function () {
    var variableName = 0;

    var init = function () {
        variableName += 1;

    return init;


Solution 4:

Simple Object

var ref = { value: 1 };

function Foo(x) {


alert(ref.value); // Alert: 3

Custom Object

Object rvar

function rvar (name, value, context) {
    if (this instanceof rvar) {
        this.value = value;
        Object.defineProperty(this, 'name', { value: name });
        Object.defineProperty(this, 'hasValue', { get: function () { return this.value !== undefined; } });
        if ((value !== undefined) && (value !== null))
            this.constructor = value.constructor;
        this.toString = function () { return this.value + ''; };
    } else {
        if (!rvar.refs)
            rvar.refs = {};
        if (!context)
            context = window;
        // Private
        rvar.refs[name] = new rvar(name, value);
        // Public
        Object.defineProperty(context, name, {
            get: function () { return rvar.refs[name]; },
            set: function (v) { rvar.refs[name].value = v; },
            configurable: true

        return context[name];

Variable Declaration

test_ref = 5; // test_ref.value = 5


rvar('test_ref', 5); // test_ref.value = 5

Test Code

test_ref_number = 5;
function Fn1 (v) { v.value = 100; }
console.log("test_ref_number = 5;");
console.log("function Fn1 (v) { v.value = 100; }");
console.log('test_ref_number.value === 5', test_ref_number.value === 5);
console.log(" ");

console.log('test_ref_number.value === 100', test_ref_number.value === 100);
console.log(" ");

console.log('test_ref_number.value === 101', test_ref_number.value === 101);
console.log(" ");

test_ref_number = test_ref_number - 10;
console.log("test_ref_number = test_ref_number - 10;");
console.log('test_ref_number.value === 91', test_ref_number.value === 91);

console.log(" ");
console.log(" ");

rvar('test_ref_str', 'a');
console.log("rvar('test_ref_str', 'a');");
console.log('test_ref_str.value === "a"', test_ref_str.value === 'a');
console.log(" ");

test_ref_str += 'bc';
console.log("test_ref_str += 'bc';");
console.log('test_ref_str.value === "abc"', test_ref_str.value === 'abc');

Test Console Result

test_ref_number = 5;
function Fn1 (v) { v.value = 100; }
test_ref_number.value === 5 true

test_ref_number.value === 100 true

test_ref_number.value === 101 true

test_ref_number = test_ref_number - 10;
test_ref_number.value === 91 true


rvar('test_ref_str', 'a');
test_ref_str.value === "a" true

test_ref_str += 'bc';
test_ref_str.value === "abc" true 

Solution 5:

Yet another approach to pass any (local, primitive) variables by reference is by wrapping variable with closure “on the fly” by eval. This also works with “use strict”. (Note: be aware that eval is not friendly to JS optimizers, also missing quotes around variable name may cause unpredictive results)

"use strict"

//return text that will reference variable by name (by capturing that variable to closure)
function byRef(varName){
    return "({get value(){return "+varName+";}, set value(v){"+varName+"=v;}})";


//assign argument by reference
function modifyArgument(argRef, multiplier){
    argRef.value = argRef.value * multiplier;


var x = 10;

alert("x before: " + x);
modifyArgument(eval(byRef("x")), 42);
alert("x after: " + x);


Live sample

Related:  Image resizing client-side with JavaScript before upload to the server

Solution 6:

I’ve been playing around with syntax to do this sort of thing, but it requires some helpers that are a little unusual. It starts with not using ‘var’ at all, but a simple ‘DECLARE’ helper that creates a local variable and defines a scope for it via an anonymous callback. By controlling how variables are declared, we can choose to wrap them into objects so that they can always be passed by reference, essentially. This is similar to one of the Eduardo Cuomo’s answer above, but the solution below does not require using strings as variable identifiers. Here’s some minimal code to show the concept.

function Wrapper(val){
    this.VAL = val;
Wrapper.prototype.toString = function(){
    return this.VAL.toString();

function DECLARE(val, callback){
    var valWrapped = new Wrapper(val);    

function INC(ref){
    if(ref && ref.hasOwnProperty('VAL')){
        ref++;//or maybe throw here instead?

    return ref;

DECLARE(5, function(five){ //consider this line the same as 'let five = 5'
console.log("five is now " + five);
INC(five); // increment
console.log("five is incremented to " + five);