返回联合类型 Promise<string | fs.WriteStream> 不工作

Question

我正在尝试使 函数 返回两种可能的数据类型。它可以返回的第一种类型是string，它可以返回的第二种类型是fs.WriteStream

在函数中，这是基于您传递给它的名为stream?: boolean的参数

如图所示，VSCode 正确显示了这个函数的这种行为

但是，智能感知以某种方式仅将其识别为string，而实际类型也可能是fs.WriteStream

但是如果我强制它是 fs.WriteSteam 类型使用

const tt = await getFromUrl(s, true) as fs.WriteStream;

效果很好

这是怎么回事？如何在不强制使其成为类型的情况下使这种联合类型正常工作？

---

这是完整的代码，以防您不想复制它

import { existsSync, readFileSync } from 'fs'
import https from 'https'
import fs from 'fs'
import crypto from 'crypto'

/**
 * Converts given source from a SRT format to a WebVTT format
 * 
 * Srt must be one of type
 * - Path to subtitle file (only for NodeJS environments)
 * - URL to a subtitle file (for browser and NodeJS)
 * - SRT text content (for browser and NodeJS)
 * 
 * @param srt { string }
 * @returns string
 * @example
 * convert(`./path/to/subtitle.srt`) // only for nodejs
 * convert(`https://example.com/english.srt`) // works for both browser and nodejs
 * convert(`1
00:00:00,207 --> 00:00:05,520
Amerikaanse Ministerie
van Magie.

2
00:00:06,625 --> 00:00:09,034
New York, 1927

3
00:00:10,878 --> 00:00:15,547
Je zal blij zijn van hem af te zijn
neem ik aan?`) // works for both browser and nodejs
 */
export async function convert(srt: string) {
    const s = srt.trim()
    const isUri = s.startsWith("http://") || s.startsWith("https://")
    const isPath = /^([a-z]:)?([.\/]+)?((\\|\/|\\\\)?[a-z0-9\s_@\-^!#$%&+={}\[\]]+)+\.srt$/i.test(s)

    if(isPath && existsSync(s)) {
        return srtToVtt(readFileSync(s, 'utf8'));
    }
    if(isUri) {
        const tt = await getFromUrl(s);

        console.log(tt.path);
    }

    // Must be the contents of an srt file of we get here
    return ''
}

/**
 * Fetches text content from srt file over web
 * 
 * @param url 
 * @param stream    - return result as a writeable stream or just the data (default true)
 */
export async function getFromUrl(srt: string, stream = true): Promise<string | fs.WriteStream> {
    return new Promise(resolve => {
        https.get(srt, response => {
            if(stream) {
                const str = fs.createWriteStream(crypto.randomBytes(16).toString("hex") + '.srt')
    
                response.pipe(str).on('finish', () => {
                    str.end().close();

                    return resolve(str)
                })
            } else {
                let srtFile = '';

                response.on("data", function(chunk) {
                    srtFile += chunk;
                });

                response.on('end', () => {
                    console.log('test')
                    return resolve(srtFile)
                })
            }
        })
    })
}

Answer 1

为什么会出现此错误：

tt 变量的类型是string | fs.WriteStream。由于您不知道该变量中有两种类型中的哪一种，因此您想要访问的任何方法或属性都必须存在于 both 类型中。

如您所见，您可以通过将变量的类型缩小到该联合的一侧或另一侧来解决此问题。您可以通过手动转换（您的as fs.WriteStream）来做到这一点或如果您使用控制流进行检查，TypeScript 可以推断出正确的类型：

if (typeof tt === "string") {
   // tt has type string in this block.
   return;
}

// tt has type fs.WriteStream from here forward.

考虑重载：

这个函数可能会从overload signature 中受益，这样就可以消除您获得联合的哪一部分的歧义。这样，TypeScript 可以根据您调用函数的方式推断出正确的返回类型。

async function getFromUrl(srt: string, stream?: false): Promise<string>;
async function getFromUrl(srt: string, stream: true): Promise<fs.WriteStream>;
async function getFromUrl(srt: string, stream?: boolean): Promise<string | fs.WriteStream> {
  return ""
}

const str1 = await getFromUrl("")         // string
const str2 = await getFromUrl("", false)  // string
const stream = await getFromUrl("", true) // fs.WriteStream