ஜாவாஸ்கிரிப்ட் சிம்பல்கள்: தனித்துவமான ப்ராப்பர்ட்டி கீகள் மற்றும் மெட்டாடேட்டா

ECMAScript 2015 (ES6) இல் அறிமுகப்படுத்தப்பட்ட ஜாவாஸ்கிரிப்ட் சிம்பல்கள், தனித்துவமான மற்றும் மாற்ற முடியாத ப்ராப்பர்ட்டி கீகளை உருவாக்குவதற்கான ஒரு வழிமுறையை வழங்குகின்றன. ஸ்டிரிங் அல்லது எண்களைப் போலல்லாமல், சிம்பல்கள் உங்கள் முழு ஜாவாஸ்கிரிப்ட் பயன்பாட்டிலும் தனித்துவமாக இருக்கும் என்பது உறுதி. பெயர் மோதல்களைத் தவிர்க்கவும், ஏற்கனவே உள்ள ப்ராப்பர்ட்டிகளில் தலையிடாமல் ஆப்ஜெக்ட்களில் மெட்டாடேட்டாவை இணைக்கவும், ஆப்ஜெக்ட் நடத்தையைத் தனிப்பயனாக்கவும் அவை ஒரு வழியை வழங்குகின்றன. இந்தக் கட்டுரை ஜாவாஸ்கிரிப்ட் சிம்பல்களின் உருவாக்கம், பயன்பாடுகள் மற்றும் சிறந்த நடைமுறைகளை உள்ளடக்கிய ஒரு விரிவான கண்ணோட்டத்தை வழங்குகிறது.

ஜாவாஸ்கிரிப்ட் சிம்பல்கள் என்றால் என்ன?

சிம்பல் என்பது ஜாவாஸ்கிரிப்டில் உள்ள ஒரு பிரிமிடிவ் டேட்டா டைப் ஆகும், இது எண்கள், ஸ்டிரிங்குகள், பூலியன்கள், நல் மற்றும் அன்டிஃபைன்ட் போன்றது. இருப்பினும், மற்ற பிரிமிடிவ் வகைகளைப் போலல்லாமல், சிம்பல்கள் தனித்துவமானவை. ஒவ்வொரு முறையும் நீங்கள் ஒரு சிம்பலை உருவாக்கும்போது, முற்றிலும் புதிய, தனித்துவமான மதிப்பைப் பெறுவீர்கள். இந்தத் தனித்துவம் சிம்பல்களைப் பின்வருவனவற்றிற்கு ஏற்றதாக ஆக்குகிறது:

• தனித்துவமான ப்ராப்பர்ட்டி கீகளை உருவாக்குதல்: சிம்பல்களை ப்ராப்பர்ட்டி கீகளாகப் பயன்படுத்துவது, உங்கள் ப்ராப்பர்ட்டிகள் ஏற்கனவே உள்ள ப்ராப்பர்ட்டிகளுடனோ அல்லது மற்ற லைப்ரரிகள் அல்லது மாட்யூல்களால் சேர்க்கப்பட்ட ப்ராப்பர்ட்டிகளுடனோ மோதாது என்பதை உறுதி செய்கிறது.
• மெட்டாடேட்டாவை சேமித்தல்: ஆப்ஜெக்ட்டின் ஒருமைப்பாட்டைப் பாதுகாக்கும் வகையில், நிலையான எனுமரேஷன் முறைகளிலிருந்து மறைக்கப்பட்ட வழியில் ஆப்ஜெக்ட்களில் மெட்டாடேட்டாவை இணைக்க சிம்பல்கள் பயன்படுத்தப்படலாம்.
• ஆப்ஜெக்ட் நடத்தையைத் தனிப்பயனாக்குதல்: ஜாவாஸ்கிரிப்ட் நன்கு அறியப்பட்ட சிம்பல்களின் தொகுப்பை வழங்குகிறது, இது ஆப்ஜெக்ட்கள் சில சூழ்நிலைகளில், அதாவது இட்டரேட் செய்யப்படும்போது அல்லது ஸ்டிரிங்காக மாற்றப்படும்போது எவ்வாறு நடந்துகொள்கின்றன என்பதைத் தனிப்பயனாக்க உங்களை அனுமதிக்கிறது.

சிம்பல்களை உருவாக்குதல்

நீங்கள் 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

நன்கு அறியப்பட்ட சிம்பல்கள்

ஜாவாஸ்கிரிப்ட் நன்கு அறியப்பட்ட சிம்பல்கள் எனப்படும் உள்ளமைக்கப்பட்ட சிம்பல்களின் தொகுப்பை வழங்குகிறது, அவை குறிப்பிட்ட நடத்தைகள் அல்லது செயல்பாடுகளைக் குறிக்கின்றன. இந்த சிம்பல்கள் 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

Symbol.toStringTag என்பது Object.prototype.toString() அழைக்கப்படும்போது ஒரு ஆப்ஜெக்ட்டின் ஸ்டிரிங் பிரதிநிதித்துவத்தைத் தனிப்பயனாக்க உங்களை அனுமதிக்கும் ஒரு சிம்பல் ஆகும்.

எடுத்துக்காட்டு: 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

Symbol.hasInstance என்பது instanceof ஆபரேட்டரின் நடத்தையைத் தனிப்பயனாக்க உங்களை அனுமதிக்கும் ஒரு சிம்பல் ஆகும். பொதுவாக, 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: "பிளகின் 1 கூடுதல் செயல்பாட்டைச் சேர்க்கிறது",
  activate: function() {
    console.log("பிளகின் 1 செயல்படுத்தப்பட்டது");
  }
};

// பிளகின் 2
const plugin2Key = Symbol("plugin2");
coreObject[plugin2Key] = {
  author: "Another Developer",
  init: function() {
    console.log("பிளகின் 2 தொடங்கப்பட்டது");
  }
};

// பிளகின்களை அணுகுதல்
console.log(coreObject[plugin1Key].description); // வெளியீடு: பிளகின் 1 கூடுதல் செயல்பாட்டைச் சேர்க்கிறது
coreObject[plugin2Key].init(); // வெளியீடு: பிளகின் 2 தொடங்கப்பட்டது

இந்த எடுத்துக்காட்டில், ஒவ்வொரு பிளகினும் ஒரு தனித்துவமான சிம்பல் கீயைப் பயன்படுத்துகிறது, இது சாத்தியமான பெயர் மோதல்களைத் தடுக்கிறது மற்றும் பிளகின்கள் அமைதியாக இணைந்து செயல்படுவதை உறுதி செய்கிறது.

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 கூறுகளுக்கு மெட்டாடேட்டாவைச் சேர்க்கிறீர்களா, அல்லது பிரைவேட் ப்ராப்பர்ட்டிகளை உருவகப்படுத்துகிறீர்களா, சிம்பல்கள் உங்கள் ஜாவாஸ்கிரிப்ட் மேம்பாட்டு பணிப்பாய்வுகளை மேம்படுத்த ஒரு மதிப்புமிக்க கருவியை வழங்குகின்றன.