Return multiple values in JavaScript?

Return multiple values in JavaScript?

I am trying to return two values in JavaScript. Is that possible?
var newCodes = function() {
var dCodes =;
var dCodes2 =;
return dCodes, dCodes2;


Solution 1:

No, but you could return an array containing your values:

function getValues() {
    return [getFirstValue(), getSecondValue()];

Then you can access them like so:

var values = getValues();
var first = values[0];
var second = values[1];

With the latest ECMAScript 6 syntax*, you can also destructure the return value more intuitively:

const [first, second] = getValues();

If you want to put “labels” on each of the returned values (easier to maintain), you can return an object:

function getValues() {
    return {
        first: getFirstValue(),
        second: getSecondValue(),

And to access them:

var values = getValues();
var first = values.first;
var second = values.second;

Or with ES6 syntax:

const {first, second} = getValues();

* See this table for browser compatibility. Basically, all modern browsers aside from IE support this syntax, but you can compile ES6 code down to IE-compatible JavaScript at build time with tools like Babel.

Solution 2:

You can do this from Javascript 1.7 onwards using “destructuring assignments”. Note that these are not available in older Javascript versions (meaning — neither with ECMAScript 3rd nor 5th editions).

It allows you to assign to 1+ variables simultaneously:

var [x, y] = [1, 2];
x; // 1
y; // 2

// or

[x, y] = (function(){ return [3, 4]; })();
x; // 3
y; // 4

You can also use object destructuring combined with property value shorthand to name the return values in an object and pick out the ones you want:

let {baz, foo} = (function(){ return {foo: 3, bar: 500, baz: 40} })();
baz; // 40
foo; // 3

And by the way, don’t be fooled by the fact that ECMAScript allows you to return 1, 2, .... What really happens there is not what might seem. An expression in return statement — 1, 2, 3 — is nothing but a comma operator applied to numeric literals (1 , 2, and 3) sequentially, which eventually evaluates to the value of its last expression — 3. That’s why return 1, 2, 3 is functionally identical to nothing more but return 3.

return 1, 2, 3;
// becomes
return 2, 3;
// becomes
return 3;

Solution 3:

Just return an object literal

function newCodes(){
    var dCodes =; // Linked ICDs  
    var dCodes2 =; //Linked CPTs       
    return {
        dCodes: dCodes, 
        dCodes2: dCodes2

var result = newCodes();

Solution 4:

Since ES6 you can do this

let newCodes = function() {  
    const dCodes =
    const dCodes2 =
    return {dCodes, dCodes2}

let {dCodes, dCodes2} = newCodes()

Return expression {dCodes, dCodes2} is property value shorthand and is equivalent to this {dCodes: dCodes, dCodes2: dCodes2}.

This assignment on last line is called object destructing assignment. It extracts property value of an object and assigns it to variable of same name. If you’d like to assign return values to variables of different name you could do it like this let {dCodes: x, dCodes2: y} = newCodes()

Solution 5:

Ecmascript 6 includes “destructuring assignments” (as kangax mentioned) so in all browsers (not just Firefox) you’ll be able to capture an array of values without having to make a named array or object for the sole purpose of capturing them.

//so to capture from this function
function myfunction()
 var n=0;var s=1;var w=2;var e=3;
 return [n,s,w,e];

//instead of having to make a named array or object like this
var IexistJusttoCapture = new Array();
IexistJusttoCapture = myfunction();

//you'll be able to just do this
[north, south, west, east] = myfunction(); 

You can try it out in Firefox already!

Solution 6:

Another worth to mention newly introduced (ES6) syntax is use of object creation shorthand in addition to destructing assignment.

function fun1() {
  var x = 'a';
  var y = 'b';
  return { x, y, z: 'c' };
  // literally means { x: x, y: y, z: 'c' };

var { z, x, y } = fun1(); // order or full presence is not really important
// literally means var r = fun1(), x = r.x, y = r.y, z = r.z;
console.log(x, y, z);

This syntax can be polyfilled with babel or other js polyfiller for older browsers but fortunately now works natively with the recent versions of Chrome and Firefox.

But as making a new object, memory allocation (and eventual gc load) are involved here, don’t expect much performance from it. JavaScript is not best language for developing highly optimal things anyways but if that is needed, you can consider putting your result on surrounding object or such techniques which are usually common performance tricks between JavaScript, Java and other languages.