Why Typescript is our god now.

Using TypeScript for better code quality and maintainability in applications

What sounds like a very fancy idea, is actually something quite simple!
If you're working on a Javascript project, you know that maintaining a large codebase can be...challenging.
There's methods and Objects everywhere, that are ever expanding with no real set "shape", maybe you have an object so large, you couldn't possibly memorise all of its properties, wouldn't it be nice to just type myObject.x and get a whole list of methods and properties?
That's one of the ways , Typescript , a superset of JavaScript can make your life easier. It also adds static typing and many other useful features to the language. In this article, we'll discuss how TypeScript can help improve code quality and maintainability in a Node.js application.

Benefits of TypeScript in Node.js applications

Catching errors at compile-time

One of the main benefits of TypeScript is that it catches errors at compile-time, before your code even runs. This can help prevent bugs from being introduced into your codebase and make it easier to maintain. For example, if you try to assign a string to a variable that is supposed to be a number, TypeScript will give you a compile-time error.

Improved code maintainability

TypeScript also makes it easier to maintain large codebases. By adding types to your code, you can make it easier to understand what each function and variable is supposed to do. This can help make your code more self-documenting and reduce the amount of time it takes to understand and modify it.

Better tooling support

TypeScript also has better tooling support than plain JavaScript. Many editors and IDEs support TypeScript out of the box, providing features like code completion and error highlighting. Additionally, TypeScript integrates well with popular build tools like webpack and babel, making it easy to set up a build process for your project.

How to use TypeScript in a Node.js project

Using TypeScript in a Node.js project is easy. Here are the steps you need to follow:

1. Install TypeScript

To start using TypeScript in your Node.js project, you first need to install it. You can do this using npm (or yarn if you like that kind of thing), a package manager, by running the following command:

npm install --save-dev typescript

1. Set up your TypeScript configuration

Next, you need to set up your TypeScript configuration. Create a tsconfig.json file in the root of your project and add the following configuration:

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "outDir": "dist",
    "sourceMap": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

This configuration tells TypeScript to compile your code to ES6, use CommonJS as the module system, output the compiled code to the dist directory, generate source maps to aid in debugging, and include all files in the src directory. It also excludes the node_modules directory, which contains third-party modules that you don't need to compile.

1. Write your TypeScript code

Now that you have TypeScript installed and configured, you can start writing your code. Use the *.ts file extension for your TypeScript files.

function greet(name: string): void {
  console.log(`Hello, ${name}!`);
}

greet("Reader");

In this example, we've defined a simple function that takes a name parameter and logs a greeting to the console.

1. Compile your TypeScript code

To compile your TypeScript code, you need to run the TypeScript compiler. You can do this using the tsc command, which is included with the TypeScript package. Here's how you can compile your code:

npx tsc

This will compile your TypeScript code and generate JavaScript files in the dist directory.

1. Run your Node.js application

Now that you've compiled your TypeScript code to JavaScript, you can run your Node.js application as you normally would. Here's how you can run the example code we defined earlier:

bash

node dist/index.js

This will run the compiled JavaScript code and output the greeting to the console.

Conclusion

In this article, we've discussed how TypeScript can help improve code quality and maintainability in Node.js applications. We've also shown how to set up TypeScript in a Node.js project and compile TypeScript code to JavaScript. By using TypeScript in your Node.js projects, you can catch errors at compile-time, improve code maintainability, and benefit from better tooling support.

If you're interested in learning more about TypeScript, check out the official TypeScript documentation. Happy hacking!

Comments

[Charlie J Smotherman]

If I have to use a type system in my frontend then I would prefer to use a type system that is built into the core of the language such as rust.

I have been using Yew in combination with Tauri.
Diesel and Sqlite for data persistence.

Wasm, this is the way!

Happy Coding everyone

[dev procedure]

I do NOT see "real-world" problem being solved by using TypeScript.

All I see are silly examples of a "function that adds or divides 2 numbers' to justify "type checking". e.g., Who writes a function just to do basic math????

Next, developers are testing (aka runtime) their code LINE-BY-LINE anyway, so "compile-time" checking isn't all that beneficial in saving a developer time.

In other words, TypeScript add a layer of complexity that doesn't have that much benefit to JavaScript world.

Some JavaScript Notes:

1. Most data on the Client Side are STRINGS anyway.
2. NUMBERS and DATES are already validated in the client's browser anyway.

[Shahed]

There's one reason and only one reason to use Typescript: "YOU'VE NOT BEEN INTRODUCED TO Scala/ScalaJS YET!

I ruined part of carrier life wasting my time with Typescript.