Question

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

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

Typescript使用“按值调用”传递所有参数。但是，如果参数是参考，则其行为与大多数时间的“按引用调用”类似。您可以为基本类型编写包装类。这是一些代码：

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

如果你想使用C＃语法，你可以使用：

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

并称之为

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

Answer 6

有时参数是未定义的，您需要在方法中实例化它。在这种情况下，您可以使用“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 7

这是另一种方式。定义一个包含out参数的回调函数：

const fs = require('fs');
const path = require('path');
const http = require('http');
const https = require('https');
const spdy = require('spdy')
const express = require('express');
const privateKey  = fs.readFileSync('certs/server.key', 'utf8');
const certificate = fs.readFileSync('certs/server.crt', 'utf8');
const credentials = {key: privateKey, cert: certificate};
const app = express();

app.use(express.static(path.join(__dirname, 'build')));
    app.get('*', (req, res) => {
       res.sendFile(path.join(__dirname + '/build/index.html'));
    });

const httpServer = http.createServer(app);
const httpsServer = spdy.createServer(credentials, app);

httpServer.listen(80);
httpsServer.listen(443);

console.log('Server started over HTTP2 protocol.');

如何使用它的示例：

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
}

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

7 个答案: