Typoskript-Schnittstelle - Möglich zu machen, "die ein oder andere" Eigenschaften, die benötigt werden?

Möglicherweise eine seltsame Frage, aber ich bin neugierig, ob es möglich ist, eine Schnittstelle, wo eine Eigenschaft oder das andere erforderlich ist.

Also, zum Beispiel...

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

interface Attachment {...}

In dem genannten Fall, würde ich mag, um sicherzustellen, dass entweder text oder attachment vorhanden ist.

Hoffentlich, das macht Sinn.

Vielen Dank im Voraus!

Edit: Dies ist, wie ich es jetzt gerade Tue. Dachte, es war ein bisschen Ausführlicher (Eingabe botkit für 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;
}
InformationsquelleAutor dsifford | 2016-06-07
  1. 45

    Können Sie ein union-Typ, dies zu tun:

    interface MessageBasics {
  timestamp?: number;
  /* more general properties here */
}
interface MessageWithText extends MessageBasics {
  text: string;
}
interface MessageWithAttachment extends MessageBasics {
  attachment: Attachment;
}
type Message = MessageWithText | MessageWithAttachment;

    Wenn Sie möchten, dass text und Anhang, schreiben Sie

    type Message = MessageWithText | MessageWithAttachment | (MessageWithText & MessageWithAttachment);
    • aber das wird ihm nicht erlauben, eine Nachricht mit einem text und einem Anhang
    • Danke für die Antwort Ryan! Das ist, wie ich wirklich bin, tun Sie es jetzt. Ich fügte hinzu, dass meine Frage oben. War nicht sicher, ob es eine sauberere Möglichkeit, darüber zu gehen.
    • Sie werden wahrscheinlich wollen, um hinzuzufügen text?: string und attachment?: Attachment zu MessageBasics. Andernfalls müssen Sie die Verwendung von type-assertion-jeder Zeit Sie finden diese Eigenschaften, z.B. (myMessage as MessageWithText).text statt nur myMessage.text.
    • Aber diese oder nicht auszuschließen! Dieses akzeptieren sowohl.
    InformationsquelleAutor Ryan Cavanaugh
  2. 6

    Danke @ryan-cavanaugh, die mich in die richtige Richtung.

    Ich habe einen ähnlichen Fall, aber dann mit array-Typen. Kämpfte ein wenig mit der syntax, weshalb ich es hier zur späteren Referenz:

    interface BaseRule {
  optionalProp?: number
}

interface RuleA extends BaseRule {
  requiredPropA: string
}

interface RuleB extends BaseRule {
  requiredPropB: string
}

type SpecialRules = Array<RuleA | RuleB>

//or

type SpecialRules = (RuleA | RuleB)[]

//or (in the strict linted project I'm in):

type SpecialRule = RuleA | RuleB
type SpecialRules = SpecialRule[]

    Update:

    Beachten Sie, dass später, könnte man immer noch Warnungen, wie Sie die deklarierte variable im code. Sie können dann die (variable as type) syntax.
    Beispiel:

    const myRules: SpecialRules = [
  {
    optionalProp: 123,
    requiredPropA: 'This object is of type RuleA'
  },
  {
    requiredPropB: 'This object is of type RuleB'
  }
]

myRules.map((rule) => {
  if ((rule as RuleA).requiredPropA) {
    //do stuff
  } else {
    //do other stuff
  }
})
    • Nur eine kurze Notiz, um Sie wissen zu lassen, dass es eine Typ-sichere, intellisense-freundliche Art und Weise zu schreiben, Ihre .map() code. Die Verwendung von type-guard mit der in Betreiber. Typoskript tun ordnungsgemäße Typ-Inferenz, etc. Also, Ihr Zustand wäre if('requiredPropA' in rule) { /* inside here, TS knows rule is of type <RuleA> */ }
    InformationsquelleAutor publicJorn
  3. 0

    Können Sie erstellen, die wenige Schnittstellen für die erforderlichen Bedingungen und nehmen Sie Sie in einer Art wie hier:

    interface SolidPart {
    name: string;
    surname: string;
    action: 'add' | 'edit' | 'delete';
    id?: number;
}
interface WithId {
    action: 'edit' | 'delete';
    id: number;
}
interface WithoutId {
    action: 'add';
    id?: number;
}

export type Entity = SolidPart & (WithId | WithoutId);

const item: Entity = { //valid
    name: 'John',
    surname: 'Doe',
    action: 'add'
}
const item: Entity = { //not valid, id required for action === 'edit'
    name: 'John',
    surname: 'Doe',
    action: 'edit'
}
    InformationsquelleAutor cuddlemeister
Schreibe einen Kommentar