ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಿಂಬಲ್ಸ್: ವಿಶಿಷ್ಟ ಪ್ರಾಪರ್ಟಿ ಕೀಗಳು ಮತ್ತು ಮೆಟಾಡೇಟಾ

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

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಿಂಬಲ್ಸ್ ಎಂದರೇನು?

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

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

ಸಿಂಬಲ್ಸ್ ರಚಿಸುವುದು

ನೀವು Symbol() ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಬಳಸಿ ಸಿಂಬಲ್ ಅನ್ನು ರಚಿಸುತ್ತೀರಿ. ನೀವು new Symbol() ಅನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯ; ಸಿಂಬಲ್ಸ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಲ್ಲ, ಆದರೆ ಪ್ರಿಮಿಟಿವ್ ಮೌಲ್ಯಗಳು.

ಮೂಲ ಸಿಂಬಲ್ ರಚನೆ

ಸಿಂಬಲ್ ರಚಿಸಲು ಸರಳವಾದ ಮಾರ್ಗವೆಂದರೆ:

const mySymbol = Symbol();
console.log(typeof mySymbol); // Output: symbol

Symbol() ಗೆ ಪ್ರತಿ ಕರೆಯು ಹೊಸ, ವಿಶಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ:

const symbol1 = Symbol();
const symbol2 = Symbol();
console.log(symbol1 === symbol2); // Output: false

ಸಿಂಬಲ್ ವಿವರಣೆಗಳು

ಸಿಂಬಲ್ ರಚಿಸುವಾಗ ನೀವು ಐಚ್ಛಿಕ ಸ್ಟ್ರಿಂಗ್ ವಿವರಣೆಯನ್ನು ಒದಗಿಸಬಹುದು. ಈ ವಿವರಣೆಯು ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ಲಾಗಿಂಗ್ ಮಾಡಲು ಉಪಯುಕ್ತವಾಗಿದೆ, ಆದರೆ ಇದು ಸಿಂಬಲ್‌ನ ವಿಶಿಷ್ಟತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.

const mySymbol = Symbol("myDescription");
console.log(mySymbol.toString()); // Output: Symbol(myDescription)

ವಿವರಣೆಯು ಸಂಪೂರ್ಣವಾಗಿ ಮಾಹಿತಿ ಉದ್ದೇಶಗಳಿಗಾಗಿ; ಒಂದೇ ವಿವರಣೆಯೊಂದಿಗೆ ಎರಡು ಸಿಂಬಲ್ಸ್ ಇನ್ನೂ ವಿಶಿಷ್ಟವಾಗಿರುತ್ತವೆ:

const symbolA = Symbol("same description");
const symbolB = Symbol("same description");
console.log(symbolA === symbolB); // Output: false

ಸಿಂಬಲ್ಸ್ ಅನ್ನು ಪ್ರಾಪರ್ಟಿ ಕೀಗಳಾಗಿ ಬಳಸುವುದು

ಸಿಂಬಲ್ಸ್ ವಿಶೇಷವಾಗಿ ಪ್ರಾಪರ್ಟಿ ಕೀಗಳಾಗಿ ಉಪಯುಕ್ತವಾಗಿವೆ ಏಕೆಂದರೆ ಅವು ವಿಶಿಷ್ಟತೆಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತವೆ, ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸೇರಿಸುವಾಗ ಹೆಸರಿನ ಘರ್ಷಣೆಗಳನ್ನು ತಡೆಯುತ್ತವೆ.

ಸಿಂಬಲ್ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸೇರಿಸುವುದು

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

const mySymbol = Symbol("myKey");
const myObject = {};

myObject[mySymbol] = "Hello, Symbol!";

console.log(myObject[mySymbol]); // Output: Hello, Symbol!

ಹೆಸರಿನ ಘರ್ಷಣೆಗಳನ್ನು ತಪ್ಪಿಸುವುದು

ನೀವು ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸೇರಿಸುವ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಲೈಬ್ರರಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೀರಿ ಎಂದು ಊಹಿಸಿ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಓವರ್‌ರೈಟ್ ಮಾಡುವ ಅಪಾಯವಿಲ್ಲದೆ ನಿಮ್ಮ ಸ್ವಂತ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸೇರಿಸಲು ನೀವು ಬಯಸಬಹುದು. ಸಿಂಬಲ್ಸ್ ಇದನ್ನು ಮಾಡಲು ಸುರಕ್ಷಿತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ:

// ಥರ್ಡ್-ಪಾರ್ಟಿ ಲೈಬ್ರರಿ (ಅನುಕರಿಸಲಾಗಿದೆ)
const libraryObject = {
  name: "Library Object",
  version: "1.0"
};

// ನಿಮ್ಮ ಕೋಡ್
const mySecretKey = Symbol("mySecret");
libraryObject[mySecretKey] = "Top Secret Information";

console.log(libraryObject.name); // Output: Library Object
console.log(libraryObject[mySecretKey]); // Output: Top Secret Information

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, mySecretKey ನಿಮ್ಮ ಪ್ರಾಪರ್ಟಿ libraryObject ನಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಯಾವುದೇ ಪ್ರಾಪರ್ಟಿಗಳೊಂದಿಗೆ ಸಂಘರ್ಷಿಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಸಿಂಬಲ್ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಎಣಿಕೆ ಮಾಡುವುದು

ಸಿಂಬಲ್ ಪ್ರಾಪರ್ಟಿಗಳ ಒಂದು ಪ್ರಮುಖ ಗುಣಲಕ್ಷಣವೆಂದರೆ ಅವು for...in ಲೂಪ್‌ಗಳು ಮತ್ತು Object.keys() ನಂತಹ ಪ್ರಮಾಣಿತ ಎಣಿಕೆಯ ವಿಧಾನಗಳಿಂದ ಮರೆಯಾಗಿರುತ್ತವೆ. ಇದು ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಸಮಗ್ರತೆಯನ್ನು ರಕ್ಷಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸಿಂಬಲ್ ಪ್ರಾಪರ್ಟಿಗಳ ಆಕಸ್ಮಿಕ ಪ್ರವೇಶ ಅಥವಾ ಮಾರ್ಪಾಡನ್ನು ತಡೆಯುತ್ತದೆ.

const mySymbol = Symbol("myKey");
const myObject = {
  name: "My Object",
  [mySymbol]: "Symbol Value"
};

console.log(Object.keys(myObject)); // Output: ["name"]

for (let key in myObject) {
  console.log(key); // Output: name
}

ಸಿಂಬಲ್ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಪ್ರವೇಶಿಸಲು, ನೀವು Object.getOwnPropertySymbols() ಅನ್ನು ಬಳಸಬೇಕು, ಇದು ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಸಿಂಬಲ್ ಪ್ರಾಪರ್ಟಿಗಳ ಅರೇಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ:

const mySymbol = Symbol("myKey");
const myObject = {
  name: "My Object",
  [mySymbol]: "Symbol Value"
};

const symbolKeys = Object.getOwnPropertySymbols(myObject);
console.log(symbolKeys); // Output: [Symbol(myKey)]
console.log(myObject[symbolKeys[0]]); // Output: Symbol Value

ಪ್ರಸಿದ್ಧ ಸಿಂಬಲ್ಸ್ (Well-Known Symbols)

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಸಿದ್ಧ ಸಿಂಬಲ್ಸ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಅಂತರ್ನಿರ್ಮಿತ ಸಿಂಬಲ್ಸ್‌ನ ಒಂದು ಸೆಟ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ನಿರ್ದಿಷ್ಟ ನಡವಳಿಕೆಗಳು ಅಥವಾ ಕಾರ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಈ ಸಿಂಬಲ್ಸ್ Symbol ಕನ್ಸ್ಟ್ರಕ್ಟರ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳಾಗಿವೆ (ಉದಾ., Symbol.iterator, Symbol.toStringTag). ಅವು ವಿವಿಧ ಸಂದರ್ಭಗಳಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಹೇಗೆ ವರ್ತಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ.

Symbol.iterator

Symbol.iterator ಎನ್ನುವುದು ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ಗಾಗಿ ಡೀಫಾಲ್ಟ್ ಇಟರೇಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಸಿಂಬಲ್ ಆಗಿದೆ. ಒಂದು ಆಬ್ಜೆಕ್ಟ್ Symbol.iterator ಕೀಲಿಯೊಂದಿಗೆ ಮೆಥೆಡ್ ಹೊಂದಿದಾಗ, ಅದು ಇಟರೇಬಲ್ ಆಗುತ್ತದೆ, ಅಂದರೆ ನೀವು ಅದನ್ನು for...of ಲೂಪ್‌ಗಳು ಮತ್ತು ಸ್ಪ್ರೆಡ್ ಆಪರೇಟರ್ (...) ನೊಂದಿಗೆ ಬಳಸಬಹುದು.

ಉದಾಹರಣೆ: ಕಸ್ಟಮ್ ಇಟರೇಬಲ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುವುದು

const myCollection = {
  items: [1, 2, 3, 4, 5],
  [Symbol.iterator]: function* () {
    for (let item of this.items) {
      yield item;
    }
  }
};

for (let item of myCollection) {
  console.log(item); // Output: 1, 2, 3, 4, 5
}

console.log([...myCollection]); // Output: [1, 2, 3, 4, 5]

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, myCollection ಎನ್ನುವುದು Symbol.iterator ಬಳಸಿ ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ. ಜನರೇಟರ್ ಫಂಕ್ಷನ್ items ಅರೇಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಐಟಂ ಅನ್ನು ನೀಡುತ್ತದೆ, ಇದರಿಂದ myCollection ಇಟರೇಬಲ್ ಆಗುತ್ತದೆ.

Symbol.toStringTag

Symbol.toStringTag ಎನ್ನುವುದು Object.prototype.toString() ಅನ್ನು ಕರೆದಾಗ ಆಬ್ಜೆಕ್ಟ್‌ನ ಸ್ಟ್ರಿಂಗ್ ನಿರೂಪಣೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಸಿಂಬಲ್ ಆಗಿದೆ.

ಉದಾಹರಣೆ: toString() ನಿರೂಪಣೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುವುದು

class MyClass {
  get [Symbol.toStringTag]() {
    return 'MyClassInstance';
  }
}

const instance = new MyClass();
console.log(Object.prototype.toString.call(instance)); // Output: [object MyClassInstance]

Symbol.toStringTag ಇಲ್ಲದಿದ್ದರೆ, ಔಟ್‌ಪುಟ್ [object Object] ಆಗಿರುತ್ತಿತ್ತು. ಈ ಸಿಂಬಲ್ ನಿಮ್ಮ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ವಿವರಣಾತ್ಮಕ ಸ್ಟ್ರಿಂಗ್ ನಿರೂಪಣೆಯನ್ನು ನೀಡಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

Symbol.hasInstance

Symbol.hasInstance ಎನ್ನುವುದು instanceof ಆಪರೇಟರ್‌ನ ನಡವಳಿಕೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಸಿಂಬಲ್ ಆಗಿದೆ. ಸಾಮಾನ್ಯವಾಗಿ, instanceof ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್‌ನಲ್ಲಿ ಕನ್ಸ್ಟ್ರಕ್ಟರ್‌ನ prototype ಪ್ರಾಪರ್ಟಿ ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. Symbol.hasInstance ಈ ನಡವಳಿಕೆಯನ್ನು ಅತಿಕ್ರಮಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: instanceof ಪರಿಶೀಲನೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುವುದು

class MyClass {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}

console.log([] instanceof MyClass); // Output: true
console.log({} instanceof MyClass); // Output: false

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, Symbol.hasInstance ಮೆಥೆಡ್ ಇನ್‌ಸ್ಟಾನ್ಸ್ ಒಂದು ಅರೇ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇದು ನಿಜವಾದ ಪ್ರೊಟೊಟೈಪ್ ಚೈನ್ ಅನ್ನು ಲೆಕ್ಕಿಸದೆ, MyClass ಅನ್ನು ಅರೇಗಳಿಗಾಗಿ ಪರಿಶೀಲನೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವಂತೆ ಮಾಡುತ್ತದೆ.

ಇತರ ಪ್ರಸಿದ್ಧ ಸಿಂಬಲ್ಸ್

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇನ್ನೂ ಹಲವಾರು ಪ್ರಸಿದ್ಧ ಸಿಂಬಲ್ಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ:

• Symbol.toPrimitive: ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಪ್ರಿಮಿಟಿವ್ ಮೌಲ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಿದಾಗ (ಉದಾ., ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಮಯದಲ್ಲಿ) ಅದರ ನಡವಳಿಕೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
• Symbol.unscopables: with ಹೇಳಿಕೆಗಳಿಂದ ಹೊರಗಿಡಬೇಕಾದ ಪ್ರಾಪರ್ಟಿ ಹೆಸರುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. (with ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ನಿರುತ್ಸಾಹಗೊಳಿಸಲಾಗುತ್ತದೆ).
• Symbol.match, Symbol.replace, Symbol.search, Symbol.split: String.prototype.match(), String.prototype.replace() ನಂತಹ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಮೆಥೆಡ್‌ಗಳೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಹೇಗೆ ವರ್ತಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಗ್ಲೋಬಲ್ ಸಿಂಬಲ್ ರಿಜಿಸ್ಟ್ರಿ

ಕೆಲವೊಮ್ಮೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿವಿಧ ಭಾಗಗಳಲ್ಲಿ ಅಥವಾ ವಿಭಿನ್ನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ನಡುವೆ ಸಿಂಬಲ್ಸ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿರುತ್ತದೆ. ಗ್ಲೋಬಲ್ ಸಿಂಬಲ್ ರಿಜಿಸ್ಟ್ರಿ ಕೀ ಮೂಲಕ ಸಿಂಬಲ್ಸ್ ಅನ್ನು ನೋಂದಾಯಿಸಲು ಮತ್ತು ಹಿಂಪಡೆಯಲು ಒಂದು ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

Symbol.for(key)

Symbol.for(key) ಮೆಥೆಡ್ ನೀಡಿದ ಕೀಲಿಯೊಂದಿಗೆ ಗ್ಲೋಬಲ್ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ಸಿಂಬಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ, ಅದು ಆ ಸಿಂಬಲ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಅದು ಕೀಲಿಯೊಂದಿಗೆ ಹೊಸ ಸಿಂಬಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ನೋಂದಾಯಿಸುತ್ತದೆ.

const globalSymbol1 = Symbol.for("myGlobalSymbol");
const globalSymbol2 = Symbol.for("myGlobalSymbol");

console.log(globalSymbol1 === globalSymbol2); // Output: true
console.log(Symbol.keyFor(globalSymbol1)); // Output: myGlobalSymbol

Symbol.keyFor(symbol)

Symbol.keyFor(symbol) ಮೆಥೆಡ್ ಗ್ಲೋಬಲ್ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿನ ಸಿಂಬಲ್‌ನೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಕೀಲಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸಿಂಬಲ್ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ, ಅದು undefined ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

const mySymbol = Symbol("localSymbol");
console.log(Symbol.keyFor(mySymbol)); // Output: undefined

const globalSymbol = Symbol.for("myGlobalSymbol");
console.log(Symbol.keyFor(globalSymbol)); // Output: myGlobalSymbol

ಪ್ರಮುಖ: Symbol() ನೊಂದಿಗೆ ರಚಿಸಲಾದ ಸಿಂಬಲ್ಸ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಗ್ಲೋಬಲ್ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ನೋಂದಾಯಿಸಲ್ಪಡುವುದಿಲ್ಲ. Symbol.for() ನೊಂದಿಗೆ ರಚಿಸಲಾದ (ಅಥವಾ ಹಿಂಪಡೆಯಲಾದ) ಸಿಂಬಲ್ಸ್ ಮಾತ್ರ ರಿಜಿಸ್ಟ್ರಿಯ ಭಾಗವಾಗಿರುತ್ತವೆ.

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

ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಸಿಂಬಲ್ಸ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುವ ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

1. ಪ್ಲಗಿನ್ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ರಚಿಸುವುದು

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

// ಕೋರ್ ಆಬ್ಜೆಕ್ಟ್
const coreObject = {
  name: "Core Object",
  version: "1.0"
};

// ಪ್ಲಗಿನ್ 1
const plugin1Key = Symbol("plugin1");
coreObject[plugin1Key] = {
  description: "ಪ್ಲಗಿನ್ 1 ಹೆಚ್ಚುವರಿ ಕಾರ್ಯವನ್ನು ಸೇರಿಸುತ್ತದೆ",
  activate: function() {
    console.log("Plugin 1 activated");
  }
};

// ಪ್ಲಗಿನ್ 2
const plugin2Key = Symbol("plugin2");
coreObject[plugin2Key] = {
  author: "Another Developer",
  init: function() {
    console.log("Plugin 2 initialized");
  }
};

// ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು
console.log(coreObject[plugin1Key].description); // Output: ಪ್ಲಗಿನ್ 1 ಹೆಚ್ಚುವರಿ ಕಾರ್ಯವನ್ನು ಸೇರಿಸುತ್ತದೆ
coreObject[plugin2Key].init(); // Output: Plugin 2 initialized

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

2. DOM ಎಲಿಮೆಂಟ್‌ಗಳಿಗೆ ಮೆಟಾಡೇಟಾ ಸೇರಿಸುವುದು

DOM ಎಲಿಮೆಂಟ್‌ಗಳಿಗೆ ಅವುಗಳ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಗುಣಲಕ್ಷಣಗಳು ಅಥವಾ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ ಅಡ್ಡಿಯಾಗದಂತೆ ಮೆಟಾಡೇಟಾವನ್ನು ಲಗತ್ತಿಸಲು ಸಿಂಬಲ್ಸ್ ಅನ್ನು ಬಳಸಬಹುದು.

const element = document.createElement("div");

const dataKey = Symbol("elementData");
element[dataKey] = {
  type: "widget",
  config: {},
  timestamp: Date.now()
};

// ಮೆಟಾಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸುವುದು
console.log(element[dataKey].type); // Output: widget

ಈ ವಿಧಾನವು ಮೆಟಾಡೇಟಾವನ್ನು ಎಲಿಮೆಂಟ್‌ನ ಪ್ರಮಾಣಿತ ಗುಣಲಕ್ಷಣಗಳಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿರಿಸುತ್ತದೆ, ನಿರ್ವಹಣೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಮತ್ತು CSS ಅಥವಾ ಇತರ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ನೊಂದಿಗೆ ಸಂಭಾವ್ಯ ಸಂಘರ್ಷಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

3. ಪ್ರೈವೇಟ್ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

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

class MyClass {
  #privateSymbol = Symbol("privateData"); // ಗಮನಿಸಿ: ಈ '#' ಸಿಂಟ್ಯಾಕ್ಸ್ ES2020 ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ *ನಿಜವಾದ* ಪ್ರೈವೇಟ್ ಫೀಲ್ಡ್ ಆಗಿದೆ, ಉದಾಹರಣೆಗಿಂತ ಭಿನ್ನವಾಗಿದೆ

  constructor(data) {
    this[this.#privateSymbol] = data;
  }

  getData() {
    return this[this.#privateSymbol];
  }
}

const myInstance = new MyClass("Sensitive Information");
console.log(myInstance.getData()); // Output: Sensitive Information

// "ಪ್ರೈವೇಟ್" ಪ್ರಾಪರ್ಟಿಯನ್ನು ಪ್ರವೇಶಿಸುವುದು (ಕಷ್ಟ, ಆದರೆ ಸಾಧ್ಯ)
const symbolKeys = Object.getOwnPropertySymbols(myInstance);
console.log(myInstance[symbolKeys[0]]); // Output: Sensitive Information

Object.getOwnPropertySymbols() ಇನ್ನೂ ಸಿಂಬಲ್ ಅನ್ನು ಬಹಿರಂಗಪಡಿಸಬಹುದಾದರೂ, ಇದು ಬಾಹ್ಯ ಕೋಡ್ ಆಕಸ್ಮಿಕವಾಗಿ "ಪ್ರೈವೇಟ್" ಪ್ರಾಪರ್ಟಿಯನ್ನು ಪ್ರವೇಶಿಸುವ ಅಥವಾ ಮಾರ್ಪಡಿಸುವ ಸಾಧ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಗಮನಿಸಿ: ನಿಜವಾದ ಪ್ರೈವೇಟ್ ಫೀಲ್ಡ್‌ಗಳು (`#` ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಬಳಸಿ) ಈಗ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಲಭ್ಯವಿವೆ ಮತ್ತು ಬಲವಾದ ಗೌಪ್ಯತೆ ಖಾತರಿಗಳನ್ನು ನೀಡುತ್ತವೆ.

ಸಿಂಬಲ್ಸ್ ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಸಿಂಬಲ್ಸ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ನೆನಪಿನಲ್ಲಿಡಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಇಲ್ಲಿವೆ:

• ವಿವರಣಾತ್ಮಕ ಸಿಂಬಲ್ ವಿವರಣೆಗಳನ್ನು ಬಳಸಿ: ಅರ್ಥಪೂರ್ಣ ವಿವರಣೆಗಳನ್ನು ಒದಗಿಸುವುದು ಡೀಬಗ್ ಮಾಡುವುದನ್ನು ಮತ್ತು ಲಾಗಿಂಗ್ ಮಾಡುವುದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
• ಗ್ಲೋಬಲ್ ಸಿಂಬಲ್ ರಿಜಿಸ್ಟ್ರಿಯನ್ನು ಪರಿಗಣಿಸಿ: ನೀವು ವಿವಿಧ ಮಾಡ್ಯೂಲ್‌ಗಳು ಅಥವಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಾದ್ಯಂತ ಸಿಂಬಲ್ಸ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳಬೇಕಾದಾಗ Symbol.for() ಅನ್ನು ಬಳಸಿ.
• ಎಣಿಕೆಯ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ: ಸಿಂಬಲ್ ಪ್ರಾಪರ್ಟಿಗಳು ಡೀಫಾಲ್ಟ್ ಆಗಿ ಎಣಿಸಲ್ಪಡುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ, ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ರವೇಶಿಸಲು Object.getOwnPropertySymbols() ಅನ್ನು ಬಳಸಿ.
• ಮೆಟಾಡೇಟಾಗಾಗಿ ಸಿಂಬಲ್ಸ್ ಬಳಸಿ: ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಅವುಗಳ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ ಅಡ್ಡಿಯಾಗದಂತೆ ಮೆಟಾಡೇಟಾವನ್ನು ಲಗತ್ತಿಸಲು ಸಿಂಬಲ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಿ.
• ಬಲವಾದ ಗೌಪ್ಯತೆ ಅಗತ್ಯವಿದ್ದಾಗ ನಿಜವಾದ ಪ್ರೈವೇಟ್ ಫೀಲ್ಡ್‌ಗಳನ್ನು ಪರಿಗಣಿಸಿ: ನಿಮಗೆ ನಿಜವಾದ ಗೌಪ್ಯತೆ ಅಗತ್ಯವಿದ್ದರೆ, ಪ್ರೈವೇಟ್ ಕ್ಲಾಸ್ ಫೀಲ್ಡ್‌ಗಳಿಗಾಗಿ `#` ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಬಳಸಿ (ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಲಭ್ಯವಿದೆ).

ತೀರ್ಮಾನ

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