Union types are a powerful way to express a value that can be one of several types. For example, you might have an API for running a program that takes a commandline as either a string, a string[] or a function that returns a string. You can now write:
\ntsinterface RunOptions {\n program: string;\n commandline: string[]|string|(() => string);\n}
Assignment to union types works very intuitively — anything you could assign to one of the union type’s members is assignable to the union:
\n\ntsvar opts: RunOptions = /* ... */;\nopts.commandline = '-hello world'; // OK\nopts.commandline = ['-hello', 'world']; // OK\nopts.commandline = [42]; // Error, number is not string or string[]
When reading from a union type, you can see any properties that are shared by them:
\n\ntsif (opts.length === 0) { // OK, string and string[] both have 'length' property\n console.log(\"it's empty\");\n}
Using Type Guards, you can easily work with a variable of a union type:
\n\ntsfunction formatCommandline(c: string|string[]) {\n if (typeof c === 'string') {\n return c.trim();\n }\n else {\n return c.join(' ');\n }\n}
With union types able to represent a wide range of type scenarios, we’ve decided to improve the strictness of certain generic calls. Previously, code like this would (surprisingly) compile without error:
\n\ntsfunction equal<T>(lhs: T, rhs: T): boolean {\n return lhs === rhs;\n}\n\n// Previously: No error\n// New behavior: Error, no best common type between 'string' and 'number'\nvar e = equal(42, 'hello');
With union types, you can now specify the desired behavior at both the function declaration site and the call site:
\n\nts// 'choose' function where types must match\nfunction choose1<T>(a: T, b: T): T { return Math.random() > 0.5 ? a : b }\nvar a = choose1('hello', 42); // Error\nvar b = choose1<string|number>('hello', 42); // OK\n\n// 'choose' function where types need not match\nfunction choose2<T, U>(a: T, b: U): T|U { return Math.random() > 0.5 ? a : b }\nvar c = choose2('bar', 'foo'); // OK, c: string\nvar d = choose2('hello', 42); // OK, d: string|number
Union types also allow for better type inference in arrays and other places where you might have multiple kinds of values in a collection:
\n\ntsvar x = [1, 'hello']; // x: Array<string|number>\nx[0] = 'world'; // OK\nx[0] = false; // Error, boolean is not string or number
let declarationsIn JavaScript, var declarations are “hoisted” to the top of their enclosing scope. This can result in confusing bugs:
\ntsconsole.log(x); // meant to write 'y' here\n/* later in the same block */\nvar x = 'hello';
The new ES6 keyword let, now supported in TypeScript, declares a variable with more intuitive “block” semantics. A let variable can only be referred to after its declaration, and is scoped to the syntactic block where it is defined:
\ntsif (foo) {\n console.log(x); // Error, cannot refer to x before its declaration\n let x = 'hello';\n}\nelse {\n console.log(x); // Error, x is not declared in this block\n}
let is only available when targeting ECMAScript 6 (--target ES6).
const declarationsThe other new ES6 declaration type supported in TypeScript is const. A const variable may not be assigned to, and must be initialized where it is declared. This is useful for declarations where you don’t want to change the value after its initialization:
\ntsconst halfPi = Math.PI / 2;\nhalfPi = 2; // Error, can't assign to a `const`
const is only available when targeting ECMAScript 6 (--target ES6).
TypeScript now supports ES6 template strings. These are an easy way to embed arbitrary expressions in strings:
\n\ntsvar name = \"TypeScript\";\nvar greeting = `Hello, ${name}! Your name has ${name.length} characters`;
When compiling to pre-ES6 targets, the string is decomposed:
\n\njsvar name = \"TypeScript!\";\nvar greeting = \"Hello, \" + name + \"! Your name has \" + name.length + \" characters\";
A common pattern in JavaScript is to use typeof or instanceof to examine the type of an expression at runtime. TypeScript now understands these conditions and will change type inference accordingly when used in an if block.
Using typeof to test a variable:
\ntsvar x: any = /* ... */;\nif(typeof x === 'string') {\n console.log(x.subtr(1)); // Error, 'subtr' does not exist on 'string'\n}\n// x is still any here\nx.unknown(); // OK
Using typeof with union types and else:
\ntsvar x: string | HTMLElement = /* ... */;\nif(typeof x === 'string') {\n // x is string here, as shown above\n}\nelse {\n // x is HTMLElement here\n console.log(x.innerHTML);\n}
Using instanceof with classes and union types:
\ntsclass Dog { woof() { } }\nclass Cat { meow() { } }\nvar pet: Dog|Cat = /* ... */;\nif (pet instanceof Dog) {\n pet.woof(); // OK\n}\nelse {\n pet.woof(); // Error\n}
You can now define an alias for a type using the type keyword:
\ntstype PrimitiveArray = Array<string|number|boolean>;\ntype MyNumber = number;\ntype NgScope = ng.IScope;\ntype Callback = () => void;
Type aliases are exactly the same as their original types; they are simply alternative names.
\nconst enum (completely inlined enums)Enums are very useful, but some programs don’t actually need the generated code and would benefit from simply inlining all instances of enum members with their numeric equivalents. The new const enum declaration works just like a regular enum for type safety, but erases completely at compile time.
\ntsconst enum Suit { Clubs, Diamonds, Hearts, Spades }\nvar d = Suit.Diamonds;
Compiles to exactly:
\n\njsvar d = 1;
TypeScript will also now compute enum values when possible:
\n\ntsenum MyFlags {\n None = 0,\n Neat = 1,\n Cool = 2,\n Awesome = 4,\n Best = Neat | Cool | Awesome\n}\nvar b = MyFlags.Best; // emits var b = 7;
-noEmitOnError commandline optionThe default behavior for the TypeScript compiler is to still emit .js files if there were type errors (for example, an attempt to assign a string to a number). This can be undesirable on build servers or other scenarios where only output from a “clean” build is desired. The new flag noEmitOnError prevents the compiler from emitting .js code if there were any errors.
This is now the default for MSBuild projects; this allows MSBuild incremental build to work as expected, as outputs are only generated on clean builds.
\nBy default AMD modules are generated anonymous. This can lead to problems when other tools are used to process the resulting modules like a bundlers (e.g. r.js).
The new amd-module name tag allows passing an optional module name to the compiler:
\nts//// [amdModule.ts]\n///<amd-module name='NamedModule'/>\nexport class C {\n}
Will result in assigning the name NamedModule to the module as part of calling the AMD define:
","headings":[{"value":"Union types","depth":2},{"value":"Overview","depth":3},{"value":"Stricter Generics","depth":3},{"value":"Better Type Inference","depth":3},{"value":"let declarations","depth":2},{"value":"const declarations","depth":2},{"value":"Template strings","depth":2},{"value":"Type Guards","depth":2},{"value":"Type Aliases","depth":2},{"value":"const enum (completely inlined enums)","depth":2},{"value":"-noEmitOnError commandline option","depth":2},{"value":"AMD Module names","depth":2}],"frontmatter":{"permalink":"/docs/handbook/release-notes/typescript-1-4.html","title":"TypeScript 1.4"}}},"pageContext":{"slug":"/docs/handbook/release-notes/typescript-1-4.html","isOldHandbook":true}}}js//// [amdModule.js]\ndefine(\"NamedModule\", [\"require\", \"exports\"], function (require, exports) {\n var C = (function () {\n function C() {\n }\n return C;\n })();\n exports.C = C;\n});