How to return two values in javascript?

AffiliatePal is reader-supported. When you buy through links on our site, we may earn an affiliate commission.



Returning multiple values in JavaScript can be a common requirement in programming. While JavaScript functions typically return a single value, there are several approaches to return multiple values. This article will explore various techniques to return two values in JavaScript.

Destructuring Assignment

One of the simplest ways to return two values in JavaScript is by using destructuring assignment. This feature allows us to extract values from arrays or objects into distinct variables. Let’s consider an example:

function getCoordinates() {
return [10, 20];

const [x, y] = getCoordinates();
console.log(x); // Output: 10
console.log(y); // Output: 20

In this example, the `getCoordinates` function returns an array with two values, which are then assigned to the variables `x` and `y` using destructuring assignment. This technique provides a concise and readable way to return multiple values.

Object Literal

Another approach is to return an object literal with named properties representing the values. This method allows for more flexibility and readability, especially when the returned values have distinct meanings. Consider the following example:

function getUser() {
return {
name: ‘John Doe’,
age: 25

const user = getUser();
console.log(; // Output: John Doe
console.log(user.age); // Output: 25

In this case, the `getUser` function returns an object literal with the properties `name` and `age`. By assigning the returned object to the `user` variable, we can access the individual values using dot notation.


Returning an array that contains multiple values is another viable option. This approach is particularly useful when the returned values are of the same type or when their order is significant. Here’s an example:

function getMinMax(numbers) {
const min = Math.min(…numbers);
const max = Math.max(…numbers);
return [min, max];

const numbers = [5, 2, 9, 1, 7];
const [minValue, maxValue] = getMinMax(numbers);
console.log(minValue); // Output: 1
console.log(maxValue); // Output: 9

In this example, the `getMinMax` function takes an array of numbers and returns an array containing the minimum and maximum values. The destructuring assignment is used to assign these values to the `minValue` and `maxValue` variables.

Custom Object

For more complex scenarios, creating a custom object to encapsulate multiple values can be beneficial. This approach allows for greater flexibility in organizing and accessing the returned data. Consider the following example:

function getPerson() {
const person = {
name: ‘Jane Smith’,
age: 30,
address: ‘123 Main St’

return person;

const person = getPerson();
console.log(; // Output: Jane Smith
console.log(person.age); // Output: 30
console.log(person.address); // Output: 123 Main St

In this case, the `getPerson` function returns a custom object representing a person. The object contains properties such as `name`, `age`, and `address`, which can be accessed using dot notation.


Returning two values in JavaScript can be achieved using various techniques. Destructuring assignment allows for extracting values from arrays or objects, while returning an object literal or an array provides a straightforward way to encapsulate multiple values. For more complex scenarios, creating a custom object can offer greater flexibility. Choose the approach that best suits your specific requirements.


– [Destructuring assignment](
– [Object literals](
– [Array](
– [Objects in JavaScript](
– [Functions](