טיפּעסקריפּט טופּלע טייפּס

אַ נעענטער קוק אויף טייפּסקריפּט טופּאַלז

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

א פּשוט ביישפּיל ווייזט ווי טופּאַלז זענען דיפיינד אין טיפּעסקריפּט.

// This tuple is defined as a set
// of two numbers.
const scores: [number, number] = [1, 2];

// For comparison, this tuple consists
// of three elements, each of a different
// type. Not that the ordered nature of
// tuples in TS becomes very clear here.
const result: [string, number, boolean] = ["id", 101, false];

// And as a "nice-to-know", you can even
// provide lables for the tuple elements.
// This doesn't have any effect on the typesystem
// itself and only (may) improve documentation.
const output: [id: number, name: string] = [101, "Tom"];

טופּאַלז מיט אַפּשאַנאַל עלעמענטן

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

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

// Similar to our previous example, but in this
// case the the tuple's last element doesn't have
// to be provided (or can be undefined at runtime).
type Tuple = [id: number, name?: string];

const a: Tuple = [101];
const b: Tuple = [42, "Tom"];

מנוחה עלעמענטן אין טייפּסקריפּט טופּאַלז

מיט רו עלעמענטן, איר האָט אַ זייער שטאַרק טיפּ אין האַנט וואָס מאַרקס אַלע די פאלגענדע עלעמענטן אין די טופּאַל פון אַ געגעבן טיפּ. אַזוי איר זאָגן אַז איר האָבן אַ טאָפּל מיט צוויי עלעמענטן און די רגע איינער איז דיפיינד ווי אַ מנוחה עלעמענט, איר קענען צושטעלן 2 + n עלעמענטן אין רונטימע צו דעם טאָפּל בייַטעוודיק.

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

// This example might be a tuple type
// for a CLI similar to Node.js. The first
// two elements are system-internal.
//
// Starting from the 3rd element, a user can
// provide as much arguments as desired, yet
// we can still cleanly handle it with TS. Nice!
let input: [number, boolean, ...string[]];

// Just to show that we really can provide any
// number of rest elements, including 0.
e = [0, false, "max-cache", "1024", "debug", "false"];
e = [0, false];
e = [0, false, "verbose"];

לידינג אָדער מיטל מנוחה עלעמענט אין טייפּאַלז

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

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

• עס איז נישט נאכגעגאנגען דורך אַ אַפּשאַנאַל עלעמענט
• קיין אנדערע מנוחה עלעמענט גייט דער ערשטער

איידער איר רעדן צו פיל טעאָריע, לאָזן אַ ביישפּיל.

// And here comes the fancy part: rest elements
// *not only* at the end of a tuple.
// 
// Note: this example is taken directly from the
// TS documentation. For more details, check out the
// links in the addendum.
let foo: [...string[], number];

foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];

let bar: [boolean, ...string[], boolean];

bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

// And here's an example that shows how the
// type system would catch your errors:
interface Clown { /*...*/ }
interface Joker { /*...*/ }

let StealersWheel: [...Clown[], "me", ...Joker[]];
//                                    ~~~~~~~~~~ Error!
// A rest element cannot follow another rest element.

let StringsAndMaybeBoolean: [...string[], boolean?];
//                                        ~~~~~~~~ Error!
// An optional element cannot follow a rest element.

די מנוחה עלעמענט פון דעם אַרטיקל

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