Közelebbről áttekintve a gépírási sorrendeket
Gyors emlékeztetőül: a tuple a legalapvetőbb definíciójában csak egy adatstruktúra, amely több részből áll. A programozási nyelvekben, például a Typescriptben a sorrend használatakor fontos megjegyezni, hogy az adatok sorrendje a leggyakrabban.
Egy egyszerű példa bemutatja, hogyan definiálják a típust a Typescript.
// 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"];
Tollak választható elemekkel
Ahogy a gépírás az idő múlásával egyre jobbá vált, úgy a sorok végrehajtása is javult. Nem csak olyan elemeket kell meghatároznia, amelyeknek kötelezőnek kell lenniük. Most már választhatóként be is írhatja az elemeket. Ha nem tudja, a Typescript a kérdőjelet használja általános szimbólumként, hogy az elemeket opcionálisként definiálja, ami azt jelenti, hogy futás közben elérhetők, de nem muszáj.
Egy másik példa bemutatja, mit akarok ezzel mondani.
// 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"];
Pihenőelemek a gépíratsorokban
A többi elemnél nagyon hatékony típus áll rendelkezésére, amely az összes következő elemet megjelöli egy adott típus dupláján. Tehát mondjuk, hogy van egy két elemű duplája, a második pedig mint rest elem, akkor futás közben 2 + n elemet adhat meg ennek a duplaváltozónak.
A definíció leszűkítése érdekében a legutóbbi időkig egy ilyen elem csak egy szakasz végén volt megengedett. Ennek van értelme, mivel ez lehetővé teszi, hogy tetszőleges számú elemet adjon meg a többi típusú futás közben, de nagyon bonyolulttá tenné a dolgokat, hogy megkülönböztessük a többi elem és egy másik, más gépelt elem között.
// 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"];
Vezető vagy középső pihenőelem páros típusokban
A tömbök többi elemének továbbfejlesztésével még kifinomultabb megvalósításokat hozhat létre, mivel a Typescript 4.2 megjelent. És itt elnézést kell kérnem: csak néhány mondattal korábban írtam, hogy a pihenőelemet csak utolsóként kell használni. Ez a korlátozás valójában már nem igaz a 4.2-es gépírás óta, mivel a pihenőelemeket szinte bárhová el lehet helyezni egy duplában.
Csak néhány korlátozás mellett a Typescript most nagyon szép szintaxist biztosít a haladó sorok számára. A pihenőelemek a duplán belül bárhol előfordulhatnak, amennyiben megfelelnek a következő két szabálynak
- nem követi opcionális elem
- egyetlen más pihenőelem sem követi az elsőt
Mielőtt túl sok elméletet beszélnénk, lássunk egy példát.
// 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.
A cikk többi eleme
Zárva ezt a kompakt útmutatót a Typescript sorrendjéről, megnéztük az alapvető megvalósítást, majd áttekintettünk néhány fejlettebb példát, hogy lássuk, hogyan teszi lehetővé a Typescript egy nagyon rugalmas típust, amikor a sorrendről van szó. Remélem, hogy tetszett a cikk, és ha kíváncsi rá, hogy többet tudjon meg, nézze meg az alábbiakban a javasolt bejegyzéseket.
