Question

想象一下一些函数convertType，它只需要一个数字并将其转换为一个选择的字符串表示，如下所示：

convertType(someNum : number) : string {
    return "Number is: " + someNum;
}

然后让一些数组：

myNestedArrayNum = new Array<Array<Array<number>>>();

迭代这个嵌套数组的最快方法是什么，利用这个转换函数，将myNestedArrayNum转换为Array<Array<Array<string>>>？

目前我正在做这样的事情：

convertNestedArray(numArray : Array<Array<Array<number>>>) : Array<Array<Array<string>>> {

    let strArray = new Array<Array<Array<string>>>();

    for (let i = 0; i < numArray.length; i++) {

        let temp1 = new Array<Array<string>>();

        for (let j = 0; j < numArray[i].length; j++) {

            let temp2 = new Array<string>();

            for (let k = 0; k < numArray[i][j].length; k++) {

                temp2.push(convertType(numArray[i][j][k]);
            }
            temp1.push(temp2);
        }
        strArray.push(temp1);
    }
    return strArray;
}

但是，必须才能做到这一点，这对吗？我们可以假设我们知道嵌套数组的深度。

谢谢！

Answer 1

我想你想要这样的东西：

// as many overloads as you need
function convertNestedArray<T, U>(f: (t: T) => U, v: Array<Array<Array<T>>>): Array<Array<Array<U>>>;
function convertNestedArray<T, U>(f: (t: T) => U, v: Array<Array<T>>): Array<Array<U>>;
function convertNestedArray<T, U>(f: (t: T) => U, v: Array<T>): Array<U>;
function convertNestedArray<T, U>(f: (t: T) => U, v: T): U;
function convertNestedArray<T, U>(f: (t: T) => U, v: T | Array<T>): U | Array<U> {
  if (Array.isArray(v)) return v.map(e => convertNestedArray(f, e));
  return f(v);
}

function convertType(someNum: number): string {
  return "Number is: " + someNum;
}

const s: string[][][] = convertNestedArray(convertType, [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]);

console.log(s);

这是使用数组map函数和递归进行转换。您需要多次重载函数以处理您拥有的数组深度。（我认为目前TypeScript中的任意深度都不能做到这一点。）

希望有所帮助。祝你好运！

有没有更简洁的方法来调用嵌套数组中所有元素的类型转换函数？

1 个答案: