تایپ اسکریپت – محافظ های نوع اتحادیه از نوع e

type NumberOrString = number | string;

type Status = "idle" | "loading" | "success" | "failure"

// React useState, can receive a value or a function as parameter to serve as initial value. 
// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/a03856975a17eba524739676affbf70ac4078176/types/react/v17/index.d.ts#L920
function useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];

// using switch
type Order = OrderCompleted | OrderProcessing | OrderReady;

function processOrder(order: Order) {
  switch (order.status) {
    case "completed": {
      console.log(order.deliveryAt) // Narrow to OrderCompleted 
      return;
    }
    case "processing": {
      console.log(order.expectDeliveryAt) // Narrow to OrderProcessing 
      return;
    }
    case "ready": {
      console.log(order.productId) // Narrow to OrderReady 
    }
  }
}

// using in operator
interface Dog {
    walk: () => void;
}

interface Fish {
    swim: () => void;
}

type Animal = Dog | Fish;

function move(animal: Animal) {
    if ("walk" in animal) {
        animal.walk(); // Narrow to Dog
        return;
    }

    animal.swim(); // Narrow to Fish
}


// using typeof
function promise(callback?: () => void) {
    // ...
    if (typeof callback !== "undefined") {
        callback(); // So in this scope you ensure that function exists
    }
}

interface User {
    name: string;
    email: string;
}

declare const api: <T>(endPoint: string) => T

function getUser() {
    const user = api<User>("/user"); // We assume that the response payload actually sent the object with the type strictly equal to User

    console.log(user.email); 
    console.log(user.name);
}

interface User {
    name: string;
    email: string;
}

function isUser(input: unknown): input is User  {
    return (
        typeof input === "object" && 
        !!input &&
        "name" in input &&
        "email" in input
    ) 
}

declare const api: <T>(endPoint: string) => T

function getUser() {
    const user = api("/user"); // We can pass the User as a generic here, however we have to remember to do the validation

    if (isUser(user)) { // With this type guard, we can be sure that the API response actually returned a User. 
        console.log(user.email); 
        console.log(user.name);
        return;
    }
}

function parseUser(input: unknown): User | null {
    const isObject = typeof input === "object" && input
    if (!isObject) return null;

    const hasUserProperties = 
        "name" in input &&
        "email" in input

    if (!hasUserProperties) return null;

    const { email, name } = input;

    if (typeof email !== "string") return null;
    if (typeof name !== "string") return null;

    return { email, name } // Property 'avatar' is missing in type '{ email: string; name: string; }' but required in type 'User'.(2741)
}

function isUser(input: unknown): input is User {
    return input !== null
}

type Payment = 
    | { status: "pending" }
    | { status: "paid", paidAt: string }
    | { status: "canceled", canceledAt: string } 

type PendingPayment = Extract<Payment, { status: "pending" }>; // { status: "pending" }
type PaidPayment = Extract<Payment, { status: "paid" }>; // { status: "paid", paidAt: string }
type CanceledPayment = Extract<Payment, { status: "canceled" }>; // { status: "canceled", canceledAt: string } 

type Shape = {
  kind: "square";
  size: number;
} | {
  kind: "circle";
  radius: number;
};

type Square = Extract<Shape, { status: "square" }>; // { kind: "square"; size: number; } 
type Circle = Extract<Shape, { status: "circle" }>; // { kind: "circle"; radius: number; }