चौकड़ी 9: एलेग्रो | टाइपप्रति

जब डेटा सत्यापन के लिए पुस्तकालय quartetबनाया गया था, तो निम्नलिखित स्थल निर्धारित किए गए थे:

• टाइपप्रति
• सादगी और सरलता
• प्रदर्शन

इस लेख में, मैं quartetटाइपस्क्रिप्ट पर ध्यान केंद्रित करने पर विचार करना चाहूंगा।

प्रेरणा

हम टाइपस्क्रिप्ट का उपयोग करके अपनी परियोजनाओं पर काम करते हैं। इसलिए, जब मैंने इस लाइब्रेरी का निर्माण किया, तो मैं चाहता था कि टाइपस्क्रिप्ट जानने वाला व्यक्ति चौकड़ी न सीखे, क्योंकि उसके लिए कुछ नया हो, लेकिन इस लाइब्रेरी में पहचानने के लिए कि वह पहले से ही क्या जानता है।

उपयोगकर्ता-परिभाषित प्रकार के गार्ड

एक उदाहरण पर विचार करें। हम एपीआई के साथ उपयोगकर्ता के बारे में डेटा का अनुरोध करते हैं। हम मानते हैं कि वे निम्न प्रकार के हैं:

interface User {
  id: string;
  name: string;
  gender: "male" | "female";
  age: number;
  phoneBook: {
    [name: string]: string;
  };
}

मैं सत्यापन समारोह से क्या प्राप्त करना चाहता हूं:

const probablyUser: unkown = { ... }

if (checkUser(probablyUser)) {
    // probablyUser has type User
    console.log(probablyUser.name)
} else {
    // probablyUser has type unkown
    throw new Error('Probably User has not type User')
}

इस लक्ष्य को प्राप्त करने के लिए, उपयोगकर्ता-परिभाषित प्रकार के गार्ड का उपयोग किया जाता है ।

यही है, समारोह घोषणा इस तरह दिखना चाहिए:

function checkUser(probablyUser: any): probablyUser is User {
  // ...
}

चलो quartetइस तरह के एक समारोह बनाने के लिए उपयोग करें:

import { v } from "quartet";

const checkUser = v({
  id: v.string,
  name: v.string,
  gender: ["male", "female"],
  age: v.number
  phoneBook: {
    [v.rest]: v.string,
  }
});

इस तरह के कोड को लिखने के बाद, हमें एक फ़ंक्शन मिलता है जो टाइपगार्ड नहीं है:

chechUser: (value: any) => boolean;

टाइपगार्ड बनाने के लिए यह घोषित करना आवश्यक है कि इस फ़ंक्शन द्वारा किस प्रकार को मान्य किया जाएगा। यह इस प्रकार किया जाता है:

const checkUser = v<User>({
  // ...
});

आखिरकार:

chechUser: (value: any) => value is User

इस मद के बारे में दो बिंदु हैं:

गारंटी

बहुत तथ्य यह है कि डेवलपर यह संकेत कर सकता है कि सर्किट किस प्रकार से मान्य है, क्योंकि यह इस तरह से लिखना संभव है:

const checkNumber = v<number>({ name: v.string });
// checkNumber: (value: any) => value is number

— { name: string }, , number.

. ( ) , — "" .

, .

const v: <T>(schema: Schema) => (value: any) => value is T;

const v: <T = any>(schema: Schema) => (value: any) => value is T;

const checkNumber = v(v.number);
const value: any = "123";

if (!checkNumber(value)) {
  // value has type never
}

const v: <T = any>(
  schema: Schema
) => IfAny<T, (value: any) => boolean, (value: any) => value is T>;

type IfAny<T,A,B> = // ...

type IfAny<T, A, B> = true extends T
  ? "1" extends T
    ? 1 extends T
      ? {} extends T
        ? (() => void) extends T
          ? null extends T
            ? A
            : B
          : B
        : B
      : B
    : B
  : B;

TypeScript

, , TypeScript'a .

@hapi/joi ajv, User.

Text Compare .

quartet

const checkUser = v({
  id: v.string,
  name: v.string,
  gender: ["male", "female"],
  age: v.number
  phoneBook: {
    [v.rest]: v.string,
  }
})

- : 24

hapi/joi

const schema = j.object({
  id: j.string().required(),
  name: j.string().required(),
  gender: j
    .string()
    .valid("male", "female")
    .required(),
  age: j.number().required(),
  phoneBook: j.object().pattern(/.*/, j.string())
});

, , 118 .

ajv

const checkUser = a.compile({
  type: "object",
  required: ["id", "name", "gender", "age", "phoneBook"],
  properties: {
    id: { type: "string" },
    name: { type: "string" },
    gender: { type: "string", enum: ["male", "female"] },
    phoneBook: {
      type: "object",
      additionalProperties: {
        type: "string"
      }
    }
  }
});

, 146 .

:

TypeScript. , , , .

TypeGuard — , .

TypeScript . — .