Вернуть несколько значений в JavaScript?

Нет, но вы можете вернуть массив, содержащий ваши значения:

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

Тогда вы можете получить к ним доступ, как так:

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

С последним синтаксис ECMAScript 6 * вы также можете более интуитивно определить возвращаемое значение:

const [first, second] = getValues();

Если вы хотите поставить «метки» для каждого из возвращаемых значений (легче поддерживать), вы можете вернуть объект:

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

И чтобы получить к ним доступ

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

Или с синтаксисом ES6:

const {first, second} = getValues();

• См. эта таблица для совместимости с браузером. По сути, все современные браузеры, кроме IE, поддерживают этот синтаксис, но вы можете скомпилировать код ES6 до IE-совместимого JavaScript во время сборки с помощью таких инструментов, как Babel.& Лт; / sup >

Вы можете сделать это с Javascript 1.7 и далее, используя «назначения для деструктуризации». Обратите внимание, что они недоступны в более старых версиях Javascript (то есть - ни с ECMAScript 3-го, ни 5-го издания).

Это позволяет назначать 1+ переменных одновременно:

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

// or

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

Вы также можете использовать деструктурирование объекта в сочетании со значением свойства shorthand, чтобы назвать возвращаемые значения в объекте и выбрать те, которые вы хотите:

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

И, кстати, не обманывайтесь тем фактом, что ECMAScript позволяет вам возвращать 1, 2, .... То, что действительно происходит, не то, что может показаться. Выражение в обратном выражении - 1, 2, 3 - является не чем иным, как оператором запятой, применяемым к числовым литералам (1, 2 и 3) последовательно, который в конечном итоге оценивается как значение его последнего выражения - 3. Вот почему «возврат 1, 2, 3» функционально идентичен только «возврат 3».

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

Просто верните объект буквально

function newCodes(){
    var dCodes = fg.codecsCodes.rs; // Linked ICDs  
    var dCodes2 = fg.codecsCodes2.rs; //Linked CPTs       
    return {
        dCodes: dCodes, 
        dCodes2: dCodes2
    };  
}

var result = newCodes();
alert(result.dCodes);
alert(result.dCodes2);

С ES6 вы можете сделать это

let newCodes = function() {  
    const dCodes = fg.codecsCodes.rs
    const dCodes2 = fg.codecsCodes2.rs
    return {dCodes, dCodes2}
};

let {dCodes, dCodes2} = newCodes()

Возвращаемое выражение {dCodes, dCodes2} является значением свойства shorthand и эквивалентно этому {dCodes: dCodes, dCodes2: dCodes2}.

Это назначение в последней строке называется заданием уничтожения объекта . Он извлекает значение свойства объекта и назначает его переменной с тем же именем. Если вы хотите назначить возвращаемые значения переменным другого имени, вы можете сделать это следующим образом: let {dCodes: x, dCodes2: y} = newCodes ()

Ecmascript 6 включает в себя «назначения для деструктуризации» (как упомянуто в kangax), поэтому во всех браузерах (не только в Firefox) вы сможете захватывать массив значений без необходимости создавать именованный массив или объект с единственной целью их захвата.

//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();
north=IexistJusttoCapture[0];
south=IexistJusttoCapture[1];
west=IexistJusttoCapture[2];
east=IexistJusttoCapture[3];

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

Вы можете попробовать это уже в Firefox!

Еще один синтаксис, который стоит упомянуть недавно введенным (ES6), - это использование стенографии создания объектов в дополнение к деструктурирующему присвоению.

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);

Этот синтаксис может быть поли заполнен babel или другим полифиллером js для старых браузеров, но, к счастью, теперь он изначально работает с последними версиями Chrome и Firefox.

Но при создании нового объекта здесь задействовано распределение памяти (и возможная загрузка gc), и вы не ожидаете от него большой производительности. В любом случае JavaScript не является лучшим языком для разработки высокооптимальных вещей, но если это необходимо, вы можете рассмотреть возможность размещения вашего результата на окружающем объекте или на таких методах, которые обычно являются общими приемами производительности между JavaScript, Java и другими языками.

Лучший способ для этого

function a(){
     var d=2;
     var c=3;
     var f=4;
     return {d:d,c:c,f:f}
}

Тогда используйте

a().f

возврат 4

в ES6 вы можете использовать этот код

function a(){
      var d=2;
      var c=3;
      var f=4;
      return {d,c,f}
}

Помимо возврата массива или объекта, как рекомендовали другие, вы также можете использовать функцию коллектора (аналогичную той, которая найдена в The Little Schemer ):

function a(collector){
  collector(12,13);
}

var x,y;
a(function(a,b){
  x=a;
  y=b;
});

Я сделал тест jsperf, чтобы увидеть, какой из трех методов быстрее. Массив самый быстрый и коллекционер самый медленный.

http://jsperf.com/returning-multiple-values-2

В JS мы можем легко вернуть кортеж с массивом или объектом, но не забываем! = > JS - это язык, ориентированный на «обратный вызов», и здесь есть небольшой секрет для «возвращения нескольких значений», о которых еще никто не упомянул, попробуйте это:

var newCodes = function() {  
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    return dCodes, dCodes2;
};

становится

var newCodes = function(fg, cb) {  
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    cb(null, dCodes, dCodes2);
};

:)

бац! Это просто еще один способ решения вашей проблемы.

Вы также можете сделать:

function a(){
  var d=2;
  var c=3;
  var f=4;
  return {d:d,c:c,f:f}
}

const {d,c,f} = a()

Вы можете использовать «Объект»

function newCodes(){
    var obj= new Object();
    obj.dCodes = fg.codecsCodes.rs;
    obj.dCodes2 = fg.codecsCodes2.rs;

    return obj;
}

Все правильно. return логически обрабатывает слева направо и возвращает последнее значение.

function foo(){
    return 1,2,3;
}

>> foo()
>> 3

Я бы предложил использовать последнее назначение по деструктуризации (Но убедитесь, что оно поддерживается в вашей среде)

var newCodes = function () {
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    return {firstCodes: dCodes, secondCodes: dCodes2};
};
var {firstCodes, secondCodes} = newCodes()

Очень распространенный способ вернуть несколько значений в javascript - это использовать object literals , что-то вроде:

const myFunction = () => {
  const firstName = "Alireza", 
        familyName = "Dezfoolian",
        age = 35;
  return { firstName, familyName, age};
}

и получить такие значения:

myFunction().firstName; //Alireza
myFunction().familyName; //Dezfoolian
myFunction().age; //age

или даже короче:

const {firstName, familyName, age} = myFunction();

и получить их индивидуально, как:

firstName; //Alireza
familyName; //Dezfoolian
age; //35

Я знаю два способа сделать это:

1. Вернись как Массив
2. Вернуться как объект

Вот пример, который я нашел:

<script>
// Defining function
function divideNumbers(dividend, divisor){
    var quotient = dividend / divisor;
    var arr = [dividend, divisor, quotient];
    return arr;
}

// Store returned value in a variable
var all = divideNumbers(10, 2);

// Displaying individual values
alert(all[0]); // 0utputs: 10
alert(all[1]); // 0utputs: 2
alert(all[2]); // 0utputs: 5
</script>

<script>
// Defining function
function divideNumbers(dividend, divisor){
    var quotient = dividend / divisor;
    var obj = {
        dividend: dividend,
        divisor: divisor,
        quotient: quotient
    };
    return obj;
}

// Store returned value in a variable
var all = divideNumbers(10, 2);

// Displaying individual values
alert(all.dividend); // 0utputs: 10
alert(all.divisor); // 0utputs: 2
alert(all.quotient); // 0utputs: 5
</script>

Я ничего не добавляю здесь нового, кроме другого альтернативного способа.

 var newCodes = function() {
     var dCodes = fg.codecsCodes.rs;
     var dCodes2 = fg.codecsCodes2.rs;
     let [...val] = [dCodes,dCodes2];
     return [...val];
 };

Добавление недостающих важных частей, чтобы сделать этот вопрос полным ресурсом, так как это появляется в результатах поиска.

Объект деструктуризации

В деструктуризации объектов вам не обязательно использовать то же значение ключа, что и имя вашей переменной, вы можете назначить другое имя переменной, определив его как показано ниже:

const newCodes = () => {  
    let dCodes = fg.codecsCodes.rs;
    let dCodes2 = fg.codecsCodes2.rs;
    return { dCodes, dCodes2 };
};

//destructuring
let { dCodes: code1, dCodes2: code2 } = newCodes();

//now it can be accessed by code1 & code2
console.log(code1, code2);

Разрушение массива

В деструктуризации массива вы можете пропустить значения, которые вам не нужны.

const newCodes = () => {  
    //...
    return [ dCodes, dCodes2, dCodes3 ];
};

let [ code1, code2 ] = newCodes(); //first two items
let [ code1, ,code3 ] = newCodes(); //skip middle item, get first & last
let [ ,, code3 ] = newCodes(); //skip first two items, get last
let [ code1, ...rest ] = newCodes(); //first item, and others as an array

Стоит отметить это ...restвсегда должен быть в конце, так как нет никакого смысла разрушать что-либо после того, как все остальное агрегируется в rest.

Я надеюсь, что это добавит некоторую ценность этому вопросу :)

Несколько дней назад у меня было аналогичное требование - получать несколько возвращаемых значений от функции, которую я создал.

Из многих возвращаемых значений мне нужно было вернуть только определенное значение для данного условия, а затем другое возвращаемое значение, соответствующее другому условию.

Вот пример того, как я это сделал:

Функция:

function myTodayDate(){
    var today = new Date();
    var day = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
    var month = ["January","February","March","April","May","June","July","August","September","October","November","December"];
    var myTodayObj = 
    {
        myDate : today.getDate(),
        myDay : day[today.getDay()],
        myMonth : month[today.getMonth()],
        year : today.getFullYear()
    }
    return myTodayObj;
}

Получение необходимого возвращаемого значения от объекта, возвращаемого функцией:

var todayDate = myTodayDate().myDate;
var todayDay = myTodayDate().myDay;
var todayMonth = myTodayDate().myMonth;
var todayYear = myTodayDate().year;

Весь смысл ответа на этот вопрос состоит в том, чтобы поделиться этим подходом получения даты в хорошем формате. Надеюсь, это помогло тебе :)

Ну, мы не можем точно делать то, что вы пытаетесь. Но что-то, вероятно, ниже, может быть сделано.

function multiReturnValues(){
    return {x:10,y:20};
}

Затем при вызове метода

const {x,y} = multiReturnValues();

console.log(x) ---> 10
console.log(y) ---> 20