JavaScript simboliai: unikalūs savybių raktai ir metaduomenų saugojimas

JavaScript simboliai, pristatyti ECMAScript 2015 (ES6), siūlo galingą mechanizmą unikaliems ir nekintamiems objektų savybių raktams kurti. Skirtingai nuo eilučių, simboliai yra garantuotai unikalūs, taip išvengiant atsitiktinių savybių pavadinimų susidūrimų ir leidžiant taikyti pažangias programavimo technikas, tokias kaip privačių savybių įgyvendinimas ir metaduomenų saugojimas. Šiame straipsnyje pateikiama išsami JavaScript simbolių apžvalga, apimanti jų kūrimą, naudojimą, gerai žinomus simbolius ir praktinius pritaikymus.

Kas yra JavaScript simboliai?

Simbolis (Symbol) yra primityvus duomenų tipas JavaScript kalboje, kaip ir skaičiai, eilutės ir loginės reikšmės. Tačiau simboliai turi unikalią savybę: kiekvienas sukurtas simbolis yra garantuotai unikalus ir skirtingas nuo visų kitų simbolių. Dėl šio unikalumo simboliai idealiai tinka naudoti kaip objektų savybių raktus, užtikrinant, kad savybės nebūtų netyčia perrašytos ar pasiektos iš kitų kodo dalių. Tai ypač naudinga dirbant su bibliotekomis ar karkasais, kur neturite visiškos kontrolės, kokios savybės gali būti pridėtos prie objekto.

Galvokite apie simbolius kaip apie būdą pridėti prie objektų specialias, paslėptas žymes, kurias galite pasiekti tik jūs (arba kodas, kuris žino konkretų simbolį). Tai leidžia sukurti savybes, kurios veikia kaip privačios, arba pridėti prie objektų metaduomenis, netrukdant jų esamoms savybėms.

Simbolių kūrimas

Simboliai kuriami naudojant Symbol() konstruktorių. Konstruktorius priima neprivalomą eilutės argumentą, kuris tarnauja kaip simbolio aprašymas. Šis aprašymas yra naudingas derinimui ir identifikavimui, bet neturi įtakos simbolio unikalumui. Du simboliai, sukurti su tuo pačiu aprašymu, vis tiek yra skirtingi.

Paprastas simbolių kūrimas

Štai kaip sukurti paprastą simbolį:

            
const mySymbol = Symbol();
const anotherSymbol = Symbol("My Description");

console.log(mySymbol);       // Output: Symbol()
console.log(anotherSymbol);  // Output: Symbol(My Description)
console.log(typeof mySymbol);  // Output: symbol

            

              
                Copy
              
            
          

Kaip matote, typeof operatorius patvirtina, kad mySymbol ir anotherSymbol iš tikrųjų yra symbol tipo.

Simboliai yra unikalūs

Norėdami pabrėžti simbolių unikalumą, apsvarstykite šį pavyzdį:

            
const symbol1 = Symbol("example");
const symbol2 = Symbol("example");

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

            

              
                Copy
              
            
          

Nors abu simboliai buvo sukurti su tuo pačiu aprašymu ("example"), jie nėra lygūs. Tai parodo esminį simbolių unikalumą.

Simbolių naudojimas kaip savybių raktų

Pagrindinis simbolių naudojimo atvejis yra kaip objektų savybių raktai. Naudojant simbolį kaip savybės raktą, svarbu jį įdėti į laužtinius skliaustus. Taip yra todėl, kad JavaScript traktuoja simbolius kaip išraiškas, o laužtinių skliaustų notacija yra būtina išraiškai įvertinti.

Simbolių savybių pridėjimas prie objektų

Štai pavyzdys, kaip pridėti simbolių savybes prie objekto:

            
const myObject = {};
const symbolA = Symbol("propertyA");
const symbolB = Symbol("propertyB");

myObject[symbolA] = "Value A";
myObject[symbolB] = "Value B";

console.log(myObject[symbolA]);  // Output: Value A
console.log(myObject[symbolB]);  // Output: Value B

            

              
                Copy
              
            
          

Šiame pavyzdyje symbolA ir symbolB naudojami kaip unikalūs raktai reikšmėms saugoti myObject objekte.

Kodėl verta naudoti simbolius kaip savybių raktus?

Simbolių naudojimas kaip savybių raktų suteikia keletą privalumų:

• Savybių pavadinimų susidūrimų prevencija: Simboliai garantuoja, kad savybių pavadinimai yra unikalūs, išvengiant atsitiktinių perrašymų dirbant su išorinėmis bibliotekomis ar karkasais.
• Inkapsuliacija: Simbolius galima naudoti savybėms, kurios veikia kaip privačios, kurti, nes jos nėra išvardijamos ir sunkiai pasiekiamos iš objekto išorės.
• Metaduomenų saugojimas: Simbolius galima naudoti metaduomenims prie objektų pridėti, netrukdant jų esamoms savybėms.

Simboliai ir išvardijimas

Viena svarbi simbolių savybių charakteristika yra ta, kad jos nėra išvardijamos. Tai reiškia, kad jos neįtraukiamos iteruojant per objekto savybes naudojant tokius metodus kaip for...in ciklai, Object.keys() ar Object.getOwnPropertyNames().

Neišvardijamų simbolių savybių pavyzdys

            
const myObject = {
  name: "Example",
  age: 30
};

const symbolC = Symbol("secret");
myObject[symbolC] = "Top Secret!";

console.log(Object.keys(myObject));          // Output: [ 'name', 'age' ]
console.log(Object.getOwnPropertyNames(myObject)); // Output: [ 'name', 'age' ]

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

            

              
                Copy
              
            
          

Kaip matote, simbolio savybė symbolC neįtraukiama į Object.keys(), Object.getOwnPropertyNames() ar for...in ciklo išvestį. Toks elgesys prisideda prie simbolių naudojimo inkapsuliacijos privalumų.

Prieiga prie simbolių savybių

Norėdami pasiekti simbolių savybes, turite naudoti Object.getOwnPropertySymbols(), kuris grąžina visų simbolių savybių, tiesiogiai rastų objekte, masyvą.

            
const symbolProperties = Object.getOwnPropertySymbols(myObject);
console.log(symbolProperties);            // Output: [ Symbol(secret) ]
console.log(myObject[symbolProperties[0]]); // Output: Top Secret!

            

              
                Copy
              
            
          

Šis metodas leidžia gauti ir dirbti su simbolių savybėmis, kurios nėra išvardijamos kitais būdais.

Gerai žinomi simboliai

JavaScript pateikia iš anksto apibrėžtų simbolių rinkinį, žinomą kaip „gerai žinomi simboliai“. Šie simboliai atspindi specifinį vidinį kalbos elgesį ir gali būti naudojami objektų elgesiui tam tikrose situacijose pritaikyti. Gerai žinomi simboliai yra Symbol konstruktoriaus savybės, tokios kaip Symbol.iterator, Symbol.toStringTag ir Symbol.hasInstance.

Dažniausiai naudojami gerai žinomi simboliai

Štai keletas dažniausiai naudojamų gerai žinomų simbolių:

• Symbol.iterator: Nurodo numatytąjį objekto iteratorių. Jį naudoja for...of ciklai iteruoti per objekto elementus.
• Symbol.toStringTag: Nurodo pasirinktinį objekto eilutės aprašymą, kai iškviečiamas Object.prototype.toString().
• Symbol.hasInstance: Nustato, ar objektas laikomas klasės egzemplioriumi. Jį naudoja instanceof operatorius.
• Symbol.toPrimitive: Nurodo metodą, kuris konvertuoja objektą į primityvią reikšmę.
• Symbol.asyncIterator: Nurodo numatytąjį objekto asinchroninį iteratorių. Jį naudoja for await...of ciklai.

Symbol.iterator naudojimas

Symbol.iterator yra vienas naudingiausių gerai žinomų simbolių. Jis leidžia apibrėžti, kaip objektas turėtų būti iteruojamas naudojant for...of ciklus.

            
const myIterable = {
  data: [1, 2, 3, 4, 5],
  [Symbol.iterator]() {
    let index = 0;
    return {
      next: () => {
        if (index < this.data.length) {
          return { value: this.data[index++], done: false };
        } else {
          return { value: undefined, done: true };
        }
      }
    };
  }
};

for (const value of myIterable) {
  console.log(value); // Output: 1, 2, 3, 4, 5
}

            

              
                Copy
              
            
          

Šiame pavyzdyje mes apibrėžiame pasirinktinį iteratorių objektui myIterable, naudodami Symbol.iterator. Iteratorius grąžina reikšmes iš data masyvo po vieną, kol pasiekiama masyvo pabaiga.

Symbol.toStringTag naudojimas

Symbol.toStringTag leidžia pritaikyti objekto eilutės reprezentaciją, kai naudojamas Object.prototype.toString().

            
class MyClass {}
MyClass.prototype[Symbol.toStringTag] = "MyCustomClass";

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

            

              
                Copy
              
            
          

Be Symbol.toStringTag, išvestis būtų [object Object]. Šis simbolis leidžia pateikti aprašomesnę eilutės reprezentaciją.

Praktinis simbolių pritaikymas

Simboliai turi įvairių praktinių pritaikymų JavaScript programavime. Štai keletas pavyzdžių:

Privačių savybių įgyvendinimas

Nors JavaScript neturi tikrų privačių savybių, kaip kai kurios kitos kalbos, simbolius galima naudoti privačioms savybėms imituoti. Naudodami simbolį kaip savybės raktą ir laikydami jį uždarinio (closure) aprėptyje, galite užkirsti kelią išorinei prieigai prie savybės.

            
const createCounter = () => {
  const count = Symbol("count");
  const obj = {
    [count]: 0,
    increment() {
      this[count]++;
    },
    getCount() {
      return this[count];
    }
  };
  return obj;
};

const counter = createCounter();
counter.increment();
console.log(counter.getCount()); // Output: 1
console.log(counter[Symbol("count")]); // Output: undefined (outside scope)

            

              
                Copy
              
            
          

Šiame pavyzdyje count simbolis yra apibrėžtas createCounter funkcijos viduje, todėl jis nepasiekiamas iš uždarinio išorės. Nors tai nėra tikrai privatu, šis metodas suteikia gerą inkapsuliacijos lygį.

Metaduomenų pridėjimas prie objektų

Simbolius galima naudoti metaduomenims prie objektų pridėti, netrukdant jų esamoms savybėms. Tai naudinga, kai reikia pridėti papildomos informacijos prie objekto, kuri neturėtų būti išvardijama ar pasiekiama standartine savybių prieiga.

            
const myElement = document.createElement("div");
const metadataKey = Symbol("metadata");

myElement[metadataKey] = {
  author: "John Doe",
  timestamp: Date.now()
};

console.log(myElement[metadataKey]); // Output: { author: 'John Doe', timestamp: 1678886400000 }

            

              
                Copy
              
            
          

Čia simbolis naudojamas metaduomenims pridėti prie DOM elemento, nepaveikiant jo standartinių savybių ar atributų.

Trečiųjų šalių objektų išplėtimas

Dirbant su trečiųjų šalių bibliotekomis ar karkasais, simbolius galima naudoti objektams išplėsti su pasirinktiniu funkcionalumu, nerizikuojant savybių pavadinimų susidūrimais. Tai leidžia pridėti funkcijų ar elgsenų prie objektų nekeičiant originalaus kodo.

            
// Assume 'libraryObject' is an object from an external library
const libraryObject = {
  name: "Library Object",
  version: "1.0"
};

const customFunction = Symbol("customFunction");
libraryObject[customFunction] = () => {
  console.log("Custom function called!");
};

libraryObject[customFunction](); // Output: Custom function called!

            

              
                Copy
              
            
          

Šiame pavyzdyje prie libraryObject pridedama pasirinktinė funkcija naudojant simbolį, užtikrinant, kad ji nesikirstų su jokiomis esamomis savybėmis.

Simboliai ir globalus simbolių registras

Be lokalių simbolių kūrimo, JavaScript taip pat siūlo globalų simbolių registrą. Šis registras leidžia kurti ir gauti simbolius, kurie yra bendrinami tarp skirtingų jūsų programos dalių ar net tarp skirtingų JavaScript aplinkų (pvz., skirtingų iframe'ų naršyklėje).

Globalaus simbolių registro naudojimas

Norėdami sukurti ar gauti simbolį iš globalaus registro, naudojate Symbol.for() metodą. Šis metodas priima eilutės argumentą, kuris tarnauja kaip simbolio raktas. Jei registre jau egzistuoja simbolis su nurodytu raktu, Symbol.for() grąžina esamą simbolį. Priešingu atveju, jis sukuria naują simbolį su nurodytu raktu ir prideda jį į registrą.

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

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

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

            

              
                Copy
              
            
          

Šiame pavyzdyje tiek globalSymbol1, tiek globalSymbol2 nurodo tą patį simbolį globaliame registre. Symbol.keyFor() metodas grąžina raktą, susietą su simboliu registre.

Globalaus simbolių registro privalumai

Globalus simbolių registras suteikia keletą privalumų:

• Simbolių bendrinimas: Leidžia bendrinti simbolius tarp skirtingų jūsų programos dalių ar net tarp skirtingų JavaScript aplinkų.
• Nuoseklumas: Užtikrina, kad tas pats simbolis būtų nuosekliai naudojamas skirtingose jūsų kodo dalyse.
• Sąveika: Palengvina sąveiką tarp skirtingų bibliotekų ar karkasų, kuriems reikia bendrinti simbolius.

Geriausios simbolių naudojimo praktikos

Dirbant su simboliais, svarbu laikytis kelių geriausių praktikų, kad jūsų kodas būtų aiškus, prižiūrimas ir efektyvus:

• Naudokite aprašomuosius simbolių aprašymus: Kurdami simbolius, pateikite prasmingus aprašymus, kad palengvintumėte derinimą ir identifikavimą.
• Venkite globalaus simbolių registro taršos: Kai tik įmanoma, naudokite lokalius simbolius, kad išvengtumėte globalaus simbolių registro teršimo.
• Dokumentuokite simbolių naudojimą: Aiškiai dokumentuokite simbolių paskirtį ir naudojimą savo kode, kad pagerintumėte skaitomumą ir prižiūrimumą.
• Atsižvelkite į našumo pasekmes: Nors simboliai paprastai yra efektyvūs, per didelis jų naudojimas gali turėti įtakos našumui, ypač didelėse programose.

Pavyzdžiai iš realaus pasaulio skirtingose šalyse

Simbolių naudojimas apima įvairias programinės įrangos kūrimo sritis visame pasaulyje. Štai keletas konceptualių pavyzdžių, pritaikytų skirtingiems regionams ir pramonės šakoms:

• E. prekybos platforma (visame pasaulyje): Didelė tarptautinė e. prekybos platforma naudoja simbolius vartotojų nuostatoms dėl produkto informacijos rodymo saugoti. Tai padeda personalizuoti vartotojo patirtį nekeičiant pagrindinių produkto duomenų struktūrų, laikantis duomenų privatumo taisyklių skirtingose šalyse (pvz., BDAR Europoje).
• Sveikatos priežiūros sistema (Europa): Europos sveikatos priežiūros sistema naudoja simbolius pacientų įrašams pažymėti saugumo lygiais, užtikrinant, kad jautri medicininė informacija būtų prieinama tik įgaliotiems asmenims. Tai išnaudoja simbolių unikalumą, kad būtų išvengta atsitiktinių duomenų pažeidimų, laikantis griežtų sveikatos priežiūros privatumo įstatymų.
• Finansų įstaiga (Šiaurės Amerika): Šiaurės Amerikos bankas naudoja simbolius operacijoms, kurioms reikalinga papildoma sukčiavimo analizė, pažymėti. Šie simboliai, nepasiekiami įprastoms apdorojimo rutinoms, aktyvuoja specializuotus algoritmus, skirtus padidintam saugumui, taip sumažinant rizikas, susijusias su finansiniais nusikaltimais.
• Švietimo platforma (Azija): Azijos švietimo platforma naudoja simbolius metaduomenims apie mokymosi išteklius, tokius kaip sudėtingumo lygis ir tikslinė auditorija, saugoti. Tai leidžia sukurti pritaikytus mokymosi kelius studentams, optimizuojant jų mokymosi patirtį nekeičiant originalaus turinio.
• Tiekimo grandinės valdymas (Pietų Amerika): Pietų Amerikos logistikos įmonė naudoja simbolius siuntoms, kurioms reikalingas specialus tvarkymas, pavyzdžiui, temperatūros kontroliuojamas transportas ar pavojingų medžiagų procedūros, pažymėti. Tai užtikrina, kad jautrūs daiktai būtų tvarkomi tinkamai, sumažinant rizikas ir laikantis tarptautinių siuntimo taisyklių.

Išvada

JavaScript simboliai yra galinga ir universali funkcija, galinti pagerinti jūsų kodo saugumą, inkapsuliaciją ir išplėtimą. Suteikdami unikalius savybių raktus ir mechanizmą metaduomenims saugoti, simboliai leidžia rašyti tvirtesnes ir lengviau prižiūrimas programas. Supratimas, kaip efektyviai naudoti simbolius, yra būtinas bet kuriam JavaScript kūrėjui, siekiančiam įvaldyti pažangias programavimo technikas. Nuo privačių savybių įgyvendinimo iki objektų elgsenos pritaikymo, simboliai siūlo platų galimybių spektrą jūsų kodui tobulinti.

Nesvarbu, ar kuriate žiniatinklio programas, serverio pusės programas, ar komandų eilutės įrankius, apsvarstykite galimybę naudoti simbolius, kad pagerintumėte savo JavaScript kodo kokybę ir saugumą. Ištirkite gerai žinomus simbolius ir eksperimentuokite su skirtingais naudojimo atvejais, kad atskleistumėte visą šios galingos funkcijos potencialą.

Papildomi mokymosi šaltiniai

• MDN Web Docs: Simbolis
• ECMAScript 2015 kalbos specifikacija: Simbolių objektai
• JavaScript.info: Simboliai