在JavaScript中返回多个值？

Question

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

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

Answer 1

不,但您可以返回包含您的值的数组:

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(),
    };
}

Answer 2

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

它允许您同时分配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允许的事实所迷惑return 1, 2, ....真正发生的事情并非如此.在return语句表达- 1, 2, 3-不过是应用于数字文字一个逗号(1,2和3)顺序,最终计算结果为它的最后一个表达式的值- 3.这就是为什么return 1, 2, 3功能上只相同而已return 3.

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

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

Answer 4

从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}.

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

Answer 5

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中试试吧!

Answer 6

另一个值得一提的新引入(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和其他语言之间的常见性能技巧.

Answer 7

最好的方法是

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

Answer 8

除了像其他人推荐的那样返回数组或对象之外,您还可以使用收集器函数(类似于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

Answer 9

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

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

Answer 10

你也可以这样做：

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

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

Answer 11

在JS中,我们可以轻松返回带有数组或对象的元组,但不要忘记!=> JS是一种callback定向语言,这里有一个小秘密用于"返回多个值",没有人提到过,试试这个:

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

:)

嘭!这只是解决问题的另一种方法.

Answer 12

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

对象解构

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

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.

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