Class fields

Baseline Widely available

This feature is well established and works across many devices and browser versions. Its been available across browsers since septiembre de 2022.

Learn more
See full compatibility

Nota: Las declaraciones de campos pblicos y privados son una caracterstica experimental (en estado 3) propuesta por el TC39, el comite de estandares de JavaScript. El soporte y funcionamiento en navegadores es limitado, pero la funcionalidad puede ser usada a travs de un paso durante el proceso del build por medio de sistemas como Babel. Revise compat information mas abajo.

Los campos pblicos y estticos son propieades editables, enumerables, y configurables. A diferencia de su contraparte privada, estos participan en la herencia de prototipo.

Sintaxis

class ClassWithInstanceField {
  instanceField = "instance field";
}

class ClassWithStaticField {
  static staticField = "static field";
}

class ClassWithPublicInstanceMethod {
  publicMethod() {
    return "hello world";
  }
}

Ejemplos

Campos pblicos estticos

Los campos estticos pblicos son tiles cuando desea que exista un campo solo una vez por clase, no en cada instancia de clase que cree. Esto es til para cachs, configuracin fija o cualquier otro dato que no necesite replicarse en todas las instancias.

Los campos estticos pblicos se declaran utilizando la palabra clave static. Se agregan al constructor de la clase en el momento de la evaluacin de la clase utilizando Object.defineProperty(). Se accede nuevamente desde el constructor de la clase.

class ClassWithStaticField {
  static staticField = "static field";
}

console.log(ClassWithStaticField.staticField);
// expected output: "static field"

Campos sin inicializadores son inicializados como undefined.

class ClassWithStaticField {
  static staticField;
}

console.assert(ClassWithStaticField.hasOwnProperty("staticField"));
console.log(ClassWithStaticField.staticField);
// expected output: "undefined"

Los campos estticos pblicos no se reinicializan en las subclases, pero se puede acceder a ellos a travs de la cadena de prototipo.

class ClassWithStaticField {
  static baseStaticField = "base field";
}

class SubClassWithStaticField extends ClassWithStaticField {
  static subStaticField = "sub class field";
}

console.log(SubClassWithStaticField.subStaticField);
// expected output: "sub class field"

console.log(SubClassWithStaticField.baseStaticField);
// expected output: "base field"

Cuando se inicializasn campos this se refiere al constuctor de clase. Tambien puede ser referenciado por nombre, y se puede usar super para obtener el constructor de la superclase si lo tiene.

class ClassWithStaticField {
  static baseStaticField = "base static field";
  static anotherBaseStaticField = this.baseStaticField;

  static baseStaticMethod() {
    return "base static method output";
  }
}

class SubClassWithStaticField extends ClassWithStaticField {
  static subStaticField = super.baseStaticMethod();
}

console.log(ClassWithStaticField.anotherBaseStaticField);
// expected output: "base static field"

console.log(SubClassWithStaticField.subStaticField);
// expected output: "base static method output"

Campos de instancia pblicos

Los campos de instancia pblicos existen en cada instancia de la clase que se ha creado. Al declarar un campo publico podemos asegurarnos que dicho campo siempre esta presente, y la definicion de la clase esta auto-documentada.

Los campos de instancia pblicos son agregados with Object.defineProperty ya sea a la hora de ser construido en la clase base (antes que el metodo constructor corra), o justo despues que super() returne en una subclase.

class ClassWithInstanceField {
  instanceField = "instance field";
}

const instance = new ClassWithInstanceField();
console.log(instance.instanceField);
// expected output: "instance field"

Campos sin inicializadores son inicilizados en undefined.

class ClassWithInstanceField {
  instanceField;
}

const instance = new ClassWithInstanceField();
console.assert(instance.hasOwnProperty("instanceField"));
console.log(instance.instanceField);
// expected output: "undefined"

Al igual que las propiedades, los nombres de campos pueden ser calculados (computed)

const PREFIX = "prefix";

class ClassWithComputedFieldName {
  [`${PREFIX}Field`] = "prefixed field";
}

const instance = new ClassWithComputedFieldName();
console.log(instance.prefixField);
// expected output: "prefixed field"

Cuando se inicializan campos this se refiere a la instancia de clase que esta siendo construida. Al igual que con los metodos publicos de instancia, si usted esta en una subclase puede acceder a al prototypo de la superclase usando super.

class ClassWithInstanceField {
  baseInstanceField = "base field";
  anotherBaseInstanceField = this.baseInstanceField;
  baseInstanceMethod() {
    return "base method output";
  }
}

class SubClassWithInstanceField extends ClassWithInstanceField {
  subInstanceField = super.baseInstanceMethod();
}

const base = new ClassWithInstanceField();
const sub = new SubClassWithInstanceField();

console.log(base.anotherBaseInstanceField);
// expected output: "base field"

console.log(sub.subInstanceField);
// expected output: "base method output"

Mtodos pblicos

Mtodos pblicos estticos

La palabra reservada static define un metodo esttico para una clase. Los mtodos estticos no son llamads usando una instancia de la clase. En lugar de eso son llamados sobre la clase como tal. Estos metodos estticos son frecuentemente funciones utilitarias que permiten por ejemplo la creacin y clonacion de objetos.

class ClassWithStaticMethod {
  static staticMethod() {
    return "static method has been called.";
  }
}

console.log(ClassWithStaticMethod.staticMethod());
// expected output: "static method has been called."

Los mtodos estticos son agregados al constructor de la clase usando Object.defineProperty duranten el evaluacin de la clase. Estos metodos son "escribibles" (writable), no-enumerables y configurables.

Mtodos pblicos de instancia

Como su nombre lo indica, los mtodos publicos de instancia son metodos que estan disponibles para cualquier instancia de una clase.

class ClassWithPublicInstanceMethod {
  publicMethod() {
    return "hello world";
  }
}

const instance = new ClassWithPublicInstanceMethod();
console.log(instance.publicMethod());
// expected output: "hello world"

Los mtodos pblicos de instancia son agregeados al prototipo de clase durante la evaluacn de la clase usando Object.defineProperty. Estos metodos son "escribibles" (writable), no-enumerables y configurables.

Usted puede usar un generador, async y funciones generadoras asincronas

class ClassWithFancyMethods {
  *generatorMethod() {}
  async asyncMethod() {}
  async *asyncGeneratorMethod() {}
}

Dentro de un metodo de instancia, this se referie a la instancia como tal. En las subclases, super le permite acceder el prototipo de la superclase, permitiendo as llamar mtodos de la superclase.

class BaseClass {
  msg = "hello world";
  basePublicMethod() {
    return this.msg;
  }
}

class SubClass extends BaseClass {
  subPublicMethod() {
    return super.basePublicMethod();
  }
}

const instance = new SubClass();
console.log(instance.subPublicMethod());
// expected output: "hello world"

Existen metodos especiales llamados "Getters" y "Setters" que se vinculan a una propiedad de una clase, y que son ejecutados o llamados cuando esa propiedad es consultada o moditficada. Puede usar las palabras reservaddas get y set para declarar una instancia pblica de "getter" or "setter". [N.T. prefer decir Getter/Setter que decir Consultadores/Mofificadores]

class ClassWithGetSet {
  #msg = "hello world";
  get msg() {
    return this.#msg;
  }
  set msg(x) {
    this.#msg = `hello ${x}`;
  }
}

const instance = new ClassWithGetSet();
console.log(instance.msg);
// expected output: "hello world"

instance.msg = "cake";
console.log(instance.msg);
// expected output: "hello cake"

Campos privados

Campos privados estticos

Private fields are accessible on the class constructor from inside the class declaration itself.

The limitation of static variables being called by only static methods still holds.

class ClassWithPrivateStaticField {
  static #PRIVATE_STATIC_FIELD;

  static publicStaticMethod() {
    ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD = 42;
    return ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD;
  }
}

assert(ClassWithPrivateStaticField.publicStaticMethod() === 42);

Private static fields are added to the class constructor at class evaluation time.

There is a provenance restriction on private static fields. Only the class which defines the private static field can access the field. This can lead to unexpected behaviour when using this

class BaseClassWithPrivateStaticField {
  static #PRIVATE_STATIC_FIELD;

  static basePublicStaticMethod() {
    this.#PRIVATE_STATIC_FIELD = 42;
    return this.#PRIVATE_STATIC_FIELD;
  }
}

class SubClass extends BaseClassWithPrivateStaticField {}

assertThrows(() => SubClass.basePublicStaticMethod(), TypeError);

Campos privados de instancia

Private instance fields are declared with # names ( pronounced "hash names"), which are identifiers prefixed with #. The # is a part of the name itself and is used for declaration and accessing as well.

The encapsulation is enforced by the language. It is a syntax error to refer to # names not in scope.

class ClassWithPrivateField {
  #privateField;

  constructor() {
    this.#privateField = 42;
    this.#randomField = 666; # Syntax error
  }
}

const instance = new ClassWithPrivateField();
instance.#privateField === 42; // Syntax error

Mtodos privados

Mtodos privados estticos

Like their public equivalent, private static methods are called on the class, not instances of the class. Like private static fields, they are only accessible from inside the class declaration.

Private static methods may be generator, async and async generator functions.

class ClassWithPrivateStaticMethod {
  static #privateStaticMethod() {
    return 42;
  }

  static publicStaticMethod() {
    return ClassWithPrivateStaticMethod.#privateStaticMethod();
  }
}

assert(ClassWithPrivateStaticField.publicStaticMethod() === 42);

Mtodos privados de instancia

Private instance methods are methods available on class instances whose access is restricted in the same manner as private instance fields.

class ClassWithPrivateMethod {
  #privateMethod() {
    return 'hello world';
  }

  getPrivateMessage() {
      return #privateMethod();
  }
}

const instance = new ClassWithPrivateMethod();
console.log(instance.getPrivateMessage());
// expected output: "hello world"

Private instance methods may be generator, async or async generator functions. Private getters and setters are also possible:

class ClassWithPrivateAccessor {
  #message;

  get #decoratedMessage() {
    return `${this.#message}`;
  }
  set #decoratedMessage(msg) {
    this.#message = msg;
  }

  constructor() {
    this.#decoratedMessage = "hello world";
    console.log(this.#decoratedMessage);
  }
}

new ClassWithPrivateAccessor();
// expected output: "hello world"

Especificaciones

Specification
ECMAScript 2027 LanguageSpecification # prod-FieldDefinition

Compatibilidad con navegadores

Ver tambin

The Semantics of All JS Class Elements

Help improve MDN

Was this page helpful to you?

Yes No

Learn how to contribute

This page was last modified on 29 may 2026 by MDN contributors.

View this page on GitHub Report a problem with this content

Class fields

In this article

Mtodos pblicos estticos

Mtodos pblicos de instancia

Help improve MDN