ಕನ್ನಡ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸಿ, ಇದು ದೃಢವಾದ ಮತ್ತು ಟೈಪ್-ಸೇಫ್ ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದೆ. ಸ್ಥಿತಿಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು, ಪರಿವರ್ತನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಕೋಡ್ ವಿಶ್ವಾಸಾರ್ಹತೆ ಹೆಚ್ಚಿಸಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುವುದನ್ನು ಕಲಿಯಿರಿ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳು: ಟೈಪ್-ಸೇಫ್ ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು

ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ಕ್ಷೇತ್ರದಲ್ಲಿ, ಅಪ್ಲಿಕೇಶನ್‌ನ ಸ್ಥಿತಿಯನ್ನು (state) ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ಗಳು ಸಂಕೀರ್ಣ ಸ್ಥಿತಿಯುಳ್ಳ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ರೂಪಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಅಮೂರ್ತತೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದು ವ್ಯವಸ್ಥೆಯ ತರ್ಕದ ಬಗ್ಗೆ ತಾರ್ಕಿಕತೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಊಹಿಸಬಹುದಾದ ನಡವಳಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್, ತನ್ನ ದೃಢವಾದ ಟೈಪ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ, ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳನ್ನು (ಟ್ಯಾಗ್ ಮಾಡಲಾದ ಯೂನಿಯನ್‌ಗಳು ಅಥವಾ ಆಲ್ಜಿಬ್ರಿಕ್ ಡೇಟಾ ಟೈಪ್‌ಗಳು ಎಂದೂ ಕರೆಯಲ್ಪಡುತ್ತದೆ) ಬಳಸಿ ಟೈಪ್-ಸೇಫ್ ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅದ್ಭುತವಾದ ಕಾರ್ಯವಿಧಾನವನ್ನು ನೀಡುತ್ತದೆ.

ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳು ಎಂದರೇನು?

ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್ ಎನ್ನುವುದು ಹಲವಾರು ವಿಭಿನ್ನ ಟೈಪ್‌ಗಳಲ್ಲಿ ಒಂದಾಗಿರಬಹುದಾದ ಮೌಲ್ಯವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಟೈಪ್ ಆಗಿದೆ. ಈ ಪ್ರತಿಯೊಂದು ಟೈಪ್‌ಗಳು, ಯೂನಿಯನ್‌ನ ಸದಸ್ಯರು ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತವೆ, ಡಿಸ್ಕ್ರಿಮಿನೆಂಟ್ ಅಥವಾ ಟ್ಯಾಗ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಸಾಮಾನ್ಯ, ವಿಶಿಷ್ಟ ಗುಣಲಕ್ಷಣವನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ. ಈ ಡಿಸ್ಕ್ರಿಮಿನೆಂಟ್, ಯೂನಿಯನ್‌ನ ಯಾವ ಸದಸ್ಯ ಪ್ರಸ್ತುತ ಸಕ್ರಿಯವಾಗಿದೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ನಿರ್ಧರಿಸಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದರಿಂದ ಶಕ್ತಿಯುತ ಟೈಪ್ ಚೆಕ್ಕಿಂಗ್ ಮತ್ತು ಆಟೋ-ಕಂಪ್ಲೀಷನ್ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಇದನ್ನು ಟ್ರಾಫಿಕ್ ಲೈಟ್‌ನಂತೆ ಯೋಚಿಸಿ. ಅದು ಕೆಂಪು, ಹಳದಿ, ಅಥವಾ ಹಸಿರು ಎಂಬ ಮೂರು ಸ್ಥಿತಿಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿರಬಹುದು. 'ಬಣ್ಣ' (color) ಎಂಬ ಗುಣಲಕ್ಷಣವು ಡಿಸ್ಕ್ರಿಮಿನೆಂಟ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಲೈಟ್ ಯಾವ ಸ್ಥಿತಿಯಲ್ಲಿದೆ ಎಂಬುದನ್ನು ನಮಗೆ ನಿಖರವಾಗಿ ತಿಳಿಸುತ್ತದೆ.

ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ಗಳಿಗಾಗಿ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳು ಹಲವಾರು ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳನ್ನು ತರುತ್ತವೆ:

ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳೊಂದಿಗೆ ಸ್ಟೇಟ್ ಮೆಷಿನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ಒಂದು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳನ್ನು ಬಳಸಿ ಸ್ಟೇಟ್ ಮೆಷಿನ್ ಅನ್ನು ಹೇಗೆ ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸೋಣ: ಒಂದು ಆರ್ಡರ್ ಸಂಸ್ಕರಣಾ ವ್ಯವಸ್ಥೆ. ಒಂದು ಆರ್ಡರ್ ಈ ಕೆಳಗಿನ ಸ್ಥಿತಿಗಳಲ್ಲಿರಬಹುದು: Pending, Processing, Shipped, ಮತ್ತು Delivered.

ಹಂತ 1: ಸ್ಥಿತಿ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ

ಮೊದಲಿಗೆ, ನಾವು ಪ್ರತಿ ಸ್ಥಿತಿಗಾಗಿ ಪ್ರತ್ಯೇಕ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ಪ್ರತಿಯೊಂದು ಟೈಪ್ `type` ಎಂಬ ಗುಣಲಕ್ಷಣವನ್ನು ಡಿಸ್ಕ್ರಿಮಿನೆಂಟ್ ಆಗಿ ಹೊಂದಿರುತ್ತದೆ, ಜೊತೆಗೆ ಯಾವುದೇ ಸ್ಥಿತಿ-ನಿರ್ದಿಷ್ಟ ಡೇಟಾವನ್ನು ಹೊಂದಿರುತ್ತದೆ.


interface Pending {
  type: "pending";
  orderId: string;
  customerName: string;
  items: string[];
}

interface Processing {
  type: "processing";
  orderId: string;
  assignedAgent: string;
}

interface Shipped {
  type: "shipped";
  orderId: string;
  trackingNumber: string;
}

interface Delivered {
  type: "delivered";
  orderId: string;
  deliveryDate: Date;
}

ಹಂತ 2: ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್ ಟೈಪ್ ರಚಿಸಿ

ಮುಂದೆ, ನಾವು `|` (ಯೂನಿಯನ್) ಆಪರೇಟರ್ ಬಳಸಿ ಈ ಪ್ರತ್ಯೇಕ ಟೈಪ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.


type OrderState = Pending | Processing | Shipped | Delivered;

ಈಗ, `OrderState` ಒಂದು ಮೌಲ್ಯವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಅದು `Pending`, `Processing`, `Shipped`, ಅಥವಾ `Delivered` ಆಗಿರಬಹುದು. ಪ್ರತಿ ಸ್ಥಿತಿಯೊಳಗಿನ `type` ಗುಣಲಕ್ಷಣವು ಡಿಸ್ಕ್ರಿಮಿನೆಂಟ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಅವುಗಳ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಗುರುತಿಸಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ.

ಸ್ಥಿತಿ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ನಾವು ನಮ್ಮ ಸ್ಟೇಟ್ ಮೆಷಿನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ನಂತರ, ಸ್ಥಿತಿಗಳ ನಡುವೆ ಪರಿವರ್ತನೆಗೊಳ್ಳಲು ನಮಗೆ ಒಂದು ಕಾರ್ಯವಿಧಾನ ಬೇಕು. ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ ಮತ್ತು ಕ್ರಿಯೆಯನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಂಡು ಹೊಸ ಸ್ಥಿತಿಯನ್ನು ಹಿಂದಿರುಗಿಸುವ `processOrder` ಎಂಬ ಫಂಕ್ಷನ್ ಅನ್ನು ರಚಿಸೋಣ.


interface Action {
  type: string;
  payload?: any;
}

function processOrder(state: OrderState, action: Action): OrderState {
  switch (state.type) {
    case "pending":
      if (action.type === "startProcessing") {
        return {
          type: "processing",
          orderId: state.orderId,
          assignedAgent: action.payload.agentId,
        };
      }
      return state; // No state change

    case "processing":
      if (action.type === "shipOrder") {
        return {
          type: "shipped",
          orderId: state.orderId,
          trackingNumber: action.payload.trackingNumber,
        };
      }
      return state; // No state change

    case "shipped":
      if (action.type === "deliverOrder") {
        return {
          type: "delivered",
          orderId: state.orderId,
          deliveryDate: new Date(),
        };
      }
      return state; // No state change

    case "delivered":
      // Order is already delivered, no further actions
      return state;

    default:
      // This should never happen due to exhaustiveness checking
      return state; // Or throw an error
  }
}

ವಿವರಣೆ

ಸಮಗ್ರತೆಯ ಪರಿಶೀಲನೆಯನ್ನು (Exhaustiveness Checking) ಬಳಸುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸಮಗ್ರತೆಯ ಪರಿಶೀಲನೆಯು ಒಂದು ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು, ನಿಮ್ಮ ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ನಲ್ಲಿ ನೀವು ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ಸ್ಥಿತಿಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತೀರಿ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ನೀವು `OrderState` ಯೂನಿಯನ್‌ಗೆ ಹೊಸ ಸ್ಥಿತಿಯನ್ನು ಸೇರಿಸಿ ಆದರೆ `processOrder` ಫಂಕ್ಷನ್ ಅನ್ನು ನವೀಕರಿಸಲು ಮರೆತರೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ದೋಷವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ಸಮಗ್ರತೆಯ ಪರಿಶೀಲನೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು, ನೀವು `never` ಟೈಪ್ ಅನ್ನು ಬಳಸಬಹುದು. ನಿಮ್ಮ ಸ್ವಿಚ್ ಸ್ಟೇಟ್ಮೆಂಟ್‌ನ `default` ಕೇಸ್ ಒಳಗೆ, ಸ್ಥಿತಿಯನ್ನು `never` ಟೈಪ್‌ನ ವೇರಿಯೇಬಲ್‌ಗೆ ನಿಯೋಜಿಸಿ.


function processOrder(state: OrderState, action: Action): OrderState {
  switch (state.type) {
    // ... (previous cases) ...

    default:
      const _exhaustiveCheck: never = state;
      return _exhaustiveCheck; // Or throw an error
  }
}

ಒಂದು ವೇಳೆ `switch` ಸ್ಟೇಟ್ಮೆಂಟ್ ಎಲ್ಲಾ ಸಂಭಾವ್ಯ `OrderState` ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಿದರೆ, `_exhaustiveCheck` ವೇರಿಯೇಬಲ್ `never` ಟೈಪ್‌ನದ್ದಾಗಿರುತ್ತದೆ ಮತ್ತು ಕೋಡ್ ಕಂಪೈಲ್ ಆಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನೀವು `OrderState` ಯೂನಿಯನ್‌ಗೆ ಹೊಸ ಸ್ಥಿತಿಯನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಅದನ್ನು `switch` ಸ್ಟೇಟ್ಮೆಂಟ್‌ನಲ್ಲಿ ನಿರ್ವಹಿಸಲು ಮರೆತರೆ, `_exhaustiveCheck` ವೇರಿಯೇಬಲ್ ಬೇರೆ ಟೈಪ್‌ನದ್ದಾಗಿರುತ್ತದೆ, ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಂಪೈಲ್-ಟೈಮ್ ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ, ಕಾಣೆಯಾದ ಕೇಸ್ ಬಗ್ಗೆ ನಿಮಗೆ ಎಚ್ಚರಿಕೆ ನೀಡುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಅನ್ವಯಗಳು

ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳು ಸರಳ ಆರ್ಡರ್ ಸಂಸ್ಕರಣಾ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಮೀರಿ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಅನ್ವಯವಾಗುತ್ತವೆ:

ಉದಾಹರಣೆ: UI ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್

API ನಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುವ UI ಕಾಂಪೊನೆಂಟ್‌ನ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸುವ ಒಂದು ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ. ನಾವು ಈ ಕೆಳಗಿನ ಸ್ಥಿತಿಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು:


interface Initial {
  type: "initial";
}

interface Loading {
  type: "loading";
}

interface Success {
  type: "success";
  data: T;
}

interface Error {
  type: "error";
  message: string;
}

type UIState = Initial | Loading | Success | Error;

function renderUI(state: UIState): React.ReactNode {
  switch (state.type) {
    case "initial":
      return 

ಡೇಟಾ ಲೋಡ್ ಮಾಡಲು ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ.

; case "loading": return

ಲೋಡ್ ಆಗುತ್ತಿದೆ...

; case "success": return
{JSON.stringify(state.data, null, 2)}
; case "error": return

ದೋಷ: {state.message}

; default: const _exhaustiveCheck: never = state; return _exhaustiveCheck; } }

ಈ ಉದಾಹರಣೆಯು UI ಕಾಂಪೊನೆಂಟ್‌ನ ವಿವಿಧ ಸ್ಥಿತಿಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ, ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯ ಆಧಾರದ ಮೇಲೆ UI ಸರಿಯಾಗಿ ರೆಂಡರ್ ಆಗುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. `renderUI` ಫಂಕ್ಷನ್ ಪ್ರತಿ ಸ್ಥಿತಿಯನ್ನು ಸೂಕ್ತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ, UI ಅನ್ನು ನಿರ್ವಹಿಸಲು ಸ್ಪಷ್ಟ ಮತ್ತು ಟೈಪ್-ಸೇಫ್ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳನ್ನು ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು, ಈ ಕೆಳಗಿನ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:

ಸುಧಾರಿತ ತಂತ್ರಗಳು

ಕಂಡೀಷನಲ್ ಟೈಪ್ಸ್

ಇನ್ನೂ ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ಗಳನ್ನು ರಚಿಸಲು ಕಂಡೀಷನಲ್ ಟೈಪ್‌ಗಳನ್ನು ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯ ಆಧಾರದ ಮೇಲೆ ಫಂಕ್ಷನ್‌ಗಾಗಿ ವಿಭಿನ್ನ ರಿಟರ್ನ್ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನೀವು ಕಂಡೀಷನಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.


function getData(state: UIState): T | undefined {
  if (state.type === "success") {
    return state.data;
  }
  return undefined;
}

ಈ ಫಂಕ್ಷನ್ ಸರಳವಾದ `if` ಸ್ಟೇಟ್ಮೆಂಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ಆದರೆ ನಿರ್ದಿಷ್ಟ ಟೈಪ್ ಯಾವಾಗಲೂ ಹಿಂದಿರುಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಕಂಡೀಷನಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಿ ಹೆಚ್ಚು ದೃಢವಾಗಿಸಬಹುದು.

ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳಾದ `Extract` ಮತ್ತು `Omit` ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಸಹಾಯಕವಾಗಬಹುದು. `Extract` ಒಂದು ಷರತ್ತಿನ ಆಧಾರದ ಮೇಲೆ ಯೂನಿಯನ್ ಟೈಪ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ಸದಸ್ಯರನ್ನು ಹೊರತೆಗೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ `Omit` ಒಂದು ಟೈಪ್‌ನಿಂದ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.


// UIState ಯೂನಿಯನ್‌ನಿಂದ "success" ಸ್ಥಿತಿಯನ್ನು ಹೊರತೆಗೆಯಿರಿ
type SuccessState = Extract, { type: "success" }>;

// Error ಇಂಟರ್ಫೇಸ್‌ನಿಂದ 'message' ಪ್ರಾಪರ್ಟಿಯನ್ನು ಬಿಟ್ಟುಬಿಡಿ
type ErrorWithoutMessage = Omit;

ವಿವಿಧ ಉದ್ಯಮಗಳಲ್ಲಿನ ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳು

ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳ ಶಕ್ತಿಯು ವಿವಿಧ ಕೈಗಾರಿಕೆಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ವಿಸ್ತರಿಸಿದೆ:

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳು ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಶಕ್ತಿಯುತ ಮತ್ತು ಟೈಪ್-ಸೇಫ್ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಸಂಭಾವ್ಯ ಸ್ಥಿತಿಗಳು ಮತ್ತು ಪರಿವರ್ತನೆಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ದೃಢವಾದ, ನಿರ್ವಹಿಸಬಹುದಾದ ಮತ್ತು ಅರ್ಥವಾಗುವ ಕೋಡ್ ಅನ್ನು ರಚಿಸಬಹುದು. ಟೈಪ್ ಸೇಫ್ಟಿ, ಸಮಗ್ರತೆಯ ಪರಿಶೀಲನೆ, ಮತ್ತು ಉತ್ತಮವಾದ ಕೋಡ್ ಕಂಪ್ಲೀಷನ್‌ನ ಸಂಯೋಜನೆಯು ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳನ್ನು ಸಂಕೀರ್ಣ ಸ್ಥಿತಿ ನಿರ್ವಹಣೆಯೊಂದಿಗೆ ವ್ಯವಹರಿಸುವ ಯಾವುದೇ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗೆ ಒಂದು ಅಮೂಲ್ಯವಾದ ಸಾಧನವನ್ನಾಗಿ ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ಮುಂದಿನ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ಟೈಪ್-ಸೇಫ್ ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌ನ ಪ್ರಯೋಜನಗಳನ್ನು ನೇರವಾಗಿ ಅನುಭವಿಸಿ. ನಾವು ಇ-ಕಾಮರ್ಸ್‌ನಿಂದ ಆರೋಗ್ಯ ರಕ್ಷಣೆ, ಮತ್ತು ಲಾಜಿಸ್ಟಿಕ್ಸ್‌ನಿಂದ ಶಿಕ್ಷಣದವರೆಗಿನ ವೈವಿಧ್ಯಮಯ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ತೋರಿಸಿದಂತೆ, ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳ ಮೂಲಕ ಟೈಪ್-ಸೇಫ್ ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ತತ್ವವು ಸಾರ್ವತ್ರಿಕವಾಗಿ ಅನ್ವಯವಾಗುತ್ತದೆ.

ನೀವು ಸರಳ UI ಕಾಂಪೊನೆಂಟ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ ಅಥವಾ ಸಂಕೀರ್ಣ ಎಂಟರ್‌ಪ್ರೈಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ, ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳು ಸ್ಥಿತಿಯನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಮತ್ತು ರನ್‌ಟೈಮ್ ದೋಷಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ. ಆದ್ದರಿಂದ, ಧುಮುಕಿ ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಟೈಪ್-ಸೇಫ್ ಸ್ಟೇಟ್ ಮೆಷಿನ್‌ಗಳ ಜಗತ್ತನ್ನು ಅನ್ವೇಷಿಸಿ!