ಎನಮ್‌ಗಳ ಹೊರತಾಗಿ: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು ಮತ್ತು ಯೂನಿಯನ್ ವಿಧಗಳು

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

ಸಾಂಪ್ರದಾಯಿಕ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಎನಮ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

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

ಸಂಖ್ಯಾ ಎನಮ್‌ಗಳು

ಡೀಫಾಲ್ಟ್ ಆಗಿ, ಎನಮ್ ಸದಸ್ಯರಿಗೆ 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಲಾಗಿದೆ.

            enum DirectionNumeric {
  Up,
  Down,
  Left,
  Right
}

let myDirection: DirectionNumeric = DirectionNumeric.Up;
console.log(myDirection); // Output: 0

            

              
                Copy
              
            
          

ನೀವು ಸ್ಪಷ್ಟವಾಗಿ ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳನ್ನು ಸಹ ನಿಯೋಜಿಸಬಹುದು.

            enum StatusCode {
  Success = 200,
  NotFound = 404,
  InternalError = 500
}

let responseStatus: StatusCode = StatusCode.Success;
console.log(responseStatus); // Output: 200

            

              
                Copy
              
            
          

ಸ್ಟ್ರಿಂಗ್ ಎನಮ್‌ಗಳು

ಸಂಪಾದಿಸಿದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸದಸ್ಯರ ಹೆಸರುಗಳನ್ನು ಸಂರಕ್ಷಿಸುವುದರಿಂದ ಡಿಬಗ್ ಮಾಡುವ ಅನುಭವವನ್ನು ಸುಧಾರಿಸಿದ್ದಕ್ಕಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಎನಮ್‌ಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ.

            enum ColorString {
  Red = "RED",
  Green = "GREEN",
  Blue = "BLUE"
}

let favoriteColor: ColorString = ColorString.Blue;
console.log(favoriteColor); // Output: "BLUE"

            

              
                Copy
              
            
          

ಎನಮ್‌ಗಳ ಓವರ್‌ಹೆಡ್

ಎನಮ್‌ಗಳು ಅನುಕೂಲಕರವಾಗಿದ್ದರೂ, ಅವು ಸ್ವಲ್ಪ ಓವರ್‌ಹೆಡ್‌ನೊಂದಿಗೆ ಬರುತ್ತವೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಕಂಪೈಲ್ ಮಾಡಿದಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಎನಮ್‌ಗಳನ್ನು ಆಬ್ಜೆಕ್ಟ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ, ಅದು ಹೆಚ್ಚಾಗಿ ರಿವರ್ಸ್ ಮ್ಯಾಪಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ಸಂಖ್ಯಾ ಮೌಲ್ಯವನ್ನು ಎನಮ್ ಹೆಸರಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುವುದು). ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು ಆದರೆ ಬಂಡಲ್ ಗಾತ್ರಕ್ಕೆ ಸಹ ಕೊಡುಗೆ ನೀಡುತ್ತದೆ ಮತ್ತು ಯಾವಾಗಲೂ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

ಈ ಸರಳ ಸ್ಟ್ರಿಂಗ್ ಎನಮ್ ಅನ್ನು ಪರಿಗಣಿಸಿ:

            enum Status {
  Pending = "PENDING",
  Processing = "PROCESSING",
  Completed = "COMPLETED"
}

            

              
                Copy
              
            
          

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಇದು ಈ ರೀತಿ ಆಗಬಹುದು:

            var Status;
(function (Status) {
    Status["Pending"] = "PENDING";
    Status["Processing"] = "PROCESSING";
    Status["Completed"] = "COMPLETED";
})(Status || (Status = {}));

            

              
                Copy
              
            
          

ಸರಳವಾದ, ಓದಲು ಮಾತ್ರ ಸ್ಥಿರಾಂಕಗಳಿಗಾಗಿ, ಈ ಉತ್ಪಾದಿತ ಕೋಡ್ ಸ್ವಲ್ಪ ಅತಿಯಾಗಿರಬಹುದು.

ಪರ್ಯಾಯ 1: ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು

ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು ಶಕ್ತಿಯುತವಾದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು, ಮೌಲ್ಯಕ್ಕಾಗಿ ಸಾಧ್ಯವಾದಷ್ಟು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರವನ್ನು ಊಹಿಸಲು ಕಂಪೈಲರ್‌ಗೆ ಹೇಳಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಸ್ಥಿರ ಮೌಲ್ಯಗಳ ಗುಂಪನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಉದ್ದೇಶಿಸಿರುವ ಅರೇಗಳು ಅಥವಾ ವಸ್ತುಗಳೊಂದಿಗೆ ಬಳಸಿದಾಗ, ಅವು ಎನಮ್‌ಗಳಿಗೆ ಹಗುರವಾದ ಪರ್ಯಾಯವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

ಅರೇಗಳೊಂದಿಗೆ ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು

ನೀವು ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳ ಅರೇ ಅನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ನಂತರ ಅದರ ಪ್ರಕಾರವನ್ನು ಬದಲಾಯಿಸಲಾಗದಂತೆ ಮಾಡಲು ಮತ್ತು ಅದರ ಅಂಶಗಳನ್ನು ಅಕ್ಷರಶಃ ಪ್ರಕಾರಗಳನ್ನಾಗಿ ಮಾಡಲು const ಅಸರ್ಷನ್ ಅನ್ನು ಬಳಸಬಹುದು.

            const statusArray = ["PENDING", "PROCESSING", "COMPLETED"] as const;

type StatusType = typeof statusArray[number];

let currentStatus: StatusType = "PROCESSING";
// currentStatus = "FAILED"; // Error: Type '"FAILED"' is not assignable to type 'StatusType'.

function processStatus(status: StatusType) {
  console.log(`Processing status: ${status}`);
}

processStatus("COMPLETED");

            

              
                Copy
              
            
          

ಇಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ವಿವರಿಸೋಣ:

• as const: ಈ ಅಸರ್ಷನ್ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಅರೇ ಅನ್ನು ಓದಲು ಮಾತ್ರ ಎಂದು ಪರಿಗಣಿಸಲು ಹೇಳುತ್ತದೆ ಮತ್ತು ಅದರ ಅಂಶಗಳಿಗಾಗಿ ಅತ್ಯಂತ ನಿರ್ದಿಷ್ಟವಾದ ಅಕ್ಷರಶಃ ಪ್ರಕಾರಗಳನ್ನು ಊಹಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, `string[]` ಬದಲಿಗೆ, ಪ್ರಕಾರವು `readonly ["PENDING", "PROCESSING", "COMPLETED"]`. ಆಗುತ್ತದೆ.
• typeof statusArray[number]: ಇದು ಮ್ಯಾಪ್ ಮಾಡಿದ ವಿಧವಾಗಿದೆ. ಇದು statusArrayನ ಎಲ್ಲಾ ಸೂಚ್ಯಂಕಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳ ಅಕ್ಷರಶಃ ಪ್ರಕಾರಗಳನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ. number ಸೂಚ್ಯಂಕ ಸಹಿ ಮೂಲತಃ "ಈ ಅರೇಯಲ್ಲಿನ ಯಾವುದೇ ಅಂಶದ ಪ್ರಕಾರವನ್ನು ನನಗೆ ನೀಡಿ" ಎಂದು ಹೇಳುತ್ತದೆ. ಫಲಿತಾಂಶವು ಯೂನಿಯನ್ ಪ್ರಕಾರವಾಗಿದೆ: "PENDING" | "PROCESSING" | "COMPLETED".

ಈ ವಿಧಾನವು ಸ್ಟ್ರಿಂಗ್ ಎನಮ್‌ಗಳಿಗೆ ಹೋಲುವ ಪ್ರಕಾರದ ಸುರಕ್ಷತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ ಆದರೆ ಕಡಿಮೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. statusArray ಸ್ವತಃ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಅರೇ ಆಗಿ ಉಳಿಯುತ್ತದೆ.

ವಸ್ತುಗಳೊಂದಿಗೆ ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು

ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳನ್ನು ವಸ್ತುಗಳಿಗೆ ಅನ್ವಯಿಸಿದಾಗ ಇನ್ನಷ್ಟು ಶಕ್ತಿಯುತವಾಗಿರುತ್ತದೆ. ನೀವು ಹೆಸರಿಸಲಾದ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಕೀಲಿಗಳನ್ನು ಹೊಂದಿರುವ ವಸ್ತುವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಮತ್ತು ಮೌಲ್ಯಗಳು ಅಕ್ಷರಶಃ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅಥವಾ ಸಂಖ್ಯೆಗಳಾಗಿವೆ.

            const userRoles = {
  Admin: "ADMIN",
  Editor: "EDITOR",
  Viewer: "VIEWER"
} as const;

type UserRole = typeof userRoles[keyof typeof userRoles];

let currentUserRole: UserRole = "EDITOR";
// currentUserRole = "GUEST"; // Error: Type '"GUEST"' is not assignable to type 'UserRole'.

function displayRole(role: UserRole) {
  console.log(`User role is: ${role}`);
}

displayRole(userRoles.Admin); // Valid
displayRole("EDITOR"); // Valid

            

              
                Copy
              
            
          

ಈ ವಸ್ತುವಿನ ಉದಾಹರಣೆಯಲ್ಲಿ:

• as const: ಈ ಅಸರ್ಷನ್ ಸಂಪೂರ್ಣ ವಸ್ತುವನ್ನು ಓದಲು ಮಾತ್ರ ಮಾಡುತ್ತದೆ. ಹೆಚ್ಚು ಮುಖ್ಯವಾಗಿ, ಇದು ಎಲ್ಲಾ ಆಸ್ತಿ ಮೌಲ್ಯಗಳಿಗಾಗಿ ಅಕ್ಷರಶಃ ಪ್ರಕಾರಗಳನ್ನು ಊಹಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, string ಬದಲಿಗೆ "ADMIN") ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಓದಲು ಮಾತ್ರ ಮಾಡುತ್ತದೆ.
• keyof typeof userRoles: ಈ ಅಭಿವ್ಯಕ್ತಿ userRoles ವಸ್ತುವಿನ ಕೀಲಿಗಳ ಒಕ್ಕೂಟಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ, ಇದು "Admin" | "Editor" | "Viewer" ಆಗಿದೆ.
• typeof userRoles[keyof typeof userRoles]: ಇದು ಲುಕಪ್ ಪ್ರಕಾರವಾಗಿದೆ. ಇದು ಕೀಲಿಗಳ ಒಕ್ಕೂಟವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು userRoles ಪ್ರಕಾರದಲ್ಲಿ ಅನುಗುಣವಾದ ಮೌಲ್ಯಗಳನ್ನು ನೋಡಲು ಇದನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ಮೌಲ್ಯಗಳ ಒಕ್ಕೂಟಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ: "ADMIN" | "EDITOR" | "VIEWER", ಇದು ಪಾತ್ರಗಳಿಗಾಗಿ ನಮ್ಮ ಅಪೇಕ್ಷಿತ ಪ್ರಕಾರವಾಗಿದೆ.

userRoles ಗಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಔಟ್‌ಪುಟ್ ಒಂದು ಸಾಮಾನ್ಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿರುತ್ತದೆ:

            var userRoles = {
    Admin: "ADMIN",
    Editor: "EDITOR",
    Viewer: "VIEWER"
};

            

              
                Copy
              
            
          

ಇದು ವಿಶಿಷ್ಟವಾದ ಎನಮ್‌ಗಿಂತ ಗಮನಾರ್ಹವಾಗಿ ಹಗುರವಾಗಿದೆ.

ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳನ್ನು ಯಾವಾಗ ಬಳಸುವುದು

• ಓದಲು ಮಾತ್ರ ಸ್ಥಿರಾಂಕಗಳು: ನೀವು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಬದಲಾಗಬಾರದು ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ಸಂಖ್ಯೆ ಲಿಟರಲ್‌ಗಳ ಸ್ಥಿರ ಗುಂಪನ್ನು ಬಯಸಿದಾಗ.
• ಕನಿಷ್ಠ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಔಟ್‌ಪುಟ್: ನೀವು ಬಂಡಲ್ ಗಾತ್ರದ ಬಗ್ಗೆ ಕಾಳಜಿ ವಹಿಸಿದರೆ ಮತ್ತು ನಿಮ್ಮ ಸ್ಥಿರಾಂಕಗಳಿಗೆ ಅತ್ಯಂತ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ರನ್‌ಟೈಮ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಬಯಸಿದರೆ.
• ವಸ್ತು-ರೀತಿಯ ರಚನೆ: ನೀವು ಕೀ-ಮೌಲ್ಯ ಜೋಡಿಗಳ ಓದುವಿಕೆಯನ್ನು ಬಯಸಿದಾಗ, ಡೇಟಾ ಅಥವಾ ಸಂರಚನೆಯನ್ನು ಹೇಗೆ ರಚಿಸಬಹುದು ಎಂಬುದನ್ನು ಹೋಲುತ್ತದೆ.
• ಸ್ಟ್ರಿಂಗ್-ಆಧಾರಿತ ಸೆಟ್‌ಗಳು: ವಿವರಣಾತ್ಮಕ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಂದ ಉತ್ತಮವಾಗಿ ಗುರುತಿಸಲ್ಪಟ್ಟಿರುವ ಸ್ಥಿತಿಗಳು, ವಿಧಗಳು ಅಥವಾ ವರ್ಗಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಇದು ಮುಖ್ಯವಾಗಿದೆ.

ಪರ್ಯಾಯ 2: ಯೂನಿಯನ್ ವಿಧಗಳು

ಯೂನಿಯನ್ ವಿಧಗಳು ವೇರಿಯೇಬಲ್ ಹಲವಾರು ಪ್ರಕಾರಗಳಲ್ಲಿ ಒಂದರ ಮೌಲ್ಯವನ್ನು ಹೊಂದಬಹುದು ಎಂದು ಘೋಷಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತದೆ. ಅಕ್ಷರಶಃ ಪ್ರಕಾರಗಳೊಂದಿಗೆ (ಸ್ಟ್ರಿಂಗ್, ಸಂಖ್ಯೆ, ಬೂಲಿಯನ್ ಲಿಟರಲ್‌ಗಳು) ಸಂಯೋಜಿಸಿದಾಗ, ಇದು ಸೆಟ್‌ಗಾಗಿ ಸ್ವತಃ ಸ್ಪಷ್ಟವಾದ ಸ್ಥಿರಾಂಕ ಘೋಷಣೆಯ ಅಗತ್ಯವಿಲ್ಲದೇ ಅನುಮತಿಸಲಾದ ಮೌಲ್ಯಗಳ ಗುಂಪನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಒಂದು ಪ್ರಬಲ ಮಾರ್ಗವನ್ನು ರೂಪಿಸುತ್ತದೆ.

ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳೊಂದಿಗೆ ಯೂನಿಯನ್ ವಿಧಗಳು

ನೀವು ನೇರವಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳ ಒಕ್ಕೂಟವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.

            type TrafficLightColor = "RED" | "YELLOW" | "GREEN";

let currentLight: TrafficLightColor = "YELLOW";
// currentLight = "BLUE"; // Error: Type '"BLUE"' is not assignable to type 'TrafficLightColor'.

function changeLight(color: TrafficLightColor) {
  console.log(`Changing light to: ${color}`);
}

changeLight("RED");
// changeLight("REDDY"); // Error

            

              
                Copy
              
            
          

ಇದು ಅನುಮತಿಸಲಾದ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳ ಗುಂಪನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅತ್ಯಂತ ನೇರವಾದ ಮತ್ತು ಹೆಚ್ಚಾಗಿ ಅತ್ಯಂತ ಸಂಕ್ಷಿಪ್ತ ಮಾರ್ಗವಾಗಿದೆ.

ಸಂಖ್ಯಾ ಲಿಟರಲ್‌ಗಳೊಂದಿಗೆ ಯೂನಿಯನ್ ವಿಧಗಳು

ಅಂತೆಯೇ, ನೀವು ಸಂಖ್ಯಾ ಲಿಟರಲ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

            type HttpStatusCode = 200 | 400 | 404 | 500;

let responseCode: HttpStatusCode = 404;
// responseCode = 201; // Error: Type '201' is not assignable to type 'HttpStatusCode'.

function handleResponse(code: HttpStatusCode) {
  if (code === 200) {
    console.log("Success!");
  } else {
    console.log(`Error code: ${code}`);
  }
}

handleResponse(500);

            

              
                Copy
              
            
          

ಯೂನಿಯನ್ ವಿಧಗಳನ್ನು ಯಾವಾಗ ಬಳಸುವುದು

• ಸರಳ, ನೇರ ಸೆಟ್‌ಗಳು: ಅನುಮತಿಸಲಾದ ಮೌಲ್ಯಗಳ ಸೆಟ್ ಚಿಕ್ಕದಾಗಿದ್ದಾಗ, ಸ್ಪಷ್ಟವಾಗಿದ್ದಾಗ ಮತ್ತು ಮೌಲ್ಯಗಳ ಹೊರತಾಗಿ ವಿವರಣಾತ್ಮಕ ಕೀಲಿಗಳ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ.
• ಅಂತರ್ಗತ ಸ್ಥಿರಾಂಕಗಳು: ಸೆಟ್‌ಗಾಗಿ ಹೆಸರಿಸಲಾದ ಸ್ಥಿರಾಂಕವನ್ನು ಉಲ್ಲೇಖಿಸುವ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ, ಆದರೆ ಬದಲಿಗೆ ನೇರವಾಗಿ ಅಕ್ಷರಶಃ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸಿ.
• ಗರಿಷ್ಠ ಸಂಕ್ಷಿಪ್ತತೆ: ಮೀಸಲಾದ ಆಬ್ಜೆಕ್ಟ್ ಅಥವಾ ಅರೇ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಅತಿಯಾಗಿ ತೋರುವ ನೇರ ಸನ್ನಿವೇಶಗಳಿಗಾಗಿ.
• ಕಾರ್ಯ ನಿಯತಾಂಕಗಳು/ರಿಟರ್ನ್ ವಿಧಗಳು: ಕಾರ್ಯಗಳಿಗಾಗಿ ಸ್ವೀಕಾರಾರ್ಹ ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ಸಂಖ್ಯೆ ಇನ್‌ಪುಟ್‌ಗಳು/ಔಟ್‌ಪುಟ್‌ಗಳ ನಿಖರವಾದ ಸೆಟ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅತ್ಯುತ್ತಮವಾಗಿದೆ.

ಎನಮ್‌ಗಳು, ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು ಮತ್ತು ಯೂನಿಯನ್ ವಿಧಗಳನ್ನು ಹೋಲಿಸುವುದು

ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸಗಳು ಮತ್ತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಸಾರಾಂಶಿಸೋಣ:

ರನ್‌ಟೈಮ್ ವರ್ತನೆ

• ಎನಮ್‌ಗಳು: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಸ್ತುಗಳನ್ನು ಉತ್ಪಾದಿಸಿ, ಸಂಭಾವ್ಯವಾಗಿ ರಿವರ್ಸ್ ಮ್ಯಾಪಿಂಗ್‌ಗಳೊಂದಿಗೆ.
• ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು (ಅರೇಗಳು/ವಸ್ತುಗಳು): ಸಾಮಾನ್ಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳು ಅಥವಾ ವಸ್ತುಗಳನ್ನು ಉತ್ಪಾದಿಸಿ. ಪ್ರಕಾರದ ಮಾಹಿತಿಯನ್ನು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಅಳಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಡೇಟಾ ರಚನೆಯು ಉಳಿದಿದೆ.
• ಯೂನಿಯನ್ ವಿಧಗಳು (ಲಿಟರಲ್‌ಗಳೊಂದಿಗೆ): ಯೂನಿಯನ್‌ಗಾಗಿ ಯಾವುದೇ ರನ್‌ಟೈಮ್ ಪ್ರಾತಿನಿಧ್ಯವಿಲ್ಲ. ಮೌಲ್ಯಗಳು ಕೇವಲ ಲಿಟರಲ್‌ಗಳಾಗಿವೆ. ಪ್ರಕಾರದ ಪರಿಶೀಲನೆಯು ಸಂಪೂರ್ಣವಾಗಿ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ನಡೆಯುತ್ತದೆ.

ಓದುವಿಕೆ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಶೀಲತೆ

• ಎನಮ್‌ಗಳು: ಹೆಚ್ಚಿನ ಓದುವಿಕೆ, ವಿಶೇಷವಾಗಿ ವಿವರಣಾತ್ಮಕ ಹೆಸರುಗಳೊಂದಿಗೆ. ಹೆಚ್ಚು ವಿವರವಾಗಿರಬಹುದು.
• ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು (ವಸ್ತುಗಳು): ಉತ್ತಮ ಓದುವಿಕೆ ಕೀ-ಮೌಲ್ಯ ಜೋಡಿಗಳ ಮೂಲಕ, ಸಂರಚನೆಗಳು ಅಥವಾ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಅನುಕರಿಸುವುದು.
• ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು (ಅರೇಗಳು): ಹೆಸರಿಸಲಾದ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಕಡಿಮೆ ಓದಬಹುದಾಗಿದೆ, ಮೌಲ್ಯಗಳ ಕ್ರಮಬದ್ಧ ಪಟ್ಟಿಗಾಗಿ ಹೆಚ್ಚು.
• ಯೂನಿಯನ್ ವಿಧಗಳು: ಬಹಳ ಸಂಕ್ಷಿಪ್ತ. ಓದುವಿಕೆಯು ಅಕ್ಷರಶಃ ಮೌಲ್ಯಗಳ ಸ್ಪಷ್ಟತೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.

ಟೈಪ್ ಸುರಕ್ಷತೆ

• ಎಲ್ಲಾ ಮೂರು ವಿಧಾನಗಳು ಪ್ರಬಲ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ನೀಡುತ್ತವೆ. ಅವು ವೇರಿಯೇಬಲ್‌ಗಳಿಗೆ ನಿಯೋಜಿಸಬಹುದಾದ ಅಥವಾ ಕಾರ್ಯಗಳಿಗೆ ರವಾನಿಸಬಹುದಾದ ಮಾನ್ಯವಾದ, ಪೂರ್ವನಿರ್ಧರಿತ ಮೌಲ್ಯಗಳನ್ನು ಮಾತ್ರ ಖಚಿತಪಡಿಸುತ್ತವೆ.

ಬಂಡಲ್ ಗಾತ್ರ

• ಎನಮ್‌ಗಳು: ಸಾಮಾನ್ಯವಾಗಿ ಉತ್ಪಾದಿತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಂದಾಗಿ ದೊಡ್ಡದಾಗಿದೆ.
• ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು: ಎನಮ್‌ಗಳಿಗಿಂತ ಚಿಕ್ಕದಾಗಿದೆ, ಏಕೆಂದರೆ ಅವು ಸಾಮಾನ್ಯ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆ.
• ಯೂನಿಯನ್ ವಿಧಗಳು: ಚಿಕ್ಕದಾಗಿದೆ, ಏಕೆಂದರೆ ಅವು ಪ್ರಕಾರಕ್ಕಾಗಿ ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ರನ್‌ಟೈಮ್ ಡೇಟಾ ರಚನೆಯನ್ನು ಉತ್ಪಾದಿಸುವುದಿಲ್ಲ, ಕೇವಲ ಅಕ್ಷರಶಃ ಮೌಲ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿವೆ.

ಬಳಕೆಯ ಪ್ರಕರಣಗಳ ಮ್ಯಾಟ್ರಿಕ್ಸ್

ಇಲ್ಲಿ ತ್ವರಿತ ಮಾರ್ಗದರ್ಶಿ ಇಲ್ಲಿದೆ:

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

ಉದಾಹರಣೆ 1: API ಸ್ಥಿತಿ ಕೋಡ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವುದು

ಎನಮ್:

            enum ApiStatus {
  Success = "SUCCESS",
  Error = "ERROR",
  Pending = "PENDING"
}

function handleApiResponse(status: ApiStatus) {
  // ... logic ...
}

            

              
                Copy
              
            
          

ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್ (ಆಬ್ಜೆಕ್ಟ್):

            
const apiStatusCodes = {
  SUCCESS: "SUCCESS",
  ERROR: "ERROR",
  PENDING: "PENDING"
} as const;

type ApiStatus = typeof apiStatusCodes[keyof typeof apiStatusCodes];

function handleApiResponse(status: ApiStatus) {
  // ... logic ...
}

            

              
                Copy
              
            
          

ಯೂನಿಯನ್ ವಿಧ:

            
type ApiStatus = "SUCCESS" | "ERROR" | "PENDING";

function handleApiResponse(status: ApiStatus) {
  // ... logic ...
}

            

              
                Copy
              
            
          

ಶಿಫಾರಸು: ಈ ಸನ್ನಿವೇಶಕ್ಕಾಗಿ, ಯೂನಿಯನ್ ವಿಧ ಹೆಚ್ಚಾಗಿ ಅತ್ಯಂತ ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ. ಅಕ್ಷರಶಃ ಮೌಲ್ಯಗಳು ಸಾಕಷ್ಟು ವಿವರಣಾತ್ಮಕವಾಗಿವೆ. ನೀವು ಪ್ರತಿ ಸ್ಥಿತಿಗೆ ಹೆಚ್ಚುವರಿ ಮೆಟಾಡೇಟಾವನ್ನು (ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಸಂದೇಶ) ಸಂಯೋಜಿಸಬೇಕಾದರೆ, ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್ ಆಬ್ಜೆಕ್ಟ್ ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ.

ಉದಾಹರಣೆ 2: ಬಳಕೆದಾರರ ಪಾತ್ರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ಎನಮ್:

            
enum UserRoleEnum {
  Admin = "ADMIN",
  Moderator = "MODERATOR",
  User = "USER"
}

function getUserPermissions(role: UserRoleEnum) {
  // ... logic ...
}

            

              
                Copy
              
            
          

ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್ (ಆಬ್ಜೆಕ್ಟ್):

            
const userRolesObject = {
  Admin: "ADMIN",
  Moderator: "MODERATOR",
  User: "USER"
} as const;

type UserRole = typeof userRolesObject[keyof typeof userRolesObject];

function getUserPermissions(role: UserRole) {
  // ... logic ...
}

            

              
                Copy
              
            
          

ಯೂನಿಯನ್ ವಿಧ:

            
type UserRole = "ADMIN" | "MODERATOR" | "USER";

function getUserPermissions(role: UserRole) {
  // ... logic ...
}

            

              
                Copy
              
            
          

ಶಿಫಾರಸು: ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್ ಆಬ್ಜೆಕ್ಟ್ ಇಲ್ಲಿ ಉತ್ತಮ ಸಮತೋಲನವನ್ನು ನೀಡುತ್ತದೆ. ಇದು ಸ್ಪಷ್ಟ ಕೀ-ಮೌಲ್ಯ ಜೋಡಿಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, userRolesObject.Admin) ಇದು ಪಾತ್ರಗಳನ್ನು ಉಲ್ಲೇಖಿಸುವಾಗ ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ಅದೇ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನೇರ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳು ಸಾಕಾಗಿದ್ದರೆ ಯೂನಿಯನ್ ಪ್ರಕಾರವು ಸಹ ಬಹಳ ಪ್ರಬಲ ಸ್ಪರ್ಧಿಯಾಗಿದೆ.

ಉದಾಹರಣೆ 3: ಸಂರಚನೆ ಆಯ್ಕೆಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವುದು

ವಿವಿಧ ಥೀಮ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಸಂರಚನೆ ವಸ್ತುವನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ.

ಎನಮ್:

            
enum Theme {
  Light = "light",
  Dark = "dark",
  System = "system"
}

interface AppConfig {
  theme: Theme;
  // ... other config options ...
}

            

              
                Copy
              
            
          

ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್ (ಆಬ್ಜೆಕ್ಟ್):

            
const themes = {
  Light: "light",
  Dark: "dark",
  System: "system"
} as const;

type Theme = typeof themes[keyof typeof themes];

interface AppConfig {
  theme: Theme;
  // ... other config options ...
}

            

              
                Copy
              
            
          

ಯೂನಿಯನ್ ವಿಧ:

            
type Theme = "light" | "dark" | "system";

interface AppConfig {
  theme: Theme;
  // ... other config options ...
}

            

              
                Copy
              
            
          

ಶಿಫಾರಸು: ಥೀಮ್‌ಗಳಂತಹ ಸಂರಚನೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳಿಗಾಗಿ, ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್ ಆಬ್ಜೆಕ್ಟ್ ಹೆಚ್ಚಾಗಿ ಆದರ್ಶವಾಗಿದೆ. ಇದು ಲಭ್ಯವಿರುವ ಆಯ್ಕೆಗಳನ್ನು ಮತ್ತು ಅವುಗಳ ಅನುಗುಣವಾದ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಕೀಲಿಗಳು (Light, Dark, System) ವಿವರಣಾತ್ಮಕವಾಗಿವೆ ಮತ್ತು ಮೌಲ್ಯಗಳಿಗೆ ನೇರವಾಗಿ ಮ್ಯಾಪ್ ಮಾಡುತ್ತವೆ, ಇದು ಸಂರಚನೆ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ತುಂಬಾ ಸುಲಭವಾಗಿಸುತ್ತದೆ.

ಕೆಲಸಕ್ಕಾಗಿ ಸರಿಯಾದ ಉಪಕರಣವನ್ನು ಆರಿಸುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಎನಮ್‌ಗಳು, ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್‌ಗಳು ಮತ್ತು ಯೂನಿಯನ್ ವಿಧಗಳ ನಡುವಿನ ನಿರ್ಧಾರವು ಯಾವಾಗಲೂ ಕಪ್ಪು ಮತ್ತು ಬಿಳಿ ಅಲ್ಲ. ಇದು ರನ್‌ಟೈಮ್ ಕಾರ್ಯಕ್ಷಮತೆ, ಬಂಡಲ್ ಗಾತ್ರ ಮತ್ತು ಕೋಡ್ ಓದುವಿಕೆ/ಅಭಿವ್ಯಕ್ತಿಶೀಲತೆ ನಡುವಿನ ವ್ಯಾಪಾರಕ್ಕೆ ಬರುತ್ತದೆ.

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

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

ಜಾಗತಿಕ ಪರಿಗಣನೆಗಳು

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

• ಸ್ಥಿರತೆ: ಆಯ್ದ ವಿಧಾನವನ್ನು ಲೆಕ್ಕಿಸದೆ, ನಿಮ್ಮ ಯೋಜನೆಯೊಳಗೆ ಸ್ಥಿರತೆಯು ಮುಖ್ಯವಾಗಿದೆ. ನೀವು ಪಾತ್ರಗಳಿಗಾಗಿ ಕಾನ್ಸ್‌ಟ್ ಅಸರ್ಷನ್ ವಸ್ತುಗಳನ್ನು ಬಳಸಲು ನಿರ್ಧರಿಸಿದರೆ, ಕೋಡ್‌ಬೇಸ್‌ನಾದ್ಯಂತ ಆ ಮಾದರಿಯನ್ನು ಅಂಟಿಕೊಳ್ಳಿ.
• ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n): ಅಂತರರಾಷ್ಟ್ರೀಯಗೊಳಿಸಬೇಕಾದ ಲೇಬಲ್‌ಗಳು ಅಥವಾ ಸಂದೇಶಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಾಗ, ಮಾನ್ಯವಾದ ಕೀಲಿಗಳು ಅಥವಾ ಗುರುತಿಸುವಿಕೆಗಳನ್ನು ಮಾತ್ರ ಬಳಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಟೈಪ್-ಸುರಕ್ಷಿತ ರಚನೆಗಳನ್ನು ಬಳಸಿ. ವಾಸ್ತವಿಕ ಅನುವಾದಿತ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು i18n ಲೈಬ್ರರಿಗಳ ಮೂಲಕ ಪ್ರತ್ಯೇಕವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು "PENDING", "PROCESSING", "COMPLETED" ಆಗಿರಬಹುದಾದ `status` ಕ್ಷೇತ್ರವನ್ನು ಹೊಂದಿದ್ದರೆ, ನಿಮ್ಮ i18n ಲೈಬ್ರರಿಯು ಈ ಆಂತರಿಕ ಗುರುತಿಸುವಿಕೆಗಳನ್ನು ಸ್ಥಳೀಕರಿಸಿದ ಪ್ರದರ್ಶನ ಪಠ್ಯಕ್ಕೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ.
• ಸಮಯ ವಲಯಗಳು ಮತ್ತು ಕರೆನ್ಸಿಗಳು: ಎನಮ್‌ಗಳಿಗೆ ನೇರವಾಗಿ ಸಂಬಂಧಿಸದಿದ್ದರೂ, ದಿನಾಂಕಗಳು, ಸಮಯ ಅಥವಾ ಕರೆನ್ಸಿಗಳಂತಹ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಸಿಸ್ಟಮ್ ಸರಿಯಾದ ಬಳಕೆಯನ್ನು ಜಾರಿಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಆದರೆ ನಿಖರವಾದ ಜಾಗತಿಕ ನಿರ್ವಹಣೆಗೆ ಬಾಹ್ಯ ಲೈಬ್ರರಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಅವಶ್ಯಕ. ಉದಾಹರಣೆಗೆ, `Currency` ಯೂನಿಯನ್ ವಿಧವನ್ನು `"USD" | "EUR" | "GBP"` ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಆದರೆ ವಾಸ್ತವಿಕ ಪರಿವರ್ತನೆ ತರ್ಕಕ್ಕೆ ವಿಶೇಷ ಪರಿಕರಗಳು ಬೇಕಾಗುತ್ತವೆ.

ತೀರ್ಮಾನ

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

ಈ ಪರ್ಯಾಯಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವುದರಿಂದ ಸಣ್ಣ ಬಂಡಲ್ ಗಾತ್ರಗಳು, ವೇಗವಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ನಿಮ್ಮ ಅಂತರರಾಷ್ಟ್ರೀಯ ತಂಡಕ್ಕೆ ಹೆಚ್ಚು ಊಹಿಸಬಹುದಾದ ಡೆವಲಪರ್ ಅನುಭವಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು.