相关疑难解决方法(0)

可能是一个奇怪的问题,但我很好奇是否可以创建一个需要一个属性或另一个属性的接口.

所以,例如......

interface Message {
    text: string;
    attachment: Attachment;
    timestamp?: number;
    // ...etc
}

interface Attachment {...}

在上面的例子中,我想确定是存在text还是attachment存在.

希望这是有道理的.

提前致谢!

编辑:这就是我现在正在做的事情.认为它有点冗长(输入botkit for slack).

interface Message {
    type?: string;
    channel?: string;
    user?: string;
    text?: string;
    attachments?: Slack.Attachment[];
    ts?: string;
    team?: string;
    event?: string;
    match?: [string, {index: number}, {input: string}];
}

interface AttachmentMessageNoContext extends Message {
    channel: string;
    attachments: Slack.Attachment[];
}

interface TextMessageNoContext extends Message {
    channel: string;
    text: string;
}

我怎么说我想要一个接口是一个或另一个,但不是两者兼有？

interface IFoo {
    bar: string /*^XOR^*/ can: number;
}

我试图使用Typescript Discriminated Union来模拟异步加载数据时的一个相当常见的场景:

type LoadingState = { isLoading: true; }
type SuccessState = { isLoading: false; isSuccess: true; }
type ErrorState =   { isLoading: false; isSuccess: false; errorMessage: string; }

type State = LoadingState | SuccessState | ErrorState;

根据我的理解,这应该根据类型定义限制允许的值组合.但是,类型系统很乐意接受以下组合:

const testState: State = {
    isLoading: true,
    isSuccess: true,
    errorMessage: "Error!"
}

我希望这里有一个错误.有什么我缺少或在某种程度上滥用类型定义？

考虑这个代码：

let foo: {a: any} | {b: any} = {a: 1, b: 2};

我希望 TypeScript 拒绝此代码，因为此联合类型意味着第一种类型或第二种类型，并且该值不可分配给它们中的任何一种，因此类型检查应拒绝它。但事实上它过去了，为什么呢？

（对于背景，上述类型旨在成为“此属性或该属性，但不是两者都类型”。请参阅Typescript 接口 - 是否需要“一个或另一个”属性？）

我有以下组件：

export enum Tags {
  button = 'button',
  a = 'a',
  input = 'input',
}

type ButtonProps = {
  tag: Tags.button;
} & ({ a?: string; b?: undefined } | { a?: undefined; b?: string }) &
  JSX.IntrinsicElements['button'];

type AnchorProps = {
  tag: Tags.a;
} & ({ a?: string; b?: undefined } | { a?: undefined; b?: string }) &
  JSX.IntrinsicElements['a'];

type InputProps = {
  tag: Tags.input;
} & ({ a?: string; b?: undefined } | { a?: undefined; b?: …

如果我输入以下内容：

interface A {
    x: number
}
interface B {
    y: number
}

type Z = A | B;

// here it allows me to create a variable of type Z with both members of type A and B.
let z: Z = {
    x: 5,
    y: 6,
}

我无法确保 Z 类型的对象确实包含 A 的所有成员但不包含 B 的成员（或相反）。使用 TypeScript 有可能吗？经过大量研究，我倾向于“不”的答案，但我不确定。