https://DevOpsCloud.io -- Cloud Monk Losang Jinpa

Return to TypeScript Version History, TypeScript, JavaScript

---

TypeScript 3.1, released in September 2018, introduced several key features aimed at enhancing the developer experience, improving the language's type-checking capabilities, and streamlining the development process for large-scale applications. This version focused on incremental improvements that further solidified TypeScript's position as a powerful tool for building robust web applications. Below is a summary of the main features and improvements in TypeScript 3.1, including code examples, comparisons to similar features in other programming languages, and links to essential TypeScript resources.

- Language Documentation: [TypeScript Documentation](https://www.typescriptlang.org/docs/) - GitHub Repository: [TypeScript GitHub](https://github.com/microsoft/TypeScript) - Official Website: [TypeScript](https://www.typescriptlang.org/) - Wikipedia: [TypeScript Wikipedia](https://en.wikipedia.org/wiki/TypeScript)

1. Mapped Types on Tuples and Arrays

TypeScript 3.1 extended mapped types to support tuples and arrays, enabling developers to create mapped types that transform the types of tuple and array elements.

```typescript type StringArray = string[]; type UppercasedStringArray = { [K in keyof StringArray]: Uppercase<StringArray[K]> }; ```

JavaScript does not have a type system, so this feature is specific to TypeScript. C# has similar capabilities with generics and LINQ. Java's streams can perform transformations on arrays and lists, but not at the type level. Python's type hints in PEP 484 do not support this kind of transformation.

1. Properties Declarations on Functions

TypeScript 3.1 introduced the ability to declare properties on functions, enhancing support for patterns where functions also have properties attached to them.

```typescript function greet(name: string) {

 console.log("Hello, " + name);

} greet.someProperty = 42; ```

JavaScript functions can naturally have properties, but TypeScript 3.1 allows for type-safe declarations of these properties. C# delegates and Java methods cannot have properties in the same way. Python functions can have attributes assigned to them, but without static type checking.

1. Version Selection with `typesVersions`

TypeScript 3.1 added support for the `typesVersions` field in `package.json`, allowing package authors to specify different type definitions for different TypeScript versions, improving library compatibility.

```json {

 "typesVersions": {
   "<3.1": { "*": ["ts3.0/*"] }
 }

} ```

This feature is unique to TypeScript's ecosystem. C#, Java, and Python manage library compatibility through different mechanisms, such as assembly versioning in C#, Maven or Gradle dependencies in Java, and package version specifications in Python's `pip`.

1. Refactor from `require` to `import`

TypeScript 3.1 introduced a refactor to convert `require` statements into `import` statements, aligning with modern JavaScript module syntax and promoting best practices.

```typescript // Before refactor const express = require(“express”);

// After refactor import express from “express”; ```

JavaScript ES modules offer `import` and `export` syntax, which TypeScript encourages. C#, Java, and Python have their own module and package import systems, unrelated to TypeScript's ES module syntax.

1. Improved UX for Project References

TypeScript 3.1 improved the user experience for project references, making it easier to manage and build projects with complex dependencies.

This improvement is specific to TypeScript's project management features. C#, Java, and Python have their own systems for managing project references and dependencies, such as `.csproj` files in C#, `pom.xml` or `build.gradle` files in Java, and `requirements.txt` or `Pipfile` in Python.

1. Conclusion

TypeScript 3.1 continued TypeScript's trajectory of providing powerful tools for developers to write type-safe and maintainable JavaScript code. By introducing features like mapped types on tuples and arrays, property declarations on functions, and improved project reference management, TypeScript 3.1 enhances the language's versatility and developer productivity. Comparing these features with those available in C#, Java, and Python highlights TypeScript's unique approach to integrating static typing with JavaScript's dynamic nature, offering a compelling solution for developing complex web applications.

---