Question

说我有一个像这样的字符串数组：

job_evening

除了使用const a = ['foo', ['aa'], [['zzz',['bar']]]]; export const acceptsArray = (v: Array<any>) : string => { returns flattenDeep(v).join(' '); };之外，我如何表示字符串的嵌套数组？

Answer 1

请检查我之前写的这个实用函数。

// NestedArray<T> represents T or Array of T or Array of Array of T .....
// let nestedNumbers: NestedArray<number> = [[[[[1]]]]];
export type NestedArray<T> = T | Array<NestedArray<T>>;

// Able to flatten deeply nested array
// flattenArray(nestedNumbers) should produce => [1] : Array<number>
export const flattenArray = <T>(arr: NestedArray<T>): Array<T> => {
  if (!Array.isArray(arr)) return arr ? [arr] : [];

  return arr.reduce<Array<T>>((acc: Array<T>, item: NestedArray<T>) => {
    if (Array.isArray(item)) {
      return [...acc, ...flattenArray(item)];
    }
    return [...acc, item];
  }, []);
}

Answer 2

缩短答案

const a = ['foo', ['aa'], [ ['zzz',['bar'] ] ] ];

type X = string | string[] | (string | string[])[][]

export const acceptsArray = (v: Array<X>) : string => {
   returns flattenDeep(v).join(' ');
};

完整答案

上面的答案是可行的，但让我们解决您更笼统的问题：

如何表示任意类型的任意级别的嵌套数组？

嵌套：表示形式

首先，任何数组具有类型。这是一个字符串数组：

type A = Array<string> // type definition
const a: A = ['a','b','c'] //instance

下面，我们进一步介绍一下，在数组内部引入另一个数组。具体来说，我们有一个“字符串数组”的数组，仅此而已：

type A = Array<string>
type B = Array<A>
// Ok ! 
const b0: B = [['a','b','c'],['foobar'],['1','2','3','4','5']] //ok
const b1: B = [['1','2','3']] //ok

//Attention !!!
const b2: B = ['1','2','3'] //error! Array<string> is not equal to Array<Array<string>>
const b3: B = [[1,2,3]] // error! Array<Array<number>> is not equal to Array<Array<string>>

上面的类型B可以这样写：type B = Array<Array<string>>。在Typescript中，如果需要“字符串数组”，也可以这样表示：

最短的代表

type X0 = Array<Array<string>>
type X1 = string[][]  // short form!

类似地，如果您想要“字符串数组的数组”，则可以执行以下操作：

type Y0 = Array<Array<Array<string>>>
type Y1 = string[][][] // short form!

// this also works!!
type Y2 = (string | number)[][][]

以此类推...

嵌套：类型检查

重要的是要知道Typescript对于您指定为Array类型的内容严格严格。例如：

// Given this types...
type A = string
type B = Array<string>
type Both = A | B

// and this instances...
const a:A = 'foo'
const b:B = ['foo']

// so...

const r0: Array<A> = [a,a] //ok
const r1: Array<B> = [a,a] //error: string is not of type Array<string>
const r2: Array<B> = [b,b] //ok
const r3: Array<Both> = [a,b] //ok

嵌套：通用

如果我们想要一个类型为T的数组怎么办，其中T是任何 特定的类型。

// Some specific types
type SPECIFIC_TYPE_01 = string
type SPECIFIC_TYPE_02 = number
type SPECIFIC_TYPE_03 = //...etc

// A generic array of any specific type
type GenericArray<T> = Array<T>

// use:
const a: GenericArray<SPECIFIC_TYPE_01> = ['a','b','c'] //ok
const b: GenericArray<SPECIFIC_TYPE_02> = [1,2,3] //ok

注意：显然，除了使用这些长名称，您还可以只使用Array<string>，Array<number>等。我只是在说教如何展示泛型如何与数组一起工作。

总结

下面我会用上层知识来解决您的原始问题。

// Given...
type NestedArray0<T> = T[] //same as Array<T>
type NestedArray1<T> = T[][] //same as Array<Array<T>>
type NestedArray2<T> = T[][][] // same as Array<Array<Array<T>>>
type NestedArray3<T> = T[][][][]  // etc you get the point...

// So you can do things like...
const a0: NestedArray0<number> = [1,2,3]  //ok
const a1: NestedArray1<number> = [[1,2,3]]   //ok
const a2: NestedArray2<number> = [[[1,2,3]]]   //ok
const a3: NestedArray3<number> = [[[[1,2,3]]]]  //ok

// The type of your examples (based in what you informed) is...
type MyType = 
    | string  // 'foo'
    | NestedArray0<string> // ['aa']
    | NestedArray1<string | string[]> //  [['zzz',['bar']]]

const a: Array<MyType> = ['foo', ['aa'], [['zzz',['bar']]] ]; //ok

// so you can do

export const acceptsArray = (v: Array<MyType>) : string => {
   returns flattenDeep(v).join(' ');
};

谢谢。

如何用打字稿表示嵌套数组

2 个答案: