'N Nader beskouing van Typescript tuples
As 'n vinnige herinnering is 'n tuple in sy mees basiese definisie slegs 'n datastruktuur wat uit veelvoudige dele bestaan. In die omvang van die gebruik van tipes in programmeertale, soos Typescript, is dit ook belangrik om daarop te let dat die data meestal gerangskik word.
'N Eenvoudige voorbeeld toon aan hoe tipes in Typescript gedefinieer word.
// 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"];
Tuples met opsionele elemente
Namate die Typescript met verloop van tyd beter geword het, het die implementering van tuples ook verbeter. U hoef nie net elemente te definieer wat verpligtend moet wees nie. U kan nou ook elemente as opsioneel tik. As u nie weet nie, gebruik Typescript die vraagteken as 'n algemene simbool om elemente as opsioneel te definieer, wat beteken dat dit tydens looptyd beskikbaar kan wees, maar dit nie hoef te doen nie.
'N Ander voorbeeld toon aan wat ek daarmee bedoel.
// 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"];
Ruselemente in tikskrifte vir tipes
Met ruselemente het u 'n baie kragtige tipe byderhand wat al die volgende elemente in die tupel van 'n gegewe tipe aandui. Sê nou jy het 'n tupel met twee elemente en die tweede een as 'n ruselement, jy kan dan 2 + n elemente tydens looptyd aan hierdie tupelveranderlike verskaf.
Om die definisie te beperk, is so onlangs tot onlangs net aan die einde van 'n tupel toegelaat. Dit is sinvol, want dit stel u in staat om 'n aantal elemente tydens die looptyd van die resoort te verskaf, maar dit sal baie ingewikkeld maak om dan te onderskei tussen die ruselement en nog 'n ander getikte item.
// 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"];
Voorste of middelste ruselement in tipes tipes
As u die ruselement vir tuples bevorder, kan u nog meer gesofistikeerde implementasies skep sedert Typescript 4.2 vrygestel is. En ek moet hier om verskoning vra: net 'n paar sinne vroeg, ek het geskryf hoe dit verpligtend is om 'n ruselement net as die laaste een te gebruik. Hierdie beperking is eintlik nie meer waar sedert Typescript 4.2 nie, aangesien u nou ruselemente byna oral in 'n tupel kan plaas.
Maar met slegs 'n paar beperkings, bied Typescript nou 'n baie goeie sintaksis vir gevorderde tipes. Rustelemente kan oral binne 'n tupel voorkom, solank dit aan die volgende twee reëls voldoen
- dit word nie gevolg deur 'n opsionele element nie
- geen ander ruselement volg op die eerste nie
Kom ons kyk na 'n voorbeeld voordat u te veel teorie praat.
// 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.
Die res-element van hierdie artikel
Aan die einde van hierdie kompakte gids oor tipes in Typescript, het ons die basiese implementering bekyk en vervolgens 'n paar meer gevorderde voorbeelde deurgegaan om te sien hoe Typescript 'n baie buigsame tipe stelsel toelaat as dit by tuisies kom. Ek hoop dat u die artikel geniet het en as u nuuskierig is om meer te wete te kom, kan u die voorgestelde plasings hieronder lees.
