类型保护是我发现any可以接受的少数地方之一。

• 它们采用许多东西，通常是一个并集（例如，A | B | C），并缩小并集（例如，B）。
• 他们把一个不为人所知的东西 * 它是什么 * 并给予它形状。

在前一种情况下，您可以轻松地在类型系统的范围内工作以缩小范围。
在后一种情况下，你有不同数量的“shapeless”来处理，但在极端情况下（比如你的unknown），你没有类型支持，这会导致一些看起来有点丑陋的东西。请看这里：

type HasProp<T extends object, K extends string> = T & {[P in K]: unknown};

/*
 * type guard to ensure that an arbitrary object has a given property
 */
function hasProp<T extends object, K extends string>(obj: T, prop: K): obj is HasProp<T, K> {
    return prop in obj;
}

function isErrorEvent( e: unknown ): e is ErrorEvent {
    if( !e ) return false;
    
    if (
        typeof e === "object" && //type guard determines `e` is `object | null`
        e !== null               //type guard to narrow down `e` to only `object`
    ) {
        if (
                hasProp(e, "colno") &&   //type guard to add `colno` to the properties known to be in `e`
                hasProp(e, "error") &&   //type guard to add `error` to the properties known to be in `e`
                hasProp(e, "lineno") &&  //type guard to add `lineno` to the properties known to be in `e`
                hasProp(e, "message")    //type guard to add `message` to the properties known to be in `e`
            ){
                return (
                    typeof e.colno  === 'number' &&
                    typeof e.error  === 'object' &&
                    typeof e.lineno === 'number' &&
                    
                    typeof e.message === 'string' &&
                    e.message.length > 0
                );
        }
    }
    return false;
}

Playground链接
我想明确一点-这段代码所做的所有操作都是 * 正确的 *。如果e不是一个对象，你就不能检查它是否有一些任意的属性。如果不检查属性是否存在，检查一个任意的属性值是否是一个给定的类型是有点没用的。
话虽如此，它是过于冗长，也有点迟钝。

• e !== null是无用的，因为它在一开始就已经被!e处理了。
• 检查属性是否存在以检查其值是否为数字直接等同于检查值是否为数字。通常没有区别-如果属性不存在或其值是不同的类型，则最终都是相同的。

因此，我个人很乐意将e键入为any。

function isObj(obj: unknown): obj is Record<PropertyKey, unknown> {
    return typeof obj === "object" && obj !== null;
}

function isErrorEvent( e: unknown ): e is ErrorEvent {
    if ( isObj(e) ) {
        return (
            typeof e.colno  === 'number' &&
            typeof e.error  === 'object' &&
            typeof e.lineno === 'number' &&
            
            typeof e.message === 'string' &&
            e.message.length > 0
        );
    }

    return false;
}

Playground链接
对我来说，上面的代码更容易阅读和理解。它不像编译器那样严格检查，但它也是完全正确的。当使用any时，它的行为也完全相同，因此我不反对它。只要你做适当的检查，你有一个对象，不管是Record还是any都没有什么关系。无论哪种方式，你都不会从编译器获得任何类型支持。后者在类型方面稍微正确一些，但是否有区别取决于你。
注1：你也可以使用类型Asserte as Record<PropertyKey, unknown>。这没什么关系，但额外的isObj类型保护似乎更有可能被重用。
注2：仅供记录，hasProp可以更改为应用于多个属性。它并没有解决我在类型保护中使用它的核心问题，但它可能在其他地方仍然有用：

/*
 * type guard to ensure that an arbitrary object has a given properties
 */
function hasProps<T extends object, K extends PropertyKey>(obj: T, ...props: K[]): obj is HasProp<T, K> {
    return props.every(prop => prop in obj);
}

/* ... */
if (hasProps(e, "colno", "error", "lineno", "message")) { //type guard to add `colno`, `error`, `lineno`, `message` to the properties known to be in `e`
/* ... */

Playground链接

//例如，TypeScript不会抱怨下面这行，即使我没有证明e.message实际存在，仅仅因为ErrorEvent.message是在lib.dom.d.ts中定义的
在这种情况下，你不应该试图证明它是某个具体类的示例，而只需要定义一些特定的，狭窄的特性子集，你实际上有兴趣使用，然后对特定的形状进行类型检查。
例如，你并不真正感兴趣，如果e是一个实际的ErrorEvent示例，你只关心它是否符合某种狭义的契约：

interface IErrorEvent {
    message: string;
    lineno: number;
    colno: number;
}

现在你只需要为那个确切的合约设置类型保护。我想到的最好的解决方案是使用一种方法，类似于@VLAZ的方法，只需要在isObj助手中添加一个泛型来进行推理，以在编写缩小类型检查时防止打字错误：

const isLike = <T extends object>(o: unknown): o is Record<keyof T, unknown> => (
    (o ?? false) && typeof o === 'object'
);

const isErrorEvent = (e: unknown): e is IErrorEvent => (
    isLike<IErrorEvent>(e)
        // e at this point is a { message: unknown; lineno: unknown; colno: unknown }, not IErrorEvent or ErrorEvent
        && (typeof e.message === 'string') // ok
        && (typeof e.lineno === 'number') // ok
        && (typeof e.collno === 'number') // TS2551: Property 'collno' does not exist on type 'Record '. Did you mean 'colno'?
);