Pola i metody klas

Pola klasy są deklarowane bezpośrednio w treści klasy, a nie jawnie dodane jako właściwość wartości this. Efekt jest jednak taki sam: właściwości zdefiniowanej w instancjach tej klasy.

class MyClass {
    myField;
}

const myClassInstance = new MyClass();

myClassInstance;
> MyClass { myField: undefined }

Pole możesz zainicjować wartością. Jest to często wartość domyślna, logika klasy może zastąpić:

class MyClass {
    myResult = false;
    set setValue( myValue ) {
        this.myResult = myValue;
    }
}
const myClassInstance = new MyClass();

myClassInstance;
> Object { myResult: false }

myClassInstance.setValue = true;

myClassInstance;\
> Object { myResult: true }

Pola klasy działają tak samo jak właściwości dołączone do klasy za pomocą funkcji this. Oznacza to, że można je otwierać i modyfikować spoza klasy jak każda inna właściwość.

class MyClass {
    myField = true;
}

const myClassInstance = new MyClass();

myClassInstance.myField;
> true

myClassInstance.myField = false;

myClassInstance.myField;
> false;

Pola stanowią podstawę do niektórych bardziej zaawansowanych funkcji klas.

Prywatne pola i metody

Pola i metody prywatne są niedostępne poza zajęciami. Prywatny jest powiązana z wystąpieniem klasy, co oznacza, że każde wystąpienie zawiera własny zestaw prywatnych pól i metod, które zostały zdefiniowane w klasie.

Aby ustawić usługę jako prywatną, dodaj # na początku identyfikatora, gdy w takim przypadku:

class MyClass {
    #myPrivateField = true;
    #myPrivateMethod() {}
}
const myClassInstance = new MyClass();

myClassInstance;
> MyClass { #myPrivateField: true }
    #myPrivateField: true
    <prototype>: Object {  }
        constructor: class MyClass {}
        <prototype>: Object {  }

Pole prywatne musi być zadeklarowane w treści klasy zawierającej. Dostępne opcje zmienić jego wartość później jako właściwość this, ale nie można utworzyć pola za pomocą funkcji this.

Pola prywatne nie są dostępne z innych miejsc w skrypcie. Spowoduje to zablokowanie danych właściwości nie mogą być modyfikowane poza podanymi metodami gettera i metod ustalających wchodzić w interakcję z zawartymi w nich wartościami, uniemożliwiając bezpośredni dostęp do przeznaczone do użycia wyłącznie w samej klasie.

class MyClass {
    #myResult = false;
    set setValue( myValue ) {
        this.#myResult = myValue;
    }
}
const myClassInstance = new MyClass();

myClassInstance;
> MyClass { #myResult: false }

myClassInstance.#myResult = true;
> Uncaught SyntaxError: reference to undeclared private field or method #myResult

myClassInstance.setValue = true;

myClassInstance;\
> MyClass { #myResult: true }

Pamiętaj jednak, że konsole programisty są zwykle bardzo mało restrykcyjne, ale niespójne, dotyczące zezwalania na dostęp do pól prywatnych na potrzeby debugowania cele:

class MyClass {
    #myPrivateField = true;
    #myPrivateMethod() {
        console.log( "This is inside a private method." );
    }
}
const myClassInstance = new MyClass();

myClassInstance;
> MyClass {#myPrivateField: true}

myClassInstance.#myPrivateField;
> true

myClassInstance.#myPrivateMethod();
> "This is inside a private method."
class MyClass {
    #myPrivateField = true;
    #myPrivateMethod() {
        console.log( "This is inside a private method." );
    }
}
const myClassInstance = new MyClass();

myClassInstance;
> MyClass {#myPrivateField: true}

myClassInstance.#myPrivateField;
> Uncaught SyntaxError: reference to undeclared private field or method #myPrivateField

myClassInstance.#myPrivateMethod();
> Uncaught SyntaxError: reference to undeclared private field or method #myPrivateMethod

Pola prywatne są ograniczone do treści klasy, która je zawiera. co oznacza, że nawet klasy podrzędne nie mają dostępu do pól prywatnych powiązanych z klasa nadrzędna:

class MyClass {
    #myPrivateField = true;
}
class ChildClass extends MyClass {
    childMethod() {
        console.log( this.#myPrivateField );
    }
}
> Uncaught SyntaxError: reference to undeclared private field or method #myPrivateField

Pola i metody statyczne

Pola i metody statyczne należą do samej klasy, a nie do instances tej klasy. Dzięki temu pola statyczne zapewniają centralny dla danych, które nie będą unikalne dla każdego wystąpienia klasy, ale te mogą wymagać odwołania, na przykład do udostępnionych informacji o konfiguracji. Metody statyczne są często funkcjami użytkowymi do pracy z instancjami klasy, na przykład porównując lub sortując instancje względem pola, które zawierają.

Aby zdefiniować statyczne pola i metody w treści klasy, użyj static słowo kluczowe:

class MyClass {
    static myStaticField;
    static myStaticMethod() {}
}
const myClassInstance = new MyClass();

Możesz też użyć notacji punktowej, aby utworzyć metodę statyczną:

class MyClass {
    constructor() {}
}
MyClass.myStaticMethod = function() {}

Nie można uzyskać dostępu do właściwości statycznych z wystąpienia ich klasy, ale :

class MyClass {
    static myStaticField = true;
    static myStaticMethod() {
        console.log( "A static method." );
    }
}
const myClassInstance = new MyClass();

myClassInstance.myStaticField;
> undefined

myClassInstance.myStaticMethod();
> Uncaught TypeError: myClassInstance.myStaticMethod is not a function

MyClass.myStaticField;
> true

MyClass.myStaticMethod();
> "A static method."

Nie są one wymagane technicznie, ale stosowanie metod statycznych to sprawdzona metoda podczas tworzenia narzędzi do pracy z instancjami klasy. Przykłady: dołącz metodę statyczną przeznaczoną do sortowania instancji klasy lub metodę statyczną fabryczną, która zawiera wszystkie niezbędne ustawienia do utworzenia instancji w klasie, a następnie zwraca instancję klasy:

class User {
    constructor( name, email ) {
        this.name = name;
        this.email = email;
    }
    static fromObject( myObject ) {
        return new User( myObject.name, myObject.email ?? "Omitted" );
    }
}
const userObject = {
    "name" : "My Name",
    "email" : "my@email.address"
};
const secondUserObject = {
    "name" : "My Name"
};

const firstUser = User.fromObject( userObject );
const secondUser = User.fromObject( secondUserObject );

firstUser;
> Object { name: "My Name", email: "my@email.address" }

secondUser;
> Object { name: "My Name", email: "Omitted" }

Sprawdź swoją wiedzę

Do których z poniższych typów pól można uzyskać dostęp wyłącznie z poziomu na zajęciach?

Pola klasy
Static fields
Pola prywatne