Come implementare le costanti di classe in dattiloscritto?

In TypeScript, la constparola chiave non può essere utilizzata per dichiarare le proprietà della classe. Ciò causa un errore del compilatore con "Un membro della classe non può avere la parola chiave 'const'."

Mi trovo nella necessità di indicare chiaramente nel codice che una proprietà non deve essere modificata. Voglio che l'IDE o il compilatore si verifichino se provo ad assegnare un nuovo valore alla proprietà una volta che è stata dichiarata. Come raggiungete questo ragazzi?

Attualmente sto usando una proprietà di sola lettura, ma sono nuovo su Typescript (e JavaScript) e mi chiedo se esiste un modo migliore:

get MY_CONSTANT():number {return 10};

Sto usando il dattiloscritto 1.8. Suggerimenti?

PS: ora sto usando il dattiloscritto 2.0.3, quindi ho accettato la risposta di David

TypeScript 2.0 ha il readonlymodificatore :

class MyClass {
    readonly myReadOnlyProperty = 1;

    myMethod() {
        console.log(this.myReadOnlyProperty);
        this.myReadOnlyProperty = 5; // error, readonly
    }
}

new MyClass().myReadOnlyProperty = 5; // error, readonly

Non è esattamente una costante perché consente l'assegnazione nel costruttore, ma molto probabilmente non è un grosso problema.

Soluzione alternativa

Un'alternativa è usare la staticparola chiave con readonly:

class MyClass {
    static readonly myReadOnlyProperty = 1;

    constructor() {
        MyClass.myReadOnlyProperty = 5; // error, readonly
    }

    myMethod() {
        console.log(MyClass.myReadOnlyProperty);
        MyClass.myReadOnlyProperty = 5; // error, readonly
    }
}

MyClass.myReadOnlyProperty = 5; // error, readonly

Questo ha il vantaggio di non essere assegnabile nel costruttore e di esistere solo in un posto.

Le costanti possono essere dichiarate al di fuori delle classi e utilizzate all'interno della classe. Altrimenti la getproprietà è una bella soluzione

const MY_CONSTANT: string = "wazzup";

export class MyClass {

    public myFunction() {

        alert(MY_CONSTANT);
    }
}

È possibile contrassegnare le proprietà con readonlymodificatore nella dichiarazione:

export class MyClass {
  public static readonly MY_PUBLIC_CONSTANT = 10;
  private static readonly myPrivateConstant = 5;
}

@vedi al libro di testo di tipo " Deep Dive" di sola lettura

Angolare 2 Fornisce una funzione molto bella chiamata Costanti Opache. Crea una classe e definisci tutte le costanti lì usando costanti opache.

import { OpaqueToken } from "@angular/core";

export let APP_CONFIG = new OpaqueToken("my.config");

export interface MyAppConfig {
    apiEndpoint: string;
}

export const AppConfig: MyAppConfig = {    
    apiEndpoint: "http://localhost:8080/api/"    
};

Inseriscilo nei provider in app.module.ts

Sarai in grado di usarlo su tutti i componenti.

EDIT per Angular 4:

Per Angular 4 il nuovo concetto è Token di iniezione e il token opaco è obsoleto in Angular 4.

Token di iniezione Aggiunge funzionalità oltre ai token opachi, consente di allegare informazioni sul tipo sul token tramite generici TypeScript, oltre ai token di iniezione, elimina la necessità di aggiungere @Inject

Codice di esempio

Angolare 2 con token opachi

const API_URL = new OpaqueToken('apiUrl'); //no Type Check


providers: [
  {
    provide: DataService,
    useFactory: (http, apiUrl) => {
      // create data service
    },
    deps: [
      Http,
      new Inject(API_URL) //notice the new Inject
    ]
  }
]

Angolare 4 Uso dei token di iniezione

const API_URL = new InjectionToken<string>('apiUrl'); // generic defines return value of injector


providers: [
  {
    provide: DataService,
    useFactory: (http, apiUrl) => {
      // create data service
    },
    deps: [
      Http,
      API_URL // no `new Inject()` needed!
    ]
  }
]

I token di iniezione sono progettati logicamente sulla parte superiore dei token opachi e i token opachi sono deprecati in Angular 4.

Utilizzare il modificatore readOnly con la costante che è necessario dichiarare oppure si può dichiarare una costante al di fuori della classe e utilizzarla specificamente solo nella classe richiesta utilizzando l'operatore get.

Per questo è possibile utilizzare il readonlymodificatore. Proprietà dell'oggetto che sonoreadonly possono essere assegnate solo durante l'inizializzazione dell'oggetto.

Esempio in classe:

class Circle {
  readonly radius: number;

  constructor(radius: number) {
    this.radius = radius;
  }

  get area() {
    return Math.PI * this.radius * 2;
  }
}

const circle = new Circle(12);
circle.radius = 12; // Cannot assign to 'radius' because it is a read-only property.

Esempio in oggetti letterali:

type Rectangle = {
  readonly height: number;
  readonly width: number;
};

const square: Rectangle = { height: 1, width: 2 };
square.height = 5 // Cannot assign to 'height' because it is a read-only property

Vale anche la pena sapere che il readonlymodificatore è puramente un costrutto dattiloscritto e quando il TS viene compilato in JS il costrutto non sarà presente nel JS compilato. Quando stiamo modificando le proprietà che sono di sola lettura, il compilatore TS ci avvertirà (è JS valido).

Per me nessuna delle risposte precedenti funziona. Ho dovuto convertire la mia classe statica in enum. Come questo:

export enum MyConstants {
  MyFirstConstant = 'MyFirstConstant',
  MySecondConstant = 'MySecondConstant'
}

Quindi nel mio componente aggiungo una nuova proprietà come suggerito in altre risposte

export class MyComponent {
public MY_CONTANTS = MyConstans;
constructor() { }
}

Quindi nel modello del mio componente lo uso in questo modo

<div [myDirective]="MY_CONTANTS.MyFirstConstant"> </div>

EDIT: mi dispiace. Il mio problema era diverso da quello di OP. Lascio ancora questo qui se qualcun altro ha lo stesso problema di I.