טיפּסקריפּט מוסטער שטריקל טייפּס ווי דיסקרימינאַנץ

וואָס איז "נעראָוינג" אין TS?

איידער מיר נעמען אַ קוק אין די ענכאַנסמאַנט פון ליטעראַל טייפּס אין Typescript 4.5 און שפּעטער, איך נאָר געשווינד וועלן צו רעקאַפּ וואָס "נעראָוינג" אין דעם קאָנטעקסט אַקשלי מיטל. בייסיקלי, איר קענען פאַרקלענערן אַ טיפּ אין Typescript דורך קאָנטראָלירן די פּראָפּערטיעס פון די ענטיטי. אויב אַ פאַרמאָג יגזיסץ אויף די ענטיטי וואָס איז בלויז בנימצא פֿאַר אַ זיכער טיפּ, טיפּעסקריפּט פארשטייט דעם און קענען דעריבער צושטעלן די ריכטיק טייפּס.

די פאלגענדע קאָד ביישפּיל דעמאַנסטרייץ וואָס איך מיינען מיט דעם.

type Addition = {
    sum: number;
}

type Subtraction = {
    result: number;
}

function calculate(action: Addition | Subtraction) {
    if ('sum' in action) {
      // Simple example of using properties
      // of an entity to narrow down its
      // actual type.
      //
      // 'action' is at this point of type
      // 'Addition'. Nice!
      const addition = action;
    }
}

נעראָוינג פֿאַר טעמפּלאַטע סטרינג טייפּס

סטאַרטינג מיט Typescript ווערסיע 4.5, דעם מוסטער קענען אויך זיין געווענדט פֿאַר טעמפּלאַטעס ליטעראַל טייפּס, אויך באקאנט ווי די ספּעציעל סטרינגס מיט באַקטיקקס. דער מוסטער וואָס ריכטן זיך איז טאַקע שטאַרק אין דער שפּראַך.

פון קורס, פֿאַר נעראָוינג צו ווערן ניצלעך, אַלע טייפּס אין די פאַרגלייַך האָבן צו טיילן די זעלבע פאַרמאָג שליסל. אַנדערש, איר קענען פשוט נוצן די פּראָסט נעראָוינג ווי אויבן.

די פאלגענדע קאָד ביישפּיל ווייזט ווי מוסטער סטרינגס קענען נוצן נעראָוינג:

type Addition = {
    variant: `${string}-addition`;
    sum: number;
}

type Subtraction = {
    variant: `${string}-subtraction`;
    result: number;
}

function process(action: Addition | Subtraction) {
    if (action.variant === "simple-addition") {
        // Stupid simple example, but you get the idea:
        // We used 'simple-addition', and the pattern 
        // matching by TS understood that '...-addition'
        // can be discriminated to 'Addition'.
        const addition = action;
    }
}

//
// Example that DOES NOT work.
//
// This demo illustrates that the
// discriminante has to be a string,
// else the pattern matching worn't work.

type Addition = {
    variant: `${string}-arithemtic`;
    sum: number;
}

type Subtraction = {
    variant: `${number}-arithemtic`;
    result: number;
}

function process(action: Addition | Subtraction) {
    if (action.variant === "123-arithemtic") {
        // Still 'Addion | Subtraction',
        // as we can only compare against
        // a string '123-arithmetic', which
        // is of course the same for both.
        const addition = action;
    }
}

און איצט איר וויסן וועגן נעראָוינג אַראָפּ טעמפּלאַטעס ליטעראַל אין Typescript! דאָס קען זיין אַ שטריך וואָס איר וועט נישט נוצן זייער אָפט, אָבער ווען עס איז צונעמען, איך טראַכטן עס קענען זייער רעדוצירן קאָד קאַמפּלעקסיטי און האַלטן דיין קאָדעבאַסע אַ ביסל קלינער ווי אָן די שטריך.