ES6 sınıflarında statik sabitler bildiriliyor mu?

Ben sabitleri bir uygulamak istiyorum class, çünkü bu nerede onları kodu bulmak mantıklı.

Şimdiye kadar, aşağıdaki geçici yöntemleri statik yöntemlerle uyguluyorum:

class MyClass {
    static constant1() { return 33; }
    static constant2() { return 2; }
    // ...
}

Prototiplerle uğraşma olasılığı olduğunu biliyorum, ancak birçoğu buna karşı öneride bulunuyor.

ES6 sınıflarında sabitleri uygulamanın daha iyi bir yolu var mı?

İşte yapabileceğiniz birkaç şey:

Bir verme constile ilgili modül . Kullanım durumunuza bağlı olarak şunları yapabilirsiniz:

export const constant1 = 33;

Ve bunu gerektiğinde modülden içe aktarın. Veya statik yöntem fikrinizi temel alarak bir static get erişimcisi bildirebilirsiniz :

const constant1 = 33,
      constant2 = 2;
class Example {

  static get constant1() {
    return constant1;
  }

  static get constant2() {
    return constant2;
  }
}

Bu şekilde parantez gerekmez:

const one = Example.constant1;

Babel REPL Örneği

Daha sonra, dediğin gibi, a classbir işlev için sadece sözdizimsel şeker olduğundan, yazılamaz bir özelliği şu şekilde ekleyebilirsiniz:

class Example {
}
Object.defineProperty(Example, 'constant1', {
    value: 33,
    writable : false,
    enumerable : true,
    configurable : false
});
Example.constant1; // 33
Example.constant1 = 15; // TypeError

Sadece şöyle bir şey yapabilirsek iyi olabilir:

class Example {
    static const constant1 = 33;
}

Ancak maalesef bu sınıf özellik sözdizimi yalnızca bir ES7 teklifindedir ve o zaman bile constmülke eklenmesine izin vermez .

class Whatever {
    static get MyConst() { return 10; }
}

let a = Whatever.MyConst;

Benim için iş gibi görünüyor.

Kullanıyorum babelve aşağıdaki sözdizimi benim için çalışıyor:

class MyClass {
    static constant1 = 33;
    static constant2 = {
       case1: 1,
       case2: 2,
    };
    // ...
}

MyClass.constant1 === 33
MyClass.constant2.case1 === 1

Lütfen ön ayara ihtiyacınız olduğunu düşünün "stage-0".
Yüklemek için:

npm install --save-dev babel-preset-stage-0

// in .babelrc
{
    "presets": ["stage-0"]
}

Güncelleme:

şu anda kullan stage-3

Gelen bu belgede belirtir:

Prototip veri özelliklerini (yöntemler dışında) sınıf özelliklerini veya örnek özelliğini tanımlamanın (kasıtlı olarak) doğrudan bildirici bir yolu yoktur.

Bu, bilerek böyle olduğu anlamına gelir.

Belki yapıcıda bir değişken tanımlayabilirsiniz?

constructor(){
    this.key = value
}

Ayrıca, Object.freezesınıf (es6) / yapıcı işlevi (es5) nesnesini değiştirilemez hale getirmek için kullanmak da mümkündür :

class MyConstants {}
MyConstants.staticValue = 3;
MyConstants.staticMethod = function() {
  return 4;
}
Object.freeze(MyConstants);
// after the freeze, any attempts of altering the MyConstants class will have no result
// (either trying to alter, add or delete a property)
MyConstants.staticValue === 3; // true
MyConstants.staticValue = 55; // will have no effect
MyConstants.staticValue === 3; // true

MyConstants.otherStaticValue = "other" // will have no effect
MyConstants.otherStaticValue === undefined // true

delete MyConstants.staticMethod // false
typeof(MyConstants.staticMethod) === "function" // true

Sınıfı değiştirmeye çalışmak size yumuşak bir hata verecektir (herhangi bir hata atmayacak, sadece bir etkisi olmayacaktır).

Belki de tüm sabitlerinizi donmuş bir nesneye koymalısınız?

class MyClass {

    constructor() {
        this.constants = Object.freeze({
            constant1: 33,
            constant2: 2,
        });
    }

    static get constant1() {
        return this.constants.constant1;
    }

    doThisAndThat() {
        //...
        let value = this.constants.constant2;
        //...
    }
}

Gibi https://stackoverflow.com/users/2784136/rodrigo-botti dedi, ben aradığınız düşünüyorum Object.freeze(). İşte değişmez statiklere sahip bir sınıf örneği:

class User {
  constructor(username, age) {
    if (age < User.minimumAge) {
      throw new Error('You are too young to be here!');
    }
    this.username = username;
    this.age = age;
    this.state = 'active';
  }
}

User.minimumAge = 16;
User.validStates = ['active', 'inactive', 'archived'];

deepFreeze(User);

function deepFreeze(value) {
  if (typeof value === 'object' && value !== null) {
    Object.freeze(value);
    Object.getOwnPropertyNames(value).forEach(property => {
      deepFreeze(value[property]);
    });
  }
  return value;
}

İşte yapmanın bir yolu daha

/*
one more way of declaring constants in a class,
Note - the constants have to be declared after the class is defined
*/
class Auto{
   //other methods
}
Auto.CONSTANT1 = "const1";
Auto.CONSTANT2 = "const2";

console.log(Auto.CONSTANT1)
console.log(Auto.CONSTANT2);

Not - Sipariş önemlidir, yukarıdaki sabitlere sahip olamazsınız

Kullanım console.log (Auto.CONSTANT1);

ES6 sınıflarının tuhaf bir özelliğini kullanarak bir sınıftaki statik sabitleri tanımlamanın bir yolunu oluşturabilirsiniz. Statik alt sınıfları tarafından miras alındığından, aşağıdakileri yapabilirsiniz:

const withConsts = (map, BaseClass = Object) => {
  class ConstClass extends BaseClass { }
  Object.keys(map).forEach(key => {
    Object.defineProperty(ConstClass, key, {
      value: map[key],
      writable : false,
      enumerable : true,
      configurable : false
    });
  });
  return ConstClass;
};

class MyClass extends withConsts({ MY_CONST: 'this is defined' }) {
  foo() {
    console.log(MyClass.MY_CONST);
  }
}

Sınıfı dondurarak "sabitleri" salt okunur (değişmez) yapabilirsiniz. Örneğin

class Foo {
    static BAR = "bat"; //public static read-only
}

Object.freeze(Foo); 

/*
Uncaught TypeError: Cannot assign to read only property 'BAR' of function 'class Foo {
    static BAR = "bat"; //public static read-only
}'
*/
Foo.BAR = "wut";

Eğer işlev ve sınıf sözdizimi arasında rahat karıştırma ve eşleştirme yapıyorsanız, dersten sonra sabitleri bildirebilirsiniz (sabitler 'kaldırılır'). Visual Studio Code, karışık sözdizimini otomatik olarak biçimlendirmek için uğraşacağını unutmayın (çalışmasına rağmen).

class MyClass {
    // ...

}
MyClass.prototype.consts = { 
    constant1:  33,
    constant2: 32
};
mc = new MyClass();
console.log(mc.consts.constant2);    

Bunu ben yaptım.

class Circle
{
    constuctor(radius)
    {
        this.radius = radius;
    }
    static get PI()
    {
        return 3.14159;
    }
}

PI değeri bir işlevden döndürülen bir değer olduğundan değiştirilmeye karşı korunur. Buna Circle.PI aracılığıyla erişebilirsiniz. Herhangi bir atama girişimi, [] aracılığıyla bir dize karakterine atama girişimine benzer bir şekilde yere bırakılır.

Bunu şu şekilde tanımlayabilirsiniz:

class Foo {
  static MyConst = 200;

  myFunc() {
    const doubleConst = Foo.MyConst * 2;
  }
}

import * asSözdizimi kullanabilirsiniz . Sınıf olmasa da gerçek constdeğişkenlerdir.

Constants.js

export const factor = 3;
export const pi = 3.141592;

index.js

import * as Constants from 'Constants.js'
console.log( Constants.factor );