If you use TS, you will often get errors as you write, because the type of each parameter in a function is fixed. Each time a function is used, the editor will automatically indicate which parameters of the function are required and what each type is. This type-specific feature can detect code errors very early and fail. While writing JS people may be dynamic type cool, code a lot of on-site minefield. What happened?
- What is dynamic? What is static?
Dynamically-typed languages perform type checking at runtime, while statically typed languages perform type checking at compile time.
In short, a language that reports errors when compiled is a static language, and a language that reports errors when run is a dynamic language.
JS is a dynamically typed language that knows about errors at runtime.
TS knows about errors at compile time, so it is a statically typed language.
- Strongly typed languages? Weakly typed languages?
A strongly-typed language is one in which variables are bound to specific data types, And will result in type errors if types do not match up as expected in expression — regardless of when type checking occurs.
A strongly typed language is one that enforces type definition, meaning that once a variable is typed, it will always be that data type unless cast.
A weakly-typed language on the other hand is a language in which variables are not bound to a specific data type; they still have a type, but type safety constraints are lower compared to strongly-typed languages.
A weakly typed language is a weakly typed language in which a variable is typed and can be converted automatically according to the environment without going through the current cast.
TS is strongly typed, JS is weakly typed.
Here are the details from the Wiki:
Dynamic type checking is the process of verifying the type safety of a program at runtime. Implementations of dynamically type-checked languages generally associate each runtime object with a type tag (i.e., a reference to a type)containing its type information. This runtime type information (RTTI) can also be used to implement dynamic dispatch, late binding, downcasting, reflection, and similar features.
Static typing can find type errors reliably at compile-time, which should increase the reliability of the delivered program. Static typing advocates believe programs are more reliable when they have been well type-checked, whereas dynamic-typing advocates point to distributed code that has proven reliable and to small bug databases.