在TypeScript 0.9.0.1中，尽管会出现编译器错误，但编译器仍然可以将ts文件编译为js文件。代码工作如我们所料，Visual Studio 2012可以支持自动代码补全。

更新:

在语法上，TypeScript不允许我们用字符串值创建enum，但我们可以破解编译器:p

enum Link
{
    LEARN   =   <any>'/Tutorial',
    PLAY    =   <any>'/Playground',
    GET_IT  =   <any>'/#Download',
    RUN_IT  =   <any>'/Samples',
    JOIN_IN =   <any>'/#Community'
}

alert('Link.LEARN:    '                     + Link.LEARN);
alert('Link.PLAY:    '                      + Link.PLAY);
alert('Link.GET_IT:    '                    + Link.GET_IT);
alert('Link[\'/Samples\']:    Link.'        + Link['/Samples']);
alert('Link[\'/#Community\']    Link.'      + Link['/#Community']);

操场上

有很多答案，但我没有看到任何完整的解决方案。可接受的答案以及enum {this, one}的问题是，它分散了您碰巧在许多文件中使用的字符串值。我也不太喜欢“更新”，它很复杂，也没有利用类型。我认为Michael Bromley的回答是最正确的，但它的界面有点麻烦，可以用一个类型。

我使用的是TypeScript 2.0。+……这是我会做的

export type Greeting = "hello" | "world";
export const Greeting : { hello: Greeting , world: Greeting } = {
    hello: "hello",
    world: "world"
};

然后像这样使用:

let greet: Greeting = Greeting.hello

在使用有用的IDE时，它还具有更好的类型/悬停信息。缺点是你必须写两次字符串，但至少它只在两个地方。

使用typescript@next中提供的自定义转换器(https://github.com/Microsoft/TypeScript/pull/13940)，您可以从字符串字面类型创建字符串值的枚举对象。

请查看我的npm包，ts-transformer-enumerate。

使用示例:

// The signature of `enumerate` here is `function enumerate<T extends string>(): { [K in T]: K };`
import { enumerate } from 'ts-transformer-enumerate';

type Colors = 'green' | 'yellow' | 'red';
const Colors = enumerate<Colors>();

console.log(Colors.green); // 'green'
console.log(Colors.yellow); // 'yellow'
console.log(Colors.red); // 'red'

我在TypeScript 1.5中尝试过，如下所示，它对我来说很有效

module App.Constants {
   export enum e{
        Hello= ("Hello") as any,
World= ("World") as any
    }
}

这里有一个相当干净的解决方案，它允许继承，使用TypeScript 2.0。我没有在早期的版本上尝试过。

附加条件:该值可以是任何类型!

export class Enum<T> {
  public constructor(public readonly value: T) {}
  public toString() {
    return this.value.toString();
  }
}

export class PrimaryColor extends Enum<string> {
  public static readonly Red = new Enum('#FF0000');
  public static readonly Green = new Enum('#00FF00');
  public static readonly Blue = new Enum('#0000FF');
}

export class Color extends PrimaryColor {
  public static readonly White = new Enum('#FFFFFF');
  public static readonly Black = new Enum('#000000');
}

// Usage:

console.log(PrimaryColor.Red);
// Output: Enum { value: '#FF0000' }
console.log(Color.Red); // inherited!
// Output: Enum { value: '#FF0000' }
console.log(Color.Red.value); // we have to call .value to get the value.
// Output: #FF0000
console.log(Color.Red.toString()); // toString() works too.
// Output: #FF0000

class Thing {
  color: Color;
}

let thing: Thing = {
  color: Color.Red,
};

switch (thing.color) {
  case Color.Red: // ...
  case Color.White: // ...
}

@basarat的回答很棒。下面是一个你可以使用的简化但有点扩展的例子:

export type TMyEnumType = 'value1'|'value2';

export class MyEnumType {
    static VALUE1: TMyEnumType = 'value1';
    static VALUE2: TMyEnumType = 'value2';
}

console.log(MyEnumType.VALUE1); // 'value1'

const variable = MyEnumType.VALUE2; // it has the string value 'value2'

switch (variable) {
    case MyEnumType.VALUE1:
        // code...

    case MyEnumType.VALUE2:
        // code...
}