https://RustRocket.rs -- Cloud Monk Losang Jinpa, Ph.D., MCSE / MCT, https://Rustaceans.rs, Full Stack Cloud Native Rust DevOps Engineer - Rocket Framework Rust Microservices on Kubernetes-AWS-Azure-GCP

Return to TypeScript Version History, TypeScript, JavaScript

TypeScript 3.4, released in March 2019, introduced several notable features and improvements aimed at enhancing developer productivity, optimizing performance, and extending the language's capabilities for type manipulation and runtime behavior. This version continued TypeScript's commitment to align closely with ECMAScript standards while providing powerful tools for large-scale application development. Below is an overview of the main features and enhancements introduced in TypeScript 3.4, along with comparisons to similar features in other programming languages. Additionally, essential links to TypeScript resources are provided.

- 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. Incremental Builds (`–incremental`)

TypeScript 3.4 introduced the `–incremental` flag, significantly reducing subsequent build times by saving information about the project graph from the last compilation. This feature marks TypeScript's continued efforts to improve developer experience through faster compilation times.

```bash tsc –incremental ```

Incremental compilation is a concept found in many programming languages, such as C# (with MSBuild) and Java (with tools like Gradle), to improve build performance. Python's interpreted nature means it doesn't compile in the same way, but similar concepts exist in tools like `mypy` for type checking.

1. `const` Assertions

TypeScript 3.4 introduced `const` assertions. By using `as const`, developers can signal to the compiler that no literal types in an object should be widened (e.g., string literals should not be widened to `string`), and objects should be treated as readonly.

```typescript let example = {

 name: "TypeScript",
 version: 3.4

JavaScript does not have a direct equivalent since it does not support type annotations. C# has `readonly` modifiers and `const` for compile-time constants. Java has `final`. Python uses type comments or type annotations (PEP 484) for similar purposes but does not have built-in immutability enforcement.

1. Type-Checking for `globalThis`

TypeScript 3.4 added support for `globalThis`, providing a standardized way to access the global `this` value with type safety. This addition aligns TypeScript with the ECMAScript proposal for a consistent global namespace object.

```typescript console.log(globalThis); ```

`globalThis` is a standardization effort in ECMAScript, thus JavaScript. C# uses `global` in a different context. Java and Python do not have a direct equivalent because they have different runtime environments and scoping rules.

1. Higher Order Type Inference from Generic Functions

TypeScript 3.4 improved type inference in higher-order functions, allowing for more precise typing in common patterns, particularly with functions that return functions or take functions as arguments.

```typescript function compose<A, B, C>(f: (a: A) ⇒ B, g: (b: B) ⇒ C): (a: A) ⇒ C {

 return x => g(f(x));

C#'s and Java's generics provide similar capabilities for type inference in higher-order functions. Python's typing module introduced in Python 3.5 offers generics and function overloads through `typing`, but with less powerful type inference capabilities.

1. ReadonlyArray and Readonly Tuples

TypeScript 3.4 made it possible to specify arrays and tuples as readonly, preventing assignments to indices and ensuring the immutability of the data structure.

```typescript function exampleFunction(items: readonly string[]) {

 // items.push("hello"); // Error: push does not exist on readonly arrays

JavaScript arrays are mutable by nature, and immutability can only be enforced at runtime. C# has `ReadOnlyCollection<T>`. Java offers unmodifiable collections through `Collections.unmodifiableList`. Python achieves immutability through tuple data structures, but without static type enforcement.

1. `readonly` and Mapped Types

Building on readonly capabilities, TypeScript 3.4 allows the `readonly` modifier to be used in mapped types, making it easier to create immutable versions of existing types.

```typescript type ReadonlyPerson = { readonly [K in keyof Person]: Person[K] }; ```

C#'s record types in C# 9.0 and onwards offer similar immutability features. Java's record (Java 14 and later) provides immutable data carriers. Python's data classes (with `frozen=True`) provide immutability for class instances, but without TypeScript's compile-time type safety.

1. Conclusion

TypeScript 3.4 continued to push the boundaries of what developers can achieve with static types in JavaScript, providing tools to write safer, more maintainable code. Features like incremental builds, `const` assertions, and improved

type inference enhance the language's usability and performance. Comparing these features with those in C#, Java, and Python underscores TypeScript's unique position in leveraging JavaScript's flexibility while offering the robustness of a statically typed language. These advancements demonstrate TypeScript's commitment to evolving in response to community feedback and the changing landscape of web development, ensuring it remains a powerful tool for developers worldwide.