在JavaScript中返回多个值？

我试图在JavaScript中返回两个值。这可能吗

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

---

否，但可以返回包含值的数组：

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

然后您可以像这样访问它们：

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

使用最新的*，还可以更直观地分解返回值：

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。

只需返回一个对象文本即可

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

---

您可以使用数组和从ECMAScript 6开始执行此操作。请注意，这些在较旧的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

还可以使用命名对象中的返回值，并选择所需的返回值：

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

的值。这就是为什么

return1,2,3

在功能上与

return3

完全相同的原因

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

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中试用了

除了像其他人推荐的那样返回数组或对象之外，还可以使用收集器函数（类似于Little Schemer中的函数）：

我做了一个jsperf测试，看看三种方法中哪一种更快。阵列速度最快，收集器速度最慢

然后使用

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

在新版本中：

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

您还可以执行以下操作：

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

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

---

另一个值得一提的新引入的（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 polyfiller进行多填充，但幸运的是，现在可以在Chrome和Firefox的最新版本中使用

---

但在创建新对象时，这里涉及内存分配（以及最终的gc负载），不要期望它有多大的性能。JavaScript不是最好的语言，用于开发高度优化的东西，但如果需要，可以考虑将结果放到周围对象上，或者通常是JavaScript、java和其他语言之间的常用性能技巧。但不要忘记！=>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 foo(){
    return 1,2,3;
}

>> foo()
>> 3

---

既然ES6，你就可以这样做了

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

let {dCodes, dCodes2} = newCodes()

返回表达式

{dCodes，dCodes2}

是属性值速记，与此

{dCodes:dCodes，dCodes2:dCodes2}

等价

---

最后一行的赋值称为对象销毁赋值。它提取对象的属性值并将其分配给同名变量。如果您想将返回值分配给不同名称的变量，您可以这样做：

让{dCodes:x，dCodes2:y}=newCodes（）

几天前，我有一个类似的要求，即从我创建的函数中获取多个返回值

从许多返回值中，我需要它只返回给定条件的特定值，然后返回对应于其他条件的其他返回值。

---

以下是我如何做到这一点的示例：

功能：

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

---

回答这个问题的全部目的是分享这种以良好格式获取日期的方法。希望对您有所帮助：）

我建议使用最新的解构作业

---

我不是在这里添加新内容，而是另一种方式

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

---

我知道两种方法： 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商=股息/除数；
var arr=[股息、除数、商]；
返回arr；
}
//将返回值存储在变量中
var all=除数（10,2）；
//显示单个值
警报（全部[0]）；//输出：10
警报（全部[1]）；//0输出：2
警报（全部[2]）；//输出：5
//定义功能
函数除数（除数、除数）{
var商=股息/除数；
var obj={
股息：股息，
除数：除数，
商：商
};
返回obj；
}
//将返回值存储在变量中
var all=除数（10,2）；
//显示单个值
警报（全部股息）；//输出：10
警报（全部除数）；//0输出：2
警惕（全部商数）；//输出：5

添加缺失的重要部分，使此问题成为完整的资源，因为这会出现在搜索结果中

对象分解

在对象分解中，您不一定需要使用与变量名相同的键值，您可以通过如下定义来分配不同的变量名：

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

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

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

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

const {x,y} = multiReturnValues();

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

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

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