DEV Community: Max Kovalevsky

I curate a daily newsletter with resources about Golang - Daily Golang. Here are the latest 6 issues of the newsletter

Max Kovalevsky — Mon, 19 Aug 2024 13:52:12 +0000

Hello everyone!

Not a while ago I started to run a daily newsletter with resources (blog posts, videos and projects) about Go (Golang) that I found interesting. Here are the latest 6 issues of the newsletter. I hope you will find it useful. Happy coding!

Daily Golang Issue #6 (2024-08-19)

Your daily hub for Go news, insights, and projects

⚡️ Latest

Here are the newest blog posts, videos, and projects from the Go community and all around it.

GopherCon UK published recordings of talks from the latest conference
📝 GopherCon UK 2024 by Jamie Tanna
🛠️ TreeGen
- ASCII Tree to Directory and File Structure Generator

🧭 Discoveries

Here is the list of discovered interesting blog posts, videos, and projects that are worth checking out.

📝 Blog Posts

Safer Enums in Go
- This post explores how to implement safer enums in Go, providing strategies to avoid common errors associated with enums and ensuring type safety in your code.
Random testing in Go by John Arundel
Sign in with Google in Go
- This post walks you through implementing Google OAuth authentication in a Go application. It covers setting up OAuth credentials, integrating with Google's API, and handling user sign-ins securely within your Go projects.
Building an interactive shell in Golang
- The author provides a guide to creating an interactive command-line shell in Go. The post covers topics like handling user input, executing commands, and managing the shell's environment, offering a practical approach to building robust CLI tools.

📹 Videos

🛠️ Projects

sirupsen/logrus
- Logrus is a structured, pluggable logging library for Go, designed to provide a flexible logging framework that supports various output formats and hooks.
fergusstrange/embedded-postgres
- Embedded Postgres allows running a real Postgres database locally as part of another Go application or test, providing a simple way to include Postgres in your development environment.

Daily Golang Issue #5 (2024-08-18)

Your daily hub for Go news, insights, and projects

⚡️ Latest

Here are the newest blog posts, videos, and projects from the Go community and all around it.

🧭 Discoveries

Here is the list of discovered interesting blog posts, videos, and projects that are worth checking out.

📝 Blog Posts

Moving Towards Domain Driven Design in Go
- This post discusses how to implement Domain-Driven Design (DDD) principles in Go applications. The author provides practical steps to transition from traditional application structures to DDD, focusing on aligning code with business domains for better maintainability.
Error wrapping in Go by John Arundel
Common Anti-Patterns in Go Web Applications
- The author identifies and explains several common anti-patterns in Go web applications, offering advice on how to avoid these pitfalls to create more efficient and maintainable code.
Implementing the Raft distributed consensus protocol in Go

📹 Videos

🛠️ Projects

spf13/viper
- A popular configuration management library in Go, supporting many formats, environment variables, remote configurations, and more, designed to work seamlessly with spf13/cobra.
rqlite/rqlite
- Rqlite is a lightweight, distributed relational database built on SQLite, offering an easy-to-use solution for applications requiring high availability and fault tolerance.

Daily Golang Issue #4 (2024-08-17)

Your daily hub for Go news, insights, and projects

🧭 Discoveries

Here is the list of discovered interesting blog posts, videos, and projects that are worth checking out.

📝 Blog Posts

Standalone test scripts by John Arundel
Using functional options instead of method chaining in Go
- Jon Calhoun advocates for the use of functional options as an alternative to method chaining in Go, explaining how this pattern can lead to more flexible and maintainable code.
Introduction to DDD Lite: When microservices in Go are not enough
- This article introduces a "DDD Lite" approach, explaining how it can be a middle ground between full-blown Domain-Driven Design (DDD) and simpler design patterns. It’s particularly useful when microservices alone do not sufficiently address complex business needs.
Context Control in Go

📹 Videos

🛠️ Projects

go-task/task
- simple "Make" alternative.
joho/godotenv)
- A Go port of the Ruby dotenv library, which loads environment variables from a .env file, making it easier to manage environment-specific configurations.

Daily Golang Issue #3 (2024-08-16)

Your daily hub for Go news, insights, and projects

⚡️ Latest

Here are the newest blog posts, videos, and projects from the Go community and all around it.

Go is my hammer, and everything is a nail
No Go Related:
- How to find ANYTHING in Linux – newb guide

🧭 Discoveries

Here is the list of discovered interesting blog posts, videos, and projects that are worth checking out.

📝 Blog Posts

Testing errors in Go by John Arundel
time.Now() and the Monotonic Clock
- The post discusses the use of time.Now() in Go, particularly focusing on the monotonic clock feature. The author explains how Go ensures time consistency across operations, crucial for preventing errors in time-sensitive applications.
Build Server With Go Under 10 minutes
Build a Go API with wallet authentication, JWT, Gin

📹 Videos

🛠️ Projects

gookit/config
- A comprehensive Go configuration management library that supports multiple file formats, environment variables, and command-line flags, offering flexibility in how configurations are loaded and merged.
onsi/ginkgo
- Ginkgo is a modern testing framework for Go, providing expressive syntax and powerful features for writing readable and maintainable tests, especially for behavior-driven development (BDD).

Daily Golang Issue #2 (2024-08-15)

Your daily hub for Go news, insights, and projects

⚡️ Latest

Here are the newest blog posts, videos, and projects from the Go community and all around it.

Go 1.23 Iterators Tutorial

🧭 Discoveries

Here is the list of discovered interesting blog posts, videos, and projects that are worth checking out.

📝 Blog Posts

Shameless green: TDD in Go by John Arundel
Distributed Computing With Dried, Salted Cod Fish, WASM, And (Tiny)Go
- This post creatively explores the use of WebAssembly (WASM) and TinyGo for distributed computing, drawing an analogy to the historical use of dried cod fish for trade. The author discusses the benefits of using TinyGo for running Go code in constrained environments like WASM.
Strategy pattern in Go
- This article explains the Strategy Pattern, a behavioral design pattern that allows an algorithm's behavior to be selected at runtime. The author demonstrates how to implement this pattern in Go, making code more flexible and easier to maintain.
How to start a Go project in 2023

📹 Videos

🛠️ Projects

Evertras/bubble-table
- A customizable and interactive table component designed for the Bubble Tea framework, allowing developers to build rich terminal-based UIs.
nanovms/ops
- A tool for building and running unikernels in Go, designed to simplify the creation of lightweight, secure applications by bundling them into single-purpose virtual machines.

Daily Golang Issue #1 (2024-08-14)

Your daily hub for Go news, insights, and projects

⚡️ Latest

Here are the newest blog posts, videos, and projects from the Go community and all around it.

🧭 Discoveries

Here is the list of discovered interesting blog posts, videos, and projects that are worth checking out.

📝 Blog Posts

Functional programming in Go by John Arundel
Connecting to a PostgreSQL database with Go's database/sql package
- A comprehensive guide on connecting to a PostgreSQL database using Go’s database/sql package. The post walks you through the steps to set up a connection, execute queries, and handle errors.
The One Billion Row Challenge in Go: from 1m45s to 3.4s in nine solutions
- The author discusses optimizing a Go program to handle one billion rows of data. The post details different strategies and solutions implemented to significantly reduce processing time, offering insights into performance tuning in Go.
How to parse a time or date in Go
- This article explains how to parse and format time and date strings in Go, covering common use cases and potential pitfalls. The author provides code examples to demonstrate how to handle various date and time formats effectively.

📹 Videos

🛠️ Projects

knadh/koanf
- A simple, lightweight, and extensible Go configuration management library, supporting JSON, TOML, YAML, and more. It allows easy merging and layering of configurations from various sources.
adrg/xdg
- A Go implementation of the XDG Base Directory Specification, providing a standardized way to manage user directories and application data locations across different operating systems.

Full Introduction to Golang with Test-Driven Development. Part I

Max Kovalevsky — Sun, 28 Jul 2024 15:52:42 +0000

This is a post based on the script for my video "A new learning way on how to write "Hello, World!" program in Go" which available "on my YouTube channel" and it is a part of the upcoming course "Grokking Go Fundamentals with Tests" (GGFT).

Hello and welcome. In this chapter, we will write our first Go program. As a tradition, we will create a classic "hello world" program. It is a program that prints "Hello, World!" in the terminal after you run it. In this series, we'll do all examples in the TDD way. TDD (test-driven development) is a special way of writing software. That special way of writing software is based on the Test-driven development cycle.

The Test-driven development cycle consists of the following steps:

Add a test, which means you have to write tests first for the code that solves your problem.
Run tests. All new tests must be failed because you don't have enough code that passes these tests.
Write the simplest code that passes the new test.
All tests now should be passed.
Refactor as needed, using tests after each refactor to ensure that functionality is preserved.
Repeat the cycle. So, for our first and all future examples, we're gonna follow the TDD way in general and TDD cycle in particular.

I found tests quite useful in daily programming practice but also it's a very practical way to learn a new programming language.

So first of all, we need to create a folder for our project. In this series, all our examples will be in one folder. Let's call it "go-sandbox," but you can name it whatever you want. I decided to name it "sandbox" because it will be a folder with a bunch of small examples that are mostly not related to each other; it will be basically a sandbox for our experiments with Go. I will create a folder using a Terminal emulator. You can use any terminal emulator app, for example, you can use one of the most popular terminal emulators on macOS that's called iTerm 2. In the Terminal, open the path where you're gonna create a folder for the project using the command cd.

cd projects/personal

Now I'm in the folder with all my personal projects, I'm gonna create a folder called "go-sandbox" using the command mkdir.

mkdir go-sandbox

Open this folder in the terminal using the cd command again. We will need the terminal with this opened folder later. After creating a folder open it in your editor or IDE of choice. I use different editors and IDEs for writing Go code such as Goland, VSCode, and Neovim but now I will open it inside Neovim. Once we opened the project folder in our editor, we need to talk about Go program structure. First of all, all Go projects must have a "go.mod" file where you define information about your module, such as the module's path, the minimum version of Go that uses this module, information about dependencies on other modules, etc.

But what is the module? Go code is organized into modules and packages. Basically, every Go program or project is a module. It should have a unique identifier, a path, which could be a location from which you can download this module. A module can be distributed as a dependency for another module. So, if you don't have a "go.mod" file in your project you need to use Go tool command go mod to create it or you can create it manually. Let's go back to the terminal and open the project's folder again. Type command go mod init <module_name> which in our case is go mod init go-sandbox. You will see that file "go.mod" appeared in the folder.

Now, let's follow our TDD cycle and do the first step. The first step of the test-driven development cycle is to add a test. But in the first example, let's start with creating a file that will contain the simplified version of the code for which we'll add a test. We're doing it first just to have some basic understanding of how Go code looks like. So first of all, let's start with creating a new folder for our package "helloworld" in the root of the project folder.

mkdir helloworld

Open the new folder in the terminal.

There, inside the folder, create a file called "helloworld.go" by using the command "touch," but you can create it inside your code editor.

touch helloworld.go

Open the file in your code editor. Our Go file was created and it's empty for now. Just follow me and write the first line in the file.

package helloworld

The very first line says package helloworld and that line is "package declaration." "Package declaration" always begins with the keyword "package" and must be in every Go file, and it specifies to which package file belongs to. But what is a package? Go programs are structured into packages - some kind of grouping units which Go program consist of. And as I mentioned before, every module has at least one package. We will talk about packages in future chapters.

Okay, we have our first Go file "helloworld.go"; so what's next? In most programming languages, the program "Hello, World!" contains a few lines of code where you call some method with the string "Hello, World!" as the first argument of this method. When you run the program, this method prints the string in the terminal. Since we're following the test-driven development way, we need to write a test that checks that our code works correctly and prints a string "Hello, World!" But we are not going to check the method that prints the string in the terminal. It requires a bit more knowledge for the first lesson. Instead, we're gonna write a simple function called "HelloWorld" that returns the string "Hello, World!".

If you had an experience with other programming languages before you probably know what a function is. But if not, here is a simple explanation of what a function is and what it is used for: a function is a named block of code that performs a specific task. It is like a mini-program within your program that you can call and use multiple times.

A function has a name that you choose to describe what it does. In our case, its name is "HelloWorld".
It can take inputs or parameters (if needed) to perform its task. Our function "HelloWorld" won't have any parameters.
It can also return a result (if needed) after completing its task. As I mentioned before, our function must return a string "Hello, World!"
Inside the function, you write the code that defines the task or actions it should perform.

For the function HelloWorld, we'll write a test that checks the function returns the expected value. And then in our main file of the program, we will call the function "HelloWorld" to pass the result of calling this function to the method that prints the string in the terminal. Okay, now let's start to write function HelloWorld. To write a function in Go you need to use the keyword "func".

func HelloWorld() {

}

This function doesn't return any values and doesn't have any logic inside for now. However, if we still follow the test-driven development cycle, we have to write the code inside the function on step 3.

So let's go back to step 1 and add a test for the function HelloWorld. In the folder of the package "helloworld," create the file called "helloworld_test.go." There are some naming rules for tests. Any test files that will be run by Go's built-in test runner must be named as "xxx_test.go" where "xxx" is the name of the file that contains the code which tests are written for. In our case, we're gonna write tests for the code inside the file called "helloworld.go," so we need to name our test file "helloworld_test.go."

In Go, to test some function, you need to write another function, a test function, inside a test file. This test function should contain checking of the function that we want to test. In our case, in the test function, we need to check that function HelloWorld returns the string "Hello, World!" So first of all, we need to write a function called "TestHelloWorld".

func TestHelloWorld() {

}

The name "TestHelloWorld" is very important here. There is a convention for naming a test function which looks like "TestXxx" where "Xxx" is the name of the function that we want to test, which is HelloWorld.

Okay, so now we need to write a checking that function HelloWorld returns a string "Hello, World!". To check the result of executing the function, we need to save this result somewhere first. We can use a variable to save the result of executing a function.

A variable is a named container that holds a value. It's like a labeled box that can store different types of information, such as numbers, text, or more complex data.

A variable has a name that you choose to identify it. In our case, the name is "got."
It can hold different types of values, such as numbers, strings, or booleans. Since the function "HelloWorld" returns a string, the variable "got" also should have a string type.
You can assign a value to a variable using the "=" operator. Once a value is assigned, you can change it or use it in your program.

There are several ways of declaring a variable in Go, but now we're gonna use the shortest one. It's called short variable declaration and it uses a special operator :=. The "short variable declaration" combines declaration and assignment of the variable. That means that you declare a type of the variable and also store some value in the variable.

someVariable := someValue

In our test function, we're gonna create a variable called "got":

func TestHelloWorld() {
    got := HelloWorld()
}

The line "HelloWorld()" means that we're calling the function HelloWorld() and it should return some value, and that value should be stored in a variable "got." Now let's declare another variable called "want."

func TestHelloWorld() {
    got := HelloWorld()
    want := "Hello, World!"
}

We just created a new variable called "want" and stored a value there, which is a string "Hello, World!" We're gonna use this variable to compare it with the variable "got," and that's how we will check that function HelloWorld returns the correct value.

Let's use an "if statement" to compare variables.

func TestHelloWorld() {
    got := HelloWorld()
    want := "Hello, World!"

    if expected != got {

    }
}

The "if statement" in Go is pretty much the same as the if statement in another programming language. It is used to make decisions based on a condition. It checks if something is true or false and executes different code depending on the result.

Here is a simplified algorithm for working with an "if statement":

You use the keyword "if" followed by a condition in parentheses.
If the condition is true, the code inside the "if" block is executed.
If the condition is false, the code inside the "if" block is skipped.

We use the "inequality operator" (!=) to check if the variable "want" and "got" have different values.

Okay, so what are we gonna do if variables will have different values? We need to show a message that this test failed. This message will be printed in the terminal where we will run tests for our Go program.

To show the message about the failed test, we need to use special methods that can be provided to us by Go's built-in testing framework. We can have access to Go's built-in testing framework's methods in each test function. All we need to do is just specify a parameter of the test function. So let's do it. In the function TestHelloWorld, we're gonna specify the parameter called "t," which has a special type, which is actually a struct. But don't focus too much on that now, we'll talk about this later.

func TestHelloWorld(t *testing.T) {
    got := HelloWorld()
    want := "Hello, World!"

    if want != got {

    }
}

All we need to know is that parameter "t" includes all methods of Go's built-in test framework that we need. The parameter "t" has type (capital) "T," and that capital T type is provided by the testing package. That's why we write "testing.T," not just capital T. So basically, we have a package called "testing" which is Go's built-in package.

However, to use type T from the package "testing," we need to be sure that we have access to things from package "testing" in OUR source file. For that, we need to import package "testing" in this file. In the beginning of the file, right below the package declaration, write a new line import "testing".

package helloworld

import "testing"

// ...

Now, inside the if statement body, let's call a method that will show a message that the test failed.

    if want != got {
        t.Errorf("Failed! Expected %q but received %q", want, got)
    }

We're using the method called "Errorf," and it takes the string as the first parameter. This string will be printed as a message that the test failed. You may notice that the string contains some special characters %q. The thing is that the method Errorf replaces all %q substrings by values from parameters after the first one. But there are plenty of combinations of substrings that begin with %q, and they all have their special meaning. All substrings that begin with % are called formatting verbs in Go. In this case, the formatting verb %q means that the value from the second parameter will be wrapped into double quotes and then inserted into the string from the first parameter.

Okay, we finished with our first test, and it means that we've done the first step in the Test-driven development cycle. Now it's time to make step 2 - run the test. To run the test, we're gonna use the go tool.

Open the terminal in the project folder. Now, in the terminal, type the command go test. It will show you the message:

❯ go test 
# hello-world [hello-world.test]
./hello_test.go:6:12: HelloWorld() (no value) used as value
FAIL    hello-world [build failed]

It says that the function that we're checking and calling inside the test does not return any values. And now we passed step 2 in our test-driven development cycle. Now it's time to do step 3 and write the simplest code that will pass our test. Open the file "helloworld.go" and go to the function declaration. Write type 'string' after paired parentheses.

func HelloWorld() string {

}

Now Go is expecting that function HelloWorld returns a string value. However, we didn't write the code that returns any values from HelloWorld, and that's why your IDE will probably show you some signs that something is wrong. Okay, now let's write this line which means that function HelloWorld returns a string.

func HelloWorld() string {
    return ""
}

Let's run the test again (go test). Okay, we did enough to call our function inside the test properly, and finally, we see that our test case failed.

❯ go test 
--- FAIL: TestHelloWorld (0.00s)
    hello_test.go:10: Failed! Expected "Hello, World!" but received ""
FAIL
exit status 1
FAIL    hello-world     0.624s

That's alright. We just need to make sure that our test works correctly. Now it's time to write the code inside HelloWorld to pass the test.

func HelloWorld() string {
    return "Hello, World!"
}

Great! There are not many things to refactor, so we can skip step 5. We successfully finished our test-development cycle, and now let's complete our program so that it will print the string "Hello, World!" in the terminal.

We need to run our program, and for that, we can use a special command provided by go tool. But it's not gonna work for several reasons. First of all, we didn't call our HelloWorld anywhere and didn't use the method that prints the string in the terminal.
But where do we need to write this code? We cannot just call the function inside the file we want, like in programming languages such as JavaScript or Python. In Go, we need to have a function called "main," which is an entry point to our program. This function will be called first when we run our program. Let's write this function in the file "hello.go".

func main() {

}

Now we need to use some method that will print the string in the terminal. Go has a built-in package called "fmt," which stands for formatting. The package "fmt" has a bunch of methods for formatting and printing strings. The method that we need is called "Println," so let's use it in our code.

func main() {
    fmt.Println(HelloWorld())
}

Don't forget about the import of the package which method you're gonna use in your code.

import "fmt"

The method Println takes the string as the first argument and prints it in the terminal. But it also prints a string on a newline. That's what the 'ln' in the name of the method stands for.

Okay, now it's time to run our program. Open the terminal in the root of the project's folder and type go run hello.go. It will show you the message:

❯ go run hello.go 
package command-line-arguments is not a main package

Well, the thing is that every Go program should also have a main package the same way as the main function. So the main package is an entry point in a Go program. When you run a Go program by command go run, it will look at the package "main" first and will execute the function main inside that package. Remember that we declared that our package name is "hello" in hello.go and hello_test.go files. So all we need to do is just to create a file called "main.go" in the root of the project folder.

cd ..
touch main.go

Inside the new file write the package declaration line.

package main

And move the function "main" from the file helloworld.go to main.go.

package main

func main() {
    fmt.Println(HelloWorld())
}

Since we are using the function HelloWorld from the package "helloworld," we need to import this package in the file main.go; also, don't forget about importing the package "fmt."

package main

import (
    "fmt"
    "go-sandbox/helloworld"
)

func main() {
    fmt.Println(HelloWorld())
}

But this is still not enough for this code to work. In Go, if you use some function from another package, you need to write the package's name before the name of the function on the line where you call it; like that:

    fmt.Println(helloworld.HelloWorld())

Final code:

package main

import (
    "fmt"
    "go-sandbox/helloworld"
)

func main() {
    fmt.Println(helloworld.HelloWorld())
}

Let's try to run our program again, but this time you need to run the file main.go in the project root folder instead of helloworld.go in the helloworld package folder.

go run main.go

This should work perfectly. You can also run it by using go run . instead of writing the file name properly since it will look at package main first anyway.

go run .

The full source code is available on GitHub repository GGFT.

A new learning way on how to write "Hello, World!" program in Go [video]

Max Kovalevsky — Thu, 29 Feb 2024 16:01:19 +0000

Hello DEV Community!

I want to share with you my first video in the series about Go programming language. This video is a part of my upcoming course "Grokking Go Fundamentals with Tests" (GGFT) so if you are interested in learning Go with tests and TDD way subscribe to my channel to ensure you don't miss my next videos in the series.

In this video we will write a classic "Hello, World!" program but following Test-driven development way. If you don't know what is TDD you can watch this video where I introduce to this technique.

Link to the video

#1 Weekly Dose Of Software Engineering Stuff

Max Kovalevsky — Fri, 30 Jul 2021 14:41:13 +0000

‚ùóÔ∏èüíå This post is a public version of the newsletter edition that was published 2 days ago. Sign up to Weekly Dose Of Software Engineering Stuff to be among the first to receive the newsletter.

Hello there! üëã

It's the first edition of Weekly Dose Of Software Engineering Stuff - a newsletter where you can read the content of topics that might be interesting for software developers and engineers.

The goal of this newsletter is to share resources from my blog and the Internet that are related to topics that I found interesting as a software developer. The content related to TypeScript, Node, programming languages in general, testing for devs, writing and note-taking, useful resources about computer science, algorithms and data structures, interview preparation, software architecture, books, DevOps, and many many other interesting things.

As you may have noticed, the name of the newsletter was inspired by one popular YouTube channel. But I think it's quite original üôÇ.

Short information about me. I am a software developer currently based in Prague. I work with technologies like TypeScript, React, Node, and others. The project that I'm working on with a team is a solution for cloud backups (AWS, Google Cloud, etc). So, content related to cloud computing can also be in the future.

Since you already subscribed to my newsletter you know that I have a blog. Now it's mostly about TypeScript and Node but I have plans to expand a list of content topics. Stay tuned!

Another one of my activities is a book about TypeScript which is available for free as series of posts on my blog and PDF eBook. In this letter, you can find a link to the latest version of the eBook üìö.

Blog

About a week ago I published the post What Is Strict Mode In TypeScript, Why And When You Should Use It?. It's more theoretical material for ones who are just starting out to work with TypeScript and don't know what TypeScript's strict "mode". I have a draft of another post about strict options in TypeScript that described it in a more practical way. I'm going to publish it soon.

Resources from the Internet

TypeScript

TSConf 2021 is coming and conference's team announces list of speakers, sponsors, and more details about schedule
- The conference will be on September 10 in online
Most Popular Programming Languages, according to public GitHub Repositories (Jun 2021)
- TypeScript: 7.2%
- JavaScript: 19.0%
- Python: 16.4%
- Java: 12.8%
- Go: 7.6%
Dr. Axel Rauschmayer published the article Simple monorepos via npm workspaces and TypeScript project references

Visual Studio Code

JavaScript and TypeScript Nightly Extension (marketplace.visualstudio.com)
- VS Code extension that enables the nightly build of TypeScript (typescript@next) as VS Code's built-in TypeScript version used to power JavaScript and TypeScript IntelliSense.
Visual Studio Code June 2021 (code.visualstudio.com)

Web

Interesting post The Future Of The Web by HazemOsama

Videos

Prisma Day 2021 Workshops (YouTube Playlist)

Vim

I don't use vim as much as I used before, but I'm still interested in this. Here is a special episode of Changelog podcast fully about vim with great hosts and guests

Obsidian

I use Obsidian every day for note-taking, writing blog posts, and even for this newsletter.
- Bryan Jenks published a huge video workshop about his Obsidian Zettelkasten Workflow

That's all! If you found something interesting and you want to share it with newsletter members or you have an opinion on how to improve the newsletter don't be shy to email me. Since it's just the first edition of newsletter I'm experimenting with content and format.

It would be if you invite your friends or colleagues to join the newsletter.

I'll see you next week!

Byteski

How To Configure tsconfig.json: TypeScript Strict options

Max Kovalevsky — Thu, 29 Jul 2021 14:47:49 +0000

This post is part of series of posts about TypeScript called Grokking TypeScript. It will guide you from scratch to writing full TypeScript applications on Back End and Front End. The series is available as PDF eBook for free to everyone.

TypeScript is not just a superset of JavaScript with static types. It is also a quite configurable tool that can be used for different types of projects. One parameter or group of parameters that can be configured is strict. If you are not familiar with strict mode and why you should use it for a new project then check out the post What Is Strict Mode In TypeScript, Why And When You Should Use It?. In this post I focus more on a practical side of this topic.

TypeScript's strict mode parameter can be configurated as several individual parameters for each specific case of type checking. So, basically, if you set the parameter strict to true in tsconfig.json it means that all these strict options are set to true.

List of strict options:

useUnknownInCatchVariables (new)
noImplicitAny
strictNullChecks
strictFunctionTypes
strictBindCallApply
strictPropertyInitialization
noImplicitThis
alwaysStrict

Let's explore each strict option in practice.

TypeScript Strict options in tsconfig.json: useUnknownInCatchVariables

This option was introduced in TypeScript 4.4.

The problem is that when we use construction try catch the type of variable error in catch is any:

It increases the potential risk of errors and application malfunction. The option useUnknownInCatchVariables solves this problem.

If you set option useUnknownInCatchVariables to true then variable error in every try catch in your code base will have type unknown:

{
  "compilerOptions": {
    // ...
    "useUnknownInCatchVariables": true
  }
}

You can also use type Error for error variable:

try {
    // some code
}
catch (e) {
    if (e instanceof Error) {
        console.error(e.message);
    }
}

TypeScript Strict options in tsconfig.json: noImplicitAny

Let's start with option noImplicitAny.

In the main.ts file (or whatever file you want) let's create a simple function:

function printData(data) {
  console.log(data);
}

If you run tsc command you will see that TypeScript successfully compiles the code because there is no error.

Now, set the options in configuration file tsconfig.json in your project:

{
  "compilerOptions": {
    "noImplicitAny": true
  }
}

If you're writing your code in an editor like Visual Studio Code or some IDE you probably already see that something is wrong with parameter data in the function. Let's run TypeScript compiler tsc and see what it will tell us.

TypeScript compiler will print something like this:

error TS7006: Parameter 'data' implicitly has an 'any' type.

4 function printData(data) {
                     ~~~~
Found 1 error.

So, if you set the option noImplicitAny to true, TypeScript won't allow us to write functions with parameters without types of parameters. The thing is that TypeScript doesn't know what type of the parameter data is and it doesn't infer because there is no information in the code about that value should be there.

You need to set some type to avoid this TypeScript error. For example, I'll specify type string for the data:

function printData(data: string) {
  console.log(data);
}

Also, if your parameter is not required, you can specify the default value of the parameter. And there is the thing: if you set the default value of the parameter then you won't need to specify the type. In that case, TypeScript will understand what type of the parameter is by Type inference.

An example. The default value of the parameter is empty string so type of the parameter is string:

function printData(data = "") {
  console.log(data);
}

TypeScript Strict options in tsconfig.json: Why Should noImplicitAny Be Enabled?

By setting the option noImplicitAny to true, TypeScript forces you to write safer code. How? The problem with ignorance of the type of the parameter is that you can manipulate the value in the code by methods that can't work with this value. For example, inside the function printData you can use method .toLowerCase that works with type string. Your colleague (or even you!) can use the function printData somewhere in the future. Because you don't know what the type of the parameter data is, you probably can put the number value to this parameter.

function printData(data) {
  console.log(data.toLowerCase());
}

async function main() {
  printData(10);
}

main();

The code above will successfully be compiled by tsc because there are no errors from the TypeScript perspective. But when you will run the program in the Web browser or by Node as in our case, you will see that program falls:

node dist/main.js
/ts-node-sample/dist/main.js:13
    console.log(data.toLowerCase());
                     ^
TypeError: data.toLowerCase is not a function

You can avoid this error before executing the code by specifying the type of the parameter. The TypeScript's option noImplicitAny won't allow you to escape from specifying the type in the new code.

TypeScript Strict options in tsconfig.json: strictNullChecks

Source code of this example is available on GitHub

This parameter obligates us to make a check of the variable existing. For example, let's say we have an array of some object. This data is available in a code of app from JSON file:

src/inventory.json

[
    {
        "id": "1",
        "name": "sword",
        "level": "10",
        "icon": "Ô£ø√º√≥¬∞"
    },
    {
        "id": "2",
        "name": "bow",
        "level": "7",
        "icon": "Ô£ø√º√®œÄ"
    },
    {
        "id": "3",
        "name": "shield",
        "level": "5",
        "icon": "Ô£ø√º√µ¬∞"
    }
]

In some modules, we have a code where this JSON file is imported and used as a database. The app is simple: it asks the user to type the name of the item from inventory and then if this item exists the program will print information about it.

src/main.ts

import { createQuestioner } from "./createQuestioner";
import { greeting } from "./greeting";

import inventory from "./inventory.json";

async function main() {
  try {
    const questioner = createQuestioner();
    const username = await questioner.ask("Type your username: ");

    greeting(username);

    const itemName = await questioner.ask(
      "Type the name of the inventory item: "
    );

    const foundItem = inventory.find((item) => item.name === itemName);

    console.log(
      `You've chosen an item: ${foundItem.icon} ${foundItem.name} (lvl ${foundItem.level})`
    );

    questioner.finishUp();
  } catch (e) {
    console.error(e);
  }
}

main();

If you run this program by npm run dev, type any name and one of three item's names (sword, bow, shield) the program will run as it should. The problems begin when you type the name of the item that does not exist in the inventory. If you try this, you'll see something like this:

‚Äö√π√ò npm run dev

> tsc-intro@1.0.0 dev
> tsc && node dist/main.js

Type your username: byte
Hello, @byte!
Type the name of the inventory item: spear
TypeError: Cannot read property 'icon' of undefine

All we need to do to fix this problem is to add the code that checks the variable existing before using it for printing the result. But the point is that TypeScript should highlight that we need to fix the potential problem. To do it just set option strictNullChecks to true:

tsconfig.json

{
  "compilerOptions": {
    // ...
    "strictNullChecks": true
  }
}

Now, let's run npm run dev and see that happens:

src/main.ts:20:33 - error TS2532: Object is possibly 'undefined'.

20       `You've chosen an item: ${foundItem.icon} ${foundItem.name} (lvl ${foundItem.level})`
                                   ~~~~~~~~~

src/main.ts:20:51 - error TS2532: Object is possibly 'undefined'.

20       `You've chosen an item: ${foundItem.icon} ${foundItem.name} (lvl ${foundItem.level})`
                                                     ~~~~~~~~~

src/main.ts:20:74 - error TS2532: Object is possibly 'undefined'.

20       `You've chosen an item: ${foundItem.icon} ${foundItem.name} (lvl ${foundItem.level})`
                                                                            ~~~~~~~~~

Found 3 errors

Great! Now we have information about where the problem is. Just add checking the variable foundItem:

async function main() {
  try {
    const questioner = createQuestioner();
    const username = await questioner.ask("Type your username: ");

    greeting(username);

    const itemName = await questioner.ask(
      "Type the name of the inventory item: "
    );

    const foundItem = inventory.find((item) => item.name === itemName);

    if (!foundItem) {
      console.log(`There is no item with name '${itemName}' in the inventory.`);
      questioner.finishUp();
      return;
    }

    console.log(
      `You've chosen an item: ${foundItem.icon} ${foundItem.name} (lvl ${foundItem.level})`
    );

    questioner.finishUp();
  } catch (e) {
    console.error(e);
  }
}

TypeScript Strict options in tsconfig.json: strictNullChecks and Exclamation mark

You can also use "!" in such a case when you are sure that found item or element exist. Let's see an example:

async function main() {
  try {
    const questioner = createQuestioner();
    const username = await questioner.ask("Type your username: ");

    greeting(username);

    const listOfItems = inventory
      .map(
        (item) => `${item.id}) ${item.icon} ${item.name} (lvl ${item.level})`
      )
      .join("\n");

    const option = await questioner.ask(
      `\n${listOfItems}\n\nChoose the item (type the number): `
    );

    const itemsIds = inventory.map((item) => item.id);

    if (!itemsIds.includes(option)) {
      console.log(`There is no item with option number ${option}.`);
      questioner.finishUp();
      return;
    }

    const foundItem = inventory.find((item) => item.id === option);

    console.log(
      `You've chosen an item: ${foundItem.icon} ${foundItem.name} (lvl ${foundItem.level})`
    );

    questioner.finishUp();
  } catch (e) {
    console.error(e);
  }
}

In this case, a user is not typing the name of the inventory item but type an option number offered by the app. Because the code checks that the user typed option number that surely exists (the line if (!itemsIds.includes(option)) {) we don't need to manually check that variable foundItem has data inside. But TypeScript will tell us that we need to check this variable because Object is possibly 'undefined'. To avoid this highlight we can use exclamation mark:

console.log(
  `You've chosen an item: ${foundItem!.icon} ${foundItem!.name} (lvl ${
    foundItem!.level
  })`
);

It tells TypeScript that we are totally sure that foundItem is not undefined or null. After that you can run the app it will work correctly.

I recommend not use **exclamation mark* very often because it can expand the count of potential mistakes in the future. Use it only in case when you are totally sure that some data exists.*

TypeScript Strict options in tsconfig.json: strictBindCallApply

Source code of this example is available on GitHub

The next option is not so useful nowadays since we don't need to use bind() and related methods much often in modern JavaScript. But anyway, if you need to use bind(), call(), or apply() then this option might be useful for you.

The example is unusual but you may come across this in existing projects with an old version of ECMAScript (where arrow functions are not available or their support is disabled for some reason). This function creates an object of a non-player character. You can start the dialog with this character (in our example it starts automatically after running the app) but the character is busy right now so it answers later (after 2 sec):

import { Questioner } from "./createQuestioner";

export function createMerchant(name: string, questioner: Questioner) {
  async function greeting(caller: { name: string; level: number }) {
    console.log("\nDid you complete the quest? \n 1) yes \n 2) no");
    const answer = await questioner.ask("\nYour answer: ");

    if (answer === "1") {
      console.log(`\nExcellent! Now your level is: ${caller.level + 1}`);
    } else {
      console.log("\nSee ya later");
    }

    questioner.finishUp();
  }

  const character = {
    name,
    startDialog: function (caller: { name: string; level: string }) {
      console.log("[This character is busy now]");
      setTimeout(greeting.bind(this, caller), 2000);
    },
  };

  return character;
}

Let's create a merchant in main module:

import { createQuestioner } from "./createQuestioner";
import { greeting } from "./greeting";
import { createMerchant } from "./merchant";

async function main() {
  try {
    const questioner = createQuestioner();
    const username = await questioner.ask("Type your username: ");
    const level = await questioner.ask("Type your level: ");

    greeting(username);

    const merchant = createMerchant("Trader", questioner);

    merchant.startDialog({ name: username, level });
  } catch (e) {
    console.error(e);
  }
}

main();

Now, if you run the program and type your name and level (for example, 10) and then answer "yes" in dialog (type "1") when you see something goes wrong with your level:

Excellent! Now your level is: 10

Typical problem with string and number values in JavaScript. Notice that in createMerchant in method startDialog a parameter level has type string but in function greeting the parameter caller has field level with type number. But we don't have any type checking errors after running tsc. We should tell TypeScript to check parameters of function that called by bind() (call(), apply()). This is what option strictBindCallApply is for.

tsconfig.json

{
  "compilerOptions": {
    // ...
    "strictBindCallApply": true
  }
}

Now, if you run the program you will see that TypeScript highlights the problem with different types of field level in function createMerchant:

src/merchant.ts:21:38 - error TS2769: No overload matches this call.
...
21       setTimeout(greeting.bind(this, caller), 2000);
                                        ~~~~~~
Found 1 error.

TypeScript Strict options in tsconfig.json: strictFunctionTypes

This option is intended for quite specific cases. If this option was set to true then TypeScript will not allow you to use a function in a case when types of parameters of this function are not the same as parameter's types in specified type.

An example:

type loggerFn = (id: number | string) => void;

const logTransaction: loggerFn = (id: string) => {
  console.log(`[${new Date().toDateString()}] ${id.trim()}`);
};

logTransaction(transactionId);

In this case, if options are enabled, tsc will return an error message after running:

src/main.ts:11:11 - error TS2322: Type '(id: string) => void' is not assignable to type 'loggerFn'.
  Types of parameters 'id' and 'id' are incompatible.
    Type 'string | number' is not assignable to type 'string'.
      Type 'number' is not assignable to type 'string'.

11     const logTransaction: loggerFn = (id: string) => {
             ~~~~~~~~~~~~~~~
Found 1 error

Theoretically, in this case you could specify the parameter id as a number and call function logTransaction like that: logTransaction(parseInt(transactionId)). But still, you will have a type-checking error because you cannot use method trim() for a number value.

Anyway, is good to know what specific options are needed if you enabled strict mode in your project.

TypeScript Strict options in tsconfig.json: noImplicitThis

You might know that JavaScript has a quite important nuance with the variable "this". Let's say, you have a method that prints a value of an object's field. If you wrote this method as function declaration then will lose "this" of an object where the method is specified. I would say that it's one of the famous "features" of JavaScript and Internet has tons of materials about this.

Here is an example:

const createCharacter = (name: string, level: number) => {
  return {
    label: `[${level} lvl] ${name}`,
    info(prefix: string) {
      return function () {
        console.log(`${prefix}: ${this.label}`);
      };
    }
  };
};

const ranger = createCharacter("Ranger", 77);
const printRangerInfo = ranger.info("Neutral");

printRangerInfo();

After running npm run dev you will see that it throws an error:

TypeError: Cannot read property 'label' of undefined

Now, let's set option noImplicitThis in configuration file:

{
  "compilerOptions": {
    // ...
    "noImplicitThis": true
  }
}

After that TypeScript will highlight an error in the code:

error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation.
14             console.log(`${prefix}: ${this.label}`);
                                         ~~~~

13           return function () {
                    ~~~~~~~~
An outer value of 'this' is shadowed by this container.
Found 1 error

By doing so we can fix the problem before running an application. One of a solution, in this case, is using an arrow function:

const createCharacter = (name: string, level: number) => {
  return {
    label: `[${level} lvl] ${name}`,
    info(prefix: string) {
      return () => {
        console.log(`${prefix}: ${this.label}`);
      };
    },
  };
};

When you change the nested function to arrow one TypeScript will stop highlight this line as an error. After running npm run dev you will see that the program works correctly.

TypeScript Strict options in tsconfig.json: strictPropertyInitialization

The next option is directly related to classes in JavaScript and TypeScript. In TypeScript, you can specify the properties of the class and also their types. Here is an example.

Let's say we have a special class for game characters:

export class Character {
  name: string;
  level: string;

  constructor() {}

  greeting(callerName: string) {
    console.log(`[${this.level}] ${this.name}: Hello, ${callerName}!`);
  }
}

Now, in the main module we create a character's object. The character should greetings the player:

async function main() {
  try {
    const questioner = createQuestioner();
    const name = await questioner.ask("Type your first name: ");

    const traveler = new Character();

    traveler.greeting(name);

    questioner.finishUp();
  } catch (e) {
    console.error(e);
  }
}

If you run this small example, you will see:

Type your first name: Byte 
[undefined] undefined: Hello, Byte!

I guess we didn't give a name to the traveler! Okay, we made a mistake in the code. It's not a big deal. The real problem is that TypeScript didn't say anything about it! Notice that constructor of class Character is empty. But also there is no highlighted error or warning. We don't have a specific syntax like required name: string in TypeScript to declare that properties name and level are required for initialization in the class Character. However, we can enable option strictPropertyInitialization and after that TypeScript compiler will tell us that we didn't initialize properties name and level in the constructor method of class Character.

An option strictPropertyInitialization can be enabled only if option strictNullChecks is enabled too.

{
  "compilerOptions": {
    // ...
    "strictNullChecks": true,
    "strictPropertyInitialization": true
  }
}

And after that we run tsc and see:

error TS2564: Property 'name' has no initializer and is not definitely assigned in the constructor.

2   name: string;
    ~~~~

src/Character.ts:3:3 - error TS2564: Property 'level' has no initializer and is not definitely assigned in the constructor.

3   level: string;
    ~~~~~

Found 2 errors.

This is exactly what we need. Now, let's fix the problem:

export class Character {
  // Class Property Inference from Constructors
  // since version 4.0 TypeScript can ‚Äö√Ñ√∫take" types of properties from a constructor
  // so we don't need to specify types of properties 'name' and 'level' here
  name;
  level;

  constructor(name: string, level: number) {
    this.name = name;
    this.level = level;
  }

  greeting(callerName: string) {
    console.log(`[${this.level}] ${this.name}: Hello, ${callerName}!`);
  }
}

And don't forget to give a name for the traveler in main module!

TypeScript Strict options in tsconfig.json: alwaysStrict

If you set the option alwaysStrict to true then TypeScript will parse your code in ECMAScript Strict mode and put "use strict" in each source file. If you are not familiar with ECMAScript Strict mode then check out article on MDN about it.

Conclusions

When you have already learned what errors can be prevented by TypeScript's strict options you may exclaim "It can be fixed by a few lines of code. Just add a checking of variable's existing before print it. What's the big deal?" and you'll be right. But, it's just a synthetic example to demonstrate the problem that can be solved by strict options. In reality, it could be one small part of a huge project with hundreds of files and thousands of lines of code. You cannot keep track of everything and you shouldn't. You also can make a typo or forget about doing a check because you can't concentrate after last night's party. It can also happen to your new colleague who hasn't completely figured out the codebase yet.

The point is to delegate solving errors that are related to types of variables to tools like TypeScript.

Do you like the material? Please, subscribe to my email newsletter to stay up to date.

What Is Strict Mode In TypeScript, Why And When You Should Use It?

Max Kovalevsky — Fri, 16 Jul 2021 02:14:43 +0000

This post is part of series and book about TypeScript. It will guide you from scratch to writing full TypeScript applications on Back End and Front End. The series is available as PDF eBook for free to everyone.

There are many options and parameters that can be used in the TypeScript configuration. One of the important "groups" of options is strict options. These options provide us the ability to write the safest code. How? Because TypeScript was developed primarily as superset of JavaScript, by default it allows us to write code that is not super strict in types and other aspects. It was made like this because TypeScript should be easily used by JavaScript developers. JavaScript doesn't have static types and is more flexible in some aspects of programming. It has many features to write code faster and easier (at first). However, the other side of this is that you probably will have more places where your code is unsafe. It means that the count of cases where your program will fall is big. TypeScript partially solves this problem.

What Is Strict Mode?

You may probably have heard about JavaScript strict mode and TypeScript strict mode. The point is that they are different kinds of things.

TypeScript strict mode is a bunch of TypeScript compiler parameters (that can be also be represented by one "main" parameter) that make TypeScript compiler tsc force you to follow specific rules of writing code in TypeScript. All these rules are directly related to types and managing types in the TypeScript code. For example, one of the rules forces you to always write a type of parameter in every function.

TypeScript "strict mode" could be enabled in the TypeScript configuration file by one OR a few parameters. It's a group of parameters that can be enabled individually or can be enabled all at once by one parameter.

The "main strict mode" parameter is called strict. It is a part of compilerOptions in tsconfig.json. If you set this parameter to true it will automatically set specific several parameters of configuration to true. Another important nuance is that if you enable strict parameter instead of individual strict checks parameters, the TypeScript compiler will automatically check your code with all new strict checks parameters that TypeScript may have in the next versions.

Strict checks parameters are:

noImplicitAny
strictNullChecks
strictFunctionTypes
strictBindCallApply
strictPropertyInitialization
noImplicitThis
alwaysStrict

I will introduce you to each of these parameters in next posts of the series. Let's focus on strict mode itself.

Should I Use Strict Mode?

What happens when you set this parameter to true? Well, it depends on is your project new (just created) or not. If you don't have any code in your project except configuration files or files with boilerplate code that was generated by tools like create-react-app then tsc should compile the project without errors. But if your project is not new, have a huge amount of files and code and you didn't follow specific rules of strict mode then you probably will get a list of errors provided by tsc after you attempted to compile the project.

And this is an answer to the question "Should I use strict mode in TypeScript or not?". If you just start a new project I highly recommend using strict mode in TypeScript. It will help you to avoid errors, typos, and mistakes in your code in the future. Strict mode constricts you in ways of writing your code. On other hand, you won't choose the way that will bring you to make a mistake. Sometimes a simple, verbose, and "boring" code is better than "cool" one-line code because it won't be failed.

Why strict mode in TypeScript can be enabled by several parameters? These parameters can be used in an existing project. You probably won't be able to set parameter strict to true in an existing project. But you can set some strict mode parameters to gradually rewrite your codebase following strict mode rules. For example, you can set the parameter noImplicitAny to true and rewrite your code to one that is following this rule (you should write a type of parameters in every function). You probably won't have time to rewrite all projects but you can improve specific parts of your code. Next time when you will have time to improve code quality you can set one more strict mode parameter (that suits your by time, number of changes in code, etc).

In Practice

Let's look at the example. Here is the simple console app that asks a user to type its name and then if the user exists in a database (which is basically JSON file with an array of users) prints greetings in a terminal. The source of an example is available here. Just create a new TypeScript project and create a few files with the code presented below.

git clone https://github.com/kowalevski/ts-node-sample/tree/strict-mode-example

The app has three files or modules with functions. The entry point of the app is file src/main.ts:

import { createQuestioner } from "./createQuestioner";
import { greeting } from "./greeting";
import usersDB from './users.json';

async function main() {
  try {
    const questioner = createQuestioner();
    const username = await questioner.ask("Type your name: ");

    const foundUser = usersDB.find((user) => user.username === username);

    greeting(foundUser.username);

    questioner.finishUp();
  } catch (e) {
    console.error(e);
    process.exit();
  }
}

main();

We are not interested in the module createQuestioner. Let's perceive it as a third-party library with some API. What we really need to focus on is file src/greeting.ts:

export function greeting(names) {
  console.log(`Hello, ${names.map((name) => name.toLowerCase()).join(', ')}!`);
}

Pretty simple code, isn't it? We didn't specify the type of parameter names but we expect that there will be an array of strings.

Okay, let's run our small application. Did you see any issues in the code? Because strict mode is disabled in the TypeScript configuration of this app we shouldn't see any errors in the editor.

Run the app by the following command:

tsc && node dist/main.js

npm run dev

After typing a name (it can be whatever name you want) you should see that there are errors in our code. But they were identified only after running Node, i.e. in runtime. So, the TypeScript compiler didn't find any problems in the code.

Now, let's enable strict mode and see what happens. After enabling strict parameter in tsconfig.json you should see errors in your editor (if it supports TypeScript):

And if you run TypeScript compilation you will see that TypeScript highlight the error:

src/greeting.ts:1:26 - error TS7006: Parameter 'names' implicitly has an 'any' type.

1 export function greeting(names) {
                           ~~~~~

src/greeting.ts:2:36 - error TS7006: Parameter 'name' implicitly has an 'any' type.

2   console.log(`Hello, ${names.map((name) => name.toLowerCase()).join(', ')}!`);
                                     ~~~~
Found 2 errors

Basically, the problem is that we didn't specify the type of parameter names in a function greeting. It means that the function can be called with wrong arguments in module main. Specify the type in src/greeting.ts. It should be an array of string values:

export function greeting(names: string[]) {
  console.log(`Hello, ${names.map((name) => name.toLowerCase()).join(', ')}!`);
}

Great! Let's see that we have in a file main.ts. In an editor, you probably may see that there is an error. Let's run TypeScript and see what's wrong here.

src/main.ts:12:14 - error TS2345: Argument of type '{ username: string; age: number; } | undefined' is not assignable to parameter of type 'string[]'.
  Type 'undefined' is not assignable to type 'string[]'.

12     greeting(foundUser.username);
                ~~~~~~~~~~~~~~~

Found 1 error

Okay. So, the problem is that we put a value of variable foundUser as itself (it is an object or undefined) but a function greeting receives an array of string values. It seems like a small typo because all we need to do is write argument foundUser.username as bracketed. Also, because variable foundUser could be undefined we need to check that is it false or not:

async function main() {
  try {
    const questioner = createQuestioner();
    const username = await questioner.ask("Type your name: ");

    const foundUser = usersDB.find((user) => user.username === username);

    if (!foundUser) {
        console.log('User is not found');
        questioner.finishUp();
        return;
    }

    greeting([foundUser.username]);

    questioner.finishUp();
  } catch (e) {
    console.error(e);
    process.exit();
  }
}

Now, let's run the app again:

npm run dev

It should work correctly.

Conclusions

So now you know that even code that compiles by tsc successfully can have issues and incorrect behavior when this code is running. The goal of TypeScript is to prevent times when the application works with errors or doesn't work at all before the code of the application executes. TypeScript analysis your code and based on types that were specified by you or by type inference and highlight part of the code with potential risk. And the best way it works is in strict mode. Using strict mode you will catch more potential errors and typos in your codebase before running the program.

Do you like the material? Please, subscribe to my email newsletter to stay up to date.

Configuring TypeScript: options rootDir, outDir, module, target

Max Kovalevsky — Tue, 18 May 2021 17:14:28 +0000

In the post Getting Started With TypeScript Compiler (tsc) we started to use TypeScript compiler with a few options in a simple Node project. We used tsc command to compile our app with specific rules and in watch mode. It works but we can use much more options of TypeScript compiler. However, use it just like a command in the Terminal with a bunch of flags is not so comfortable. We can improve our workflow by using TypeScript configuration file - tsconfig.json. In this post, we will learn how to create this file and configure it.

The project example will be the same as in the post Getting Started With TypeScript Compiler (tsc). It is also available on GitHub as repository mxkvl/ts-node-sample. If you didn't make the project from previous post from scratch - just download the repository from GitHub or clone the repository by this git command:

git clone https://github.com/mxkvl/ts-node-sample.git

Creating configuration file

Alright, let's start with creating the TypeScript configuration file. In the root folder of the project just use tsc with a special flag:

tsc --init

You will see the message from tsc that the file was successfully created. Now we have a new file in the folder called tsconfig.json. Let's look into this file. You will see a JSON with a bunch of different options. Most of them are commented but few options are already enabled by default. You can check out the whole commands with commentaries in tsconfig.json or check out documentation by yourself. In this guide, we will configure TypeScript for our small project from scratch so you need to delete all these options. Your tsconfig.json should look like this:

{
  "compilerOptions": {
  }
}

Okay. We already have the command from the previous post that compiles TypeScript with specific rules and in watch mode:

tsc --module ESNext --outDir "./dist" --watch src/main.ts

Just a reminder. It compiles file main.ts that is in folder /src. Compiled JavaScript files will be in the folder /dist. The option --module ESNext means that tsc will compile files in JavaScript code with ES Modules.

Now, let's configure the TypeScript compiler in tsconfig.json.

rootDir and outDir

First of all, we need to specify the folders for source code and output code. We already have folders /src and /dist for it. We just need to tell TypeScript to look at /src as a folder that contains TypeScript files with source code and to compile all files into the folder /dist. For this purpose we can use options rootDir and outDir.

rootDir is the path to the folder with the source code of the app (in our case it is /src)
outDir is the path to the folder with compiled JavaScript files that will be executed by Node or Web browser (in our case it is /dist)

Change the tsconfig.json:

{
  "compilerOptions": {
    "rootDir": "./src",
    "outDir": "./dist"
  }
}

Delete the folder /dist just to make sure that the TypeScript compiler will create it after compilation based on our configuration file:

rm -r dist

Because we use configuration file we don't need to use any options or specify file entry point (src/main.ts). Just use in the root folder of the project:

tsc

You will see that tsc successfully created folder /dist with compiled JavaScript code.

Run the app just to make sure that everything works as before:

node dist/main.js

module

We already know from the post Getting Started With TypeScript Compiler (tsc) that we can tell TypeScript to compile the code into JavaScript that uses ES Modules instead of CommonJS Modules. For that purpose we used the special option of tsc:

tsc --module ESNext src/main.ts

Now we can specify it in tsconfig.json:

{
  "compilerOptions": {
    "rootDir": "./src",
    "outDir": "./dist",
    "module": "ESNext"
  }
}

It works the same as the flag --module of tsc. You can compile the code again and see that now it uses ES Modules in compiled JavaScript code:

dist/main.js

// ...
import { createQuestioner } from "./createQuestioner";
import { greeting } from "./greeting";
// ...

target

The next important option of the TypeScript compiler is called target. You may notice that when we created tsconfig.json by command tsc --init the option target has already been set with value es5 in the configuration file.

It means that TypeScript will compile the code to JavaScript code of version ES5. In other words, this compiled code can be executed by the browser or Node with a version that supports a version of JavaScript (ECMAScript) that is no more than ES5. So, if your environment where you need to run your application (some specific version of web browser or Node) doesn't support modern features of JavaScript, you should set option target with the version of JavaScript that is supported by this environment.

In practice if your environment is a Web browser, i.e. you work on the Front End project, you probably will use value es2015 of option target. Of course, if you don't have some specific web browser and you need to run JavaScript with version ES3.

For the Node, there is information on GitHub with recommendations on what tsconfig.json settings to use.

A table with information about which target to use for a specific Node version:

version	target
16	ES2021
14	ES2020
12	ES2019
10	ES2018
8	ES2017

Also, check out the project node.green that contains information about Node.js ECMAScript compatibility.

Example

In our code example in file main.ts we use async/await construction to manage asynchronous code. async/await construction have been available since the ES2017 version of ECMAScript.

How it looks like in main.ts:

const firstName = await questioner.ask("Type your first name: ");
const username = await questioner.ask("Type your username: ");

Set the option target to ES2015:

{
  "compilerOptions": {
    "rootDir": "./src",
    "outDir": "./dist",
    "target": "ES2015"
  }
}

And compile the code:

tsc

Now, open the file dist/main.js in the editor. You will see that where in our code was async/await construction, there is now something else:

// ...
function main() {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            const questioner = createQuestioner();
            const firstName = yield questioner.ask("Type your first name: "); // async await??
            const username = yield questioner.ask("Type your username: ");
            greeting(firstName, username);
            questioner.finishUp();
        }
        catch (e) {
            console.error(e);
        }
    });
}
// ...

The reason why compiled code doesn't have async/await that we used in main.ts is that the code was compiled into the version of JavaScript that can be executed by Web browser or Node that doesn't support async/await construction.

Now, set the option target to value ES2017 (or any version that is more than ES2017) and run tsc. Open file dist/main.js again. You will see:

// ...
async function main() {
    try {
        const questioner = createQuestioner();
        const firstName = await questioner.ask("Type your first name: ");
        const username = await questioner.ask("Type your username: ");
        greeting(firstName, username);
        questioner.finishUp();
    }
    catch (e) {
        console.error(e);
    }
}
// ...

Do you like the material? Please, subscribe to my email newsletter to stay up to date.

Getting Started With TypeScript Compiler (tsc)

Max Kovalevsky — Sun, 16 May 2021 18:27:00 +0000

From the previous post TypeScript - What Is All About And Why Should You Use It? we know that TypeScript is a superset of JavaScript and programming language. But how can you use it? If you worked with JavaScript in Front End you know that your code is executing by Web browser. In Back End, your code is running by Node. What about TypeScript?

The thing is that TypeScript is provided with a special program, tool - compiler. A compiler is a program that compiles (transforms) one code to another.

What is TypeScript compiler?

As we mentioned before, TypeScript compiler is a tool, or program, that compiles (transforms) valid TypeScript code into JavaScript code. It is also a type checker and it validates TypeScript code

When you install TypeScript by npm or Yarn globally, the TypeScript compiler will be available on your local machine as a command tsc:

npm i -g typescript
tsc --version

TypeScript compiler has many flags and options to use in various types of projects. You can use it in Front End project with libraries like React. In Angular it is already used inside Angular's toolchain. You can also use tsc in Back End development with Node. Here is the post about How To Setup Node TypeScript Workflow.

In this post, we will explore how to use tsc with a few general options.

Usage

We will use tsc with a simple example. It is an command-line interface app that asks us to type our first name and username and then greetings us. It is a Node.js application and we will execute it by Node. If you didn't install Node or you have Node with a version that is lower than 15 on your local machine, check out the post How To Install or Update Node by Using nvm (Node Version Manager).

If you don't know how to run a TypeScript compiler, I recommend checking out the post Detecting Errors Before Running Code With TypeScript. We will use pretty much the same example as in that post but with small differences.

Let's create a folder called tsc-intro or whatever you want. First of all, create two helper modules (files) with the following code:

createQuestioner.ts:

import { createInterface } from "readline";
import { promisify } from "util";

interface Questioner {
  ask(text: string): Promise<string>;
  finishUp(): void;
}

export function createQuestioner(): Questioner {
  const rlInterface = createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  const ask = promisify(rlInterface.question).bind(rlInterface);

  const finishUp = () => {
    rlInterface.close();
  };

  return {
    ask,
    finishUp,
  };
}

greeting.ts:

export function greeting(firstName: string, username: string) {
  console.log(`Hello, ${firstName} (@${username})!`);
}

These two functions will be used in main module of our app which is an entry point. Let's create file main.ts:

import { createQuestioner } from "./createQuestioner";
import { greeting } from "./greeting";

async function main() {
  try {
    const questioner = createQuestioner();
    const firstName = await questioner.ask("Type your first name: ");
    const username = await questioner.ask("Type your username: ");

    greeting(firstName, username);

    questioner.finishUp();
  } catch (e) {
    console.error(e);
  }
}

main();

Also, you need to install Type Declarations of Node as a dev dependency in your local project. If you don't know about Type Declarations, check about the post What Are Type Declaration Files In TypeScript.

npm install --save-dev @types/node

Don't focus on the code too much. It's just an example of TypeScript code but first of all, we need to focus on using the TypeScript compiler.

Alright. Now it's time to use the TypeScript compiler to transform the TypeScript code into JavaScript code that we will execute by Node:

tsc main.ts

Great! Now you have compiled file main.js that you can execute by command:

node main.js

You should have noticed that there are also new files that we didn't create in our folder: createQuestioner.js and greeting.js. Although we compile only file main.ts, TypeScript also compiles all modules that were used in main.ts - greeting.ts and createQuestioner.ts. The code from these modules will be executed by Node when we will run it by node main.js.

If you are worked with Node.js before you may noticed that we imported modules in main.ts by using import smth from 'module' (ES Modules) not const smth = require('module') (CommonJS Modules). Of course, modern Node.js can work with ECMAScript modules. However, CommonJS Modules are still a general way to import and export modules in Node.

So, how does it works? The thing is that TypeScript by default compiles code that we wrote using ECMAScript modules into the JavaScript code with CommonJS Modules. Let's look into compiled files:

createQuestioner.js:

"use strict";
exports.__esModule = true;
exports.createQuestioner = void 0;
var readline_1 = require("readline");
var util_1 = require("util");
function createQuestioner() {
    var rlInterface = readline_1.createInterface({
        input: process.stdin,
        output: process.stdout
    });
    var ask = util_1.promisify(rlInterface.question).bind(rlInterface);
    var finishUp = function () {
        rlInterface.close();
    };
    return {
        ask: ask,
        finishUp: finishUp
    };
}
exports.createQuestioner = createQuestioner;

greeting.js:

"use strict";
exports.__esModule = true;
exports.greeting = void 0;
function greeting(firstName, username) {
    console.log("Hello, " + firstName + " (@" + username + ")!");
}
exports.greeting = greeting;

No code uses ECMAScript modules! In createQuestioner.js on line 20 the function createQuestioner is exporting by using CommonJS exports.greeting = greeting;. The same in greeting.js: on line 7 you will see the code exports.greeting = greeting; which is CommonJS.

Okay, the exporting is sorted out. What about importing modules?

Let's look into the file main.js:

The file is quite large so I cut the code that is not important for us right now

"use strict";
// some code here
exports.__esModule = true;
var createQuestioner_1 = require("./createQuestioner");
var greeting_1 = require("./greeting");
function main() {
    return __awaiter(this, void 0, void 0, function () {
        var questioner, firstName, username, e_1;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    _a.trys.push([0, 3, , 4]);
                    questioner = createQuestioner_1.createQuestioner();
                    return [4 /*yield*/, questioner.ask("Type your first name: ")];
                case 1:
                    firstName = _a.sent();
                    return [4 /*yield*/, questioner.ask("Type your username: ")];
                case 2:
                    username = _a.sent();
                    greeting_1.greeting(firstName, username);
                    questioner.finishUp();
                    return [3 /*break*/, 4];
                case 3:
                    e_1 = _a.sent();
                    console.error(e_1);
                    return [3 /*break*/, 4];
                case 4: return [2 /*return*/];
            }
        });
    });
}
main();

On lines 4 and 5 (in the file - 39 and 40), you will see that modules greeting and createQuestioner is imported by CommonJS modules.

The great thing is that TypeScript is a very configurable tool and we can compile TypeScript to the JavaScript code that uses ECMAScript Modules!

All we have to do is to use option --module with value ESNext:

tsc --module ESNext main.ts

The value ESNext means that TypeScript will compile code into the latest version of ECMAScript standard. For the purpose to use ECMAScript modules in compiled code it works for us.

Let's look into compiled file main.js again:

// ...
import { createQuestioner } from "./createQuestioner";
import { greeting } from "./greeting";
function main() {
    // ...
}
main();

Great! We have the code with imports that we need. It's time to execute thins code by Node:

node main.js

And... It fails. Node tells us that we need to specify parameter type with value module in file package.json. First of all, we need to create package.json in our folder:

npm init -y

And then add the parameter in the file:

{
  "devDependencies": {
    "@types/node": "^15.3.0"
  },
  "name": "tsc-intro",
  "version": "1.0.0",
  "main": "main.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "type": "module"
}

Try to run main.js again:

node main.js

It fails again!

Error [ERR_MODULE_NOT_FOUND]: Cannot find module 'tsc-intro/createQuestioner' imported from /tsc-intro/main.js
Did you mean to import ../createQuestioner.js?

The new problem is that Node can't understand modules that are imported without file extensions .js. To solve this just use the special Node option for now:

node --es-module-specifier-resolution=node main.js

Separating files into different folders

Everything works fine. But we have some mess in a folder. There are files that we wrote in TypeScript and also compiled JavaScript files. Let's clean the folder.

We can manage it by separating files into different folders. One is for source code that we write and the second one is for output code that will be executed by Node. We will use the TypeScript compiler for that purpose.

Create the folder /src and put all .ts files there:

mkdir src
mv *.ts src/

Also, remove all compiled .js files in the root folder:

rm *.js

All we have to do is run TypeScript compiled with special options outDir which is a path to the folder there should be compiled JavaScript files.

tsc --module ESNext --outDir "./dist" src/main.ts

Watch mode

Most of the time, we need to quickly change something in the code and see the result of the changes right now. Use this whole tsc command whenever we need to re-compile our project is a bit uncomfortable. We can use option --watch that re-run TypeScript compiler every time when files changes in /src folder.

tsc --module ESNext --outDir "./dist" --watch src/main.ts

Using watch mode is not enough for developing Node.js application because we also need to re-run Node after changes in the code. Check out the post How To Setup Simple Workflow To Write Node TypeScript Application In Live Reload.

Checking code without compilation

Another aspect of using TypeScript in modern Front End or Back End development is that we do not always need to compile TypeScript code into JavaScript code by using tsc. We can also use Babel for that purpose.

Compiling TypeScript or JavaScript code can be a quite long process. If you need to just check your types and validate your code you can use TypeScript without compilation by this command:

tsc --noEmit ./src/main.ts

Conclusions

In this post, we learned how to use TypeScript compiler with just several general options. We configured tsc by using command's flags but it also can be managed by using configuration file - tsconfig.json. In the next post, we will see how to configure tsc by tsconfig.json.

Do you like the material? Please, subscribe to my email newsletter to stay up to date.

Setup Simple Workflow To Write Node TypeScript Application In Live Reload (Nodemon, ts-node)

Max Kovalevsky — Wed, 12 May 2021 19:18:34 +0000

In this post, we will learn how to set up a Node project with TypeScript. It is not based on any framework or library like Fastify, Express, Nest, etc. Let's say you wanna build just a command-line application by using TypeScript and Node.

First of all, you need to install TypeScript on your computer. Install it by npm or Yarn globally.

npm i -g typescript

I'm sure you already installed Node on your computer but maybe you need to update your version. If so, check out the post about How To Install or Update Node by Using nvm (Node Version Manager).

Okay, now let's create a project's folder with name whatever you want (I name it as node-ts-setup-example). Open this folder in Terminal and your editor (I use Visual Studio Code).

Initialize the project by npm command:

npm init -y

Our project as an example will be simple - it is a command-line app that asks users to type their name in the Terminal and then prints greetings with this name.

Let's create a first file of the project - main.ts. Just put there very basic TypeScript code like this:

import { createInterface } from "readline";
import { promisify } from "util";

const rlInterface = createInterface({
  input: process.stdin,
  output: process.stdout,
});

const question = promisify(rlInterface.question).bind(rlInterface);

function greeting(name: unknown) {
  console.log(`Hello, ${name}!`);
}

async function main() {
  try {
    const name = await question("Type your name: ");

    greeting(name);

    rlInterface.close();
  } catch (e) {
    console.error(e);
  }
}

main();

Now let's try to compile this file by using the TypeScript compiler:

tsc main.ts

As you may have noticed TypeScript tells us that we need to install Type Declaration for modules of Node that we use - readline and util. If you are not familiar with Type Declarations check out the post What Are Type Declaration Files In TypeScript?. For now, let's just install these Type Declarations by npm:

npm install --save-dev @types/node

Try to compile main.ts again:

tsc main.ts

Great! The file was successfully compiled. Let's run it by Node and type our name to see greetings:

node main.js

Awesome. But what if we need to change our code a bit? When we change that we need to compile this file again and run it by Node. It would be great if our code will be automatically compiled and executed after changing. We can automate the process by running TypeScript compiler in watch mode:

tsc main.ts -w

So now TypeScript compiler automatically compiles main.ts into JavaScript code. But what about executing this? Well, TypeScript can't execute the code, only compile it.

We can set up the project to automate our development process. Let's start with TypeScript configuration. We need to create TypeScript configuration file in our project. We can use a special command that generates a configuration file with default settings:

tsc --init

It generated the file tsconfig.json. If you open this file you will see there are many options and parameters. I will write about it more in the next posts. All we need to do is focus on parameters outDir and rootDir. Uncomment these options in the tsconfig.json.

outDir is the path to folder where will be compiled from TypeScript to JavaScript code.

rootDir is the path to folder where are our TypeScript source code of the app. In our case - file main.ts.

Specify the options with values:

{
    ...
    "outDir": "./dist",
    "rootDir": "./src",
    ...
}

Also we need to uncomment parameter moduleResolution with value node:

"moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */

Create folder /src and move main.ts there.

Alright. We configured TypeScript for our project. Now we have to configure Node to execute our code in watch mode.

We need to install a few dev dependencies - ts-node and nodemon:

npm i -D ts-node nodemon

ts-node is a tool that executes code that is written in TypeScript as if it is written in JavaScript. I mean, you can perceive this as running Node but for TypeScript files. You can also use ts-node as a REPL to execute the code without files.

nodemon is a tool that restarts your Node application when some file changes. It really helps in developing because you don't need to re-run Node if you change code in your application.

Now let's specify section scripts in package.json file:

{
    ...
    "scripts": {
        "dev": "nodemon -w src src/main.ts",
        "start": "node dist/main.js",
        "build": "tsc -p ."
    },
    ...
}

To run dev server use this command:

npm run dev

Now if we change our code in main.ts it automatically re-compiles and re-run Node to execute the code.

Do you like the material? Please, subscribe to my email newsletter to stay up to date.

What Are Type Declaration Files In TypeScript?

Max Kovalevsky — Tue, 11 May 2021 18:22:28 +0000

You probably have seen files with a file extension like .d.ts in some JavaScript or TypeScript projects (libraries or frameworks) before and you wondered what are these files and what they are for. In TypeScript they are called Type Declaration files. Let's find out what is that practically.

Let's create a simple example with TypeScript code. Create a folder with the name typescript-type-defs or whatever name you want and then let's create a file called users-list.ts there with code:

const users = [
  {
    id: "1",
    name: "John",
    username: "johnsmith11",
    age: 55,
    level: 23,
  },
  {
    id: "2",
    name: "C3PO",
    username: "iamnotrobot",
    age: 112,
    level: 1,
  },
];

export const NAME_FIELD_KEY: keyof User = "name";

interface User {
  id: string;
  name: string;
  username: string;
  age: number;
  level: number;
}

export function getEntityField<Entity>(
  entities: Entity[],
  fieldName: keyof Entity
): unknown[] {
  return entities.map((entity) => entity[fieldName]);
}

export function getUsersName(users: User[]): string[] {
  return getEntityField(users, NAME_FIELD_KEY) as string[];
}

const result = getUsersName(users);

console.log(result);

What if need to use Interface User somewhere else? Not a problem, just add export before interface:

export interface User {
  id: string;
  name: string;
  username: string;
  age: number;
  level: number;
}

You can import this interface from module users-list in another module. However, sometimes we need to use this interface as a common thing between several modules. So, exporting interface from one of these modules is not an option. We need to create a special file where we can specify Interface User and use it in modules.

Create a file with name typings.d.ts and moved interface User from file users-list.ts into this new file:

export interface User {
  id: string;
  name: string;
  username: string;
  age: number;
  level: number;
}

Now we need to use this interface in module users-list. You can just import this interface from typings.d.ts:

import { User } from "./typings";

// ...

export const NAME_FIELD_KEY: keyof User = "name";

// ...

export function getUsersName(users: User[]): string[] {
  return getEntityField(users, NAME_FIELD_KEY) as string[];
}

// ...

Let's look at file typings.d.ts more. In this file, you cannot write variables, functions, and other code of TypeScript/JavaScript. All you can write there is types or interfaces. You can only define types there and use them in any modules.

Usually, you don't write types in .d.ts but in .ts files. However, .d.ts files are used in projects that are packages or libraries and are originally written in JavaScript. If you have JavaScript library and you have to add an ability to use your library in TypeScript projects, so you need to create .d.ts files. Another case is when you write your library in TypeScript but you ship it in compiled JavaScript code. In that case, you can automatically generate Type Declarations based on your TypeScript source code by using the TypeScript compiler (tsc).

Here is an example based on users-list.ts. Let's use tsc to generate Type Declaration file:

tsc users-list.ts --declaration

After that you will see a new file called users-list.d.ts with the following code:

import { User } from "./typings";
export declare const NAME_FIELD_KEY: keyof User;
export declare function getEntityField<Entity>(entities: Entity[], fieldName: keyof Entity): unknown[];
export declare function getUsersName(users: User[]): string[];

So with that Type Declaration file, you provide an ability to work with your library's API and types to someone who uses your library in their project.

There is a huge repository that contains type definitions for many libraries and packages - DefinitelyTyped. You probably have installed npm packages with names like "@types/*". The code of some of these packages is in this repository.

Do you like the material? Please, subscribe to my email newsletter to stay up to date.

Detecting Errors Before Running Code With TypeScript

Max Kovalevsky — Mon, 10 May 2021 18:25:06 +0000

The problem

In the previous post we talked about what is TypeScript and why should we use that. Now it's time to go to practice.

We need to know how to start using TypeScript in our JavaScript project. In examples of this post series, I will use mostly code that written in Node environment. It won't be any specific code that is understandable for only developers who worked with Node before. Because this material is about TypeScript I want to specify more on TypeScript itself.

Okay, let's start with an introduction to our first example. Here we have a very simple command-line application that works on Node. This example consists of one file. Let name it sum.js. When we execute this file by Node it will ask two questions in the Terminal - a value of argument X and Y. After typing these values the app will print the result of X + Y.

An example of this code is written with [[Node]]. If Node is not installed on your machine, check out the post about How To Install or Update Node by Using nvm (Node Version Manager).

Look at the code:

const readline = require("readline");

const rlInterface = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

// there is a simplified version of util.promisify method
const question = (message) => {
  return new Promise((resolve) => {
    rlInterface.question(message, (data) => {
      resolve(data);
    });
  });
};

function sum(a, b) {
  return a + b;
}

async function main() {
  try {
    const argX = await question("Type value of X: ");
    const argY = await question("Type value of Y: ");
    const result = sum(argX, argY);

    console.log(`Result: ${result}`);

    rlInterface.close();
  } catch (e) {
    console.error(e);
  }
}

main();

Don't focus on module readline, methods createInterface and question. It's just a Node specific code that allows us to take data that the user types in the Terminal. Let's focus on functions sum and main. The function main is just an entry point of our small app.

Alright. Now let's test our app that it works correctly. To run the app use this command (if you already in the same folder as file sum.js there):

node sum.js

The app is asking you to type the value of parameters X and Y. Let it be 7 and 2.

We expected that result will be 9 but the result is disappointed. The app prints:

There is a bug. The thing is that the value that function question returns have type string, not number as it expected in function sum.

It is a typical problem with JavaScript type system. I would say, it is a JavaScript trademark. Probably, you could see memes and jokes about this problem.

It's all perfectly fine, but how can we avoid this problem? Of course, you can change function sum and do something like this (unary add operator):

function sum(a, b) {
  return +a + +b;
}

But don't you think that this looks like a bad solution? It seems like that we try to use a patch to hide a hole in the tearing jacket. Instead of this, we can put on a new jacket that won't have holes (or maybe less than the previous one) - TypeScript.

The solution

Installing TypeScript

To install TypeScript globally on your machine let's use npm:

npm install -g typescript

Alright. Now we need to check that TypeScript was installed. Type this command in the Terminal:

tsc --version

It should print you something like this:

Version 4.2.4

It means that TypeScript was successfully installed on our machine. What is tsc command? It is a TypeScript compiler. As mentioned in the previous post, TypeScript compiler is a tool, or program, that turns the TypeScript code into JavaScript code. We need this feature because we will execute this compiled JavaScript code by Node.

From JavaScript to TypeScript

Alright. To solve the problem we need to write the same code as before but in TypeScript. Let's change extension of the JavaScript file sum.js to TypeScript file extension - .ts. Just rename the file from sum.js to sum.ts and let's see that we will have it in the editor.

We just renamed our file but there are already some changes in the editor (I use Visual Studio Code):

We have several lines with red underlining which means that there are TypeScript errors. There are also two dashed borders on line 11 - TypeScript warnings. But, why don't we just ignore all this stuff and execute our code? Let's try it.

For executing this file now we must first compile it by TypeScript compiler.

Run this command in the Terminal to compile TypeScript file sum.ts:

tsc sum.ts

Oops! After running this command we will see that our code cannot be compiled because of the errors that were marked in the editor.

And there is a thing. TypeScript won't allow you to compile the code that contains errors.

Fixing the code

To compile and execute this file we need to fix the code in the file. Let's see what the errors we have there.

The first four problems are about the same thing.

error TS2468: Cannot find global value 'Promise'.

sum.ts:3:18 - error TS2580: Cannot find name 'require'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node`.

3 const readline = require("readline");

TypeScript tries to understand the types of modules that we use in the code - readline. To help TypeScript know the types of the modules we need to install type definitions. You will learn about it more in the next posts. For now, let's just say that type definitions is a special notation that helps TypeScript to know types of code that were originally written in JavaScript.

Let's install it as TypeScript tells us:

npm install --sade-dev @types/node

Then, try to compile file sum.ts again:

tsc sum.ts

Great! We don't have any errors and successfully compiled our TypeScript file into JavaScript. You should see that there is a new file called sum.js in the same folder as sum.ts. No, this is not the file that we created before. This file contains compiled JavaScript code of sum.ts file.

If you open this file, well... You may be afraid. There is no our code at all! Don't jump to conclusions. It still the same code as we wrote in sum.ts but it transformed into a form that is more understandable for runtime environment (in our case - Node, also it might be Web browser).

Okay, let's execute our code again. But note that we have to execute compiled code, i.e. sum.js, not sum.ts:

node sum.js

Let's type new values: 13 and 7. We will see the wrong result, again.

But you said that we will solve this problem by using TypeScript and we will catch the errors before executing the file! Well, there is another thing of TypeScript that you need to remember. You wanna help? Help yourself!. In our case, it means that we have to say to TypeScript where the problem can be.

Use types to prevent bug

Let's describe our problem in the code. The function question returns a value that has a type string. But we don't know about it before executing the file. Because we don't know it we bravely put the values that function question returns into a parameter of function sum. The function sum expected that values will have type number and it worked with them as if they were numbers.

So, firstly, we need to say to TypeScript that function question returns string type. Let's do it!

To specify what type of value function returns we should write this code:

const question = (message): string => {
  return new Promise((resolve) => {
    rlInterface.question(message, (data) => {
      resolve(data);
    });
  });
};

Hmm. We specified the type of returned value, but TypeScript shows that there is an error:

An error sounds like this:

Type 'Promise<unknown>' is not assignable to type 'string'.ts(2322)

It means that we cannot just specify the type string as a type of returned value of function question because the function question is an asynchronous function and returns Promise.

Alright. To specify the type in this kind of function we just need to specify it like Promise<your_type> as TypeScript writes to us in the text of the error.

Let's fix that:

const question = (message): Promise<string> => {
  return new Promise((resolve) => {
    rlInterface.question(message, (data) => {
      resolve(data);
    });
  });
};

Okay. Did we tell TypeScript there might be a problem? Not yet. The next step is to specify the types of parameters of the function sum.

To specify types of function's parameters we should write this code:

function sum(a: number, b: number) {
  return a + b;
}

Let's look at the function main where functions question and sum are calling:

This is it!. This is the error that helps us to fix the bug with the wrong result that prints in the Terminal. Now, if we would try to compile file sum.ts we will see the error.

To run our program in one file use this command:

tsc sum.ts && node sum.js

We will see:

All we have to do is to write a code that converts values from string type to number:

async function main() {
  try {
    const argX = await question("Type value of X: ");
    const argY = await question("Type value of Y: ");
    + const x = Number(argX);
    + const y = Number(argY);
    - const result = sum(argX, argY);
    + const result = sum(x, y);

    console.log(`Result: ${result}`);

    rlInterface.close();
  } catch (e) {
    console.error(e);
  }
}

Let's see the result of executing our program:

Congratulations! You solve the problem and prevent the bug by using TypeScript!

TypeScript compiler is a very configurable tool. In the next post of the series we deep dive into configuring TypeScript.

Do you like the material? Please, subscribe to my email newsletter to stay up to date.

How To Install or Update Node by Using nvm (Node Version Manager)

Max Kovalevsky — Sun, 09 May 2021 18:01:20 +0000

Subscribe to my email newsletter to stay up to date.

Intro

There are few ways to install Node on your local machine. The most popular way is to install it following official website instructions. But if you use this way you will install just one specific (latest) version of Node. What if you need to install a specific version of Node? Or you need to upgrade from one version to another but only for a short while.

For that purpose, you can use a tool called nvm (Node Version Manager).

Installation

Because I use macOS on my local machine these instructions are specific to that operating system. You can find instructions that are specific to an operating system that you use on official documentation on GitHub.

To install nvm on your local machine let's use this command:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash

Now let's type the command which tells us that nvm is installed and available on our local machine:

nvm --version

You should see the current version of Node Version Manager that is installed on your local machine.

Shell Troubleshooting

If you use some shell as Z shell or Fish Shell you probably will have something like this in the Terminal:

fish: Unknown command: nvm

Currently, I use Fish Shell. If you use something else you should check detail information about troubleshooting on GitHub.

Unfortunately, nvm doesn't support Fish. However, there is a solution called fish-nvm. It is a wrapper for Fish Shell. You can install this by using Fisher (Fish Shell Plugin Manager):

fisher install FabioAntunes/fish-nvm edc/bass

Now, if you type nvm --version you should see a version of Node Version Manager that is installed on your local machine.

Usage

Node Installation

Now it's time to start using Node Version Manager to install Node on the local machine.

To install latest version of Node you can use the command:

nvm install node

To see all versions of Node that are installed on your machine use the command:

nvm ls

It should print in the Terminal something like this:

->      v16.1.0
         system
default -> node (-> v16.1.0)
iojs -> N/A (default)
unstable -> N/A (default)
node -> stable (-> v16.1.0) (default)
stable -> 16.1 (-> v16.1.0) (default)

...

Pay attention to the symbol "->". It shows us which version of Node is current on the local machine. So, basically, when you type node -v you should see the same version as with "->" before (in that case this version is 16.1.0).

Now let's install another version of Node. Let's say, I want to use some older version of Node. For example, 14 version. To install it use the command:

nvm install 14

It should install Node v.14.16.1. Let's look at the list of installed Node versions (nvm ls):

->     v14.16.1
        v16.1.0
         system
default -> node (-> v16.1.0)
iojs -> N/A (default)
unstable -> N/A (default)
node -> stable (-> v16.1.0) (default)
stable -> 16.1 (-> v16.1.0) (default)

...

Now we have two versions: 14.16.1 and 16.1.0. The current is 14 (the symbol "->" before).

To switch to version 16 use this command:

nvm use 16

We should see the answer of nvm:

Now using node v16.1.0 (npm v7.11.2)

And if we use the command nvm ls again we will see that the current version is 16.1.0.

Uninstall Node

To uninstall latest version of Node use command:

nvm uninstall node

To uninstall specific version of Node (for example - 14) use command:

nvm uninstall 14

Global npm packages

If you have some installed globally npm packages you should notice one thing. When you installed this npm package on one version of Node and then you switch to another version of Node, the installed npm package won't be available for you. It's because npm packages that were installed on different versions of Node located in different places.

An example. Now I am on version 16 of Node. I want to install Prettier globally on my computer by npm:

npm i -g prettier

And then we switch to version 14:

nvm use 14
prettier --version

You will see something like this:

prettier: command not found

Don't worry! If you want to use that package on version 14 you just need to install it again.

npm packages are located in specific folders for each version of Node that is installed by nvm.

Packages are located here (on macOS):

~/.nvm/versions/node/<version>/lib/node_modules

Do you like the material? Please, subscribe to my email newsletter to stay up to date.

DEV Community: Max Kovalevsky

I curate a daily newsletter with resources about Golang - Daily Golang. Here are the latest 6 issues of the newsletter

Daily Golang Issue #6 (2024-08-19)

Your daily hub for Go news, insights, and projects

⚡️ Latest

🧭 Discoveries

📝 Blog Posts

📹 Videos

🛠️ Projects

Daily Golang Issue #5 (2024-08-18)

Your daily hub for Go news, insights, and projects

⚡️ Latest

🧭 Discoveries

📝 Blog Posts

📹 Videos

🛠️ Projects

Daily Golang Issue #4 (2024-08-17)

Your daily hub for Go news, insights, and projects

🧭 Discoveries

📝 Blog Posts

📹 Videos

🛠️ Projects

Daily Golang Issue #3 (2024-08-16)

Your daily hub for Go news, insights, and projects

⚡️ Latest

🧭 Discoveries

📝 Blog Posts

📹 Videos

🛠️ Projects

Daily Golang Issue #2 (2024-08-15)

Your daily hub for Go news, insights, and projects

⚡️ Latest

🧭 Discoveries

📝 Blog Posts

📹 Videos

🛠️ Projects

Daily Golang Issue #1 (2024-08-14)

Your daily hub for Go news, insights, and projects

⚡️ Latest

🧭 Discoveries

📝 Blog Posts

📹 Videos

🛠️ Projects

Full Introduction to Golang with Test-Driven Development. Part I

A new learning way on how to write "Hello, World!" program in Go [video]

#1 Weekly Dose Of Software Engineering Stuff

Blog

Resources from the Internet

TypeScript

Node

NestJS

JavaScript

React

Visual Studio Code

Web

Videos

Vim

Obsidian

How To Configure tsconfig.json: TypeScript Strict options

TypeScript Strict options in tsconfig.json: useUnknownInCatchVariables

TypeScript Strict options in tsconfig.json: noImplicitAny

TypeScript Strict options in tsconfig.json: Why Should noImplicitAny Be Enabled?

TypeScript Strict options in tsconfig.json: strictNullChecks

TypeScript Strict options in tsconfig.json: strictNullChecks and Exclamation mark

TypeScript Strict options in tsconfig.json: strictBindCallApply

TypeScript Strict options in tsconfig.json: strictFunctionTypes

TypeScript Strict options in tsconfig.json: noImplicitThis

TypeScript Strict options in tsconfig.json: strictPropertyInitialization

TypeScript Strict options in tsconfig.json: alwaysStrict

Conclusions

What Is Strict Mode In TypeScript, Why And When You Should Use It?

What Is Strict Mode?

Should I Use Strict Mode?

In Practice

Conclusions

Configuring TypeScript: options rootDir, outDir, module, target

Creating configuration file

rootDir and outDir

module

target