typescript

TypeScript 3.3

Return to TypeScript Version History, TypeScript, JavaScript

TypeScript 3.3, released in January 2019, introduced a smaller set of new features compared to previous releases, focusing on enhancements that improve the language's usability and developer experience. This version aimed at refining existing capabilities and fixing known issues, demonstrating TypeScript's commitment to stability and performance. Below is a summary of the main features and improvements in TypeScript 3.3, including code examples and 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)

Improved Behavior for Calling Union Types

TypeScript 3.3 improved the behavior when calling functions that are part of a union type, making it easier to work with functions that might have different sets of parameters.

```typescript type StringOrNumberFunc = ¹⁾; // Correct usage ```

JavaScript's dynamic nature allows `bind`, `call`, and `apply` without static type checks. C# uses delegates and `Expression` trees to achieve similar functionality, with strong typing. Java's method references and functional interfaces offer similar capabilities in a statically typed manner. Python's `functools.partial` function can be used to pre-bind arguments to functions, but without static type checking.

Conclusion

TypeScript 3.3 focused on enhancing developer productivity and improving the language's tooling and compilation strategies. While this release was smaller in scope, the improvements to union type function calls and the build system for composite projects represent TypeScript's ongoing efforts to balance new feature development with optimizations and stability enhancements. Comparing these features with those in languages like C#, Java, and Python highlights TypeScript's unique position in the development ecosystem, providing JavaScript developers with tools typically found in statically typed languages to ensure code reliability and efficiency.

SYI LU SENG E MU CHYWE YE. NAN. WEI LA YE. WEI LA YE. SA WA HE.

¹⁾

str: string) ⇒ void) | ((num: number) ⇒ void); function func(fn: StringOrNumberFunc) {

 fn("test"); // Correctly identified as an error in TS 3.3

} ``` In comparison, JavaScript does not have static typing, so similar patterns would not cause compile-time errors. C# and Java have method overloading, which can achieve similar functionality but requires methods to be part of the same class. Python uses duck typing, with runtime checks typically used to handle different parameter types.

Incremental File Watching for Composite Projects

TypeScript 3.3 introduced more efficient file watching for composite projects. This feature optimizes the incremental build process, reducing build times by only recompiling affected files and their dependencies. ```json {

 "compilerOptions": {
   "incremental": true,
   "composite": true
 }

} ``` This feature is specific to TypeScript's build system. C# and Java IDEs have similar features for incremental builds in large projects, typically managed by the IDE or build tools like MSBuild for C# and Gradle or Maven for Java. Python does not have a direct equivalent but tools like `watchdog` can be used for watching file changes in development.

Smarter Type-Checking for the `bind`, `call`, and `apply` Methods

TypeScript 3.3 made type-checking for `bind`, `call`, and `apply` methods on functions stricter, ensuring that arguments for these methods match the original function's parameters more accurately. ```typescript function add(a: number, b: number) {

 return a + b;

} const addOne = add.bind(null, 1); console.log(addOne(2