ജാവാസ്ക്രിപ്റ്റ് സിംബലുകൾ: തനതായ പ്രോപ്പർട്ടി കീകളും മെറ്റാഡാറ്റയും

ജാവാസ്ക്രിപ്റ്റ് സിംബലുകൾ, ECMAScript 2015 (ES6)-ൽ അവതരിപ്പിച്ചത്, തനതായതും മാറ്റാനാവാത്തതുമായ പ്രോപ്പർട്ടി കീകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു സംവിധാനം നൽകുന്നു. സ്ട്രിംഗുകളിൽ നിന്നും നമ്പറുകളിൽ നിന്നും വ്യത്യസ്തമായി, സിംബലുകൾ നിങ്ങളുടെ മുഴുവൻ ജാവാസ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനിലും തികച്ചും സവിശേഷമാണെന്ന് ഉറപ്പുനൽകുന്നു. പേരുകളിലെ വൈരുദ്ധ്യങ്ങൾ ഒഴിവാക്കാനും, നിലവിലുള്ള പ്രോപ്പർട്ടികളിൽ ഇടപെടാതെ ഒബ്ജക്റ്റുകളിലേക്ക് മെറ്റാഡാറ്റ ചേർക്കാനും, ഒബ്ജക്റ്റിന്റെ സ്വഭാവം ഇഷ്ടാനുസൃതമാക്കാനും അവ ഒരു മാർഗ്ഗം നൽകുന്നു. ഈ ലേഖനം ജാവാസ്ക്രിപ്റ്റ് സിംബലുകളുടെ നിർമ്മാണം, ഉപയോഗങ്ങൾ, മികച്ച രീതികൾ എന്നിവയെക്കുറിച്ച് വിശദമായ ഒരു അവലോകനം നൽകുന്നു.

എന്താണ് ജാവാസ്ക്രിപ്റ്റ് സിംബലുകൾ?

ജാവാസ്ക്രിപ്റ്റിലെ ഒരു പ്രിമിറ്റീവ് ഡാറ്റാ ടൈപ്പാണ് സിംബൽ; നമ്പറുകൾ, സ്ട്രിംഗുകൾ, ബൂളിയനുകൾ, null, undefined എന്നിവ പോലെ. എന്നിരുന്നാലും, മറ്റ് പ്രിമിറ്റീവ് ടൈപ്പുകളിൽ നിന്ന് വ്യത്യസ്തമായി, സിംബലുകൾ സവിശേഷമാണ്. ഓരോ തവണയും നിങ്ങൾ ഒരു സിംബൽ സൃഷ്ടിക്കുമ്പോൾ, നിങ്ങൾക്ക് തികച്ചും പുതിയതും സവിശേഷവുമായ ഒരു മൂല്യം ലഭിക്കുന്നു. ഈ പ്രത്യേകത സിംബലുകളെ ഇനിപ്പറയുന്നവയ്ക്ക് അനുയോജ്യമാക്കുന്നു:

• തനതായ പ്രോപ്പർട്ടി കീകൾ സൃഷ്ടിക്കുന്നു: സിംബലുകൾ പ്രോപ്പർട്ടി കീകളായി ഉപയോഗിക്കുന്നത് നിങ്ങളുടെ പ്രോപ്പർട്ടികൾ നിലവിലുള്ളവയുമായോ മറ്റ് ലൈബ്രറികൾ ചേർത്തവയുമായോ വൈരുദ്ധ്യത്തിലാകില്ലെന്ന് ഉറപ്പാക്കുന്നു.
• മെറ്റാഡാറ്റ സംഭരിക്കുന്നു: ഒബ്ജക്റ്റിന്റെ ഘടനയെ ബാധിക്കാതെ, സാധാരണ എന്യൂമറേഷൻ രീതികളിൽ നിന്ന് മറഞ്ഞിരിക്കുന്ന രീതിയിൽ മെറ്റാഡാറ്റ ചേർക്കാൻ സിംബലുകൾ ഉപയോഗിക്കാം.
• ഒബ്ജക്റ്റിന്റെ സ്വഭാവം ഇഷ്ടാനുസൃതമാക്കുന്നു: ജാവാസ്ക്രിപ്റ്റ് വെൽ-നോൺ സിംബലുകളുടെ ഒരു കൂട്ടം നൽകുന്നു, ഇത് ഇറ്ററേറ്റ് ചെയ്യുമ്പോഴോ സ്ട്രിംഗായി മാറ്റുമ്പോഴോ പോലുള്ള ചില സാഹചര്യങ്ങളിൽ ഒബ്ജക്റ്റുകൾ എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് ഇഷ്ടാനുസൃതമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

സിംബലുകൾ നിർമ്മിക്കുന്നു

Symbol() കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ചാണ് നിങ്ങൾ ഒരു സിംബൽ നിർമ്മിക്കുന്നത്. നിങ്ങൾക്ക് new Symbol() ഉപയോഗിക്കാൻ കഴിയില്ല എന്നത് ശ്രദ്ധിക്കേണ്ടത് പ്രധാനമാണ്; സിംബലുകൾ ഒബ്ജക്റ്റുകളല്ല, മറിച്ച് പ്രിമിറ്റീവ് മൂല്യങ്ങളാണ്.

അടിസ്ഥാന സിംബൽ നിർമ്മാണം

ഒരു സിംബൽ നിർമ്മിക്കാനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗം ഇതാണ്:

const mySymbol = Symbol();
console.log(typeof mySymbol); // ഔട്ട്പുട്ട്: symbol

Symbol()-ന്റെ ഓരോ വിളിയും പുതിയതും സവിശേഷവുമായ ഒരു മൂല്യം സൃഷ്ടിക്കുന്നു:

const symbol1 = Symbol();
const symbol2 = Symbol();
console.log(symbol1 === symbol2); // ഔട്ട്പുട്ട്: false

സിംബൽ വിവരണങ്ങൾ

ഒരു സിംബൽ നിർമ്മിക്കുമ്പോൾ നിങ്ങൾക്ക് ഒരു ഓപ്ഷണൽ സ്ട്രിംഗ് വിവരണം നൽകാം. ഈ വിവരണം ഡീബഗ്ഗിംഗിനും ലോഗിംഗിനും ഉപയോഗപ്രദമാണ്, പക്ഷേ ഇത് സിംബലിന്റെ പ്രത്യേകതയെ ബാധിക്കില്ല.

const mySymbol = Symbol("myDescription");
console.log(mySymbol.toString()); // ഔട്ട്പുട്ട്: Symbol(myDescription)

വിവരണം പൂർണ്ണമായും വിവര ആവശ്യങ്ങൾക്ക് മാത്രമുള്ളതാണ്; ഒരേ വിവരണമുള്ള രണ്ട് സിംബലുകൾ ഇപ്പോഴും സവിശേഷമായിരിക്കും:

const symbolA = Symbol("same description");
const symbolB = Symbol("same description");
console.log(symbolA === symbolB); // ഔട്ട്പുട്ട്: false

സിംബലുകൾ പ്രോപ്പർട്ടി കീകളായി ഉപയോഗിക്കുന്നു

പ്രോപ്പർട്ടി കീകളായി സിംബലുകൾ വളരെ ഉപയോഗപ്രദമാണ്, കാരണം അവ തനിമ ഉറപ്പ് നൽകുന്നു, ഒബ്ജക്റ്റുകളിലേക്ക് പ്രോപ്പർട്ടികൾ ചേർക്കുമ്പോൾ പേരുകളിലെ വൈരുദ്ധ്യങ്ങൾ തടയുന്നു.

സിംബൽ പ്രോപ്പർട്ടികൾ ചേർക്കുന്നു

സ്ട്രിംഗുകളോ നമ്പറുകളോ പോലെ നിങ്ങൾക്ക് സിംബലുകളും പ്രോപ്പർട്ടി കീകളായി ഉപയോഗിക്കാം:

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

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

console.log(myObject[mySymbol]); // ഔട്ട്പുട്ട്: Hello, Symbol!

പേരുകളിലെ വൈരുദ്ധ്യങ്ങൾ ഒഴിവാക്കുന്നു

നിങ്ങൾ ഒരു തേർഡ്-പാർട്ടി ലൈബ്രറിയുമായി പ്രവർത്തിക്കുകയാണെന്ന് കരുതുക, അത് ഒബ്ജക്റ്റുകളിലേക്ക് പ്രോപ്പർട്ടികൾ ചേർക്കുന്നു. നിലവിലുള്ളവയെ മാറ്റിയെഴുതാതെ നിങ്ങളുടെ സ്വന്തം പ്രോപ്പർട്ടികൾ ചേർക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഇത് സുരക്ഷിതമായി ചെയ്യാൻ സിംബലുകൾ ഒരു മാർഗ്ഗം നൽകുന്നു:

// തേർഡ്-പാർട്ടി ലൈബ്രറി (അനുകരിച്ചത്)
const libraryObject = {
  name: "Library Object",
  version: "1.0"
};

// നിങ്ങളുടെ കോഡ്
const mySecretKey = Symbol("mySecret");
libraryObject[mySecretKey] = "Top Secret Information";

console.log(libraryObject.name); // ഔട്ട്പുട്ട്: Library Object
console.log(libraryObject[mySecretKey]); // ഔട്ട്പുട്ട്: 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)); // ഔട്ട്പുട്ട്: ["name"]

for (let key in myObject) {
  console.log(key); // ഔട്ട്പുട്ട്: name
}

സിംബൽ പ്രോപ്പർട്ടികൾ ആക്സസ് ചെയ്യാൻ, നിങ്ങൾ Object.getOwnPropertySymbols() ഉപയോഗിക്കേണ്ടതുണ്ട്, ഇത് ഒരു ഒബ്ജക്റ്റിലെ എല്ലാ സിംബൽ പ്രോപ്പർട്ടികളുടെയും ഒരു അറേ നൽകുന്നു:

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

const symbolKeys = Object.getOwnPropertySymbols(myObject);
console.log(symbolKeys); // ഔട്ട്പുട്ട്: [Symbol(myKey)]
console.log(myObject[symbolKeys[0]]); // ഔട്ട്പുട്ട്: 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); // ഔട്ട്പുട്ട്: 1, 2, 3, 4, 5
}

console.log([...myCollection]); // ഔട്ട്പുട്ട്: [1, 2, 3, 4, 5]

ഈ ഉദാഹരണത്തിൽ, myCollection എന്നത് Symbol.iterator ഉപയോഗിച്ച് ഇറ്ററേറ്റർ പ്രോട്ടോക്കോൾ നടപ്പിലാക്കുന്ന ഒരു ഒബ്ജക്റ്റാണ്. ജനറേറ്റർ ഫംഗ്ഷൻ items അറേയിലെ ഓരോ ഐറ്റവും നൽകുന്നു, ഇത് myCollection-നെ ഇറ്ററബിൾ ആക്കുന്നു.

Symbol.toStringTag

Object.prototype.toString() വിളിക്കുമ്പോൾ ഒരു ഒബ്ജക്റ്റിന്റെ സ്ട്രിംഗ് റെപ്രസെന്റേഷൻ ഇഷ്ടാനുസൃതമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു സിംബലാണ് Symbol.toStringTag.

ഉദാഹരണം: toString() റെപ്രസെന്റേഷൻ ഇഷ്ടാനുസൃതമാക്കുന്നു

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

const instance = new MyClass();
console.log(Object.prototype.toString.call(instance)); // ഔട്ട്പുട്ട്: [object MyClassInstance]

Symbol.toStringTag ഇല്ലെങ്കിൽ, ഔട്ട്പുട്ട് [object Object] ആയിരിക്കും. ഈ സിംബൽ നിങ്ങളുടെ ഒബ്ജക്റ്റുകൾക്ക് കൂടുതൽ വിവരണാത്മകമായ സ്ട്രിംഗ് റെപ്രസെന്റേഷൻ നൽകാൻ ഒരു മാർഗ്ഗം നൽകുന്നു.

Symbol.hasInstance

instanceof ഓപ്പറേറ്ററിന്റെ സ്വഭാവം ഇഷ്ടാനുസൃതമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു സിംബലാണ് Symbol.hasInstance. സാധാരണയായി, instanceof ഒരു ഒബ്ജക്റ്റിന്റെ പ്രോട്ടോടൈപ്പ് ചെയിനിൽ ഒരു കൺസ്ട്രക്റ്ററിന്റെ prototype പ്രോപ്പർട്ടി അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്നു. ഈ സ്വഭാവം മാറ്റിയെഴുതാൻ Symbol.hasInstance നിങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണം: instanceof പരിശോധന ഇഷ്ടാനുസൃതമാക്കുന്നു

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

console.log([] instanceof MyClass); // ഔട്ട്പുട്ട്: true
console.log({} instanceof MyClass); // ഔട്ട്പുട്ട്: 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); // ഔട്ട്പുട്ട്: true
console.log(Symbol.keyFor(globalSymbol1)); // ഔട്ട്പുട്ട്: myGlobalSymbol

Symbol.keyFor(symbol)

Symbol.keyFor(symbol) മെത്തേഡ് ഗ്ലോബൽ രജിസ്ട്രിയിലെ ഒരു സിംബലുമായി ബന്ധപ്പെട്ട കീ തിരികെ നൽകുന്നു. സിംബൽ രജിസ്ട്രിയിൽ ഇല്ലെങ്കിൽ, അത് undefined തിരികെ നൽകുന്നു.

const mySymbol = Symbol("localSymbol");
console.log(Symbol.keyFor(mySymbol)); // ഔട്ട്പുട്ട്: undefined

const globalSymbol = Symbol.for("myGlobalSymbol");
console.log(Symbol.keyFor(globalSymbol)); // ഔട്ട്പുട്ട്: myGlobalSymbol

പ്രധാനപ്പെട്ടത്: Symbol() ഉപയോഗിച്ച് നിർമ്മിച്ച സിംബലുകൾ ഗ്ലോബൽ രജിസ്ട്രിയിൽ സ്വയമേവ രജിസ്റ്റർ ചെയ്യപ്പെടുന്നില്ല. Symbol.for() ഉപയോഗിച്ച് നിർമ്മിച്ച (അല്ലെങ്കിൽ വീണ്ടെടുത്ത) സിംബലുകൾ മാത്രമേ രജിസ്ട്രിയുടെ ഭാഗമാകൂ.

പ്രായോഗിക ഉദാഹരണങ്ങളും ഉപയോഗങ്ങളും

യഥാർത്ഥ സാഹചര്യങ്ങളിൽ സിംബലുകൾ എങ്ങനെ ഉപയോഗിക്കാം എന്ന് കാണിക്കുന്ന ചില പ്രായോഗിക ഉദാഹരണങ്ങൾ ഇതാ:

1. പ്ലഗിൻ സിസ്റ്റങ്ങൾ നിർമ്മിക്കുന്നു

വിവിധ മൊഡ്യൂളുകൾക്ക് പരസ്പരം പ്രോപ്പർട്ടികളുമായി വൈരുദ്ധ്യമില്ലാതെ ഒരു കോർ ഒബ്ജക്റ്റിന്റെ പ്രവർത്തനം വികസിപ്പിക്കാൻ കഴിയുന്ന പ്ലഗിൻ സിസ്റ്റങ്ങൾ നിർമ്മിക്കാൻ സിംബലുകൾ ഉപയോഗിക്കാം.

// കോർ ഒബ്ജക്റ്റ്
const coreObject = {
  name: "Core Object",
  version: "1.0"
};

// പ്ലഗിൻ 1
const plugin1Key = Symbol("plugin1");
coreObject[plugin1Key] = {
  description: "Plugin 1 adds extra functionality",
  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); // ഔട്ട്പുട്ട്: Plugin 1 adds extra functionality
coreObject[plugin2Key].init(); // ഔട്ട്പുട്ട്: 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); // ഔട്ട്പുട്ട്: 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()); // ഔട്ട്പുട്ട്: Sensitive Information

// "പ്രൈവറ്റ്" പ്രോപ്പർട്ടി ആക്സസ് ചെയ്യുന്നു (ബുദ്ധിമുട്ടാണ്, പക്ഷേ സാധ്യമാണ്)
const symbolKeys = Object.getOwnPropertySymbols(myInstance);
console.log(myInstance[symbolKeys[0]]); // ഔട്ട്പുട്ട്: Sensitive Information

Object.getOwnPropertySymbols()-ന് ഇപ്പോഴും സിംബലിനെ വെളിപ്പെടുത്താൻ കഴിയുമെങ്കിലും, ബാഹ്യ കോഡ് ആകസ്മികമായി "പ്രൈവറ്റ്" പ്രോപ്പർട്ടി ആക്സസ് ചെയ്യാനോ മാറ്റം വരുത്താനോ ഉള്ള സാധ്യത ഇത് കുറയ്ക്കുന്നു. ശ്രദ്ധിക്കുക: യഥാർത്ഥ പ്രൈവറ്റ് ഫീൽഡുകൾ (`#` പ്രിഫിക്സ് ഉപയോഗിച്ച്) ഇപ്പോൾ ആധുനിക ജാവാസ്ക്രിപ്റ്റിൽ ലഭ്യമാണ്, അവ ശക്തമായ സ്വകാര്യത ഉറപ്പ് നൽകുന്നു.

സിംബലുകൾ ഉപയോഗിക്കുന്നതിനുള്ള മികച്ച രീതികൾ

സിംബലുകളുമായി പ്രവർത്തിക്കുമ്പോൾ മനസ്സിൽ സൂക്ഷിക്കേണ്ട ചില മികച്ച രീതികൾ ഇതാ:

• വിവരണാത്മകമായ സിംബൽ വിവരണങ്ങൾ ഉപയോഗിക്കുക: അർത്ഥവത്തായ വിവരണങ്ങൾ നൽകുന്നത് ഡീബഗ്ഗിംഗും ലോഗിംഗും എളുപ്പമാക്കുന്നു.
• ഗ്ലോബൽ സിംബൽ രജിസ്ട്രി പരിഗണിക്കുക: വിവിധ മൊഡ്യൂളുകൾക്കിടയിലോ ആപ്ലിക്കേഷനുകൾക്കിടയിലോ സിംബലുകൾ പങ്കിടേണ്ടിവരുമ്പോൾ Symbol.for() ഉപയോഗിക്കുക.
• എന്യൂമറേഷനെക്കുറിച്ച് അറിഞ്ഞിരിക്കുക: സിംബൽ പ്രോപ്പർട്ടികൾ ഡിഫോൾട്ടായി എന്യൂമറബിൾ അല്ലെന്ന് ഓർക്കുക, അവ ആക്സസ് ചെയ്യാൻ Object.getOwnPropertySymbols() ഉപയോഗിക്കുക.
• മെറ്റാഡാറ്റയ്ക്കായി സിംബലുകൾ ഉപയോഗിക്കുക: ഒബ്ജക്റ്റുകളുടെ നിലവിലുള്ള പ്രോപ്പർട്ടികളിൽ ഇടപെടാതെ മെറ്റാഡാറ്റ ചേർക്കാൻ സിംബലുകൾ പ്രയോജനപ്പെടുത്തുക.
• ശക്തമായ സ്വകാര്യത ആവശ്യമുള്ളപ്പോൾ യഥാർത്ഥ പ്രൈവറ്റ് ഫീൽഡുകൾ പരിഗണിക്കുക: നിങ്ങൾക്ക് യഥാർത്ഥ സ്വകാര്യത വേണമെങ്കിൽ, പ്രൈവറ്റ് ക്ലാസ് ഫീൽഡുകൾക്കായി `#` പ്രിഫിക്സ് ഉപയോഗിക്കുക (ആധുനിക ജാവാസ്ക്രിപ്റ്റിൽ ലഭ്യമാണ്).

ഉപസംഹാരം

ജാവാസ്ക്രിപ്റ്റ് സിംബലുകൾ തനതായ പ്രോപ്പർട്ടി കീകൾ സൃഷ്ടിക്കുന്നതിനും, ഒബ്ജക്റ്റുകളിലേക്ക് മെറ്റാഡാറ്റ ചേർക്കുന്നതിനും, ഒബ്ജക്റ്റിന്റെ സ്വഭാവം ഇഷ്ടാനുസൃതമാക്കുന്നതിനും ശക്തമായ ഒരു സംവിധാനം നൽകുന്നു. സിംബലുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കുകയും മികച്ച രീതികൾ പിന്തുടരുകയും ചെയ്യുന്നതിലൂടെ, നിങ്ങൾക്ക് കൂടുതൽ കരുത്തുറ്റതും, പരിപാലിക്കാൻ എളുപ്പമുള്ളതും, വൈരുദ്ധ്യങ്ങളില്ലാത്തതുമായ ജാവാസ്ക്രിപ്റ്റ് കോഡ് എഴുതാൻ കഴിയും. നിങ്ങൾ പ്ലഗിൻ സിസ്റ്റങ്ങൾ നിർമ്മിക്കുകയാണെങ്കിലും, DOM എലമെന്റുകളിലേക്ക് മെറ്റാഡാറ്റ ചേർക്കുകയാണെങ്കിലും, അല്ലെങ്കിൽ പ്രൈവറ്റ് പ്രോപ്പർട്ടികൾ അനുകരിക്കുകയാണെങ്കിലും, നിങ്ങളുടെ ജാവാസ്ക്രിപ്റ്റ് ഡെവലപ്മെന്റ് വർക്ക്ഫ്ലോ മെച്ചപ്പെടുത്തുന്നതിനുള്ള ഒരു വിലപ്പെട്ട ഉപകരണം സിംബലുകൾ നൽകുന്നു.