typescript - 如何使用 Typescript 在函数中包含输出参数？

Question

是否可以在使用 TypeScript 的函数中包含输出参数？类似于Func1(string val1, int out k1, int out k2)C# 中的东西。

Answer 1

不是现在。

您可以返回一个可以包含多个属性的对象。

return { k1: 5, k2: 99 };

您可以将其与解构结合起来，使中间对象变得不可见......

function myFunction() {
    return { k1: 5, k2: 99 };
}

const { k1, k2 } = myFunction();

console.log(k1);
console.log(k2);

您也可以使用元组实现相同的目的，但这非常易读。

Answer 2

通常，您只返回一个具有多个属性的对象，其中一个包含您的函数。像这样的东西：

var foo = function (val1 : string){
    // do something

    return {
        k1: 22,
        k2: 33
    };
}

你也可以让它实现一个接口，这样你就知道返回的对象是什么。

interface IFoo {
    (val1: string): INumbers;
}
interface INumbers {
    k1 : number;
    k2 : number;
}

var foo : IFoo = (val1 : string){
    // do something

    return {
        k1: 22,
        k2: 33
    };
}

Answer 3

打字稿通过“按值调用”传递所有参数。但是，如果参数是引用，则大多数情况下它的行为类似于“按引用调用”。您可以为原始类型编写包装类。这是一些代码：

var func=function(param:Str){
    param.str="modified";
}
class Str{
    str:string="unmodified";
}
var test:Str=new Str();
alert(test.str); //alerts "unmodified"
func(test);
alert(test.str); //alerts "modified"

但是，您需要小心：

var func=function(param:Str){
    param=new Str("modified");
}
class Str{
    str:string;
    constructor(param:string){
        this.str=param;
    }
}

var test:Str=new Str("unmodified");
alert(test.str); //alerts "unmodified"
func(test);
alert(test.str); //alerts "unmodified"

函数参数是“按值调用”传递的。因此，在函数体内，您正在使用引用的副本。此引用指向与您作为参数传递的引用相同的对象，因此您可以访问其成员并修改它们。但是，如果您将一个新对象分配给该引用，则所有进一步的更改都将应用于这个新对象。因此，上面的代码会打印两次未经修改。我认为 C# 也是这样工作的。

Answer 4

如果您真的非常想要一个输出参数，即使您可以返回一个对象或数组（作为临时元组对象），请查看 foo 和 foo 的调用站点...

function p(s) {
  document.body.appendChild(document.createTextNode(s));
  document.body.appendChild(document.createElement('BR'));
}
function foo(output: any): void {
  output.uno = 1;
  output.dos = 2;
}
var o: any = {};
function foo(o);
p(o.uno + " " + o.dos);

Answer 5

有时参数未定义，您需要在方法中实例化它。在这种情况下，您可以使用“lambda 函数”或“箭头函数”并使用以下命令模拟输出参数：

例子：

class classA
{
   propertyA : number;
   constructor(value: number){
        propertyA = number;
   }
}

class classB {

    // ...

    exampleMethod(){
       let classAInstance: classA;
       this.sumValueMethod((p) => classAInstance = p, 10);

       if(classAInstance != undefined)
           alert("Yeah"); 
    }

    sumValueMethod(paramA:(p: classA) => any, paramB: number){

       let variableA: classA = new classA(0);
       variableA.propertyA += paramB;

       paramA(variableA);
    }
}

Answer 6

这是另一种方式。定义一个回调函数，其中将包含您的输出参数：

function Func1(val1: string, out: (k1: number, k2: number) => void): void {
    out(1, 2);
}

如何使用它的示例：

function anotherFunction(): void {

    let k1: number;
    let k2: number;

    Func1("something", (v1, v2) => {
        k1 = v1;
        k2 = v2;
    });

    console.log(k1); // output: 1
    console.log(k2); // output: 2
}

我发现它对这样的东西最有用：

const keys: string[] = [];
const values: number[] = [];

function tryGet(key: string, out: (value: number) => void): void {
    const index = keys.indexOf(key);
    if (index >= 0) {
        out(values[index]);
    }
}

function test(): void {

    const key = "myValue";

    tryGet(key, (value) => {
        console.log(`Key '${key}' exist with value ${value}`);
    });
}

Answer 7

如果你想保持类似 C# 的语法，你可以使用：

function func(val1, k1, k2)
{
    k1.v = 7;
    k2.v = 9;
    return "";
}

并称之为

func("", {}, {});