CoffeeScript, Dart, Elm, and TypeScript
TypeScript
Microsoft has also worked for several years on a JavaScript alternative named TypeScript [15]. JavaScript libraries like jQuery can still be used in TypeScript, which also adds proprietary constructs to the latest version of ECMAScript, much like CoffeeScript. Today, elements from TypeScript are regularly fed back into the official ECMAScript standard. Microsoft offers a compiler for TypeScript [16] that translates TypeScript programs into ECMAScript. Like the alternative scripting languages, you can test TypeScript programs in an online editor – the Playground editor (Figure 4) [17] in this case.
As in Dart, you need to set the variable type; the compiler then performs a static type check. In the following example, the second line defines a function; the return type follows the name:
var name: string = "Tim"; function output: void (a: string) { console.log(a); }
The void()
return type tells the compiler that the function returns nothing. The special return type never
defines functions that do not terminate, as is the case with exceptions. In addition to strings, TypeScript supports Boolean values (boolean
) and floating-point numbers (number
).
If the type of a variable is unknown, you explicitly assign the any
type, which tells the compiler to switch off type checking. Conversely, you can check the type explicitly two ways:
var length: any = (<string>firstname).length; var length: any = (firstname as string).length;
In functions, you can allow several alternative types for a single parameter. The following example passes in either a number or a string:
function foo(value: string | number) { ... }
You can also dictate the exact values that the string is allowed to contain (string literal types), which is useful to enforce certain settings in web applications. Like Dart, TypeScript supports the enumerated type enum
:
enum Color {Red, Yellow, Blue};
Tuples are an alternative. In the following example, workers
stores two values: John
and 34
. This pair of values can be accessed with the use of an index, as with an array:
var workers: var workers: workers = ["John", 34]. workers[1] = 35;
Classes are defined as in ES2015. On request, the TypeScript compiler translates them to older ECMAScript. If a property or a method is preceded by the private
keyword, only the methods from the class are allowed to access it. In the case of protected
, however, all derived classes also have access.
The static
keyword tells TypeScript to create properties that all objects of a class share. TypeScript adds notation for getter and setter methods:
class Auto { protected _model: string; get model(): string { return this. _model; }}
TypeScript adds interfaces to the class concept that describe only the structure or the interface of an object (e.g., Listing 4). A property that is marked with a question mark is optional. The extends
keyword lets an interface extend another interface or class; for classes, the interface only adopts the methods and properties.
Listing 4
Example of Interfaces in TypeScript
In TypeScript, two types are compatible with each other if their internal structure is the same. Unlike other languages, then, you do not need to implement the interface explicitly. It is sufficient if an object provides the interface described. Listing 4 shows an example in which sayHello()
correctly processes an Employee
. An interface describes functions as well as classes. In addition to interfaces are abstract classes, which only let you derive other classes.
In the case of objects created with const
, you can also change the properties of the object. This is only prevented by the readonly
keyword preceding the corresponding property. Indexable types transform an interface into an array or a dictionary.
In the following example, the Employees
interface comprises several names:
interface Employees {} [index: number]: string; }
Access is as in an array. Here, the index is a number, and the stored values are text (string
). You replace number
with string
to access the stored values by way of terms (e.g., zip["Lawrence"]
).
In some cases, TypeScript groups several declarations to form a single declaration (declaration merging). In the following example, the compiler automatically merges the two interface declarations:
interface Dot { x: number; } interface Dot { y: number; } let p: Dot = {x: 1, y: 2};
TypeScript also offers generics, with notation similar to Java or Dart. Mixins compile several classes to create a new one, and intersection types allow combining of types. For example, Person & Employee & Student
is a person, and an employee, and a student.
TypeScript supports ECMAScript modules and produces code that is suitable for modular solutions from Node.js (CommonJS), RequireJS (AMD), Isomorphic (UMD), and SystemJS. TypeScript encapsulates variables, classes, and other elements in its own namespace on request, reducing the risk that an imported function uses the same name as your own function.
If you enjoy experiments, you can already use decorators in the current version. They give a class, property, or method additional properties. The example assigns the decorator @sealed
to the class foo
:
@sealed class Foo { ... }
What this modification actually does is determined in a private function. The TypeScript compiler supports the JSX specification [18] and points out typical JavaScript errors. Plugins integrate TypeScript with multiple build tools such as Maven. Plugins exist for Atom, Eclipse, and many other editors and IDEs. The compiler itself is written in TypeScript and needs Node.js to execute.
The tools developed by Microsoft and the compiler itself are available under the Apache 2.0 license; the language specification is under the Open Web Foundation Final Specification Agreement Version 1.0 (OWF 1.0) [19] open license.
Conclusions
The choice between CoffeeScript, Dart, Elm, and TypeScript depends on the project in question, your requirements, and your own preferences. CoffeeScript is slightly out of touch with ECMAScript and does not offer type checking. The advantage of this scripting language is thus limited to Python-style code formatting with tabs and the ability to mix Markdown with CoffeeScript.
Dart can be run in a special VM and offers modern object-oriented concepts, such as mixins, but it is oriented more on Java and C than on JavaScript.
Elm specifically targets fans of functional programming who can develop web applications using familiar patterns of thought. Thanks to automatic type deduction, run-time errors are also rare in Elm.
TypeScript is now used as a playground for future versions of ECMAScript. Because it is based on JavaScript, making the move is easy, and typing ensures fewer run-time errors. Dart and TypeScript let you mix typed and typeless variables, so despite compiler support, a small error source remains.
Infos
- ECMAScript specification: https://github.com/tc39/ecma262/
- CoffeeScript: http://coffeescript.org
- jQuery: https://jquery.com
- CoffeeScript online editor: http://coffeescript.org
- Dart: https://www.dartlang.org
- Dartium: https://webdev.dartlang.org/tools/dartium
- Atom editor: https://atom.io
- Emacs: https://www.gnu.org/software/emacs/
- WebStorm: https://www.jetbrains.com/webstorm/
- DartPad: https://dartpad.dartlang.org
- Dart ECMA specification: http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf
- Elm: http://elm-lang.org
- IntelliJ IDEA: https://www.jetbrains.com/idea/
- Elm editor: http://elm-lang.org/try
- TypeScript: http://typescriptlang.org
- TypeScript tools on GitHub: https://github.com/Microsoft/Typescript
- TypeScript Playground: http://www.typescriptlang.org/play/index.html
- JSX: http://www.typescriptlang.org/docs/handbook/jsx.html
- OWF 1.0: https://github.com/Microsoft/Typescript/blob/master/doc/spec.md
« Previous 1 2
Buy this article as PDF
(incl. VAT)