Campos e métodos de classe

Os campos de classe são declarados diretamente no corpo de uma classe, não explicitamente adicionada como uma propriedade do valor this. No entanto, o resultado é o mesmo: um propriedade definida nas instâncias dessa classe.

class MyClass {
    myField;
}

const myClassInstance = new MyClass();

myClassInstance;
> MyClass { myField: undefined }

É possível inicializar um campo com um valor. Esse é geralmente um valor padrão lógica dentro da classe pode substituir:

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 }

Os campos de classe são funcionalmente idênticos às propriedades anexadas à classe usando this. Isso significa que eles podem ser acessados e modificados fora como qualquer outra propriedade.

class MyClass {
    myField = true;
}

const myClassInstance = new MyClass();

myClassInstance.myField;
> true

myClassInstance.myField = false;

myClassInstance.myField;
> false;

Os campos fornecem uma base para alguns dos atributos mais avançados das classes.

Campos particulares e métodos

Os campos e métodos particulares são inacessíveis fora de uma classe. Um é associada a uma instância de uma classe, ou seja, cada instância contém seu próprio conjunto de métodos e campos privados, conforme definido na classe.

Para tornar uma propriedade particular, adicione um # ao início do identificador quando você a declarar:

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

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

Um campo privado precisa ser declarado no corpo da classe que a contém. Você pode mudar o valor dele depois como uma propriedade de this, mas não é possível criar o campo. usando this.

Os campos privados não podem ser acessados de outro lugar em um script. Isso evita que os dados propriedades sejam alteradas fora dos métodos getter e setter fornecidos interajam com os valores que elas contêm e impede o acesso direto aos que se destinam apenas ao uso dentro da própria classe.

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 }

No entanto, tenha em mente que os navegadores consoles de desenvolvedores são geralmente muito permissivo, embora inconsistente, sobre permitir acesso a campos privados para depuração finalidades:

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

Os campos particulares têm um escopo restrito para o corpo da classe que os contém, ou seja, até mesmo as classes filhas não podem acessar campos privados associados a uma classe pai:

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

Campos e métodos estáticos

Os campos e métodos estáticos são membros de uma classe em si, não membros da instances dessa classe. Por isso, os campos estáticos fornecem uma camada central para dados que não serão exclusivos a cada instância de uma classe, instâncias podem precisar fazer referência, por exemplo, informações de configuração compartilhadas. Os métodos estáticos geralmente são funções utilitárias para trabalhar com instâncias de um como comparar ou classificar instâncias com relação a um campo que elas contenham.

Para definir campos e métodos estáticos no corpo de uma classe, use o método static palavra-chave:

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

Também é possível usar a notação de ponto para criar um método estático:

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

Não é possível acessar propriedades estáticas de uma instância da classe, mas elas são disponível no construtor da classe:

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."

Eles não são tecnicamente obrigatórios, mas o uso de métodos estáticos é a prática recomendada para criação de utilitários para trabalhar com instâncias de uma classe; Exemplos disso podem incluem um método estático dedicado para classificar instâncias de uma classe ou uma método de fábrica que contém as configurações necessárias para criar uma instância de um e, em seguida, retorna a instância da classe:

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" }

Teste seu conhecimento

Quais dos tipos de campos a seguir podem ser acessados apenas de dentro da classe?

Static fields
Campos da classe
Campos particulares