在JavaScript中返回多个值？


Return multiple values in JavaScript?

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

1
2
3
4
5
var newCodes = function() {  
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    return dCodes, dCodes2;
};
相关讨论

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

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

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

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

使用最新的ECMAScript 6语法*，您还可以更直观地构造返回值：

1
const [first, second] = getValues();

如果要在每个返回值上放置"标签"(更易于维护)，则可以返回一个对象：

1
2
3
4
5
6
function getValues() {
    return {
        first: getFirstValue(),
        second: getSecondValue(),
    };
}

并访问它们：

1
2
3
var values = getValues();
var first = values.first;
var second = values.second;

或者使用ES6语法：

1
const {first, second} = getValues();

*有关浏览器兼容性，请参阅此表。基本上，除IE之外的所有现代浏览器都支持这种语法，但您可以使用像Babel这样的工具在构建时将ES6代码编译为与IE兼容的JavaScript。

相关讨论

您可以使用"解构分配"从Javascript 1.7开始执行此操作。请注意，这些版本在较旧的Javascript版本中不可用(意思是 - 无论是ECMAScript 3rd还是5th edition)。

它允许您同时分配1+个变量：

1
2
3
4
5
6
7
8
9
var [x, y] = [1, 2];
x; // 1
y; // 2

// or

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

您还可以使用对象解构与属性值缩写相结合来命名对象中的返回值并选择所需的值：

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

顺便说一下，不要被ECMAScript允许你return 1, 2, ...的事实所迷惑。真正发生的事情并非如此。 return语句中的表达式 - 1, 2, 3 - 只是一个逗号运算符，它依次应用于数字文字(1，2和3)，最终计算其最后一个表达式的值 - 3 。这就是return 1, 2, 3在功能上与return 3完全相同的原因。

1
2
3
4
5
return 1, 2, 3;
// becomes
return 2, 3;
// becomes
return 3;
相关讨论

只需返回一个对象文字

1
2
3
4
5
6
7
8
9
10
11
12
13
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开始，你就可以做到这一点

1
2
3
4
5
6
7
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}。

最后一行上的这个赋值称为对象破坏赋值。它提取对象的属性值并将其分配给同名变量。如果您想将返回值分配给不同名称的变量，您可以像这样let {dCodes: x, dCodes2: y} = newCodes()

Ecmascript 6包含"解构分配"(如kangax所述)，因此在所有浏览器(不仅仅是Firefox)中，您将能够捕获一组值而无需为了捕获它们而创建命名数组或对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//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)语法除了破坏赋值之外还使用对象创建速记。

1
2
3
4
5
6
7
8
9
10
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和其他语言之间的常见性能技巧。

相关讨论

最好的方法是

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

然后用

1
a().f

返回4

在ES6中，您可以使用此代码

1
2
3
4
5
6
function a(){
      var d=2;
      var c=3;
      var f=4;
      return {d,c,f}
}
相关讨论

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

1
2
3
4
5
6
7
8
9
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是一种面向callback的语言，这里有一个关于"返回多个值"的秘密，没有人提到过，试试这个：

1
2
3
4
5
var newCodes = function() {  
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    return dCodes, dCodes2;
};

变

1
2
3
4
5
var newCodes = function(fg, cb) {  
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    cb(null, dCodes, dCodes2);
};

:)

嘭！这只是解决问题的另一种方法。

你也可以这样做：

1
2
3
4
5
6
7
8
function a(){
  var d=2;
  var c=3;
  var f=4;
  return {d:d,c:c,f:f}
}

const {d,c,f} = a()
相关讨论

你可以使用"对象"

1
2
3
4
5
6
7
function newCodes(){
    var obj= new Object();
    obj.dCodes = fg.codecsCodes.rs;
    obj.dCodes2 = fg.codecsCodes2.rs;

    return obj;
}

我建议使用最新的解构分配(但要确保它在您的环境中得到支持)

1
2
3
4
5
6
var newCodes = function () {
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    return {firstCodes: dCodes, secondCodes: dCodes2};
};
var {firstCodes, secondCodes} = newCodes()

在javascript中返回多个值的一种非常常见的方法是使用对象文字，如下所示：

1
2
3
4
5
6
const myFunction = () => {
  const firstName ="Alireza",
        familyName ="Dezfoolian",
        age = 35;
  return { firstName, familyName, age};
}

并获得如下值：

1
2
3
myFunction().firstName; //Alireza
myFunction().familyName; //Dezfoolian
myFunction().age; //age

甚至更短的方式：

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

让它们像个人一样：

1
2
3
firstName; //Alireza
familyName; //Dezfoolian
age; //35

我知道有两种方法可以做到这一点：
1.作为数组返回
2.作为对象返回

这是我发现的一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// 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





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

一切都正确。 return从左到右逻辑处理并返回最后一个值。

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

>> foo()
>> 3
相关讨论

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

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

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

功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
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;
}

从函数返回的对象获取必需的返回值：

1
2
3
4
var todayDate = myTodayDate().myDate;
var todayDay = myTodayDate().myDay;
var todayMonth = myTodayDate().myMonth;
var todayYear = myTodayDate().year;

回答这个问题的重点是分享这种以良好格式获取日期的方法。希望它能帮助你:)

我不是在这里添加新东西，而是另一种替代方式。

1
2
3
4
5
6
 var newCodes = function() {
     var dCodes = fg.codecsCodes.rs;
     var dCodes2 = fg.codecsCodes2.rs;
     let [...val] = [dCodes,dCodes2];
     return [...val];
 };

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

对象解构

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

1
2
3
4
5
6
7
8
9
10
11
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);

数组解构

在数组解构中，您可以跳过不需要的值。

1
2
3
4
5
6
7
8
9
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之后销毁任何内容都没有任何意义。

我希望这会为这个问题增加一些价值:)

好吧，我们不能完全按照您的尝试去做。但可能会在下面做些什么。

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

然后在调用方法时

1
2
3
4
const {x,y} = multiReturnValues();

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