Need advice about which tool to choose?Ask the StackShare community!
Flow Type vs TypeScript: What are the differences?
Introduction
Flow Type and TypeScript are both popular static type checkers for JavaScript. They offer similar functionality as they both provide static type checking for JavaScript applications. However, there are several key differences between the two that set them apart. This article will highlight six of these key differences.
1. Type Inference:
In Flow Type, type inference is powerful and does not require explicit type annotations in many cases. The type checker can often automatically infer the types of variables and expressions based on their usage in the code. On the other hand, TypeScript requires explicit type annotations for variables, function parameters, and return types. This means that developers using TypeScript must define the types explicitly, even if they can be inferred.
2. Nullable and Undefined Types:
In Flow Type, variables are nullable by default, meaning they can hold both a defined value and the value null. This is different from JavaScript, where variables are undefined by default. In TypeScript, variables are not nullable by default. Instead, developers can explicitly specify whether a variable can be assigned null or undefined by using the null and undefined types.
3. Type Checking Philosophy:
Flow Type focuses on gradual typing and aims to introduce static types into existing JavaScript codebases without requiring a complete overhaul. It allows developers to add types incrementally and gradually improve the type safety of their codebase. On the other hand, TypeScript takes a stricter approach to type checking and aims to enforce type correctness throughout the entire codebase. It requires developers to define types more explicitly and provides stricter type checking rules.
4. Community and Ecosystem:
TypeScript has a larger and more active community compared to Flow Type. This results in a larger ecosystem of libraries, tools, and resources built specifically for TypeScript. TypeScript's popularity also means that it is more commonly used in industry, making it easier to find experienced TypeScript developers and resources. Flow Type, although less popular, still has a dedicated community and a growing ecosystem.
5. Integration with Build Tools:
Flow Type integrates more seamlessly with build tools such as Babel. It can be used as a Babel plugin, allowing developers to gradually add static typing to JavaScript codebases without any additional build steps. TypeScript, on the other hand, requires compilation to JavaScript and relies on its own build system. This can sometimes introduce an extra step in the development workflow, especially when using tools like Babel.
6. Type System Features:
Flow Type and TypeScript have some differences in their type systems. For example, Flow Type supports exact object types, which means that object types must precisely match their defined shape. TypeScript, on the other hand, supports structural typing, where object types can have additional properties as long as they match the required properties. Additionally, Flow Type supports opaque types, allowing developers to create types that are only compatible with other instances of the same opaque type. TypeScript does not have an equivalent feature.
In summary, the key differences between Flow Type and TypeScript include their approach to type inference, handling of nullable and undefined types, type checking philosophy, community and ecosystem support, integration with build tools, and the features of their type systems.
From a StackShare community member: "We are looking to rewrite our outdated front-end with TypeScript. Right now we have a mix of CoffeeScript and vanilla JavaScript. I have read that adopting TypeScript can help enforce better code quality, and best practices. I also heard good things about Flow (JS). Which one would you recommend and why?"
I use TypeScript because:
- incredible developer tooling and community support
- actively developed and supported by Microsoft (yes, I like Microsoft) ;)
- easier to make sense of a TS codebase because the annotations provide so much more context than plain JS
- refactors become easier (VSCode has superb support for TS)
I've switched back and forth between TS and Flow and decided a year ago to abandon Flow completely in favor of TS. I don't want to bash Flow, however, my main grievances are very poor tooling (editor integration leaves much to be desired), a slower release cycle, and subpar docs and community support.
I use TypeScript because it isn't just about validating the types I'm expecting to receive though that is a huge part of it too. Flow (JS) seems to be a type system only. TypeScript also allows you to use the latest features of JavaScript while also providing the type checking. To be fair to Flow (JS), I have not used it, but likely wouldn't have due to the additional features I get from TypeScript.
We originally (in 2017) started rewriting our platform from JavaScript to Flow (JS) but found the library support for Flow was lacking. After switching gears to TypeScript we've never looked back. At this point we're finding that frontend and backend libraries are supporting TypeScript out of the box and where the support is missing that the commuity is typically got a solution in hand.
I use TypeScript because the tooling is more mature (the decision to discontinue TSLint in favor of moving all its checks to ESLint is a thoughtful and mature decision), there's a ton of examples and tutorials for it, and it just generally seems to be where the industry is headed. Flow (JS) is a fine tool, but it just hasn't seen the uptake that TS has, and as a result is lacking a lot of the nicer small things, like thorough Visual Studio Code integration, offered by TS.
We currently use TypeScript at work. Previously we used Flow (JS) but it was sometimes really difficult to make the types work the way you want. Especially non-trivial types were problematic. And the IDE support wasn't good, Flow took too much resources and sometimes remain stuck and do not show errors (I use Visual Studio Code). With TypeScript we almost do not have these problems. IDE support is superb, working with types is much easier and typing system seems more mature and powerful. There are some downsides (like partion inheritance etc.), but TS team is still pushing it forward. So for me TypeScript is clear winner.
We use Underscore because it's a reasonable library for providing all the reasonable helper functions missing from JavaScript ES5 (or that perform poorly if you use the default ES5 version).
Since we're migrating the codebase to TypeScript , we'll likely end up removing most usage of it and ultimately no longer needing it, but we've been very happy with the library.
I use TypeScript for Web Applications and for both frontend and backend because it has a lot of tooling around it and they really got the types and type safety right. Flow (JS) on the other hand lacks tooling and most of the times I scramble to find the right way of building my contracts in which TypeScript is very intuitive and natural. Additionally TypeScript is very similar to Java so your backend engineers and full stack engineers can work with it without much of context switch.
The only time I think Flow shines is (based on probably my outdated knowledge) Flow is/was the only option if you want/wanted to build a React Native application mainly because React Native transpiler at the time I was working with it would only work with flow.
I use TypeScript because it's adoption by many developers, it's supported by many companies, and it's growth. AngularJS, React, @ASP.NET Core. I started using it in .NET Core, then for a job. Later I added more Angular experience and wrote more React software. It makes your code easier to understand and read... which means it makes other people's code easier to understand and read.
If you will start a project from scratch I recommend to use TypeScript. But, If you work with legacy projects written in JavaScript I recommend Flow (JS). Both tools have the same objective: reduce the bad code (which create illegible code, generate bugs e problems to maintenance). Flex helps you to avoid fall in bad codes, but TypeScript prevent you to c you to create bad codes. I believe cause this some JavaScript fans don't like TS, because TS block you to write some types o code. This is the fundamental difference between TS and Flow: Flow avoid problems, but no force. TS force you to prevent problems.
I use TypeScript because it's the most mature/issue-free Javascript type-checker available, as far as I've seen.
I use TypeScript because of broad support, on tools, repos, community ... the only reason to consider flow is if you're a facebook employee
I use TypeScript because I tried both on a Meteor project, and found the quantity of errors it enabled us to catch and the simplification of code it allowed was higher than Flow (JS).
I recommend TypeScript. When used correctly, TypeScript can enable your application to be scalable, easy to refactor, safe, and stable. One of the biggest draws of working with any typed language is that it forces you to think about your functions' inputs and outputs. This is invaluable as it can lead to more declarative, functional style code that ultimately can be easier to reason about.
TypeScript is however not a silver bullet. Just like anything new it takes time to fully understand the concepts of types, interfaces, abstract classes, and enums. In my experience engineers who excel when using TypeScript are those who have experience working with a statically typed language.
I use TypeScript because i love to program in Angular and used in node as well
As our codebase grew in size, we were looking for ways to improve code quality. We chose TypeScript over Flow due to its rapid industry adoption and overall tools support.
We noticed how different open-source projects were migrating from Flow to TypeScript. Most notably, it was Jest, even though Jest and Flow were both developed by Facebook. See this HN thread if you want to dive into an interesting discussion around this move.
Additionally, at the beginning of 2019, both Babel and ESLint enabled seamless TypeScript support, which allowed easy migration path in a backward-compatible way.
Initially making a decision to use Flow vs Typescript we decided to go with flow as we wanted our code to run in a way we wrote it, because when using Flow types are simply removed from the code without modifying the code itself. Sadly, the type system of Flow was in some cases very hard to understand and declare the types correctly, especially in cases when the structure is very dynamic (e.g. object keys and values are created dynamically). Another reason was bad integration with IDE and frequent crashes which made DX very poor. Therefore, we made another evaluation of Typescript and decided to move towards it. As our code base was pretty big when we decided to migrate to TS we couldn't just stop and re-write everything, that's why we started writing new modules in Typescript as well as transforming old components. To make that possible we had to configure Webpack loader to support simultaneous bundling of Flow&JS and Typescript. After around 2 months of the transformation we have around 40% of code being written in Typescript and we are more than happy with integration TS has with IDE, as well as ease of declaring types for dynamic modules and functions.
Pros of Flow (JS)
Pros of TypeScript
- More intuitive and type safe javascript174
- Type safe106
- JavaScript superset80
- The best AltJS ever48
- Best AltJS for BackEnd27
- Powerful type system, including generics & JS features15
- Compile time errors11
- Nice and seamless hybrid of static and dynamic typing11
- Aligned with ES development for compatibility10
- Angular7
- Structural, rather than nominal, subtyping7
- Starts and ends with JavaScript5
- Garbage collection1
Sign up to add or upvote prosMake informed product decisions
Cons of Flow (JS)
Cons of TypeScript
- Code may look heavy and confusing5
- Hype4
Sign up to add or upvote consMake informed product decisions
What is Flow (JS)?
What is TypeScript?
Need advice about which tool to choose?Ask the StackShare community!
What companies use Flow (JS)?
Sign up to get full access to all the companiesMake informed product decisions
What tools integrate with Flow (JS)?
Sign up to get full access to all the tool integrationsMake informed product decisions
Blog Posts
+32
+17
+13