Why TypeScript Beats ESLint: Pros, Cons, and Alternatives for Modern Frontend Development

Current Situation

1. Detecting code errors with ESLint

Typescript‑eslint is omitted because it leverages TypeScript type information to assist linting.

ESLint detects errors at the AST level and can only diagnose issues within a single file.

It checks for potential bugs and enforces coding style.

Because it works on AST only, ESLint cannot solve problems such as:

Incorrect import module paths or missing modules.

Importing a module that exists but has mismatched method signatures.

Function call arguments that do not match the signature.

Incorrect usage of unfamiliar DOM APIs.

Other similar issues.

2. A non‑smooth coding experience

Function parameters are often objects, requiring source code inspection to know exact input and output formats.

Parameters may be optional (undefined) and have a contagious effect.

In Egg.js, methods and properties are attached to a global IoC container and must be accessed via context, making it hard to locate implementations without deep familiarity.

Unreliable code hints and completions.

- VSCode 中 JS 文件的 LSP 也是 TypeScript，但在没有类型辅助的情况下，自动类型推导是残缺的，比如 React 中 React.MouseEventHandler 是需要手动约束才能确定对应 callback 参数类型的；比如以下的代码提示也是不能用的，因为在 egg IoC 中，这些模板需要通过 this/ctx 等去访问。

Introducing TypeScript

TypeScript is like JavaScript but with no surprises.

Compared with JavaScript, TypeScript is designed for large‑scale projects to improve coding efficiency and convenience.

1. TypeScript popularity trends

The State of JavaScript 2018 survey shows developers love TypeScript’s robustness and coding style.

The State of JavaScript 2021 also reports high usage of compiled‑to‑JS languages, with TypeScript remaining popular.

Stack Overflow 2020 developer survey ranked TypeScript as the second most loved language.

In the 2021 Stack Overflow survey, TypeScript was again among the most wanted languages to try.

2. Pros

Immersive coding experience without constantly checking API docs.

Advantages of strong/static typing:

More complete Language Server Protocol features and smoother refactoring in IDEs like VSCode.

Decorator support enables code reuse and AOP‑style programming.

Facilitates introduction of design patterns, improving encapsulation and reducing coupling.

3. Cons

The type system has a learning curve.

Code must be compiled to JavaScript; static types exist only at compile time, so runtime validation is still required.

Node.js projects need tsc compilation, slightly reducing readability of generated code.

Object‑oriented paradigm differs from the functional‑programming style favored by many React projects.

Enabling strict mode ( strict: true) may require extensive manual type annotations.

Unit tests that mock objects need fully typed mock implementations, which can be more cumbersome.

TypeScript releases sometimes break semver, requiring handling of type incompatibilities.

“Competitors”

1. JSDoc

Can coexist with TypeScript; JSDoc provides comments while TS provides types.

Using JSDoc for typing results in more code than TS.

No automatic type inference.

TS’s official documentation format, TSDoc, is based on JSDoc.

2. Intellicode / Tabnine / Copilot

Intellicode and Tabnine use AI to learn from current and open‑source code for code completion.

Copilot generates code snippets from natural‑language comments, but carries copyright and data‑security risks and cannot replace comprehensive type‑aware tooling.

These tools do not conflict with TypeScript and can be used together; they address different problems (completion vs. LSP capabilities).

3. Flow

Mostly used within Meta; has fallen behind TypeScript, with Jest also migrating to TS.

Weaker IDE support and smaller community.

Requires OCaml for installation.

4. Kotlin / Elm / ReScript

Can compile to JavaScript.

Higher onboarding and migration costs.

5. Rust / Go

Can compile to WebAssembly and bind to V8 in Node.js.

Higher learning and migration costs.

Among these “competitors”, some are not true rivals—they can coexist with TypeScript—while others are less suitable for the current project’s technology stack.

Conclusion

Considering learning and adoption costs, we believe introducing TypeScript will inject more vitality into the project, even though a long road remains ahead. Remember:

any is fun for a moment, but refactoring becomes a graveyard.