Ytterligere funksjoner i klasser i JavaScript
I denne artikkelen vil vi forklare de ekstra funksjonene i klasser i JavaScript.
YouTube Video
Ytterligere funksjoner i klasser i JavaScript
Private egenskaper i JavaScript
I JavaScript er private egenskaper egenskaper som kun er tilgjengelige innenfor objektet eller klassen. Dette muliggjør en mer sikker og robust kodedesign ved å tilby innkapsling, slik at direkte modifikasjon eller referanse fra ekstern kode ikke er mulig.
I ECMAScript 2020 (ES11) ble bruken av # (hash) for å definere private felter i en klasse introdusert. Dette gir en tydeligere måte, som erstatter tradisjonelle private konvensjoner i JavaScript (for eksempel variabelnavn som begynner med en understrek).
Fordeler med private egenskaper
Følgende er fordelene med private egenskaper.
- Innkapsling: Skjuler intern tilstand fra utsiden og opprettholder datakonsistens.
- Sikkerhet: Forhindrer at egenskaper tilfeldig modifiseres av ekstern kode.
- Forbedret vedlikeholdbarhet: Skjuler implementeringen av objekter eller klasser og klargjør grensesnittet som eksponeres til utsiden.
Hvordan bruke private egenskaper
Definere private egenskaper i klasser
Private felter defineres ved å bruke et navn som starter med #. Dette feltet kan ikke aksesseres direkte fra instanser av klassen eller dens underklasser.
1class Person {
2 // Define private property
3 #name;
4
5 constructor(name) {
6 this.#name = name;
7 }
8
9 // Method to access the private property
10 getName() {
11 return this.#name;
12 }
13
14 // Method to change the private property
15 setName(newName) {
16 this.#name = newName;
17 }
18}
19
20const john = new Person("John");
21console.log(john.getName()); // John
22
23// Cannot access private property directly
24console.log(john.#name); // SyntaxError: Private field '#name' must be declared in an enclosing class
I koden ovenfor er #name en privat egenskap som ikke kan aksesseres direkte fra utsiden av Person-klassen. Du kan kun få tilgang til eller endre navnet gjennom metodene getName og setName.
Definere private metoder
På samme måte som private egenskaper defineres private metoder også ved å bruke et navn som starter med #. Private metoder kan bare kalles fra innsiden av klassen.
1class Counter {
2 #count = 0;
3
4 increment() {
5 this.#count++;
6 this.#logCount(); // Calling private method
7 }
8
9 // Private method
10 #logCount() {
11 console.log(`Current count: ${this.#count}`);
12 }
13}
14
15const counter = new Counter();
16counter.increment(); // Current count: 1
17
18// Cannot access private method directly
19counter.#logCount(); // SyntaxError: Private field '#logCount' must be declared in an enclosing class
Her er #logCount definert som en privat metode og kan ikke aksesseres fra utsiden av klassen. Denne metoden brukes kun innenfor klassen.
Fordeler og hensyn ved private egenskaper
Fordel
- Fordi det ikke kan nås direkte fra utsiden av klassen, forhindres utilsiktede endringer eller operasjoner.
- Fordi deler som ikke er synlige fra utsiden kan skjules godt, kan du tydelig administrere de delene du eksponerer som et API.
Notater
- Fordi private felt er helt skjult fra utsiden av klassen, kan testing og feilsøking bli vanskelig. Derfor er det viktig å tilby et API som kan testes grundig i designfasen.
- Private felt oppfører seg annerledes enn andre deler av JavaScript med prototype-baserte egenskaper fordi de er unike for hver instans.
Tradisjonell pseudonym implementasjon av private egenskaper
Før introduksjonen av private felt med #, hadde ikke JavaScript en offisiell syntaks for private egenskaper. Derfor ble pseudo-private egenskaper tidligere implementert på følgende måter.
Konvensjonsbruk av understreker
Utviklere indikerte konvensjonelt 'private' ved å legge til et understrek foran variabelnavnene.
1class Car {
2 constructor(brand) {
3 this._brand = brand; // Using an underscore to indicate private
4 }
5
6 getBrand() {
7 return this._brand;
8 }
9}
10
11const car = new Car("Toyota");
12console.log(car.getBrand()); // Toyota
13console.log(car._brand); // Toyota (Accessible from outside)
Denne metoden er bare en 'konvensjon', og i praksis kan egenskapene fortsatt nås fra utsiden.
Implementasjon av private egenskaper ved bruk av closures
Det er også mulig å oppnå private egenskaper ved å bruke closures med funksjonsomfang.
1function createPerson(name) {
2 let _name = name; // Private variable within function scope
3
4 return {
5 getName: function() {
6 return _name;
7 },
8 setName: function(newName) {
9 _name = newName;
10 }
11 };
12}
13
14const person = createPerson("Alice");
15console.log(person.getName()); // Alice
16person.setName("Bob");
17console.log(person.getName()); // Bob
18
19// Cannot access directly from outside
20console.log(person._name); // undefined
Med denne metoden er variabelen _name innelukket i funksjonsomfanget og kan ikke nås direkte fra utsiden.
Sammendrag
Private egenskaper i JavaScript er svært effektive for å tilby kapsling i klasse- og objektutforming, og bidrar til å beskytte data sikkert. Notasjonen # for private felt introdusert i ES2020 gir en klarere og mer sikker metode for personvernbehandling sammenlignet med tradisjonelle konvensjoner og closures.
Valgfri kjeding i JavaScript
Valgfri kjeding er en svært nyttig syntaks i JavaScript for å få tilgang til egenskaper for dypt nestede objekter. Det forbedrer lesbarhet og vedlikehold av kode ved å tillate sikker tilgang uten å måtte sjekke individuelt om spesifikke egenskaper eksisterer.
Grunnleggende syntaks for valgfri kjeding
Valgfri kjeding kan brukes ved å plassere ? før punktumet (.) eller parentesnotasjonen som brukes for å få tilgang til egenskaper. Denne notasjonen returnerer undefined når en traversert egenskap er null eller undefined, slik at programmet kan fortsette trygg behandling uten å kaste en feil.
Eksempel:
1const user = {
2 name: 'John',
3 address: {
4 street: '123 Main St',
5 city: 'New York'
6 }
7};
8
9// Without using optional chaining
10const city = user && user.address && user.address.city;
11console.log(city); // New York
12
13// Using optional chaining
14const cityWithOptionalChaining = user?.address?.city;
15console.log(cityWithOptionalChaining); // New York
I dette eksemplet får vi tilgang til address og dens city-egenskap for user-objektet. Uten å bruke valgfri kjeding, må du utføre flere eksistenskontroller, men med valgfri kjeding kan du trygt få tilgang til egenskapen med en enkelt setning.
Bruke valgfri kjeding med arrayer og funksjoner
Valgfri kjeding gjelder ikke bare for objekt-egenskaper, men også for elementer i arrayer og funksjonskall.
Eksempel med arrayer:
1const users = [{ name: 'Alice' }, { name: 'Bob' }];
2
3// Accessing the non-existent third element
4const thirdUser = users[2]?.name;
5console.log(thirdUser); // undefined
Eksempel med funksjoner:
1const user = {
2 greet: function() {
3 return 'Hello!';
4 }
5};
6
7// Call the function only if greet exists
8const greeting = user.greet?.();
9console.log(greeting); // Hello!
10
11// Return undefined if greet does not exist
12const nonExistentGreeting = user.nonExistentMethod?.();
13console.log(nonExistentGreeting); // undefined
Kombinere valgfri kjeding med standardverdier
Når du bruker valgfri kjeding, er det vanlig å bruke den logiske ELLER-operatoren (||) eller nullsammenslåingsoperatoren (??) for å angi standardverdier hvis en egenskap ikke finnes.
Eksempel:
1const user = {
2 name: 'John',
3 address: {
4 city: 'New York'
5 }
6};
7
8// Set a default value for a non-existent property
9const state = user?.address?.state || 'Unknown';
10console.log(state); // Unknown
11
12// Example using the nullish coalescing operator
13const zipCode = user?.address?.zipCode ?? '00000';
14console.log(zipCode); // 00000
||-operatoren behandler false, 0, '', etc., som falske, mens ??-operatoren bare bruker standardverdien hvis operanden er null eller undefined.
Fordeler med valgfri kjeding
- Trygg tilgang til nestede objekter: Ved å bruke valgfri kjeding trenger du ikke lenger utføre eksplisitte eksistenskontroller, noe som gjør koden mer konsis.
- Unngåelse av feil: Det kan forhindre kjøretidsfeil selv om en egenskap er
nullellerundefined. - Bedre lesbarhet og vedlikeholdbarhet: Spesielt når du arbeider med mange nestede objekter, forbedres kodens lesbarhet betydelig.
Forholdsregler med valgfri kjeding
- Hyppig bruk av valgfri kjeding kan være et tegn på at datastrukturens design er unødvendig komplisert. Du bør strebe etter en enkel datamodell.
- Siden noen eldre nettlesere og JavaScript-motorer ikke støtter det, kan det hende du må bruke polyfills eller transpilers.
Konklusjon
Valgfri kjeding er en kraftig funksjon som forenkler trygg tilgang til egenskaper og funksjoner i nestede objekter i JavaScript. Det er spesielt effektivt når du får tilgang til dypt nestede datastrukturer, noe som bidrar til feilforebygging og bedre lesbarhet av koden.
Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.