Retornar vários valores em JavaScript?

Estou tentando retornar dois valores em JavaScript . Isso é possível?

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

Não, mas você pode retornar uma matriz contendo seus valores:

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

Então você pode acessá-los assim:

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

Com a mais recente sintaxe do ECMAScript 6 *, você também pode desestruturar o valor de retorno de forma mais intuitiva:

const [first, second] = getValues();

Se você deseja colocar "rótulos" em cada um dos valores retornados (mais fáceis de manter), você pode retornar um objeto:

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

E para acessá-los:

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

Ou com a sintaxe do ES6:

const {first, second} = getValues();

^{* Consulte esta tabela para compatibilidade do navegador. Basicamente, todos os navegadores modernos, exceto o IE, oferecem suporte a essa sintaxe, mas você pode compilar o código ES6 até o JavaScript compatível com o IE no momento da criação, com ferramentas como Babel .}

Você pode fazer isso do Javascript 1.7 em diante usando "atribuições de desestruturação" . Observe que eles não estão disponíveis nas versões Javascript mais antigas (ou seja, nem nas edições 3 e 5 do ECMAScript).

Permite atribuir 1 ou mais variáveis ​​simultaneamente:

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

// or

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

Você também pode usar a desestruturação do objeto combinada com a abreviação do valor da propriedade para nomear os valores retornados em um objeto e selecionar os que deseja:

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

E, a propósito, não se deixe enganar pelo fato de que o ECMAScript permite return 1, 2, .... O que realmente acontece não é o que pode parecer. Uma expressão na instrução de retorno - 1, 2, 3- nada mais é que um operador vírgula aplicada a literais numéricos ( 1, 2e 3) sequencialmente, o que eventualmente avalia para o valor de sua última expressão - 3. É por isso que return 1, 2, 3é funcionalmente idêntico a nada além disso return 3.

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

Basta retornar um objeto literal

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

Desde o ES6, você pode fazer isso

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

let {dCodes, dCodes2} = newCodes()

A expressão de retorno {dCodes, dCodes2}é um valor abreviado da propriedade e é equivalente a isso {dCodes: dCodes, dCodes2: dCodes2}.

Essa atribuição na última linha é chamada de atribuição de destruição de objeto . Ele extrai o valor da propriedade de um objeto e o atribui à variável de mesmo nome. Se você deseja atribuir valores de retorno a variáveis ​​de nome diferente, você pode fazê-lo assimlet {dCodes: x, dCodes2: y} = newCodes()

O Ecmascript 6 inclui "atribuições de desestruturação" (como mencionado no kangax) para que em todos os navegadores (não apenas no Firefox) você possa capturar uma matriz de valores sem precisar criar uma matriz ou objeto nomeado com o único objetivo de capturá-los.

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

Você já pode experimentá-lo no Firefox!

Outro destaque a ser mencionado na sintaxe recém-introduzida (ES6) é o uso da abreviação de criação de objeto, além de destruir a atribuição.

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

Essa sintaxe pode ser preenchida com babel ou outro js polyfiller para navegadores mais antigos, mas felizmente agora funciona nativamente com as versões recentes do Chrome e Firefox.

Mas, ao criar um novo objeto, a alocação de memória (e eventual carga de gc) está envolvida aqui, não espere muito desempenho dele. O JavaScript não é a melhor linguagem para o desenvolvimento de coisas altamente ideais, mas se necessário, você pode colocar o resultado em objetos ao redor ou em técnicas que geralmente são truques comuns de desempenho entre JavaScript, Java e outras linguagens.

A melhor maneira para isso é

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

Então use

a().f

retorno 4

no ES6 você pode usar esse código

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

Além de retornar uma matriz ou um objeto, como outros recomendaram, você também pode usar uma função de coletor (semelhante à encontrada em The Little Schemer ):

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

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

Fiz um teste jsperf para ver qual dos três métodos é mais rápido. A matriz é mais rápida e o coletor é mais lento.

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

Em JS, podemos facilmente retornar uma tupla com uma matriz ou objeto, mas não esqueça! => JS é uma callbacklinguagem orientada, e há um pequeno segredo aqui para "retornar vários valores" que ninguém ainda mencionou, tente o seguinte:

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

torna-se

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

:)

bam! Esta é simplesmente outra maneira de resolver seu problema.

Adicionando as partes importantes que faltam para tornar essa pergunta um recurso completo, pois isso aparece nos resultados da pesquisa.

Destruição de Objetos

Na destruição de objeto, você não precisa necessariamente usar o mesmo valor da chave que o nome da sua variável, pode atribuir um nome de variável diferente, definindo-o como abaixo:

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

Reestruturação de matriz

Na desestruturação da matriz, você pode pular os valores que não precisa.

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

Vale notar que ...restsempre deve estar no final, pois não faz sentido destruir nada depois que todo o resto é agregado arest .

Espero que isso agregue algum valor a essa pergunta :)

Você também pode fazer:

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

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

Uma maneira muito comum de retornar vários valores em javascript é usar um literal de objeto , algo como:

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

e obtenha os valores assim:

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

ou até uma maneira mais curta:

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

e obtenha-os individualmente como:

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

Você pode usar "Objeto"

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

    return obj;
}

Tudo está correto. returnprocessa logicamente da esquerda para a direita e retorna o último valor.

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

>> foo()
>> 3

Sugiro usar a última tarefa de desestruturação (mas verifique se ela é suportada em seu ambiente )

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

Conheço duas maneiras de fazer isso: 1. Retornar como matriz 2. Retornar como objeto

Aqui está um exemplo que eu encontrei:

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

Poucos dias atrás, eu tinha o requisito semelhante de obter vários valores de retorno de uma função que eu criei.

De muitos valores de retorno, eu precisava que ele retornasse apenas um valor específico para uma determinada condição e, em seguida, outro valor de retorno correspondente a outra condição.

Aqui está o exemplo de como eu fiz isso:

Função:

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

Obtendo o valor de retorno necessário do objeto retornado pela função:

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

O ponto principal de responder a essa pergunta é compartilhar essa abordagem de obter o Date em bom formato. Espero que tenha ajudado :)

Não estou acrescentando nada de novo aqui, mas de outra maneira alternativa.

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

Bem, não podemos exatamente fazer o que você está tentando. Mas algo provável abaixo pode ser feito.

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

Então, ao chamar o método

const {x,y} = multiReturnValues();

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